gstflacparse.c 57.9 KB
Newer Older
1
2
3
/* GStreamer
 *
 * Copyright (C) 2008 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
4
5
6
 * Copyright (C) 2009 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
 * Copyright (C) 2009 Nokia Corporation. All rights reserved.
 *   Contact: Stefan Kost <stefan.kost@nokia.com>
7
8
9
10
11
12
13
14
15
16
17
18
19
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
Tim-Philipp Müller's avatar
Tim-Philipp Müller committed
20
21
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
22
23
 */

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * SECTION:element-flacparse
 * @see_also: flacdec, oggdemux, vorbisparse
 *
 * The flacparse element will parse the header packets of the FLAC
 * stream and put them as the streamheader in the caps. This is used in the
 * multifdsink case where you want to stream live FLAC streams to multiple
 * clients, each client has to receive the streamheaders first before they can
 * consume the FLAC packets.
 *
 * This element also makes sure that the buffers that it pushes out are properly
 * timestamped and that their offset and offset_end are set. The buffers that
 * flacparse outputs have all of the metadata that oggmux expects to receive,
 * which allows you to (for example) remux an ogg/flac or convert a native FLAC
 * format file to an ogg bitstream.
 *
 * <refsect2>
 * <title>Example pipelines</title>
 * |[
43
 * gst-launch-1.0 -v filesrc location=sine.flac ! flacparse ! identity \
44
45
46
47
48
49
50
51
 *            ! oggmux ! filesink location=sine-remuxed.ogg
 * ]| This pipeline converts a native FLAC format file to an ogg bitstream.
 * It also illustrates that the streamheader is set in the caps, and that each
 * buffer has the timestamp, duration, offset, and offset_end set.
 * </refsect2>
 *
 */

52
53
54
55
56
57
58
59
60
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "gstflacparse.h"

#include <string.h>
#include <gst/tag/tag.h>
#include <gst/audio/audio.h>
61
62
#include <gst/base/base.h>
#include <gst/pbutils/pbutils.h>
63
64
65
66

GST_DEBUG_CATEGORY_STATIC (flacparse_debug);
#define GST_CAT_DEFAULT flacparse_debug

67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
/* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
static const guint8 crc8_table[256] = {
  0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
  0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
  0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
  0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
  0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
  0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
  0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
  0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
  0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
  0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
  0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
  0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
  0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
  0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
  0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
  0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
  0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
  0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
  0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
  0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
  0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
  0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
  0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
  0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
  0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
  0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
  0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
  0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
  0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
  0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
  0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
  0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
};

static guint8
gst_flac_calculate_crc8 (const guint8 * data, guint length)
{
  guint8 crc = 0;

  while (length--) {
    crc = crc8_table[crc ^ *data];
    ++data;
  }

  return crc;
}

116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
/* CRC-16, poly = x^16 + x^15 + x^2 + x^0, init = 0 */
static const guint16 crc16_table[256] = {
  0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,
  0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,
  0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
  0x0050, 0x8055, 0x805f, 0x005a, 0x804b, 0x004e, 0x0044, 0x8041,
  0x80c3, 0x00c6, 0x00cc, 0x80c9, 0x00d8, 0x80dd, 0x80d7, 0x00d2,
  0x00f0, 0x80f5, 0x80ff, 0x00fa, 0x80eb, 0x00ee, 0x00e4, 0x80e1,
  0x00a0, 0x80a5, 0x80af, 0x00aa, 0x80bb, 0x00be, 0x00b4, 0x80b1,
  0x8093, 0x0096, 0x009c, 0x8099, 0x0088, 0x808d, 0x8087, 0x0082,
  0x8183, 0x0186, 0x018c, 0x8189, 0x0198, 0x819d, 0x8197, 0x0192,
  0x01b0, 0x81b5, 0x81bf, 0x01ba, 0x81ab, 0x01ae, 0x01a4, 0x81a1,
  0x01e0, 0x81e5, 0x81ef, 0x01ea, 0x81fb, 0x01fe, 0x01f4, 0x81f1,
  0x81d3, 0x01d6, 0x01dc, 0x81d9, 0x01c8, 0x81cd, 0x81c7, 0x01c2,
  0x0140, 0x8145, 0x814f, 0x014a, 0x815b, 0x015e, 0x0154, 0x8151,
  0x8173, 0x0176, 0x017c, 0x8179, 0x0168, 0x816d, 0x8167, 0x0162,
  0x8123, 0x0126, 0x012c, 0x8129, 0x0138, 0x813d, 0x8137, 0x0132,
  0x0110, 0x8115, 0x811f, 0x011a, 0x810b, 0x010e, 0x0104, 0x8101,
  0x8303, 0x0306, 0x030c, 0x8309, 0x0318, 0x831d, 0x8317, 0x0312,
  0x0330, 0x8335, 0x833f, 0x033a, 0x832b, 0x032e, 0x0324, 0x8321,
  0x0360, 0x8365, 0x836f, 0x036a, 0x837b, 0x037e, 0x0374, 0x8371,
  0x8353, 0x0356, 0x035c, 0x8359, 0x0348, 0x834d, 0x8347, 0x0342,
  0x03c0, 0x83c5, 0x83cf, 0x03ca, 0x83db, 0x03de, 0x03d4, 0x83d1,
  0x83f3, 0x03f6, 0x03fc, 0x83f9, 0x03e8, 0x83ed, 0x83e7, 0x03e2,
  0x83a3, 0x03a6, 0x03ac, 0x83a9, 0x03b8, 0x83bd, 0x83b7, 0x03b2,
  0x0390, 0x8395, 0x839f, 0x039a, 0x838b, 0x038e, 0x0384, 0x8381,
  0x0280, 0x8285, 0x828f, 0x028a, 0x829b, 0x029e, 0x0294, 0x8291,
  0x82b3, 0x02b6, 0x02bc, 0x82b9, 0x02a8, 0x82ad, 0x82a7, 0x02a2,
  0x82e3, 0x02e6, 0x02ec, 0x82e9, 0x02f8, 0x82fd, 0x82f7, 0x02f2,
  0x02d0, 0x82d5, 0x82df, 0x02da, 0x82cb, 0x02ce, 0x02c4, 0x82c1,
  0x8243, 0x0246, 0x024c, 0x8249, 0x0258, 0x825d, 0x8257, 0x0252,
  0x0270, 0x8275, 0x827f, 0x027a, 0x826b, 0x026e, 0x0264, 0x8261,
  0x0220, 0x8225, 0x822f, 0x022a, 0x823b, 0x023e, 0x0234, 0x8231,
  0x8213, 0x0216, 0x021c, 0x8219, 0x0208, 0x820d, 0x8207, 0x0202
};

