← Back to branch summary

~ubuntu-branches/ubuntu/precise/gst-plugins-base0.10/precise-updates

« back to all changes in this revision

Viewing changes to tests/check/elements/volume.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2011-12-12 12:40:13 UTC
  • mfrom: (36.1.15 experimental)
  • Revision ID: package-import@ubuntu.com-20111212124013-onyadfb150d8c5dk
Tags: 0.10.35.2-2
* debian/libgstreamer-plugins-base.install:
  + Add license translations file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/check/elements/volume.c
309
309
 
310
310
GST_END_TEST;
311
311
 
 
312
GST_START_TEST (test_ten_s8)
 
313
{
 
314
  GstElement *volume;
 
315
  GstBuffer *inbuffer;
 
316
  GstBuffer *outbuffer;
 
317
  GstCaps *caps;
 
318
  gint8 in[2] = { 64, -10 };
 
319
  gint8 out[2] = { 127, -100 }; /* notice the clamped sample */
 
320
  gint8 *res;
 
321
 
 
322
  volume = setup_volume ();
 
323
  g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
 
324
  fail_unless (gst_element_set_state (volume,
 
325
          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 
326
      "could not set to playing");
 
327
 
 
328
  inbuffer = gst_buffer_new_and_alloc (2);
 
329
  memcpy (GST_BUFFER_DATA (inbuffer), in, 2);
 
330
  fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 2) == 0);
 
331
  caps = gst_caps_from_string (VOLUME_CAPS_STRING_S8);
 
332
  gst_buffer_set_caps (inbuffer, caps);
 
333
  gst_caps_unref (caps);
 
334
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
335
  /* FIXME: reffing the inbuffer should make the transformation not be
 
336
   * inplace
 
337
   gst_buffer_ref (inbuffer);
 
338
   */
 
339
 
 
340
  /* pushing gives away my reference ... */
 
341
  fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 
342
  /* ... but it ends up being modified inplace and
 
343
   * collected on the global buffer list */
 
344
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
345
  fail_unless_equals_int (g_list_length (buffers), 1);
 
346
  fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 
347
  fail_unless (inbuffer == outbuffer);
 
348
  res = (gint8 *) GST_BUFFER_DATA (outbuffer);
 
349
  GST_INFO ("expected %+5d %+5d  real %+5d %+5d", out[0], out[1], res[0],
 
350
      res[1]);
 
351
  fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), out, 2) == 0);
 
352
 
 
353
  /* cleanup */
 
354
  cleanup_volume (volume);
 
355
}
 
356
 
 
357
GST_END_TEST;
 
358
 
312
359
GST_START_TEST (test_mute_s8)
313
360
{
314
361
  GstElement *volume;
487
534
 
488
535
GST_END_TEST;
489
536
 
 
537
GST_START_TEST (test_ten_s16)
 
538
{
 
539
  GstElement *volume;
 
540
  GstBuffer *inbuffer;
 
541
  GstBuffer *outbuffer;
 
542
  GstCaps *caps;
 
543
  gint16 in[2] = { 16384, -10 };
 
544
  gint16 out[2] = { 32767, -100 };      /* notice the clamped sample */
 
545
  gint16 *res;
 
546
 
 
547
  volume = setup_volume ();
 
548
  g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
 
549
  fail_unless (gst_element_set_state (volume,
 
550
          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 
551
      "could not set to playing");
 
552
 
 
553
  inbuffer = gst_buffer_new_and_alloc (4);
 
554
  memcpy (GST_BUFFER_DATA (inbuffer), in, 4);
 
555
  fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 4) == 0);
 
556
  caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
 
557
  gst_buffer_set_caps (inbuffer, caps);
 
558
  gst_caps_unref (caps);
 
559
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
560
  /* FIXME: reffing the inbuffer should make the transformation not be
 
561
   * inplace
 
562
   gst_buffer_ref (inbuffer);
 
563
   */
 
564
 
 
565
  /* pushing gives away my reference ... */
 
566
  fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 
567
  /* ... but it ends up being modified inplace and
 
568
   * collected on the global buffer list */
 
569
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
570
  fail_unless_equals_int (g_list_length (buffers), 1);
 
571
  fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 
572
  fail_unless (inbuffer == outbuffer);
 
573
  res = (gint16 *) GST_BUFFER_DATA (outbuffer);
 
574
  GST_INFO ("expected %+5d %+5d  real %+5d %+5d", out[0], out[1], res[0],
 
575
      res[1]);
 
576
  fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), out, 4) == 0);
 
