id3v2mux.c 15 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/* GStreamer
 *
 * unit test for the taglib-based id3v2mux element
 *
 * Copyright (C) 2006 Tim-Philipp Müller  <tim centricular net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <gst/check/gstcheck.h>

#include <gst/gst.h>
#include <string.h>

#define TEST_ARTIST           "Ar T\303\255st"
#define TEST_TITLE            "M\303\274llermilch!"
#define TEST_ALBUM            "Boom"
#define TEST_DATE             g_date_new_dmy(1,1,2006)
#define TEST_TRACK_NUMBER     7
#define TEST_TRACK_COUNT      19
#define TEST_VOLUME_NUMBER    2
#define TEST_VOLUME_COUNT     3
36
37
38
39
#define TEST_TRACK_GAIN      1.45
#define TEST_ALBUM_GAIN      0.78
#define TEST_TRACK_PEAK      0.83
#define TEST_ALBUM_PEAK      0.18
40
#define TEST_BPM             113.0
41
42
43
44
45
46
47
48
49

/* for dummy mp3 frame sized MP3_FRAME_SIZE bytes,
 * start: ff fb b0 44 00 00 08 00  00 4b 00 00 00 00 00 00 */
static const guint8 mp3_dummyhdr[] = { 0xff, 0xfb, 0xb0, 0x44, 0x00, 0x00,
  0x08, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00
};

#define MP3_FRAME_SIZE 626

50
51
52
53
54
55
56
57
58
59
60
61
/* the peak and gain values are stored pretty roughly, so check that they're
 * within 2% of the expected value.
 */
#define fail_unless_sorta_equals_float(a, b)				\
G_STMT_START {								\
  double first = a;							\
  double second = b;							\
  fail_unless(fabs (first - second) < (0.02 * fabs (first)),		\
      "'" #a "' (%g) is not equal to '" #b "' (%g)", first, second);	\
} G_STMT_END;


62
63
64
65
66
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
static GstTagList *
test_taglib_id3mux_create_tags (guint32 mask)
{
  GstTagList *tags;

  tags = gst_tag_list_new ();

  if (mask & (1 << 0)) {
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_ARTIST, TEST_ARTIST, NULL);
  }
  if (mask & (1 << 1)) {
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_TITLE, TEST_TITLE, NULL);
  }
  if (mask & (1 << 2)) {
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_ALBUM, TEST_ALBUM, NULL);
  }
  if (mask & (1 << 3)) {
    GDate *date;

    date = TEST_DATE;
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP, GST_TAG_DATE, date, NULL);
    g_date_free (date);
  }
  if (mask & (1 << 4)) {
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_TRACK_NUMBER, TEST_TRACK_NUMBER, NULL);
  }
  if (mask & (1 << 5)) {
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_TRACK_COUNT, TEST_TRACK_COUNT, NULL);
  }
  if (mask & (1 << 6)) {
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_ALBUM_VOLUME_NUMBER, TEST_VOLUME_NUMBER, NULL);
  }
  if (mask & (1 << 7)) {
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_ALBUM_VOLUME_COUNT, TEST_VOLUME_COUNT, NULL);
  }
  if (mask & (1 << 8)) {
105
106
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_TRACK_GAIN, TEST_TRACK_GAIN, NULL);
107
108
  }
  if (mask & (1 << 9)) {
109
110
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_ALBUM_GAIN, TEST_ALBUM_GAIN, NULL);
111
112
  }
  if (mask & (1 << 10)) {
113
114
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_TRACK_PEAK, TEST_TRACK_PEAK, NULL);
115
116
  }
  if (mask & (1 << 11)) {
117
118
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_ALBUM_PEAK, TEST_ALBUM_PEAK, NULL);
119
120
  }
  if (mask & (1 << 12)) {
121
122
    gst_tag_list_add (tags, GST_TAG_MERGE_KEEP,
        GST_TAG_BEATS_PER_MINUTE, TEST_BPM, NULL);
123
124
125
126
127
128
  }
  if (mask & (1 << 13)) {
  }
  return tags;
}

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
static gboolean
utf8_string_in_buf (GstBuffer * buf, const gchar * s)
{
  gint i, len;

  len = strlen (s);
  for (i = 0; i < (GST_BUFFER_SIZE (buf) - len); ++i) {
    if (memcmp (GST_BUFFER_DATA (buf) + i, s, len) == 0) {
      return TRUE;
    }
  }

  return FALSE;
}