static guint16
gst_flac_calculate_crc16 (const guint8 * data, guint length)
{
  guint16 crc = 0;

  while (length--) {
    crc = ((crc << 8) ^ crc16_table[(crc >> 8) ^ *data]) & 0xffff;
    data++;
  }

  return crc;
}

enum
{
  PROP_0,
  PROP_CHECK_FRAME_CHECKSUMS
};

#define DEFAULT_CHECK_FRAME_CHECKSUMS FALSE

173
174
175
static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
176
    GST_STATIC_CAPS ("audio/x-flac, framed = (boolean) true, "
177
178
179
180
181
182
        "channels = (int) [ 1, 8 ], " "rate = (int) [ 1, 655350 ]")
    );

static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
183
    GST_STATIC_CAPS ("audio/x-flac")
184
185
    );

186
187
188
static GstBuffer *gst_flac_parse_generate_vorbiscomment (GstFlacParse *
    flacparse);

189
190
static inline void gst_flac_parse_reset_buffer_time_and_offset (GstBuffer *
    buffer);
191
static void gst_flac_parse_reset (GstFlacParse * parser);
192
193
static gboolean gst_flac_parse_handle_block_type (GstFlacParse * flacparse,
    guint type, GstBuffer * sbuffer);
194
static void gst_flac_parse_finalize (GObject * object);
195
196
197
198
static void gst_flac_parse_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec);
static void gst_flac_parse_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec);
199
200
201

static gboolean gst_flac_parse_start (GstBaseParse * parse);
static gboolean gst_flac_parse_stop (GstBaseParse * parse);
202
203
static GstFlowReturn gst_flac_parse_handle_frame (GstBaseParse * parse,
    GstBaseParseFrame * frame, gint * skipsize);
204
static GstFlowReturn gst_flac_parse_parse_frame (GstBaseParse * parse,
205
    GstBaseParseFrame * frame, gint size);
206
207
static GstFlowReturn gst_flac_parse_pre_push_frame (GstBaseParse * parse,
    GstBaseParseFrame * frame);
208
209
210
static gboolean gst_flac_parse_convert (GstBaseParse * parse,
    GstFormat src_format, gint64 src_value, GstFormat dest_format,
    gint64 * dest_value);
211
212
static gboolean gst_flac_parse_src_event (GstBaseParse * parse,
    GstEvent * event);
213
214
static GstCaps *gst_flac_parse_get_sink_caps (GstBaseParse * parse,
    GstCaps * filter);
215

216
217
#define gst_flac_parse_parent_class parent_class
G_DEFINE_TYPE (GstFlacParse, gst_flac_parse, GST_TYPE_BASE_PARSE);
218
219
220
221
222

static void
gst_flac_parse_class_init (GstFlacParseClass * klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
223
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
224
225
  GstBaseParseClass *baseparse_class = GST_BASE_PARSE_CLASS (klass);

226
227
228
  GST_DEBUG_CATEGORY_INIT (flacparse_debug, "flacparse", 0,
      "Flac parser element");

229
  gobject_class->finalize = gst_flac_parse_finalize;
230
231
232
233
234
235
236
237
  gobject_class->set_property = gst_flac_parse_set_property;
  gobject_class->get_property = gst_flac_parse_get_property;

  g_object_class_install_property (gobject_class, PROP_CHECK_FRAME_CHECKSUMS,
      g_param_spec_boolean ("check-frame-checksums", "Check Frame Checksums",
          "Check the overall checksums of every frame",
          DEFAULT_CHECK_FRAME_CHECKSUMS,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
238
239
240

  baseparse_class->start = GST_DEBUG_FUNCPTR (gst_flac_parse_start);
  baseparse_class->stop = GST_DEBUG_FUNCPTR (gst_flac_parse_stop);
241
242
  baseparse_class->handle_frame =
      GST_DEBUG_FUNCPTR (gst_flac_parse_handle_frame);
243
244
  baseparse_class->pre_push_frame =
      GST_DEBUG_FUNCPTR (gst_flac_parse_pre_push_frame);
245
  baseparse_class->convert = GST_DEBUG_FUNCPTR (gst_flac_parse_convert);
246
  baseparse_class->src_event = GST_DEBUG_FUNCPTR (gst_flac_parse_src_event);
247
248
  baseparse_class->get_sink_caps =
      GST_DEBUG_FUNCPTR (gst_flac_parse_get_sink_caps);
249
250
251
252
253
254

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&src_factory));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&sink_factory));

255
  gst_element_class_set_static_metadata (element_class, "FLAC audio parser",
256
257
258
      "Codec/Parser/Audio",
      "Parses audio with the FLAC lossless audio codec",
      "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
259
260
261
}

static void
262
gst_flac_parse_init (GstFlacParse * flacparse)
263
{
264
  flacparse->check_frame_checksums = DEFAULT_CHECK_FRAME_CHECKSUMS;
265
  GST_PAD_SET_ACCEPT_INTERSECT (GST_BASE_PARSE_SINK_PAD (flacparse));
266
  GST_PAD_SET_ACCEPT_TEMPLATE (GST_BASE_PARSE_SINK_PAD (flacparse));
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
}