577
 
 
578
  /* cleanup */
 
579
  cleanup_volume (volume);
 
580
}
 
581
 
 
582
GST_END_TEST;
 
583
 
490
584
 
491
585
GST_START_TEST (test_mute_s16)
492
586
{
703
797
 
704
798
GST_END_TEST;
705
799
 
 
800
GST_START_TEST (test_ten_s24)
 
801
{
 
802
  GstElement *volume;
 
803
  GstBuffer *inbuffer;
 
804
  GstBuffer *outbuffer;
 
805
  GstCaps *caps;
 
806
  gint32 in_32[2] = { 4194304, -10 };
 
807
  guint8 in[6];
 
808
  guint8 *res;
 
809
  gint32 res_32[2];
 
810
  gint32 out_32[2] = { 8388607, -100 }; /* notice the clamped sample */
 
811
 
 
812
  write_unaligned_u24 (in, in_32[0]);
 
813
  write_unaligned_u24 (in + 3, in_32[1]);
 
814
 
 
815
  volume = setup_volume ();
 
816
  g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
 
817
  fail_unless (gst_element_set_state (volume,
 
818
          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 
819
      "could not set to playing");
 
820
 
 
821
  inbuffer = gst_buffer_new_and_alloc (6);
 
822
  memcpy (GST_BUFFER_DATA (inbuffer), in, 6);
 
823
  fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 6) == 0);
 
824
  caps = gst_caps_from_string (VOLUME_CAPS_STRING_S24);
 
825
  gst_buffer_set_caps (inbuffer, caps);
 
826
  gst_caps_unref (caps);
 
827
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
828
  /* FIXME: reffing the inbuffer should make the transformation not be
 
829
   * inplace
 
830
   gst_buffer_ref (inbuffer);
 
831
   */
 
832
 
 
833
  /* pushing gives away my reference ... */
 
834
  fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 
835
  /* ... but it ends up being modified inplace and
 
836
   * collected on the global buffer list */
 
837
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
838
  fail_unless_equals_int (g_list_length (buffers), 1);
 
839
  fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 
840
  fail_unless (inbuffer == outbuffer);
 
841
  res = GST_BUFFER_DATA (outbuffer);
 
842
 
 
843
  res_32[0] = get_unaligned_i24 (res);
 
844
  res_32[1] = get_unaligned_i24 ((res + 3));
 
845
 
 
846
  GST_INFO ("expected %+5d %+5d  real %+5d %+5d", out_32[0], out_32[1],
 
847
      res_32[0], res_32[1]);
 
848
  fail_unless (memcmp (res_32, out_32, 8) == 0);
 
849
 
 
850
  /* cleanup */
 
851
  cleanup_volume (volume);
 
852
}
 
853
 
 
854
GST_END_TEST;
706
855
 
707
856
GST_START_TEST (test_mute_s24)
708
857
{
892
1041
 
893
1042
GST_END_TEST;
894
1043
 
 
1044
GST_START_TEST (test_ten_s32)
 
1045
{
 
1046
  GstElement *volume;
 
1047
  GstBuffer *inbuffer;
 
1048
  GstBuffer *outbuffer;
 
1049
  GstCaps *caps;
 
1050
  gint32 in[2] = { 1073741824, -10 };
 
1051
  gint32 out[2] = { 2147483647, -100 }; /* notice the clamped sample */
 
1052
  gint32 *res;
 
1053
 
 
1054
  volume = setup_volume ();
 
1055
  g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
 
1056
  fail_unless (gst_element_set_state (volume,
 
1057
          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 
1058
      "could not set to playing");
 
1059
 
 
1060
  inbuffer = gst_buffer_new_and_alloc (8);
 
1061
  memcpy (GST_BUFFER_DATA (inbuffer), in, 8);
 
1062
  fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 8) == 0);
 
1063
  caps = gst_caps_from_string (VOLUME_CAPS_STRING_S32);
 
1064
  gst_buffer_set_caps (inbuffer, caps);
 
1065
  gst_caps_unref (caps);
 
1066
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
1067
  /* FIXME: reffing the inbuffer should make the transformation not be
 
1068
   * inplace
 
1069
   gst_buffer_ref (inbuffer);
 
1070
   */
 
1071
 
 
1072
  /* pushing gives away my reference ... */
 
1073
  fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 
1074
  /* ... but it ends up being modified inplace and
 
1075
   * collected on the global buffer list */
 
1076
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
1077
  fail_unless_equals_int (g_list_length (buffers), 1);
 
1078
  fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 
1079
  fail_unless (inbuffer == outbuffer);
 
1080
  res = (gint32 *) GST_BUFFER_DATA (outbuffer);
 
1081
  GST_INFO ("expected %+5d %+5d  real %+5d %+5d", out[0], out[1], res[0],
 
1082
      res[1]);
 
1083
  fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), out, 8) == 0);
 