static void
test_taglib_id3mux_check_tag_buffer (GstBuffer * buf, guint32 mask)
{
  /* make sure our UTF-8 string hasn't been put into the tag as ISO-8859-1 */
  if (mask & (1 << 0)) {
    fail_unless (utf8_string_in_buf (buf, TEST_ARTIST));
  }
  /* make sure our UTF-8 string hasn't been put into the tag as ISO-8859-1 */
  if (mask & (1 << 1)) {
    fail_unless (utf8_string_in_buf (buf, TEST_TITLE));
  }
  /* make sure our UTF-8 string hasn't been put into the tag as ISO-8859-1 */
  if (mask & (1 << 2)) {
    fail_unless (utf8_string_in_buf (buf, TEST_ALBUM));
  }
}

161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
static void
test_taglib_id3mux_check_tags (GstTagList * tags, guint32 mask)
{
  if (mask & (1 << 0)) {
    gchar *s = NULL;

    fail_unless (gst_tag_list_get_string (tags, GST_TAG_ARTIST, &s));
    fail_unless (g_str_equal (s, TEST_ARTIST));
    g_free (s);
  }
  if (mask & (1 << 1)) {
    gchar *s = NULL;

    fail_unless (gst_tag_list_get_string (tags, GST_TAG_TITLE, &s));
    fail_unless (g_str_equal (s, TEST_TITLE));
    g_free (s);
  }
  if (mask & (1 << 2)) {
    gchar *s = NULL;

    fail_unless (gst_tag_list_get_string (tags, GST_TAG_ALBUM, &s));
    fail_unless (g_str_equal (s, TEST_ALBUM));
    g_free (s);
  }
  if (mask & (1 << 3)) {
    GDate *shouldbe, *date = NULL;

    shouldbe = TEST_DATE;
    fail_unless (gst_tag_list_get_date (tags, GST_TAG_DATE, &date));
    fail_unless (g_date_compare (shouldbe, date) == 0);
    g_date_free (shouldbe);
    g_date_free (date);
  }
  if (mask & (1 << 4)) {
195
196
197
198
    guint num;

    fail_unless (gst_tag_list_get_uint (tags, GST_TAG_TRACK_NUMBER, &num));
    fail_unless (num == TEST_TRACK_NUMBER);
199
200
  }
  if (mask & (1 << 5)) {
201
202
203
204
    guint count;

    fail_unless (gst_tag_list_get_uint (tags, GST_TAG_TRACK_COUNT, &count));
    fail_unless (count == TEST_TRACK_COUNT);
205
206
  }
  if (mask & (1 << 6)) {
207
208
209
210
211
    guint num;

    fail_unless (gst_tag_list_get_uint (tags, GST_TAG_ALBUM_VOLUME_NUMBER,
            &num));
    fail_unless (num == TEST_VOLUME_NUMBER);
212
213
  }
  if (mask & (1 << 7)) {
214
215
216
217
218
    guint count;

    fail_unless (gst_tag_list_get_uint (tags, GST_TAG_ALBUM_VOLUME_COUNT,
            &count));
    fail_unless (count == TEST_VOLUME_COUNT);
219
220
  }
  if (mask & (1 << 8)) {
221
222
223
    gdouble gain;

    fail_unless (gst_tag_list_get_double (tags, GST_TAG_TRACK_GAIN, &gain));
224
    fail_unless_sorta_equals_float (gain, TEST_TRACK_GAIN);
225
226
  }
  if (mask & (1 << 9)) {
227
228
229
    gdouble gain;

    fail_unless (gst_tag_list_get_double (tags, GST_TAG_ALBUM_GAIN, &gain));
230
    fail_unless_sorta_equals_float (gain, TEST_ALBUM_GAIN);
231
232
  }
  if (mask & (1 << 10)) {
233
234
235
236
    gdouble peak;

    fail_unless (gst_tag_list_get_double (tags, GST_TAG_TRACK_PEAK, &peak));
    fail_unless_sorta_equals_float (peak, TEST_TRACK_PEAK);
237
238
  }
  if (mask & (1 << 11)) {
239
240
241
242
    gdouble peak;

    fail_unless (gst_tag_list_get_double (tags, GST_TAG_ALBUM_PEAK, &peak));
    fail_unless_sorta_equals_float (peak, TEST_ALBUM_PEAK);
243
244
  }
  if (mask & (1 << 12)) {
245
246
247
248
249
    gdouble bpm;

    fail_unless (gst_tag_list_get_double (tags, GST_TAG_BEATS_PER_MINUTE,
            &bpm));
    fail_unless_sorta_equals_float (bpm, TEST_BPM);
250
251
252
253
254
255
256
257
258
  }
  if (mask & (1 << 13)) {
  }
}

