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   /* this should not work and issue a warning: FRONT_MONO + NONE */

    77   _gst_check_expecting_log = TRUE;

    78   gst_audio_set_channel_positions (s, pos_2_mixed);

    79   _gst_check_expecting_log = FALSE;

    80   fail_if (structure_contains_channel_positions (s));

    81 

    82   /* this should work: NONE + NONE */

    83   gst_audio_set_channel_positions (s, pos_2_none);

    84   fail_unless (structure_contains_channel_positions (s));

    85   gst_structure_remove_field (s, "channel-positions");

    86 

    87   /* this should also work: FRONT_LEFT + FRONT_RIGHT */

    88   gst_audio_set_channel_positions (s, pos_2_flr);

    89   fail_unless (structure_contains_channel_positions (s));

    90   gst_structure_remove_field (s, "channel-positions");

    91 

    92   /* this should not work and issue a warning: FRONT_RIGHT twice */

    93   _gst_check_expecting_log = TRUE;

    94   gst_audio_set_channel_positions (s, pos_2_frr);

    95   _gst_check_expecting_log = FALSE;

    96 

    97 /* FIXME: did I misunderstand _set_structure_channel_positions_list? */

    98 #if  0

    99   /* this should not work and issue a warning: FRONT_RIGHT twice */

   100   _gst_check_expecting_log = TRUE;

   101   gst_audio_set_structure_channel_positions_list (s, pos_2_frr, 2);

   102   _gst_check_expecting_log = FALSE;

   103 

   104   /* this should not work and issue a warning: FRONT_MONO + NONE */

   105   _gst_check_expecting_log = TRUE;

   106   gst_audio_set_structure_channel_positions_list (s, pos_2_mixed, 2);

   107   _gst_check_expecting_log = FALSE;

   108 

   109   /* this should not work either (channel count mismatch) */

   110   _gst_check_expecting_log = TRUE;

   111   gst_audio_set_structure_channel_positions_list (s, pos_2_none, 44);

   112   _gst_check_expecting_log = FALSE;

   113   fail_if (structure_contains_channel_positions (s));

   114 #endif

   115 

   116   gst_structure_free (s);

   117 }

   118 

   119 GST_END_TEST;

   120 

   121 GST_START_TEST (test_buffer_clipping_time)

   122 {

   123   GstSegment s;

   124   GstBuffer *buf;

   125   GstBuffer *ret;

   126   guint8 *data;

   127 

   128   /* Clip start and end */

   129   buf = gst_buffer_new ();

   130   data = (guint8 *) g_malloc (1000);

   131   GST_BUFFER_SIZE (buf) = 1000;

   132   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   133 

   134   gst_segment_init (&s, GST_FORMAT_TIME);

   135   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 4 * GST_SECOND,

   136       8 * GST_SECOND, 4 * GST_SECOND);

   137 

   138   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   139   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   140   GST_BUFFER_OFFSET (buf) = 200;

   141   GST_BUFFER_OFFSET_END (buf) = 1200;

   142 

   143   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   144   fail_unless (ret != NULL);

   145 

   146   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);

   147   fail_unless (GST_BUFFER_DURATION (ret) == 4 * GST_SECOND);

   148   fail_unless (GST_BUFFER_OFFSET (ret) == 400);

   149   fail_unless (GST_BUFFER_OFFSET_END (ret) == 800);

   150   fail_unless (GST_BUFFER_DATA (ret) == data + 200);

   151   fail_unless (GST_BUFFER_SIZE (ret) == 400);

   152 

   153   gst_buffer_unref (ret);

   154 

   155   /* Clip only start */

   156   buf = gst_buffer_new ();

   157   data = (guint8 *) g_malloc (1000);

   158   GST_BUFFER_SIZE (buf) = 1000;

   159   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   160 

   161   gst_segment_init (&s, GST_FORMAT_TIME);

   162   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 4 * GST_SECOND,

   163       12 * GST_SECOND, 4 * GST_SECOND);

   164 

   165   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   166   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   167   GST_BUFFER_OFFSET (buf) = 200;

   168   GST_BUFFER_OFFSET_END (buf) = 1200;

   169 

   170   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   171   fail_unless (ret != NULL);

   172 

   173   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);

   174   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);

   175   fail_unless (GST_BUFFER_OFFSET (ret) == 400);

   176   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1200);

   177   fail_unless (GST_BUFFER_DATA (ret) == data + 200);

   178   fail_unless (GST_BUFFER_SIZE (ret) == 800);

   179 

   180   gst_buffer_unref (ret);

   181 

   182   /* Clip only stop */

   183   buf = gst_buffer_new ();

   184   data = (guint8 *) g_malloc (1000);

   185   GST_BUFFER_SIZE (buf) = 1000;

   186   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   187 

   188   gst_segment_init (&s, GST_FORMAT_TIME);

   189   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 2 * GST_SECOND,

   190       10 * GST_SECOND, 2 * GST_SECOND);

   191 

   192   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   193   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   194   GST_BUFFER_OFFSET (buf) = 200;

   195   GST_BUFFER_OFFSET_END (buf) = 1200;

   196 

   197   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   198   fail_unless (ret != NULL);

   199 

   200   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 2 * GST_SECOND);

   201   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);

   202   fail_unless (GST_BUFFER_OFFSET (ret) == 200);

   203   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1000);

   204   fail_unless (GST_BUFFER_DATA (ret) == data);

   205   fail_unless (GST_BUFFER_SIZE (ret) == 800);

   206 

   207   gst_buffer_unref (ret);

   208 

   209   /* Buffer outside segment */

   210   buf = gst_buffer_new ();

   211   data = (guint8 *) g_malloc (1000);

   212   GST_BUFFER_SIZE (buf) = 1000;

   213   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   214 

   215   gst_segment_init (&s, GST_FORMAT_TIME);

   216   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 12 * GST_SECOND,

   217       20 * GST_SECOND, 12 * GST_SECOND);

   218 

   219   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   220   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   221   GST_BUFFER_OFFSET (buf) = 200;

   222   GST_BUFFER_OFFSET_END (buf) = 1200;

   223 

   224   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   225   fail_unless (ret == NULL);

   226 

   227   /* Clip start and end but don't touch duration and offset_end */

   228   buf = gst_buffer_new ();

   229   data = (guint8 *) g_malloc (1000);

   230   GST_BUFFER_SIZE (buf) = 1000;

   231   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   232 

   233   gst_segment_init (&s, GST_FORMAT_TIME);

   234   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 4 * GST_SECOND,

   235       8 * GST_SECOND, 4 * GST_SECOND);

   236 

   237   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   238   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;

   239   GST_BUFFER_OFFSET (buf) = 200;

   240   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;

   241 

   242   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   243   fail_unless (ret != NULL);

   244 

   245   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);

   246   fail_unless (GST_BUFFER_DURATION (ret) == GST_CLOCK_TIME_NONE);

   247   fail_unless (GST_BUFFER_OFFSET (ret) == 400);

   248   fail_unless (GST_BUFFER_OFFSET_END (ret) == GST_BUFFER_OFFSET_NONE);

   249   fail_unless (GST_BUFFER_DATA (ret) == data + 200);

   250   fail_unless (GST_BUFFER_SIZE (ret) == 400);

   251 

   252   gst_buffer_unref (ret);

   253 

   254   /* If the buffer has no timestamp it should assert()

   255    * FIXME: check if return value is the same as the input buffer.

   256    *        probably can't be done because the assert() does a SIGABRT.

   257    */

   258   buf = gst_buffer_new ();

   259   data = (guint8 *) g_malloc (1000);

   260   GST_BUFFER_SIZE (buf) = 1000;

   261   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   262 

   263   gst_segment_init (&s, GST_FORMAT_TIME);

   264   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_TIME, 0 * GST_SECOND,

   265       10 * GST_SECOND, 0 * GST_SECOND);

   266 

   267   GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;

   268   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;

   269   GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;

   270   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;

   271 

   272   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   273   fail_unless (ret == buf);

   274 

   275   gst_buffer_unref (buf);

   276 

   277   /* If the format is not TIME or DEFAULT it should assert()

   278    * FIXME: check if return value is the same as the input buffer.

   279    *        probably can't be done because the assert() does a SIGABRT.

   280    */

   281   buf = gst_buffer_new ();

   282   data = (guint8 *) g_malloc (1000);

   283   GST_BUFFER_SIZE (buf) = 1000;

   284   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   285 

   286   gst_segment_init (&s, GST_FORMAT_PERCENT);

   287   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_PERCENT, 0, 10, 0);

   288 

   289   GST_BUFFER_TIMESTAMP (buf) = 0 * GST_SECOND;

   290   GST_BUFFER_DURATION (buf) = 0;

   291   GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;

   292   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;

   293 

   294   ASSERT_CRITICAL (ret = gst_audio_buffer_clip (buf, &s, 100, 1));

   295 

   296   gst_buffer_unref (buf);

   297 

   298 }

   299 

   300 GST_END_TEST;

   301 

   302 GST_START_TEST (test_buffer_clipping_samples)

   303 {

   304   GstSegment s;

   305   GstBuffer *buf;

   306   GstBuffer *ret;

   307   guint8 *data;

   308 

   309   /* Clip start and end */

   310   buf = gst_buffer_new ();

   311   data = (guint8 *) g_malloc (1000);

   312   GST_BUFFER_SIZE (buf) = 1000;

   313   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   314 

   315   gst_segment_init (&s, GST_FORMAT_DEFAULT);

   316   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 400,

   317       800, 400);

   318 

   319   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   320   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   321   GST_BUFFER_OFFSET (buf) = 200;

   322   GST_BUFFER_OFFSET_END (buf) = 1200;

   323 

   324   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   325   fail_unless (ret != NULL);

   326 

   327   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);

   328   fail_unless (GST_BUFFER_DURATION (ret) == 4 * GST_SECOND);

   329   fail_unless (GST_BUFFER_OFFSET (ret) == 400);

   330   fail_unless (GST_BUFFER_OFFSET_END (ret) == 800);

   331   fail_unless (GST_BUFFER_DATA (ret) == data + 200);

   332   fail_unless (GST_BUFFER_SIZE (ret) == 400);

   333 

   334   gst_buffer_unref (ret);

   335 

   336   /* Clip only start */

   337   buf = gst_buffer_new ();

   338   data = (guint8 *) g_malloc (1000);

   339   GST_BUFFER_SIZE (buf) = 1000;

   340   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   341 

   342   gst_segment_init (&s, GST_FORMAT_DEFAULT);

   343   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 400,

   344       1200, 400);

   345 

   346   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   347   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   348   GST_BUFFER_OFFSET (buf) = 200;

   349   GST_BUFFER_OFFSET_END (buf) = 1200;

   350 

   351   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   352   fail_unless (ret != NULL);

   353 

   354   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);

   355   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);

   356   fail_unless (GST_BUFFER_OFFSET (ret) == 400);

   357   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1200);

   358   fail_unless (GST_BUFFER_DATA (ret) == data + 200);

   359   fail_unless (GST_BUFFER_SIZE (ret) == 800);

   360 

   361   gst_buffer_unref (ret);

   362 

   363   /* Clip only stop */

   364   buf = gst_buffer_new ();

   365   data = (guint8 *) g_malloc (1000);

   366   GST_BUFFER_SIZE (buf) = 1000;

   367   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   368 

   369   gst_segment_init (&s, GST_FORMAT_DEFAULT);

   370   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 200,

   371       1000, 200);

   372 

   373   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   374   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   375   GST_BUFFER_OFFSET (buf) = 200;

   376   GST_BUFFER_OFFSET_END (buf) = 1200;

   377 

   378   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   379   fail_unless (ret != NULL);

   380 

   381   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 2 * GST_SECOND);

   382   fail_unless (GST_BUFFER_DURATION (ret) == 8 * GST_SECOND);

   383   fail_unless (GST_BUFFER_OFFSET (ret) == 200);

   384   fail_unless (GST_BUFFER_OFFSET_END (ret) == 1000);

   385   fail_unless (GST_BUFFER_DATA (ret) == data);

   386   fail_unless (GST_BUFFER_SIZE (ret) == 800);

   387 

   388   gst_buffer_unref (ret);

   389 

   390   /* Buffer outside segment */

   391   buf = gst_buffer_new ();

   392   data = (guint8 *) g_malloc (1000);

   393   GST_BUFFER_SIZE (buf) = 1000;

   394   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   395 

   396   gst_segment_init (&s, GST_FORMAT_DEFAULT);

   397   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 1200,

   398       2000, 1200);

   399 

   400   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   401   GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;

   402   GST_BUFFER_OFFSET (buf) = 200;

   403   GST_BUFFER_OFFSET_END (buf) = 1200;

   404 

   405   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   406   fail_unless (ret == NULL);

   407 

   408   /* Clip start and end but don't touch duration and offset_end */

   409   buf = gst_buffer_new ();

   410   data = (guint8 *) g_malloc (1000);

   411   GST_BUFFER_SIZE (buf) = 1000;

   412   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   413 

   414   gst_segment_init (&s, GST_FORMAT_DEFAULT);

   415   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 400,

   416       800, 400);

   417 

   418   GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;

   419   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;

   420   GST_BUFFER_OFFSET (buf) = 200;

   421   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;

   422 

   423   ret = gst_audio_buffer_clip (buf, &s, 100, 1);

   424   fail_unless (ret != NULL);

   425 

   426   fail_unless (GST_BUFFER_TIMESTAMP (ret) == 4 * GST_SECOND);

   427   fail_unless (GST_BUFFER_DURATION (ret) == GST_CLOCK_TIME_NONE);

   428   fail_unless (GST_BUFFER_OFFSET (ret) == 400);

   429   fail_unless (GST_BUFFER_OFFSET_END (ret) == GST_BUFFER_OFFSET_NONE);

   430   fail_unless (GST_BUFFER_DATA (ret) == data + 200);

   431   fail_unless (GST_BUFFER_SIZE (ret) == 400);

   432 

   433   gst_buffer_unref (ret);

   434 

   435   /* If the buffer has no offset it should assert()

   436    * FIXME: check if return value is the same as the input buffer.

   437    *        probably can't be done because the assert() does a SIGABRT.

   438    */

   439   buf = gst_buffer_new ();

   440   data = (guint8 *) g_malloc (1000);

   441   GST_BUFFER_SIZE (buf) = 1000;

   442   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   443 

   444   gst_segment_init (&s, GST_FORMAT_DEFAULT);

   445   gst_segment_set_newsegment (&s, FALSE, 1.0, GST_FORMAT_DEFAULT, 0, 10, 0);

   446 

   447   GST_BUFFER_TIMESTAMP (buf) = 0 * GST_SECOND;

   448   GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;

   449   GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;

   450   GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;

   451 

   452   ASSERT_CRITICAL (ret = gst_audio_buffer_clip (buf, &s, 100, 1));

   453 

   454   gst_buffer_unref (buf);

   455 }

   456 

   457 GST_END_TEST;

   458 

   459 static void

   460 init_value_to_channel_layout (GValue * val, GstAudioChannelPosition pos1,

   461     GstAudioChannelPosition pos2)

   462 {

   463   GValue pos = { 0, };

   464 

   465   g_value_init (val, GST_TYPE_ARRAY);

   466   g_value_init (&pos, GST_TYPE_AUDIO_CHANNEL_POSITION);

   467   g_value_set_enum (&pos, pos1);

   468   gst_value_array_append_value (val, &pos);

   469   g_value_set_enum (&pos, pos2);

   470   gst_value_array_append_value (val, &pos);

   471   g_value_unset (&pos);

   472 }

   473 

   474 GST_START_TEST (test_channel_layout_value_intersect)

   475 {

   476   GValue layout = { 0, };

   477   GValue list = { 0, };

   478   GValue res = { 0, };

   479 

   480   g_value_init (&list, GST_TYPE_LIST);

   481   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,

   482       GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT);

   483   gst_value_list_append_value (&list, &layout);

   484   g_value_unset (&layout);

   485   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,

   486       GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);

   487   gst_value_list_append_value (&list, &layout);

   488   g_value_unset (&layout);

   489 

   490   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,

   491       GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);

   492 

   493   /* we should get the second layout in the list, as it matches the input */

   494   fail_unless (gst_value_intersect (&res, &layout, &list));

   495   g_value_unset (&layout);

   496   fail_unless (GST_VALUE_HOLDS_ARRAY (&res));

   497   fail_unless_equals_int (gst_value_array_get_size (&res), 2);

   498   fail_unless_equals_int (g_value_get_enum (gst_value_array_get_value (&res,

   499               0)), GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT);

   500   fail_unless_equals_int (g_value_get_enum (gst_value_array_get_value (&res,

   501               1)), GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);

   502   g_value_unset (&res);

   503 

   504   /* this (with rear position) should not yield any results */

   505   init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,

   506       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT);

   507   fail_if (gst_value_intersect (&res, &layout, &list));

   508   g_value_unset (&layout);

   509 

   510   g_value_unset (&list);

   511 }

   512 

   513 GST_END_TEST;

   514 

   515 static Suite *

   516 audio_suite (void)

   517 {

   518   Suite *s = suite_create ("audio support library");

   519   TCase *tc_chain = tcase_create ("general");

   520 

   521   suite_add_tcase (s, tc_chain);

   522   tcase_add_test (tc_chain, test_multichannel_checks);

   523   tcase_add_test (tc_chain, test_buffer_clipping_time);

   524   tcase_add_test (tc_chain, test_buffer_clipping_samples);

   525   tcase_add_test (tc_chain, test_channel_layout_value_intersect);

   526 

   527   return s;

   528 }

   529 

   530 int

   531 main (int argc, char **argv)

   532 {

   533   int nf;

   534 

   535   Suite *s = audio_suite ();

   536   SRunner *sr = srunner_create (s);

   537 

   538   gst_check_init (&argc, &argv);

   539 

   540   srunner_run_all (sr, CK_NORMAL);

   541   nf = srunner_ntests_failed (sr);

   542   srunner_free (sr);

   543 

   544   return nf;

   545 }