1084
 
 
1085
  /* cleanup */
 
1086
  cleanup_volume (volume);
 
1087
}
 
1088
 
 
1089
GST_END_TEST;
895
1090
 
896
1091
GST_START_TEST (test_mute_s32)
897
1092
{
1075
1270
 
1076
1271
GST_END_TEST;
1077
1272
 
 
1273
GST_START_TEST (test_ten_f32)
 
1274
{
 
1275
  GstElement *volume;
 
1276
  GstBuffer *inbuffer;
 
1277
  GstBuffer *outbuffer;
 
1278
  GstCaps *caps;
 
1279
  gfloat in[2] = { 0.75, -0.25 };
 
1280
  gfloat out[2] = { 7.5, -2.5 };        /* nothing is clamped */
 
1281
  gfloat *res;
 
1282
 
 
1283
  volume = setup_volume ();
 
1284
  g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
 
1285
  fail_unless (gst_element_set_state (volume,
 
1286
          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 
1287
      "could not set to playing");
 
1288
 
 
1289
  inbuffer = gst_buffer_new_and_alloc (8);
 
1290
  memcpy (GST_BUFFER_DATA (inbuffer), in, 8);
 
1291
  fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 8) == 0);
 
1292
  caps = gst_caps_from_string (VOLUME_CAPS_STRING_F32);
 
1293
  gst_buffer_set_caps (inbuffer, caps);
 
1294
  gst_caps_unref (caps);
 
1295
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
1296
  /* FIXME: reffing the inbuffer should make the transformation not be
 
1297
   * inplace
 
1298
   gst_buffer_ref (inbuffer);
 
1299
   */
 
1300
 
 
1301
  /* pushing gives away my reference ... */
 
1302
  fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 
1303
  /* ... but it ends up being modified inplace and
 
1304
   * collected on the global buffer list */
 
1305
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
1306
  fail_unless_equals_int (g_list_length (buffers), 1);
 
1307
  fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 
1308
  fail_unless (inbuffer == outbuffer);
 
1309
  res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 
1310
  GST_INFO ("expected %+1.4f %+1.4f  real %+1.4f %+1.4f", out[0], out[1],
 
1311
      res[0], res[1]);
 
1312
  fail_unless_equals_float (res[0], out[0]);
 
1313
  fail_unless_equals_float (res[1], out[1]);
 
1314
 
 
1315
  /* cleanup */
 
1316
  cleanup_volume (volume);
 
1317
}
 
1318
 
 
1319
GST_END_TEST;
 
1320
 
1078
1321
 
