tests/check/libs/audio.c

   1 /* GStreamer
   2  *
   3  * unit tests for audio support library
   4  *
   5  * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <gst/check/gstcheck.h>
  28
  29 #include <gst/audio/audio.h>
  30 #include <gst/audio/multichannel.h>
  31 #include <string.h>
  32
  33 static gboolean
  34 structure_contains_channel_positions (const GstStructure * s)
  35 {
  36   return (gst_structure_get_value (s, "channel-positions") != NULL);
  37 }
  38
  39 #if 0
  40 static gboolean
  41 fixed_caps_have_channel_positions (const GstCaps * caps)
  42 {
  43   GstStructure *s;
  44
  45   fail_unless (caps != NULL);
  46
  47   s = gst_caps_get_structure (caps, 0);
  48   fail_unless (s != NULL);
  49
  50   return structure_contains_channel_positions (s);
  51 }
  52 #endif
  53
  54 GST_START_TEST (test_multichannel_checks)
  55 {
  56   GstAudioChannelPosition pos_2_mixed[2] = {
  57     GST_AUDIO_CHANNEL_POSITION_FRONT_MONO,
  58     GST_AUDIO_CHANNEL_POSITION_NONE
  59   };
  60   GstAudioChannelPosition pos_2_none[2] = {
  61     GST_AUDIO_CHANNEL_POSITION_NONE,
  62     GST_AUDIO_CHANNEL_POSITION_NONE
  63   };
  64   GstAudioChannelPosition pos_2_flr[2] = {
  65     GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  66     GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT
  67   };
  68   GstAudioChannelPosition pos_2_frr[2] = {
  69     GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  70     GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT
  71   };
  72   GstStructure *s;
  73
  74   s = gst_structure_new ("audio/x-raw-int", "channels", G_TYPE_INT, 2, NULL);
  75
  76   /* check if the audio channel position checks work */
  77   fail_if (gst_audio_check_channel_positions (pos_2_mixed, 2));
  78   fail_unless (gst_audio_check_channel_positions (pos_2_none, 2));
  79   fail_unless (gst_audio_check_channel_positions (pos_2_flr, 2));
  80   fail_if (gst_audio_check_channel_positions (pos_2_frr, 2));
  81
  82   /* this should not work and issue a warning: FRONT_MONO + NONE */
  83   _gst_check_expecting_log = TRUE;
  84   gst_audio_set_channel_positions (s, pos_2_mixed);
  85   _gst_check_expecting_log = FALSE;
  86   fail_if (structure_contains_channel_positions (s));
  87
  88   /* this should work: NONE + NONE */
  89   gst_audio_set_channel_positions (s, pos_2_none);
  90   fail_unless (structure_contains_channel_positions (s));
  91   gst_structure_remove_field (s, "channel-positions");
  92
  93   /* this should also work: FRONT_LEFT + FRONT_RIGHT */
  94   gst_audio_set_channel_positions (s, pos_2_flr);
  95   fail_unless (structure_contains_channel_positions (s));
  96   gst_structure_remove_field (s, "channel-positions");
  97
  98   /* this should not work and issue a warning: FRONT_RIGHT twice */
  99   _gst_check_expecting_log = TRUE;
 100   gst_audio_set_channel_positions (s, pos_2_frr);
 101   _gst_check_expecting_log = FALSE;
 102
 103 /* FIXME: did I misunderstand _set_structure_channel_positions_list? */
 104 #if  0
 105   /* this should not work and issue a warning: FRONT_RIGHT twice */
 106   _gst_check_expecting_log = TRUE;
 107   gst_audio_set_structure_channel_positions_list (s, pos_2_frr, 2);
 108   _gst_check_expecting_log = FALSE;
 109
 110   /* this should not work and issue a warning: FRONT_MONO + NONE */
 111   _gst_check_expecting_log = TRUE;
 112   gst_audio_set_structure_channel_positions_list (s, pos_2_mixed, 2);
 113   _gst_check_expecting_log = FALSE;
 114
 115   /* this should not work either (channel count mismatch) */
 116   _gst_check_expecting_log = TRUE;
 117   gst_audio_set_structure_channel_positions_list (s, pos_2_none, 44);
 118   _gst_check_expecting_log = FALSE;
 119   fail_if (structure_contains_channel_positions (s));
 120 #endif
 121
 122   gst_structure_free (s);
 123 }
 124
 125 GST_END_TEST;
 126
 127 GST_START_TEST (test_buffer_clipping_time)
 128 {
 129   GstSegment s;
 130
 131   GstBuffer *buf;
 132
 133   GstBuffer *ret;
 134
 135   guint8 *data;
 136
 137   /* Clip start and end */
 138   buf = gst_buffer_new ();
 139   data = (guint8 *) g_malloc (1000);
 140   GST_BUFFER_SIZE (buf) = 1000;
 141   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 142
 143   gst_segment_init (&s, GST_FORMAT_TIME);
 144   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 4 * GST_SECOND,
 145       8 * GST_SECOND, 4 * GST_SECOND);
 146
 147   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 148   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 149   GST_BUFFER_OFFSET (buf) = 200;
 150   GST_BUFFER_OFFSET_END (buf) = 1200;
 151
 152   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 153   fail_unless (ret != NULL);
 154
 155   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);
 156   fail_unless (GST_BUFFER_DURATION (ret) == 4 * GST_SECOND);
 157   fail_unless (GST_BUFFER_OFFSET (ret) == 400);
 158   fail_unless (GST_BUFFER_OFFSET_END (ret) == 800);
 159   fail_unless (GST_BUFFER_DATA (ret) == data + 200);
 160   fail_unless (GST_BUFFER_SIZE (ret) == 400);
 161
 162   gst_buffer_unref (ret);
 163
 164   /* Clip only start */
 165   buf = gst_buffer_new ();
 166   data = (guint8 *) g_malloc (1000);
 167   GST_BUFFER_SIZE (buf) = 1000;
 168   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 169
 170   gst_segment_init (&s, GST_FORMAT_TIME);
 171   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 4 * GST_SECOND,
 172       12 * GST_SECOND, 4 * GST_SECOND);
 173
 174   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 175   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 176   GST_BUFFER_OFFSET (buf) = 200;
 177   GST_BUFFER_OFFSET_END (buf) = 1200;
 178
 179   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 180   fail_unless (ret != NULL);
 181
 182   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);
 183   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);
 184   fail_unless (GST_BUFFER_OFFSET (ret) == 400);
 185   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1200);
 186   fail_unless (GST_BUFFER_DATA (ret) == data + 200);
 187   fail_unless (GST_BUFFER_SIZE (ret) == 800);
 188
 189   gst_buffer_unref (ret);
 190
 191   /* Clip only stop */
 192   buf = gst_buffer_new ();
 193   data = (guint8 *) g_malloc (1000);
 194   GST_BUFFER_SIZE (buf) = 1000;
 195   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 196
 197   gst_segment_init (&s, GST_FORMAT_TIME);
 198   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 2 * GST_SECOND,
 199       10 * GST_SECOND, 2 * GST_SECOND);
 200
 201   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 202   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 203   GST_BUFFER_OFFSET (buf) = 200;
 204   GST_BUFFER_OFFSET_END (buf) = 1200;
 205
 206   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 207   fail_unless (ret != NULL);
 208
 209   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 2 * GST_SECOND);
 210   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);
 211   fail_unless (GST_BUFFER_OFFSET (ret) == 200);
 212   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1000);
 213   fail_unless (GST_BUFFER_DATA (ret) == data);
 214   fail_unless (GST_BUFFER_SIZE (ret) == 800);
 215
 216   gst_buffer_unref (ret);
 217
 218   /* Buffer outside segment */
 219   buf = gst_buffer_new ();
 220   data = (guint8 *) g_malloc (1000);
 221   GST_BUFFER_SIZE (buf) = 1000;
 222   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 223
 224   gst_segment_init (&s, GST_FORMAT_TIME);
 225   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 12 * GST_SECOND,
 226       20 * GST_SECOND, 12 * GST_SECOND);
 227
 228   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 229   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 230   GST_BUFFER_OFFSET (buf) = 200;
 231   GST_BUFFER_OFFSET_END (buf) = 1200;
 232
 233   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 234   fail_unless (ret == NULL);
 235
 236   /* Clip start and end but don't touch duration and offset_end */
 237   buf = gst_buffer_new ();
 238   data = (guint8 *) g_malloc (1000);
 239   GST_BUFFER_SIZE (buf) = 1000;
 240   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 241
 242   gst_segment_init (&s, GST_FORMAT_TIME);
 243   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 4 * GST_SECOND,
 244       8 * GST_SECOND, 4 * GST_SECOND);
 245
 246   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 247   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
 248   GST_BUFFER_OFFSET (buf) = 200;
 249   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
 250
 251   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 252   fail_unless (ret != NULL);
 253
 254   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);
 255   fail_unless (GST_BUFFER_DURATION (ret) == GST_CLOCK_TIME_NONE);
 256   fail_unless (GST_BUFFER_OFFSET (ret) == 400);
 257   fail_unless (GST_BUFFER_OFFSET_END (ret) == GST_BUFFER_OFFSET_NONE);
 258   fail_unless (GST_BUFFER_DATA (ret) == data + 200);
 259   fail_unless (GST_BUFFER_SIZE (ret) == 400);
 260
 261   gst_buffer_unref (ret);
 262
 263   /* If the buffer has no timestamp it should assert()
 264    * FIXME: check if return value is the same as the input buffer.
 265    *        probably can't be done because the assert() does a SIGABRT.
 266    */
 267   buf = gst_buffer_new ();
 268   data = (guint8 *) g_malloc (1000);
 269   GST_BUFFER_SIZE (buf) = 1000;
 270   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 271
 272   gst_segment_init (&s, GST_FORMAT_TIME);
 273   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 0 * GST_SECOND,
 274       10 * GST_SECOND, 0 * GST_SECOND);
 275
 276   GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
 277   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
 278   GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
 279   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
 280
 281   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 282   fail_unless (ret == buf);
 283
 284   gst_buffer_unref (buf);
 285
 286   /* If the format is not TIME or DEFAULT it should assert()
 287    * FIXME: check if return value is the same as the input buffer.
 288    *        probably can't be done because the assert() does a SIGABRT.
 289    */
 290   buf = gst_buffer_new ();
 291   data = (guint8 *) g_malloc (1000);
 292   GST_BUFFER_SIZE (buf) = 1000;
 293   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 294
 295   gst_segment_init (&s, GST_FORMAT_PERCENT);
 296   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_PERCENT, 0, 10, 0);
 297
 298   GST_BUFFER_TIMESTAMP (buf) = 0 * GST_SECOND;
 299   GST_BUFFER_DURATION (buf) = 0;
 300   GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
 301   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
 302
 303   ASSERT_CRITICAL (ret = gst_audio_buffer_clip (buf, &s, 100, 1));
 304
 305   gst_buffer_unref (buf);
 306
 307 }
 308
 309 GST_END_TEST;
 310
 311 GST_START_TEST (test_buffer_clipping_samples)
 312 {
 313   GstSegment s;
 314
 315   GstBuffer *buf;
 316
 317   GstBuffer *ret;
 318
 319   guint8 *data;
 320
 321   /* Clip start and end */
 322   buf = gst_buffer_new ();
 323   data = (guint8 *) g_malloc (1000);
 324   GST_BUFFER_SIZE (buf) = 1000;
 325   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 326
 327   gst_segment_init (&s, GST_FORMAT_DEFAULT);
 328   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 400,
 329       800, 400);
 330
 331   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 332   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 333   GST_BUFFER_OFFSET (buf) = 200;
 334   GST_BUFFER_OFFSET_END (buf) = 1200;
 335
 336   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 337   fail_unless (ret != NULL);
 338
 339   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);
 340   fail_unless (GST_BUFFER_DURATION (ret) == 4 * GST_SECOND);
 341   fail_unless (GST_BUFFER_OFFSET (ret) == 400);
 342   fail_unless (GST_BUFFER_OFFSET_END (ret) == 800);
 343   fail_unless (GST_BUFFER_DATA (ret) == data + 200);
 344   fail_unless (GST_BUFFER_SIZE (ret) == 400);
 345
 346   gst_buffer_unref (ret);
 347
 348   /* Clip only start */
 349   buf = gst_buffer_new ();
 350   data = (guint8 *) g_malloc (1000);
 351   GST_BUFFER_SIZE (buf) = 1000;
 352   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 353
 354   gst_segment_init (&s, GST_FORMAT_DEFAULT);
 355   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 400,
 356       1200, 400);
 357
 358   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 359   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 360   GST_BUFFER_OFFSET (buf) = 200;
 361   GST_BUFFER_OFFSET_END (buf) = 1200;
 362
 363   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 364   fail_unless (ret != NULL);
 365
 366   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);
 367   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);
 368   fail_unless (GST_BUFFER_OFFSET (ret) == 400);
 369   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1200);
 370   fail_unless (GST_BUFFER_DATA (ret) == data + 200);
 371   fail_unless (GST_BUFFER_SIZE (ret) == 800);
 372
 373   gst_buffer_unref (ret);
 374
 375   /* Clip only stop */
 376   buf = gst_buffer_new ();
 377   data = (guint8 *) g_malloc (1000);
 378   GST_BUFFER_SIZE (buf) = 1000;
 379   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 380
 381   gst_segment_init (&s, GST_FORMAT_DEFAULT);
 382   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 200,
 383       1000, 200);
 384
 385   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 386   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 387   GST_BUFFER_OFFSET (buf) = 200;
 388   GST_BUFFER_OFFSET_END (buf) = 1200;
 389
 390   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 391   fail_unless (ret != NULL);
 392
 393   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 2 * GST_SECOND);
 394   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);
 395   fail_unless (GST_BUFFER_OFFSET (ret) == 200);
 396   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1000);
 397   fail_unless (GST_BUFFER_DATA (ret) == data);
 398   fail_unless (GST_BUFFER_SIZE (ret) == 800);
 399
 400   gst_buffer_unref (ret);
 401
 402   /* Buffer outside segment */
 403   buf = gst_buffer_new ();
 404   data = (guint8 *) g_malloc (1000);
 405   GST_BUFFER_SIZE (buf) = 1000;
 406   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 407
 408   gst_segment_init (&s, GST_FORMAT_DEFAULT);
 409   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 1200,
 410       2000, 1200);
 411
 412   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 413   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
 414   GST_BUFFER_OFFSET (buf) = 200;
 415   GST_BUFFER_OFFSET_END (buf) = 1200;
 416
 417   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 418   fail_unless (ret == NULL);
 419
 420   /* Clip start and end but don't touch duration and offset_end */
 421   buf = gst_buffer_new ();
 422   data = (guint8 *) g_malloc (1000);
 423   GST_BUFFER_SIZE (buf) = 1000;
 424   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 425
 426   gst_segment_init (&s, GST_FORMAT_DEFAULT);
 427   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 400,
 428       800, 400);
 429
 430   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
 431   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
 432   GST_BUFFER_OFFSET (buf) = 200;
 433   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
 434
 435   ret = gst_audio_buffer_clip (buf, &s, 100, 1);
 436   fail_unless (ret != NULL);
 437
 438   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);
 439   fail_unless (GST_BUFFER_DURATION (ret) == GST_CLOCK_TIME_NONE);
 440   fail_unless (GST_BUFFER_OFFSET (ret) == 400);
 441   fail_unless (GST_BUFFER_OFFSET_END (ret) == GST_BUFFER_OFFSET_NONE);
 442   fail_unless (GST_BUFFER_DATA (ret) == data + 200);
 443   fail_unless (GST_BUFFER_SIZE (ret) == 400);
 444
 445   gst_buffer_unref (ret);
 446
 447   /* If the buffer has no offset it should assert()
 448    * FIXME: check if return value is the same as the input buffer.
 449    *        probably can't be done because the assert() does a SIGABRT.
 450    */
 451   buf = gst_buffer_new ();
 452   data = (guint8 *) g_malloc (1000);
 453   GST_BUFFER_SIZE (buf) = 1000;
 454   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;
 455
 456   gst_segment_init (&s, GST_FORMAT_DEFAULT);
 457   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 0, 10, 0);
 458
 459   GST_BUFFER_TIMESTAMP (buf) = 0 * GST_SECOND;
 460   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
 461   GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
 462   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
 463
 464   ASSERT_CRITICAL (ret = gst_audio_buffer_clip (buf, &s, 100, 1));
 465
 466   gst_buffer_unref (buf);
 467 }
 468
 469 GST_END_TEST;
 470
 471 static void
 472 init_value_to_channel_layout (GValue * val, GstAudioChannelPosition pos1,
 473     GstAudioChannelPosition pos2)
 474 {
 475   GValue pos = { 0, };
 476
 477   g_value_init (val, GST_TYPE_ARRAY);
 478   g_value_init (&pos, GST_TYPE_AUDIO_CHANNEL_POSITION);
 479   g_value_set_enum (&pos, pos1);
 480   gst_value_array_append_value (val, &pos);
 481   g_value_set_enum (&pos, pos2);
 482   gst_value_array_append_value (val, &pos);
 483   g_value_unset (&pos);
 484 }
 485
 486 GST_START_TEST (test_channel_layout_value_intersect)
 487 {
 488   GValue layout = { 0, };
 489   GValue list = { 0, };
 490   GValue res = { 0, };
 491
 492   g_value_init (&list, GST_TYPE_LIST);
 493   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
 494       GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT);
 495   gst_value_list_append_value (&list, &layout);
 496   g_value_unset (&layout);
 497   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 498       GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);
 499   gst_value_list_append_value (&list, &layout);
 500   g_value_unset (&layout);
 501
 502   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 503       GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);
 504
 505   /* we should get the second layout in the list, as it matches the input */
 506   fail_unless (gst_value_intersect (&res, &layout, &list));
 507   g_value_unset (&layout);
 508   fail_unless (GST_VALUE_HOLDS_ARRAY (&res));
 509   fail_unless_equals_int (gst_value_array_get_size (&res), 2);
 510   fail_unless_equals_int (g_value_get_enum (gst_value_array_get_value (&res,
 511               0)), GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT);
 512   fail_unless_equals_int (g_value_get_enum (gst_value_array_get_value (&res,
 513               1)), GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);
 514   g_value_unset (&res);
 515
 516   /* this (with rear position) should not yield any results */
 517   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 518       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT);
 519   fail_if (gst_value_intersect (&res, &layout, &list));
 520   g_value_unset (&layout);
 521
 522   g_value_unset (&list);
 523 }
 524
 525 GST_END_TEST;
 526
 527 static Suite *
 528 audio_suite (void)
 529 {
 530   Suite *s = suite_create ("audio support library");
 531
 532   TCase *tc_chain = tcase_create ("general");
 533
 534   suite_add_tcase (s, tc_chain);
 535   tcase_add_test (tc_chain, test_multichannel_checks);
 536   tcase_add_test (tc_chain, test_buffer_clipping_time);
 537   tcase_add_test (tc_chain, test_buffer_clipping_samples);
 538   tcase_add_test (tc_chain, test_channel_layout_value_intersect);
 539
 540   return s;
 541 }
 542
 543 int
 544 main (int argc, char **argv)
 545 {
 546   int nf;
 547
 548   Suite *s = audio_suite ();
 549
 550   SRunner *sr = srunner_create (s);
 551
 552   gst_check_init (&argc, &argv);
 553
 554   srunner_run_all (sr, CK_NORMAL);
 555   nf = srunner_ntests_failed (sr);
 556   srunner_free (sr);
 557
 558   return nf;
 559 }