File: Reverse.cpp

package info (click to toggle)
audacity 0.98-3
  • links: PTS
  • area: main
  • in suites: woody
  • size: 2,896 kB
  • ctags: 4,089
  • sloc: cpp: 26,099; ansic: 4,961; sh: 2,465; makefile: 156; perl: 23
file content (83 lines) | stat: -rw-r--r-- 1,876 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/**********************************************************************

  Audacity: A Digital Audio Editor

  Reverse.cpp

  Mark Phillips

  This class reverses the selected audio.

**********************************************************************/

#include "Reverse.h"
#include "../WaveTrack.h"

//
// EffectReverse
//

EffectReverse::EffectReverse()
{
}

bool EffectReverse::Process()
{
   TrackListIterator iter(mWaveTracks);
   VTrack *t = iter.First();
   int count = 0;
   while(t) {
      sampleCount start, len;
      GetSamples((WaveTrack *)t, &start, &len);
      bool success = ProcessOne(count, (WaveTrack *)t, start, len);
      
      if (!success)
         return false;
   
      t = iter.Next();
      count++;
   }
   
   return true;
}

bool EffectReverse::ProcessOne(int count, WaveTrack *t,
                               sampleCount start, sampleCount len)
{
   // keep track of two blocks whose data we will swap
   sampleCount first = start, second;
   sampleCount originalLen = len;
   sampleCount blockSize = t->GetMaxBlockSize();
   sampleType tmp;
   sampleType *buffer1 = new sampleType[blockSize],
              *buffer2 = new sampleType[blockSize];
   
   while (len > 1) {
      unsigned int block = t->GetBestBlockSize(first);
      if (block > len / 2)
         block = len / 2;
      second = first + len - block;

      t->Get(buffer1, first, block);
      t->Get(buffer2, second, block);
      for (unsigned int i = 0; i < block; i++) {
         tmp = buffer1[i];
         buffer1[i] = buffer2[block-i-1];
         buffer2[block-i-1] = tmp;
      }
      t->Set(buffer1, first, block);
      t->Set(buffer2, second, block);

      len -= 2 * block;
      first += block;
      
      if (TrackProgress(count, 2*(first-start)/(double)originalLen))
         break;
   }

   delete[] buffer1;
   delete[] buffer2;

   return true;
}