1079
1322
GST_START_TEST (test_mute_f32)
1080
1323
{
1259
1502
 
1260
1503
GST_END_TEST;
1261
1504
 
 
1505
GST_START_TEST (test_ten_f64)
 
1506
{
 
1507
  GstElement *volume;
 
1508
  GstBuffer *inbuffer;
 
1509
  GstBuffer *outbuffer;
 
1510
  GstCaps *caps;
 
1511
  gdouble in[2] = { 0.75, -0.25 };
 
1512
  gdouble out[2] = { 7.5, -2.5 };       /* nothing is clamped */
 
1513
  gdouble *res;
 
1514
 
 
1515
  volume = setup_volume ();
 
1516
  g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
 
1517
  fail_unless (gst_element_set_state (volume,
 
1518
          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 
1519
      "could not set to playing");
 
1520
 
 
1521
  inbuffer = gst_buffer_new_and_alloc (16);
 
1522
  memcpy (GST_BUFFER_DATA (inbuffer), in, 16);
 
1523
  fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 16) == 0);
 
1524
  caps = gst_caps_from_string (VOLUME_CAPS_STRING_F64);
 
1525
  gst_buffer_set_caps (inbuffer, caps);
 
1526
  gst_caps_unref (caps);
 
1527
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
1528
  /* FIXME: reffing the inbuffer should make the transformation not be
 
1529
   * inplace
 
1530
   gst_buffer_ref (inbuffer);
 
1531
   */
 
1532
 
 
1533
  /* pushing gives away my reference ... */
 
1534
  fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 
1535
  /* ... but it ends up being modified inplace and
 
1536
   * collected on the global buffer list */
 
1537
  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 
1538
  fail_unless_equals_int (g_list_length (buffers), 1);
 
1539
  fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 
1540
  fail_unless (inbuffer == outbuffer);
 
1541
  res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 
1542
  GST_INFO ("expected %+1.4f %+1.4f  real %+1.4f %+1.4f", out[0], out[1],
 
1543
      res[0], res[1]);
 
1544
  fail_unless_equals_float (res[0], out[0]);
 
1545
  fail_unless_equals_float (res[1], out[1]);
 
1546
 
 
1547
  /* cleanup */
 
1548
  cleanup_volume (volume);
 
1549
}
 
1550
 
 
1551
GST_END_TEST;
 
1552
 
1262
1553
 
1263
1554
GST_START_TEST (test_mute_f64)
1264
1555
{
1493
1784
  tcase_add_test (tc_chain, test_unity_s8);
1494
1785
  tcase_add_test (tc_chain, test_half_s8);
1495
1786
  tcase_add_test (tc_chain, test_double_s8);
 
1787
  tcase_add_test (tc_chain, test_ten_s8);
1496
1788
  tcase_add_test (tc_chain, test_mute_s8);
1497
1789
  tcase_add_test (tc_chain, test_unity_s16);
1498
1790
  tcase_add_test (tc_chain, test_half_s16);
1499
1791
  tcase_add_test (tc_chain, test_double_s16);
 
1792
  tcase_add_test (tc_chain, test_ten_s16);
1500
1793
  tcase_add_test (tc_chain, test_mute_s16);
1501
1794
  tcase_add_test (tc_chain, test_unity_s24);
1502
1795
  tcase_add_test (tc_chain, test_half_s24);
1503
1796
  tcase_add_test (tc_chain, test_double_s24);
 
1797
  tcase_add_test (tc_chain, test_ten_s24);
1504
1798
  tcase_add_test (tc_chain, test_mute_s24);
1505
1799
  tcase_add_test (tc_chain, test_unity_s32);
1506
1800
  tcase_add_test (tc_chain, test_half_s32);
1507
1801
  tcase_add_test (tc_chain, test_double_s32);
 
1802
  tcase_add_test (tc_chain, test_ten_s32);
1508
1803
  tcase_add_test (tc_chain, test_mute_s32);
1509
1804
  tcase_add_test (tc_chain, test_unity_f32);
1510
1805
  tcase_add_test (tc_chain, test_half_f32);
1511
1806
  tcase_add_test (tc_chain, test_double_f32);
 
1807
  tcase_add_test (tc_chain, test_ten_f32);
1512
1808
  tcase_add_test (tc_chain, test_mute_f32);
1513
1809
  tcase_add_test (tc_chain, test_unity_f64);
1514
1810
  tcase_add_test (tc_chain, test_half_f64);
1515
1811
  tcase_add_test (tc_chain, test_double_f64);
 
1812
  tcase_add_test (tc_chain, test_ten_f64);
1516
1813
  tcase_add_test (tc_chain, test_mute_f64);
1517
1814
  tcase_add_test (tc_chain, test_wrong_caps);
1518
1815
  tcase_add_test (tc_chain, test_passthrough);