static void
fill_mp3_buffer (GstElement * fakesrc, GstBuffer * buf, GstPad * pad,
    guint64 * p_offset)
{
259
  fail_unless (GST_BUFFER_SIZE (buf) == MP3_FRAME_SIZE);
260
261
262
263
264

  GST_LOG ("filling buffer with fake mp3 data, offset = %" G_GUINT64_FORMAT,
      *p_offset);

  memcpy (GST_BUFFER_DATA (buf), mp3_dummyhdr, sizeof (mp3_dummyhdr));
265
266
267
268
269
270

  /* can't use gst_buffer_set_caps() here because the metadata isn't writable
   * because of the extra refcounts taken by the signal emission mechanism;
   * we know it's fine to use GST_BUFFER_CAPS() here though */
  GST_BUFFER_CAPS (buf) = gst_caps_new_simple ("audio/mpeg", "mpegversion",
      G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
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
299
300
301
302
303
304
305
306

  GST_BUFFER_OFFSET (buf) = *p_offset;
  *p_offset += GST_BUFFER_SIZE (buf);
}

static void
got_buffer (GstElement * fakesink, GstBuffer * buf, GstPad * pad,
    GstBuffer ** p_buf)
{
  gint64 off;
  guint size;

  off = GST_BUFFER_OFFSET (buf);
  size = GST_BUFFER_SIZE (buf);

  GST_LOG ("got buffer, size=%u, offset=%" G_GINT64_FORMAT, size, off);

  fail_unless (GST_BUFFER_OFFSET_IS_VALID (buf));

  if (*p_buf == NULL || (off + size) > GST_BUFFER_SIZE (*p_buf)) {
    GstBuffer *newbuf;

    /* not very elegant, but who cares */
    newbuf = gst_buffer_new_and_alloc (off + size);
    if (*p_buf) {
      memcpy (GST_BUFFER_DATA (newbuf), GST_BUFFER_DATA (*p_buf),
          GST_BUFFER_SIZE (*p_buf));
    }
    memcpy (GST_BUFFER_DATA (newbuf) + off, GST_BUFFER_DATA (buf), size);
    if (*p_buf)
      gst_buffer_unref (*p_buf);
    *p_buf = newbuf;
  } else {
    memcpy (GST_BUFFER_DATA (*p_buf) + off, GST_BUFFER_DATA (buf), size);
  }
}
307

308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
static void
demux_pad_added (GstElement * id3demux, GstPad * srcpad, GstBuffer ** p_outbuf)
{
  GstElement *fakesink, *pipeline;

  GST_LOG ("id3demux added source pad with caps %" GST_PTR_FORMAT,
      GST_PAD_CAPS (srcpad));

  pipeline = id3demux;
  while (GST_OBJECT_PARENT (pipeline) != NULL)
    pipeline = (GstElement *) GST_OBJECT_PARENT (pipeline);

  fakesink = gst_element_factory_make ("fakesink", "fakesink");
  g_assert (fakesink != NULL);

  /* set up sink */
  g_object_set (fakesink, "signal-handoffs", TRUE, NULL);
  g_signal_connect (fakesink, "handoff", G_CALLBACK (got_buffer), p_outbuf);

  gst_bin_add (GST_BIN (pipeline), fakesink);
  gst_element_set_state (fakesink, GST_STATE_PLAYING);

  fail_unless (gst_element_link (id3demux, fakesink));
}

static void
test_taglib_id3mux_check_output_buffer (GstBuffer * buf)
{
  guint8 *data = GST_BUFFER_DATA (buf);
  guint size = GST_BUFFER_SIZE (buf);
  guint off;

  g_assert (size % MP3_FRAME_SIZE == 0);

  for (off = 0; off < size; off += MP3_FRAME_SIZE) {
    fail_unless (memcmp (data + off, mp3_dummyhdr, sizeof (mp3_dummyhdr)) == 0);
  }
}

347
348
349
350
351
352
353
354
static void
identity_cb (GstElement * identity, GstBuffer * buf, GstBuffer ** p_tagbuf)
{
  if (*p_tagbuf == NULL) {
    *p_tagbuf = gst_buffer_ref (buf);
  }
}

355
356
357
358
359
static void
test_taglib_id3mux_with_tags (GstTagList * tags, guint32 mask)
{
  GstMessage *msg;
  GstTagList *tags_read = NULL;
360
  GstElement *pipeline, *id3mux, *id3demux, *fakesrc, *identity;
361
362
363
  GstBus *bus;
  guint64 offset;
  GstBuffer *outbuf = NULL;
364
  GstBuffer *tagbuf = NULL;
365
  GstStateChangeReturn state_result;
366
367
368
369
370
371
372

  pipeline = gst_pipeline_new ("pipeline");
  g_assert (pipeline != NULL);

  fakesrc = gst_element_factory_make ("fakesrc", "fakesrc");
  g_assert (fakesrc != NULL);

Thomas Vander Stichele's avatar
Thomas Vander Stichele committed
373
  id3mux = gst_element_factory_make ("id3v2mux", "id3v2mux");
374
375
  g_assert (id3mux != NULL);

376
377
378
  identity = gst_element_factory_make ("identity", "identity");
  g_assert (identity != NULL);

379
380
381
382
383
384
385
386
387
  id3demux = gst_element_factory_make ("id3demux", "id3demux");
  g_assert (id3demux != NULL);

  outbuf = NULL;
  g_signal_connect (id3demux, "pad-added",
      G_CALLBACK (demux_pad_added), &outbuf);

  gst_bin_add (GST_BIN (pipeline), fakesrc);
  gst_bin_add (GST_BIN (pipeline), id3mux);
388
  gst_bin_add (GST_BIN (pipeline), identity);
389
390
391
392
393
  gst_bin_add (GST_BIN (pipeline), id3demux);

  gst_tag_setter_merge_tags (GST_TAG_SETTER (id3mux), tags,
      GST_TAG_MERGE_APPEND);

394
  gst_element_link_many (fakesrc, id3mux, identity, id3demux, NULL);
395
396
397
398

  /* set up source */
  g_object_set (fakesrc, "signal-handoffs", TRUE, "can-activate-pull", FALSE,
      "filltype", 2, "sizetype", 2, "sizemax", MP3_FRAME_SIZE,
399
      "num-buffers", 16, NULL);
400
401
402
403

  offset = 0;
  g_signal_connect (fakesrc, "handoff", G_CALLBACK (fill_mp3_buffer), &offset);

404
405
406
  /* set up identity to catch tag buffer */
  g_signal_connect (identity, "handoff", G_CALLBACK (identity_cb), &tagbuf);

Wim Taymans's avatar
Wim Taymans committed
407
  GST_LOG ("setting and getting state ...");
408
  gst_element_set_state (pipeline, GST_STATE_PLAYING);
409
410
411
412
  state_result = gst_element_get_state (pipeline, NULL, NULL, -1);
  fail_unless (state_result == GST_STATE_CHANGE_SUCCESS,
      "Unexpected result from get_state(). Expected success, got %d",
      state_result);
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440

  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

  GST_LOG ("Waiting for tag ...");
  msg =
      gst_bus_poll (bus, GST_MESSAGE_TAG | GST_MESSAGE_EOS | GST_MESSAGE_ERROR,
      -1);
  if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR) {
    GError *err;
    gchar *dbg;

    gst_message_parse_error (msg, &err, &dbg);
    g_printerr ("ERROR from element %s: %s\n%s\n",
        GST_OBJECT_NAME (msg->src), err->message, GST_STR_NULL (dbg));
    g_error_free (err);
    g_free (dbg);
  } else if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_EOS) {
    g_printerr ("EOS message, but were waiting for TAGS!\n");
  }
  fail_unless (msg->type == GST_MESSAGE_TAG);

  gst_message_parse_tag (msg, &tags_read);
  gst_message_unref (msg);

  GST_LOG ("Got tags: %" GST_PTR_FORMAT, tags_read);
  test_taglib_id3mux_check_tags (tags_read, mask);
  gst_tag_list_free (tags_read);

