libs/audiographer/tests/general/silence_trimmer_test.cc

   1 #include "tests/utils.h"
   2
   3 #include "audiographer/general/silence_trimmer.h"
   4
   5 using namespace AudioGrapher;
   6
   7 class SilenceTrimmerTest : public CppUnit::TestFixture
   8 {
   9   CPPUNIT_TEST_SUITE (SilenceTrimmerTest);
  10   CPPUNIT_TEST (testExceptions);
  11   CPPUNIT_TEST (testFullBuffers);
  12   CPPUNIT_TEST (testPartialBuffers);
  13   CPPUNIT_TEST (testAddSilenceBeginning);
  14   CPPUNIT_TEST (testAddSilenceEnd);
  15   CPPUNIT_TEST_SUITE_END ();
  16
  17   public:
  18         void setUp()
  19         {
  20                 frames = 128;
  21
  22                 random_data = TestUtils::init_random_data(frames);
  23                 random_data[0] = 0.5;
  24                 random_data[frames - 1] = 0.5;
  25
  26                 zero_data = new float[frames];
  27                 memset(zero_data, 0, frames * sizeof(float));
  28
  29                 half_random_data = TestUtils::init_random_data(frames);
  30                 memset(half_random_data, 0, (frames / 2) * sizeof(float));
  31
  32                 trimmer.reset (new SilenceTrimmer<float> (frames / 2));
  33                 sink.reset (new AppendingVectorSink<float>());
  34
  35                 trimmer->set_trim_beginning (true);
  36                 trimmer->set_trim_end (true);
  37         }
  38
  39         void tearDown()
  40         {
  41                 delete [] random_data;
  42                 delete [] zero_data;
  43                 delete [] half_random_data;
  44         }
  45
  46         void testFullBuffers()
  47         {
  48                 trimmer->add_output (sink);
  49
  50                 {
  51                 ProcessContext<float> c (zero_data, frames, 1);
  52                 trimmer->process (c);
  53                 framecnt_t frames_processed = sink->get_data().size();
  54                 CPPUNIT_ASSERT_EQUAL ((framecnt_t) 0, frames_processed);
  55                 }
  56
  57                 {
  58                 ProcessContext<float> c (random_data, frames, 1);
  59                 trimmer->process (c);
  60                 framecnt_t frames_processed = sink->get_data().size();
  61                 CPPUNIT_ASSERT_EQUAL (frames, frames_processed);
  62                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, frames));
  63                 }
  64
  65                 {
  66                 ProcessContext<float> c (zero_data, frames, 1);
  67                 trimmer->process (c);
  68                 framecnt_t frames_processed = sink->get_data().size();
  69                 CPPUNIT_ASSERT_EQUAL (frames, frames_processed);
  70                 }
  71
  72                 {
  73                 ProcessContext<float> c (random_data, frames, 1);
  74                 trimmer->process (c);
  75                 framecnt_t frames_processed = sink->get_data().size();
  76                 CPPUNIT_ASSERT_EQUAL (3 * frames, frames_processed);
  77                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, frames));
  78                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames], zero_data, frames));
  79                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[2 * frames], random_data, frames));
  80                 }
  81
  82                 {
  83                 ProcessContext<float> c (zero_data, frames, 1);
  84                 trimmer->process (c);
  85                 framecnt_t frames_processed = sink->get_data().size();
  86                 CPPUNIT_ASSERT_EQUAL (3 * frames, frames_processed);
  87                 }
  88         }
  89
  90         void testPartialBuffers()
  91         {
  92                 trimmer->add_output (sink);
  93                 trimmer->reset (frames / 4);
  94                 trimmer->set_trim_beginning (true);
  95                 trimmer->set_trim_end (true);
  96
  97                 {
  98                 ProcessContext<float> c (half_random_data, frames, 1);
  99                 trimmer->process (c);
 100                 framecnt_t frames_processed = sink->get_data().size();
 101                 CPPUNIT_ASSERT_EQUAL (frames / 2, frames_processed);
 102                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), &half_random_data[frames / 2], frames / 2));
 103                 }
 104
 105                 {
 106                 ProcessContext<float> c (zero_data, frames, 1);
 107                 trimmer->process (c);
 108                 framecnt_t frames_processed = sink->get_data().size();
 109                 CPPUNIT_ASSERT_EQUAL (frames / 2, frames_processed);
 110                 }
 111
 112                 {
 113                 ProcessContext<float> c (half_random_data, frames, 1);
 114                 trimmer->process (c);
 115                 framecnt_t frames_processed = sink->get_data().size();
 116                 CPPUNIT_ASSERT_EQUAL (2 * frames + frames / 2, frames_processed);
 117                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames + frames / 2], half_random_data, frames));
 118                 }
 119         }
 120
 121         void testExceptions()
 122         {
 123                 {
 124                 CPPUNIT_ASSERT_THROW (trimmer->reset (0), Exception);
 125                 }
 126         }
 127
 128         void testAddSilenceBeginning()
 129         {
 130                 trimmer->add_output (sink);
 131
 132                 framecnt_t silence = frames / 2;
 133                 trimmer->add_silence_to_beginning (silence);
 134
 135                 {
 136                 ProcessContext<float> c (random_data, frames, 1);
 137                 trimmer->process (c);
 138                 }
 139
 140                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), zero_data, silence));
 141                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[silence], random_data, frames));
 142         }
 143
 144         void testAddSilenceEnd()
 145         {
 146                 trimmer->add_output (sink);
 147
 148                 framecnt_t silence = frames / 3;
 149                 trimmer->add_silence_to_end (silence);
 150
 151                 {
 152                 ProcessContext<float> c (random_data, frames, 1);
 153                 trimmer->process (c);
 154                 }
 155
 156                 {
 157                 ProcessContext<float> c (random_data, frames, 1);
 158                 c.set_flag (ProcessContext<float>::EndOfInput);
 159                 trimmer->process (c);
 160                 }
 161
 162                 framecnt_t frames_processed = sink->get_data().size();
 163                 framecnt_t total_frames = 2 * frames + silence;
 164                 CPPUNIT_ASSERT_EQUAL (total_frames, frames_processed);
 165                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, frames));
 166                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames], random_data, frames));
 167                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames * 2], zero_data, silence));
 168         }
 169
 170   private:
 171         boost::shared_ptr<SilenceTrimmer<float> > trimmer;
 172         boost::shared_ptr<AppendingVectorSink<float> > sink;
 173
 174         float * random_data;
 175         float * zero_data;
 176         float * half_random_data;
 177         framecnt_t frames;
 178 };
 179
 180 CPPUNIT_TEST_SUITE_REGISTRATION (SilenceTrimmerTest);