mobile/tests/check/libs/bitreader.c

   1 /* GStreamer
   2  *
   3  * unit test for GstBitReader
   4  *
   5  * Copyright (C) <2008> Sebastian Dröge <sebastian.droege@collabora.co.uk>
   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/gst.h>
  28 #include <gst/check/gstcheck.h>
  29 #include <gst/base/gstbitreader.h>
  30
  31 #ifndef fail_unless_equals_int64
  32 #define fail_unless_equals_int64(a, b)                                  \
  33 G_STMT_START {                                                          \
  34   gint64 first = a;                                                     \
  35   gint64 second = b;                                                    \
  36   fail_unless(first == second,                                          \
  37     "'" #a "' (%" G_GINT64_FORMAT ") is not equal to '" #b"' (%"        \
  38     G_GINT64_FORMAT ")", first, second);                                \
  39 } G_STMT_END;
  40 #endif
  41
  42 GST_START_TEST (test_initialization)
  43 {
  44   guint8 data[] = { 0x01, 0x02, 0x03, 0x04 };
  45   GstBuffer *buffer = gst_buffer_new ();
  46   GstBitReader reader = GST_BIT_READER_INIT (data, 4);
  47   GstBitReader *reader2;
  48   guint8 x = 0;
  49
  50   GST_BUFFER_DATA (buffer) = data;
  51   GST_BUFFER_SIZE (buffer) = 4;
  52
  53   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
  54   fail_unless_equals_int (x, 0x01);
  55   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
  56   fail_unless_equals_int (x, 0x02);
  57
  58   memset (&reader, 0, sizeof (GstBitReader));
  59
  60   gst_bit_reader_init (&reader, data, 4);
  61   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
  62   fail_unless_equals_int (x, 0x01);
  63   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
  64   fail_unless_equals_int (x, 0x02);
  65
  66   gst_bit_reader_init_from_buffer (&reader, buffer);
  67   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
  68   fail_unless_equals_int (x, 0x01);
  69   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
  70   fail_unless_equals_int (x, 0x02);
  71
  72   reader2 = gst_bit_reader_new (data, 4);
  73   fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
  74   fail_unless_equals_int (x, 0x01);
  75   fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
  76   fail_unless_equals_int (x, 0x02);
  77   gst_bit_reader_free (reader2);
  78
  79   reader2 = gst_bit_reader_new_from_buffer (buffer);
  80   fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
  81   fail_unless_equals_int (x, 0x01);
  82   fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
  83   fail_unless_equals_int (x, 0x02);
  84   gst_bit_reader_free (reader2);
  85
  86   gst_buffer_unref (buffer);
  87 }
  88
  89 GST_END_TEST;
  90
  91 #define GET_CHECK(reader, dest, bits, nbits, val) { \
  92   fail_unless (gst_bit_reader_get_bits_uint##bits (reader, &dest, nbits)); \
  93   fail_unless_equals_uint64 (dest, val); \
  94 }
  95
  96 #define PEEK_CHECK(reader, dest, bits, nbits, val) { \
  97   fail_unless (gst_bit_reader_peek_bits_uint##bits (reader, &dest, nbits)); \
  98   fail_unless_equals_uint64 (dest, val); \
  99 }
 100
 101 #define GET_CHECK_FAIL(reader, dest, bits, nbits) { \
 102   fail_if (gst_bit_reader_get_bits_uint##bits (reader, &dest, nbits)); \
 103 }
 104
 105 #define PEEK_CHECK_FAIL(reader, dest, bits, nbits) { \
 106   fail_if (gst_bit_reader_peek_bits_uint##bits (reader, &dest, nbits)); \
 107 }
 108
 109 GST_START_TEST (test_get_bits)
 110 {
 111   guint8 data[] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
 112     0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21
 113   };
 114   GstBitReader reader = GST_BIT_READER_INIT (data, 16);
 115   guint8 a = 0;
 116   guint16 b = 0;
 117   guint32 c = 0;
 118   guint64 d = 0;
 119
 120   /* 8 bit */
 121   GET_CHECK (&reader, a, 8, 8, 0x12);
 122   GET_CHECK (&reader, a, 8, 4, 0x03);
 123   GET_CHECK (&reader, a, 8, 4, 0x04);
 124   GET_CHECK (&reader, a, 8, 3, 0x02);
 125   GET_CHECK (&reader, a, 8, 1, 0x01);
 126   GET_CHECK (&reader, a, 8, 2, 0x01);
 127   GET_CHECK (&reader, a, 8, 2, 0x02);
 128
 129   PEEK_CHECK (&reader, a, 8, 8, 0x78);
 130   PEEK_CHECK (&reader, a, 8, 8, 0x78);
 131   fail_unless (gst_bit_reader_skip (&reader, 8));
 132
 133   PEEK_CHECK (&reader, a, 8, 8, 0x90);
 134   GET_CHECK (&reader, a, 8, 1, 0x01);
 135   GET_CHECK (&reader, a, 8, 1, 0x00);
 136   GET_CHECK (&reader, a, 8, 1, 0x00);
 137   GET_CHECK (&reader, a, 8, 1, 0x01);
 138   fail_unless (gst_bit_reader_skip (&reader, 4));
 139
 140   fail_unless (gst_bit_reader_skip (&reader, 10 * 8));
 141   GET_CHECK (&reader, a, 8, 8, 0x21);
 142   GET_CHECK_FAIL (&reader, a, 8, 1);
 143   PEEK_CHECK_FAIL (&reader, a, 8, 1);
 144
 145   /* 16 bit */
 146   gst_bit_reader_init (&reader, data, 16);
 147
 148   GET_CHECK (&reader, b, 16, 16, 0x1234);
 149   PEEK_CHECK (&reader, b, 16, 13, 0x0acf);
 150   GET_CHECK (&reader, b, 16, 8, 0x56);
 151   GET_CHECK (&reader, b, 16, 4, 0x07);
 152   GET_CHECK (&reader, b, 16, 2, 0x02);
 153   GET_CHECK (&reader, b, 16, 2, 0x00);
 154   PEEK_CHECK (&reader, b, 16, 8, 0x90);
 155   fail_unless (gst_bit_reader_skip (&reader, 11 * 8));
 156   GET_CHECK (&reader, b, 16, 8, 0x21);
 157   GET_CHECK_FAIL (&reader, b, 16, 16);
 158   PEEK_CHECK_FAIL (&reader, b, 16, 16);
 159
 160   /* 32 bit */
 161   gst_bit_reader_init (&reader, data, 16);
 162
 163   GET_CHECK (&reader, c, 32, 32, 0x12345678);
 164   GET_CHECK (&reader, c, 32, 24, 0x90abcd);
 165   GET_CHECK (&reader, c, 32, 16, 0xeffe);
 166   GET_CHECK (&reader, c, 32, 8, 0xdc);
 167   GET_CHECK (&reader, c, 32, 4, 0x0b);
 168   GET_CHECK (&reader, c, 32, 2, 0x02);
 169   GET_CHECK (&reader, c, 32, 2, 0x02);
 170   PEEK_CHECK (&reader, c, 32, 8, 0x09);
 171   fail_unless (gst_bit_reader_skip (&reader, 3 * 8));
 172   GET_CHECK (&reader, c, 32, 15, 0x2190);
 173   GET_CHECK (&reader, c, 32, 1, 0x1);
 174   GET_CHECK_FAIL (&reader, c, 32, 1);
 175
 176   /* 64 bit */
 177   gst_bit_reader_init (&reader, data, 16);
 178
 179   GET_CHECK (&reader, d, 64, 64, G_GINT64_CONSTANT (0x1234567890abcdef));
 180   GET_CHECK (&reader, d, 64, 7, 0xfe >> 1);
 181   GET_CHECK (&reader, d, 64, 1, 0x00);
 182   GET_CHECK (&reader, d, 64, 24, 0xdcba09);
 183   GET_CHECK (&reader, d, 64, 32, 0x87654321);
 184   GET_CHECK_FAIL (&reader, d, 64, 32);
 185 }
 186
 187 GST_END_TEST;
 188
 189 #undef GET_CHECK
 190 #undef PEEK_CHECK
 191 #undef GET_CHECK_FAIL
 192 #undef PEEK_CHECK_FAIL
 193
 194 GST_START_TEST (test_position_tracking)
 195 {
 196   guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 197     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 198   };
 199   GstBitReader reader = GST_BIT_READER_INIT (data, 16);
 200   guint8 a = 0;
 201
 202   fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 0);
 203   fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8);
 204
 205   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &a, 3));
 206   fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 3);
 207   fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 3);
 208
 209   fail_unless (gst_bit_reader_set_pos (&reader, 9));
 210   fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 9);
 211   fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 9);
 212
 213   fail_unless (gst_bit_reader_skip (&reader, 3));
 214   fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 12);
 215   fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 12);
 216
 217   fail_unless (gst_bit_reader_skip_to_byte (&reader));
 218   fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 16);
 219   fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 16);
 220
 221   fail_unless (gst_bit_reader_set_pos (&reader, 16 * 8));
 222   fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 16 * 8);
 223   fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 0);
 224
 225   fail_unless (gst_bit_reader_skip (&reader, 0));
 226   fail_if (gst_bit_reader_skip (&reader, 1));
 227   fail_unless (gst_bit_reader_skip_to_byte (&reader));
 228 }
 229
 230 GST_END_TEST;
 231
 232 static Suite *
 233 gst_bit_reader_suite (void)
 234 {
 235   Suite *s = suite_create ("GstBitReader");
 236   TCase *tc_chain = tcase_create ("general");
 237
 238   suite_add_tcase (s, tc_chain);
 239
 240   tcase_add_test (tc_chain, test_initialization);
 241   tcase_add_test (tc_chain, test_get_bits);
 242   tcase_add_test (tc_chain, test_position_tracking);
 243
 244   return s;
 245 }
 246
 247
 248 GST_CHECK_MAIN (gst_bit_reader);