441
442
443
444
  fail_unless (tagbuf != NULL);
  test_taglib_id3mux_check_tag_buffer (tagbuf, mask);
  gst_buffer_unref (tagbuf);

445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
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
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
  GST_LOG ("Waiting for EOS ...");
  msg = gst_bus_poll (bus, GST_MESSAGE_EOS | GST_MESSAGE_ERROR, -1);
  if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR) {
    GError *err;
    gchar *dbg;

    gst_message_parse_error (msg, &err, &dbg);
    g_printerr ("ERROR from element %s: %s\n%s\n",
        GST_OBJECT_NAME (msg->src), err->message, GST_STR_NULL (dbg));
    g_error_free (err);
    g_free (dbg);
  }
  fail_unless (msg->type == GST_MESSAGE_EOS);
  gst_message_unref (msg);

  gst_object_unref (bus);

  GST_LOG ("Got EOS, shutting down ...");
  gst_element_set_state (pipeline, GST_STATE_NULL);
  gst_object_unref (pipeline);

  test_taglib_id3mux_check_output_buffer (outbuf);
  gst_buffer_unref (outbuf);

  GST_LOG ("Done");
}

GST_START_TEST (test_id3v2mux)
{
  GstTagList *tags;
  gint i;

  g_random_set_seed (247166295);

  /* internal consistency check */
  tags = test_taglib_id3mux_create_tags (0xFFFFFFFF);
  test_taglib_id3mux_check_tags (tags, 0xFFFFFFFF);
  gst_tag_list_free (tags);

  /* now the real tests */
  for (i = 0; i < 50; ++i) {
    guint32 mask;

    mask = g_random_int ();
    GST_LOG ("tag mask = %08x (i=%d)", mask, i);

    if (mask == 0)
      continue;

    /* create tags */
    tags = test_taglib_id3mux_create_tags (mask);
    GST_LOG ("tags for mask %08x = %" GST_PTR_FORMAT, mask, tags);

    /* double-check for internal consistency */
    test_taglib_id3mux_check_tags (tags, mask);

    /* test with pipeline */
    test_taglib_id3mux_with_tags (tags, mask);

    /* free tags */
    gst_tag_list_free (tags);
  }
}

GST_END_TEST;

static Suite *
512
id3v2mux_suite (void)
513
{
514
  Suite *s = suite_create ("id3v2mux");
515
516
517
518
519
520
521
522
523
524
525
526
527
  TCase *tc_chain = tcase_create ("general");

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_id3v2mux);

  return s;
}

int
main (int argc, char **argv)
{
  int nf;

528
  Suite *s = id3v2mux_suite ();
529
530
531
532
533
534
535
536
537
538
  SRunner *sr = srunner_create (s);

  gst_check_init (&argc, &argv);

  srunner_run_all (sr, CK_NORMAL);
  nf = srunner_ntests_failed (sr);
  srunner_free (sr);

  return nf;
}