static void
gst_flac_parse_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstFlacParse *flacparse = GST_FLAC_PARSE (object);

  switch (prop_id) {
    case PROP_CHECK_FRAME_CHECKSUMS:
      flacparse->check_frame_checksums = g_value_get_boolean (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_flac_parse_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstFlacParse *flacparse = GST_FLAC_PARSE (object);

  switch (prop_id) {
    case PROP_CHECK_FRAME_CHECKSUMS:
      g_value_set_boolean (value, flacparse->check_frame_checksums);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
299
300
301
}

static void
302
gst_flac_parse_reset (GstFlacParse * parser)
303
{
304
305
306
  if (parser->tags) {
    gst_tag_list_unref (parser->tags);
    parser->tags = NULL;
307
  }
308
309
310
  if (parser->toc) {
    gst_toc_unref (parser->toc);
    parser->toc = NULL;
Anton Belka's avatar
Anton Belka committed
311
  }
312
313
314
  if (parser->seektable) {
    gst_buffer_unref (parser->seektable);
    parser->seektable = NULL;
315
  }
316

317
318
319
320
321
322
323
324
325
  g_list_foreach (parser->headers, (GFunc) gst_mini_object_unref, NULL);
  g_list_free (parser->headers);
  parser->headers = NULL;
}

static void
gst_flac_parse_finalize (GObject * object)
{
  GstFlacParse *flacparse = GST_FLAC_PARSE (object);
326

327
  gst_flac_parse_reset (flacparse);
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static gboolean
gst_flac_parse_start (GstBaseParse * parse)
{
  GstFlacParse *flacparse = GST_FLAC_PARSE (parse);

  flacparse->state = GST_FLAC_PARSE_STATE_INIT;
  flacparse->min_blocksize = 0;
  flacparse->max_blocksize = 0;
  flacparse->min_framesize = 0;
  flacparse->max_framesize = 0;

  flacparse->upstream_length = -1;

  flacparse->samplerate = 0;
  flacparse->channels = 0;
  flacparse->bps = 0;
  flacparse->total_samples = 0;

  flacparse->offset = GST_CLOCK_TIME_NONE;
  flacparse->blocking_strategy = 0;
  flacparse->block_size = 0;
  flacparse->sample_number = 0;
353
  flacparse->strategy_checked = FALSE;
354

355
356
  flacparse->sent_codec_tag = FALSE;

357
358
  /* "fLaC" marker */
  gst_base_parse_set_min_frame_size (GST_BASE_PARSE (flacparse), 4);
359

360
  /* inform baseclass we can come up with ts, based on counters in packets */
361
362
  gst_base_parse_set_has_timing_info (GST_BASE_PARSE_CAST (flacparse), TRUE);
  gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (flacparse), TRUE);
363
364
365
366
367
368
369
370
371

  return TRUE;
}

static gboolean
gst_flac_parse_stop (GstBaseParse * parse)
{
  GstFlacParse *flacparse = GST_FLAC_PARSE (parse);

372
  gst_flac_parse_reset (flacparse);
373
374
375
  return TRUE;
}

376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
static const guint8 sample_size_table[] = { 0, 8, 12, 0, 16, 20, 24, 0 };

static const guint16 blocksize_table[16] = {
  0, 192, 576 << 0, 576 << 1, 576 << 2, 576 << 3, 0, 0,
  256 << 0, 256 << 1, 256 << 2, 256 << 3, 256 << 4, 256 << 5, 256 << 6,
  256 << 7,
};

static const guint32 sample_rate_table[16] = {
  0,
  88200, 176400, 192000,
  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
  0, 0, 0, 0,
};

391
typedef enum
392
{
393
394
395
396
397
398
399
  FRAME_HEADER_VALID,
  FRAME_HEADER_INVALID,
  FRAME_HEADER_MORE_DATA
} FrameHeaderCheckReturn;

static FrameHeaderCheckReturn
gst_flac_parse_frame_header_is_valid (GstFlacParse * flacparse,
400
401
    const guint8 * data, guint size, gboolean set, guint16 * block_size_ret,
    gboolean * suspect)
402
403
404
405
406
407
408
{
  GstBitReader reader = GST_BIT_READER_INIT (data, size);
  guint8 blocking_strategy;
  guint16 block_size;
  guint32 samplerate = 0;
  guint64 sample_number;
  guint8 channels, bps;
409
410
  guint8 tmp = 0;
  guint8 actual_crc, expected_crc = 0;
411
412

  /* Skip 14 bit sync code */
413
  gst_bit_reader_skip_unchecked (&reader, 14);
414
415

  /* Must be 0 */
416
  if (gst_bit_reader_get_bits_uint8_unchecked (&reader, 1) != 0)
417
418
419
    goto error;

  /* 0 == fixed block size, 1 == variable block size */
420
  blocking_strategy = gst_bit_reader_get_bits_uint8_unchecked (&reader, 1);
421
422
  if (flacparse->force_variable_block_size)
    blocking_strategy = 1;
423
424

  /* block size index, calculation of the real blocksize below */
425
426
  block_size = gst_bit_reader_get_bits_uint16_unchecked (&reader, 4);
  if (block_size == 0)
427
428
429
    goto error;

  /* sample rate index, calculation of the real samplerate below */
430
431
  samplerate = gst_bit_reader_get_bits_uint16_unchecked (&reader, 4);
  if (samplerate == 0x0f)
432
433
434
    goto error;

  /* channel assignment */
435
436
437
438
439
440
  channels = gst_bit_reader_get_bits_uint8_unchecked (&reader, 4);
  if (channels < 8) {
    channels++;
  } else if (channels <= 10) {
    channels = 2;
  } else if (channels > 10) {
441
442
    goto error;
  }
443
444
  if (flacparse->channels && flacparse->channels != channels)
    goto error;
445
446

  /* bits per sample */
447
448
  bps = gst_bit_reader_get_bits_uint8_unchecked (&reader, 3);
  if (bps == 0x03 || bps == 0x07) {
449
    goto error;
450
  } else if (bps == 0 && flacparse->bps == 0) {
451
452
    goto need_streaminfo;
  }
453
  bps = sample_size_table[bps];
454
455
  if (flacparse->bps && bps != flacparse->bps)
    goto error;
456
457

  /* reserved, must be 0 */
458
  if (gst_bit_reader_get_bits_uint8_unchecked (&reader, 1) != 0)
459
460
461
462
    goto error;

  /* read "utf8" encoded sample/frame number */
  {
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
    gint len = 0;

    len = gst_bit_reader_get_bits_uint8_unchecked (&reader, 8);

    /* This is slightly faster than a loop */
    if (!(len & 0x80)) {
      sample_number = len;
      len = 0;
    } else if ((len & 0xc0) && !(len & 0x20)) {
      sample_number = len & 0x1f;
      len = 1;
    } else if ((len & 0xe0) && !(len & 0x10)) {
      sample_number = len & 0x0f;
      len = 2;
    } else if ((len & 0xf0) && !(len & 0x08)) {
      sample_number = len & 0x07;
      len = 3;
    } else if ((len & 0xf8) && !(len & 0x04)) {
      sample_number = len & 0x03;
      len = 4;
    } else if ((len & 0xfc) && !(len & 0x02)) {
      sample_number = len & 0x01;
      len = 5;
    } else if ((len & 0xfe) && !(len & 0x01)) {
      sample_number = len & 0x0;
      len = 6;
    } else {
490
      goto error;
491
    }
492

493
494
    if ((blocking_strategy == 0 && len > 5) ||
        (blocking_strategy == 1 && len > 6))
495
496
      goto error;

497
498
499
    while (len > 0) {
      if (!gst_bit_reader_get_bits_uint8 (&reader, &tmp, 8))
        goto need_more_data;
500

501
502
      if ((tmp & 0xc0) != 0x80)
        goto error;
503

504
505
506
      sample_number <<= 6;
      sample_number |= (tmp & 0x3f);
      len--;
507
508
509
510
    }
  }

  /* calculate real blocksize from the blocksize index */
511
  if (block_size == 6) {
512
    if (!gst_bit_reader_get_bits_uint16 (&reader, &block_size, 8))
513
      goto need_more_data;
514
515
516
    block_size++;
  } else if (block_size == 7) {
    if (!gst_bit_reader_get_bits_uint16 (&reader, &block_size, 16))
517
      goto need_more_data;
518
    block_size++;
519
520
  } else {
    block_size = blocksize_table[block_size];
521
522
523
524
525
  }

  /* calculate the real samplerate from the samplerate index */
  if (samplerate == 0 && flacparse->samplerate == 0) {
    goto need_streaminfo;
526
527
  } else if (samplerate < 12) {
    samplerate = sample_rate_table[samplerate];
528
  } else if (samplerate == 12) {
529
    if (!gst_bit_reader_get_bits_uint32 (&reader, &samplerate, 8))
530
531
532
      goto need_more_data;
    samplerate *= 1000;
  } else if (samplerate == 13) {
533
    if (!gst_bit_reader_get_bits_uint32 (&reader, &samplerate, 16))
534
535
      goto need_more_data;
  } else if (samplerate == 14) {
536
    if (!gst_bit_reader_get_bits_uint32 (&reader, &samplerate, 16))
537
538
539
540
      goto need_more_data;
    samplerate *= 10;
  }

541
542
543
  if (flacparse->samplerate && flacparse->samplerate != samplerate)
    goto error;

544
545
  /* check crc-8 for the header */
  if (!gst_bit_reader_get_bits_uint8 (&reader, &expected_crc, 8))
546
547
    goto need_more_data;

548
  actual_crc =
549
      gst_flac_calculate_crc8 (data,
550
      (gst_bit_reader_get_pos (&reader) / 8) - 1);
551
552
553
554
  if (actual_crc != expected_crc) {
    GST_DEBUG_OBJECT (flacparse,
        "Checksum mismatch. Header CRC was '%d' but frame has '%d'",
        expected_crc, actual_crc);
555
    goto error;
556
  }
557

558
559
560
  /* Sanity check sample number against blocking strategy, as it seems
     some files claim fixed block size but supply sample numbers,
     rather than block numbers. */
561
562
563
564
565
566
567
568
569
570
  if (blocking_strategy == 0 && flacparse->block_size != 0) {
    if (!flacparse->strategy_checked) {
      if (block_size == sample_number) {
        GST_WARNING_OBJECT (flacparse, "This file claims fixed block size, "
            "but seems to be lying: assuming variable block size");
        flacparse->force_variable_block_size = TRUE;
        blocking_strategy = 1;
      }
      flacparse->strategy_checked = TRUE;
    }
571
572
  }

573
574
575
576
577
578
579
580
581
582
  /* documentation says:
   * The "blocking strategy" bit must be the same throughout the entire stream. */
  if (flacparse->blocking_strategy != blocking_strategy) {
    if (flacparse->block_size != 0) {
      GST_WARNING_OBJECT (flacparse, "blocking strategy is not constant");
      if (suspect)
        *suspect = TRUE;
    }
  }

583
  /*
584
585
586
587
588
589
590
591
592
     The FLAC format documentation says:
     The "blocking strategy" bit determines how to calculate the sample number
     of the first sample in the frame. If the bit is 0 (fixed-blocksize), the
     frame header encodes the frame number as above, and the frame's starting
     sample number will be the frame number times the blocksize. If it is 1
     (variable-blocksize), the frame header encodes the frame's starting
     sample number itself. (In the case of a fixed-blocksize stream, only the
     last block may be shorter than the stream blocksize; its starting sample
     number will be calculated as the frame number times the previous frame's
593
     blocksize, or zero if it is the first frame).
594
595
596
597
598
599
600
601
602
603
604
605
606

     Therefore, when in fixed block size mode, we only update the block size
     the first time, then reuse that block size for subsequent calls.
     This will also fix a timestamp problem with the last block's timestamp
     being miscalculated by scaling the block number by a "wrong" block size.
   */
  if (blocking_strategy == 0) {
    if (flacparse->block_size != 0) {
      /* after first block */
      if (flacparse->block_size != block_size) {
        /* TODO: can we know we're on the last frame, to avoid warning ? */
        GST_WARNING_OBJECT (flacparse, "Block size is not constant");
        block_size = flacparse->block_size;
607
608
        if (suspect)
          *suspect = TRUE;
609
610
611
612
      }
    }
  }

613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
  if (set) {
    flacparse->block_size = block_size;
    if (!flacparse->samplerate)
      flacparse->samplerate = samplerate;
    if (!flacparse->bps)
      flacparse->bps = bps;
    if (!flacparse->blocking_strategy)
      flacparse->blocking_strategy = blocking_strategy;
    if (!flacparse->channels)
      flacparse->channels = channels;
    if (!flacparse->sample_number)
      flacparse->sample_number = sample_number;

    GST_DEBUG_OBJECT (flacparse,
        "Parsed frame at offset %" G_GUINT64_FORMAT ":\n" "Block size: %u\n"
        "Sample/Frame number: %" G_GUINT64_FORMAT, flacparse->offset,
        flacparse->block_size, flacparse->sample_number);
  }
631

632
633
  if (block_size_ret)
    *block_size_ret = block_size;
634

635
  return FRAME_HEADER_VALID;
636

637
need_streaminfo:
638
639
  GST_ERROR_OBJECT (flacparse, "Need STREAMINFO metadata. Bits per sample "
      "or sample rate not in frame header");
640
641
error:
  return FRAME_HEADER_INVALID;
642

643
644
645
need_more_data:
  return FRAME_HEADER_MORE_DATA;
}
646

647
static gboolean
648
gst_flac_parse_frame_is_valid (GstFlacParse * flacparse,
649
    const guint8 * data, gsize size, guint * ret)
650
{
651
  guint max, remaining;
652
653
654
  guint i, search_start, search_end;
  FrameHeaderCheckReturn header_ret;
  guint16 block_size;
655
  gboolean suspect_start = FALSE, suspect_end = FALSE;
656

657
  if (size < flacparse->min_framesize)
658
659
660
    goto need_more;

  header_ret =
661
      gst_flac_parse_frame_header_is_valid (flacparse, data, size, TRUE,
662
      &block_size, &suspect_start);
663
664
  if (header_ret == FRAME_HEADER_INVALID) {
    *ret = 0;
665
    return FALSE;
666
  }
667
668
  if (header_ret == FRAME_HEADER_MORE_DATA)
    goto need_more;
669

670
  /* mind unknown framesize */
671
  search_start = MAX (2, flacparse->min_framesize);
672
  if (flacparse->max_framesize)
673
    search_end = MIN (size, flacparse->max_framesize + 9 + 2);
674
  else
675
    search_end = size;
676
  search_end -= 2;
677

678
  remaining = size;
679

680
  for (i = search_start; i < search_end; i++, remaining--) {
681

682
    if ((GST_READ_UINT16_BE (data + i) & 0xfffe) != 0xfff8)
683
684
685
686
687
      continue;

    GST_LOG_OBJECT (flacparse, "possible frame end at offset %d", i);
    suspect_end = FALSE;
    header_ret =
688
        gst_flac_parse_frame_header_is_valid (flacparse, data + i,
689
690
691
        remaining, FALSE, NULL, &suspect_end);
    if (header_ret == FRAME_HEADER_VALID) {
      if (flacparse->check_frame_checksums || suspect_start || suspect_end) {
692
693
        guint16 actual_crc = gst_flac_calculate_crc16 (data, i - 2);
        guint16 expected_crc = GST_READ_UINT16_BE (data + i - 2);
694
695

        GST_LOG_OBJECT (flacparse,
696
            "Found possible frame (%d, %d). Checking for CRC match",
697
698
            suspect_start, suspect_end);
        if (actual_crc != expected_crc) {
699
700
701
          GST_DEBUG_OBJECT (flacparse,
              "Checksum mismatch. Header CRC was '%d' but frame has '%d'",
              expected_crc, actual_crc);
702
          continue;
703
704
        }
      }
705
706
      *ret = i;
      flacparse->block_size = block_size;
707
      return TRUE;
708
709
    } else if (header_ret == FRAME_HEADER_MORE_DATA) {
      goto need_more;
710
711
712
    }
  }

713
  /* For the last frame output everything to the end */
714
  if (G_UNLIKELY (GST_BASE_PARSE_DRAINING (flacparse))) {
715
    if (flacparse->check_frame_checksums) {
716
717
      guint16 actual_crc = gst_flac_calculate_crc16 (data, size - 2);
      guint16 expected_crc = GST_READ_UINT16_BE (data + size - 2);
718

719
      if (actual_crc == expected_crc) {
720
        *ret = size;
721
        flacparse->block_size = block_size;
722
        return TRUE;
723
724
      }
    } else {
725
      *ret = size;
726
      flacparse->block_size = block_size;
727
      return TRUE;
728
729
730
    }
  }

731
732
733
734
735
736
737
738
739
  /* so we searched to expected end and found nothing,
   * give up on this frame (start) */
  if (flacparse->max_framesize && i > 2 * flacparse->max_framesize) {
    GST_LOG_OBJECT (flacparse,
        "could not determine valid frame end, discarding frame (start)");
    *ret = 1;
    return FALSE;
  }

740
741
742
743
need_more:
  max = flacparse->max_framesize + 16;
  if (max == 16)
    max = 1 << 24;
744
745
  *ret = MIN (size + 4096, max);
  return TRUE;
746
747
}

748
749
750
static GstFlowReturn
gst_flac_parse_handle_frame (GstBaseParse * parse,
    GstBaseParseFrame * frame, gint * skipsize)
751
752
{
  GstFlacParse *flacparse = GST_FLAC_PARSE (parse);
753
  GstBuffer *buffer = frame->buffer;
Wim Taymans's avatar
Wim Taymans committed
754
  GstMapInfo map;
755
  gboolean result = TRUE;
756
  GstFlowReturn ret = GST_FLOW_OK;
757
  guint framesize = 0;
758

Wim Taymans's avatar
Wim Taymans committed
759
  gst_buffer_map (buffer, &map, GST_MAP_READ);
760

761
762
  *skipsize = 1;

Wim Taymans's avatar
Wim Taymans committed
763
  if (G_UNLIKELY (map.size < 4)) {
764
765
766
    result = FALSE;
    goto cleanup;
  }
767

768
  if (flacparse->state == GST_FLAC_PARSE_STATE_INIT) {
Wim Taymans's avatar
Wim Taymans committed
769
    if (memcmp (map.data, "fLaC", 4) == 0) {
770
      GST_DEBUG_OBJECT (flacparse, "fLaC marker found");
771
      framesize = 4;
772
773
      goto cleanup;
    }
Wim Taymans's avatar
Wim Taymans committed
774
    if (map.data[0] == 0xff && (map.data[1] >> 2) == 0x3e) {
775
776
      GST_DEBUG_OBJECT (flacparse, "Found headerless FLAC");
      /* Minimal size of a frame header */
777
      gst_base_parse_set_min_frame_size (GST_BASE_PARSE (flacparse), 9);
778
779
      flacparse->state = GST_FLAC_PARSE_STATE_GENERATE_HEADERS;
      *skipsize = 0;
780
781
      result = FALSE;
      goto cleanup;
782
    }
783
784
785
786
787
788
    GST_DEBUG_OBJECT (flacparse, "fLaC marker not found");
    result = FALSE;
    goto cleanup;
  }

  if (flacparse->state == GST_FLAC_PARSE_STATE_HEADERS) {
Wim Taymans's avatar
Wim Taymans committed
789
    guint size = 4 + ((map.data[1] << 16) | (map.data[2] << 8) | (map.data[3]));
790
791

    GST_DEBUG_OBJECT (flacparse, "Found metadata block of size %u", size);
792
    framesize = size;
793
794
    goto cleanup;
  }
795

Wim Taymans's avatar
Wim Taymans committed
796
  if ((GST_READ_UINT16_BE (map.data) & 0xfffe) == 0xfff8) {
797
798
    gboolean ret;
    guint next;
799

800
801
802
    flacparse->offset = GST_BUFFER_OFFSET (buffer);
    flacparse->blocking_strategy = 0;
    flacparse->sample_number = 0;
803

804
    GST_DEBUG_OBJECT (flacparse, "Found sync code");
805
    ret = gst_flac_parse_frame_is_valid (flacparse, map.data, map.size, &next);
806
    if (ret) {
807
      framesize = next;
808
      goto cleanup;
809
810
811
812
813
814
815
    }
    /* If we're at EOS and the frame was not valid, drop it! */
    if (G_UNLIKELY (GST_BASE_PARSE_DRAINING (flacparse))) {
      GST_WARNING_OBJECT (flacparse, "EOS");
      result = FALSE;
      goto cleanup;
    }
816

817
818
819
820
821
822
823
824
825
826
827
828
    if (next == 0) {
    } else if (next > map.size) {
      GST_DEBUG_OBJECT (flacparse, "Requesting %u bytes", next);
      *skipsize = 0;
      gst_base_parse_set_min_frame_size (parse, next);
      result = FALSE;
      goto cleanup;
    } else {
      GST_ERROR_OBJECT (flacparse,
          "Giving up on invalid frame (%" G_GSIZE_FORMAT " bytes)", map.size);
      result = FALSE;
      goto cleanup;
829
    }
830
831
832
833
  } else {
    GstByteReader reader;
    gint off;

Wim Taymans's avatar
Wim Taymans committed
834
    gst_byte_reader_init (&reader, map.data, map.size);
835
836
    off =
        gst_byte_reader_masked_scan_uint32 (&reader, 0xfffc0000, 0xfff80000,
Wim Taymans's avatar
Wim Taymans committed
837
        0, map.size);
838
839
840
841
842
843
844

    if (off > 0) {
      GST_DEBUG_OBJECT (parse, "Possible sync at buffer offset %d", off);
      *skipsize = off;
      result = FALSE;
      goto cleanup;
    }
845
846
847
848
849

    GST_DEBUG_OBJECT (flacparse, "Sync code not found");
    *skipsize = map.size - 3;
    result = FALSE;
    goto cleanup;
850
851
  }

852
853
854
  result = FALSE;

cleanup:
Wim Taymans's avatar
Wim Taymans committed
855
  gst_buffer_unmap (buffer, &map);
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870

  if (result)
    *skipsize = 0;

  if (result && framesize <= map.size) {
    ret = gst_flac_parse_parse_frame (parse, frame, framesize);
    if (ret == GST_BASE_PARSE_FLOW_DROPPED) {
      frame->flags |= GST_BASE_PARSE_FRAME_FLAG_DROP;
      ret = GST_FLOW_OK;
    }
    if (ret == GST_FLOW_OK)
      ret = gst_base_parse_finish_frame (parse, frame, framesize);
  }

  return ret;
871
872
873
874
875
}

static gboolean
gst_flac_parse_handle_streaminfo (GstFlacParse * flacparse, GstBuffer * buffer)
{
876
  GstBitReader reader;
Wim Taymans's avatar
Wim Taymans committed
877
  GstMapInfo map;
878

Wim Taymans's avatar
Wim Taymans committed
879
880
  gst_buffer_map (buffer, &map, GST_MAP_READ);
  gst_bit_reader_init (&reader, map.data, map.size);
881

Wim Taymans's avatar
Wim Taymans committed
882
  if (map.size != 4 + 34) {
883
    GST_ERROR_OBJECT (flacparse,
Wim Taymans's avatar
Wim Taymans committed
884
        "Invalid metablock size for STREAMINFO: %" G_GSIZE_FORMAT "", map.size);
885
    goto failure;
886
887
888
  }

  /* Skip metadata block header */
889
890
  if (!gst_bit_reader_skip (&reader, 32))
    goto error;
891
892
893
894

  if (!gst_bit_reader_get_bits_uint16 (&reader, &flacparse->min_blocksize, 16))
    goto error;
  if (flacparse->min_blocksize < 16) {
895
    GST_WARNING_OBJECT (flacparse, "Invalid minimum block size: %u",
896
897
898
899
900
901
        flacparse->min_blocksize);
  }

  if (!gst_bit_reader_get_bits_uint16 (&reader, &flacparse->max_blocksize, 16))
    goto error;
  if (flacparse->max_blocksize < 16) {
902
    GST_WARNING_OBJECT (flacparse, "Invalid maximum block size: %u",
903
904
905
906
907
908
909
910
911
912
913
914
        flacparse->max_blocksize);
  }

  if (!gst_bit_reader_get_bits_uint32 (&reader, &flacparse->min_framesize, 24))
    goto error;
  if (!gst_bit_reader_get_bits_uint32 (&reader, &flacparse->max_framesize, 24))
    goto error;

  if (!gst_bit_reader_get_bits_uint32 (&reader, &flacparse->samplerate, 20))
    goto error;
  if (flacparse->samplerate == 0) {
    GST_ERROR_OBJECT (flacparse, "Invalid sample rate 0");
915
    goto failure;
916
917
918
919
920
921
922
923
  }

  if (!gst_bit_reader_get_bits_uint8 (&reader, &flacparse->channels, 3))
    goto error;
  flacparse->channels++;
  if (flacparse->channels > 8) {
    GST_ERROR_OBJECT (flacparse, "Invalid number of channels %u",
        flacparse->channels);
924
    goto failure;
925
926
927
928
929
930
931
932
  }

  if (!gst_bit_reader_get_bits_uint8 (&reader, &flacparse->bps, 5))
    goto error;
  flacparse->bps++;

  if (!gst_bit_reader_get_bits_uint64 (&reader, &flacparse->total_samples, 36))
    goto error;
933
934
935
936
  if (flacparse->total_samples) {
    gst_base_parse_set_duration (GST_BASE_PARSE (flacparse),
        GST_FORMAT_DEFAULT, flacparse->total_samples, 0);
  }
937

Wim Taymans's avatar
Wim Taymans committed
938
  gst_buffer_unmap (buffer, &map);
939

940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
  GST_DEBUG_OBJECT (flacparse, "STREAMINFO:\n"
      "\tmin/max blocksize: %u/%u,\n"
      "\tmin/max framesize: %u/%u,\n"
      "\tsamplerate: %u,\n"
      "\tchannels: %u,\n"
      "\tbits per sample: %u,\n"
      "\ttotal samples: %" G_GUINT64_FORMAT,
      flacparse->min_blocksize, flacparse->max_blocksize,
      flacparse->min_framesize, flacparse->max_framesize,
      flacparse->samplerate,
      flacparse->channels, flacparse->bps, flacparse->total_samples);

  return TRUE;

error:
  GST_ERROR_OBJECT (flacparse, "Failed to read data");
956
failure:
Wim Taymans's avatar
Wim Taymans committed
957
  gst_buffer_unmap (buffer, &map);
958
959
960
961
962
963
964
  return FALSE;
}

static gboolean
gst_flac_parse_handle_vorbiscomment (GstFlacParse * flacparse,
    GstBuffer * buffer)
{
965
  GstTagList *tags;
Wim Taymans's avatar
Wim Taymans committed
966
  GstMapInfo map;
967

Wim Taymans's avatar
Wim Taymans committed
968
  gst_buffer_map (buffer, &map, GST_MAP_READ);
969

970
  tags =
Wim Taymans's avatar
Wim Taymans committed
971
972
      gst_tag_list_from_vorbiscomment (map.data, map.size, map.data, 4, NULL);
  gst_buffer_unmap (buffer, &map);
973

974
  if (tags == NULL) {
975
    GST_ERROR_OBJECT (flacparse, "Invalid vorbiscomment block");
976
977
978
979
980
981
982
  } else if (gst_tag_list_is_empty (tags)) {
    gst_tag_list_unref (tags);
  } else if (flacparse->tags == NULL) {
    flacparse->tags = tags;
  } else {
    gst_tag_list_insert (flacparse->tags, tags, GST_TAG_MERGE_APPEND);
    gst_tag_list_unref (tags);
983
984
985
986
987
  }

  return TRUE;
}

Anton Belka's avatar
Anton Belka committed
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
static gboolean
gst_flac_parse_handle_cuesheet (GstFlacParse * flacparse, GstBuffer * buffer)
{
  GstByteReader reader;
  GstMapInfo map;
  guint i, j;
  guint8 n_tracks, track_num, index;
  guint64 offset;
  gint64 start, stop;
  gchar *id;
  gchar isrc[13];
  GstTagList *tags;
  GstToc *toc;
  GstTocEntry *cur_entry = NULL, *prev_entry = NULL;

  gst_buffer_map (buffer, &map, GST_MAP_READ);
  gst_byte_reader_init (&reader, map.data, map.size);

1006
  toc = gst_toc_new (GST_TOC_SCOPE_GLOBAL);
Anton Belka's avatar
Anton Belka committed
1007
1008

  /* skip 4 bytes METADATA_BLOCK_HEADER */
1009
  /* https://xiph.org/flac/format.html#metadata_block_header */
Anton Belka's avatar
Anton Belka committed
1010
1011
1012
1013
  if (!gst_byte_reader_skip (&reader, 4))
    goto error;

  /* skip 395 bytes from METADATA_BLOCK_CUESHEET */
1014
  /* https://xiph.org/flac/format.html#metadata_block_cuesheet */
Anton Belka's avatar
Anton Belka committed
1015
1016
1017
1018
1019
1020
1021
  if (!gst_byte_reader_skip (&reader, 395))
    goto error;

  if (!gst_byte_reader_get_uint8 (&reader, &n_tracks))
    goto error;

  /* CUESHEET_TRACK */
1022
  /* https://xiph.org/flac/format.html#cuesheet_track */
Anton Belka's avatar
Anton Belka committed
1023
1024
1025
1026
1027
  for (i = 0; i < n_tracks; i++) {
    if (!gst_byte_reader_get_uint64_be (&reader, &offset))
      goto error;
    if (!gst_byte_reader_get_uint8 (&reader, &track_num))
      goto error;
1028
1029

    if (gst_byte_reader_get_remaining (&reader) < 12)
Anton Belka's avatar
Anton Belka committed
1030
1031
      goto error;
    memcpy (isrc, map.data + gst_byte_reader_get_pos (&reader), 12);
1032
1033
1034
1035
1036
    /* \0-terminate the string */
    isrc[12] = '\0';
    if (!gst_byte_reader_skip (&reader, 12))
      goto error;

Anton Belka's avatar
Anton Belka committed
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
    /* skip 14 bytes from CUESHEET_TRACK */
    if (!gst_byte_reader_skip (&reader, 14))
      goto error;
    if (!gst_byte_reader_get_uint8 (&reader, &index))
      goto error;
    /* add tracks in TOC */
    /* lead-out tack has number 170 or 255 */
    if (track_num != 170 && track_num != 255) {
      prev_entry = cur_entry;
      /* previous track stop time = current track start time */
      if (prev_entry != NULL) {
        gst_toc_entry_get_start_stop_times (prev_entry, &start, NULL);
        stop =
            gst_util_uint64_scale_round (offset, GST_SECOND,
            flacparse->samplerate);
        gst_toc_entry_set_start_stop_times (prev_entry, start, stop);
      }
      id = g_strdup_printf ("%08x", track_num);
      cur_entry = gst_toc_entry_new (GST_TOC_ENTRY_TYPE_TRACK, id);
      g_free (id);
      start =
          gst_util_uint64_scale_round (offset, GST_SECOND,
          flacparse->samplerate);
      gst_toc_entry_set_start_stop_times (cur_entry, start, -1);
      /* add ISRC as tag in track */
      if (strlen (isrc) != 0) {
        tags = gst_tag_list_new_empty ();
        gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_ISRC, isrc, NULL);
        gst_toc_entry_set_tags (cur_entry, tags);
      }
      gst_toc_append_entry (toc, cur_entry);
      /* CUESHEET_TRACK_INDEX */
1069
      /* https://xiph.org/flac/format.html#cuesheet_track_index */
Anton Belka's avatar
Anton Belka committed
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
      for (j = 0; j < index; j++) {
        if (!gst_byte_reader_skip (&reader, 12))
          goto error;
      }
    } else {
      /* set stop time in last track */
      stop =
          gst_util_uint64_scale_round (offset, GST_SECOND,
          flacparse->samplerate);
      gst_toc_entry_set_start_stop_times (cur_entry, start, stop);
    }
  }

  /* send data as TOC */
  if (!flacparse->toc)
    flacparse->toc = toc;

  gst_buffer_unmap (buffer, &map);
  return TRUE;

error:
  GST_ERROR_OBJECT (flacparse, "Error reading data");
  gst_buffer_unmap (buffer, &map);
  return FALSE;
}

1096
1097
1098
static gboolean
gst_flac_parse_handle_picture (GstFlacParse * flacparse, GstBuffer * buffer)
{
1099
  GstByteReader reader;
Wim Taymans's avatar
Wim Taymans committed
1100
  GstMapInfo map;
1101
1102
  guint32 img_len = 0, img_type = 0;
  guint32 img_mimetype_len = 0, img_description_len = 0;
1103

Wim Taymans's avatar
Wim Taymans committed
1104
1105
  gst_buffer_map (buffer, &map, GST_MAP_READ);
  gst_byte_reader_init (&reader, map.data, map.size);
1106

1107
1108
1109
  if (!gst_byte_reader_skip (&reader, 4))
    goto error;

1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
  if (!gst_byte_reader_get_uint32_be (&reader, &img_type))
    goto error;

  if (!gst_byte_reader_get_uint32_be (&reader, &img_mimetype_len))
    goto error;
  if (!gst_byte_reader_skip (&reader, img_mimetype_len))
    goto error;

  if (!gst_byte_reader_get_uint32_be (&reader, &img_description_len))
    goto error;
  if (!gst_byte_reader_skip (&reader, img_description_len))
    goto error;

  if (!gst_byte_reader_skip (&reader, 4 * 4))
    goto error;

  if (!gst_byte_reader_get_uint32_be (&reader, &img_len))
    goto error;

1129
1130
1131
  if (gst_byte_reader_get_pos (&reader) + img_len > map.size)
    goto error;

1132
  GST_INFO_OBJECT (flacparse, "Got image of %d bytes", img_len);
1133
1134

  if (img_len > 0) {
1135
1136
1137
    if (flacparse->tags == NULL)
      flacparse->tags = gst_tag_list_new_empty ();

1138
1139
1140
    gst_tag_list_add_id3_image (flacparse->tags,
        map.data + gst_byte_reader_get_pos (&reader), img_len, img_type);
  }
1141

Wim Taymans's avatar
Wim Taymans committed
1142
  gst_buffer_unmap (buffer, &map);
1143
1144
1145
1146
  return TRUE;

error:
  GST_ERROR_OBJECT (flacparse, "Error reading data");
Wim Taymans's avatar
Wim Taymans committed
1147
  gst_buffer_unmap (buffer, &map);
1148
1149
1150
  return FALSE;
}

Mark Nauwelaerts's avatar
Mark Nauwelaerts committed
1151
1152
1153
1154
1155
1156
1157
static gboolean
gst_flac_parse_handle_seektable (GstFlacParse * flacparse, GstBuffer * buffer)
{

  GST_DEBUG_OBJECT (flacparse, "storing seektable");
  /* only store for now;
   * offset of the first frame is needed to get real info */
1158
1159
  if (flacparse->seektable)
    gst_buffer_unref (flacparse->seektable);
Mark Nauwelaerts's avatar
Mark Nauwelaerts committed
1160
1161
1162
1163
1164
1165
1166
1167
1168
  flacparse->seektable = gst_buffer_ref (buffer);

  return TRUE;
}

static void
gst_flac_parse_process_seektable (GstFlacParse * flacparse, gint64 boffset)
{
  GstByteReader br;
1169
  gint64 offset = 0, samples = 0;
Wim Taymans's avatar
Wim Taymans committed
1170
  GstMapInfo map;
Mark Nauwelaerts's avatar
Mark Nauwelaerts committed
1171
1172
1173
1174
1175

  GST_DEBUG_OBJECT (flacparse,
      "parsing seektable; base offset %" G_GINT64_FORMAT, boffset);

  if (boffset <= 0)
1176
    goto exit;
Mark Nauwelaerts's avatar
Mark Nauwelaerts committed
1177

Wim Taymans's avatar
Wim Taymans committed
1178
1179
  gst_buffer_map (flacparse->seektable, &map, GST_MAP_READ);
  gst_byte_reader_init (&br, map.data, map.size);
1180

Mark Nauwelaerts's avatar
Mark Nauwelaerts committed
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
  /* skip header */
  if (!gst_byte_reader_skip (&br, 4))
    goto done;

  /* seekpoints */
  while (gst_byte_reader_get_remaining (&br)) {
    if (!gst_byte_reader_get_int64_be (&br, &samples))
      break;
    if (!gst_byte_reader_get_int64_be (&br, &offset))
      break;
    if (!gst_byte_reader_skip (&br, 2))
      break;

    GST_LOG_OBJECT (flacparse, "samples %" G_GINT64_FORMAT " -> offset %"
        G_GINT64_FORMAT, samples, offset);

    /* sanity check */
    if (G_LIKELY