Audacity  3.0.3
Benchmark.cpp
Go to the documentation of this file.
1 /**********************************************************************
2 
3  Audacity: A Digital Audio Editor
4 
5  Benchmark.cpp
6 
7  Dominic Mazzoni
8 
9 *******************************************************************//*******************************************************************/
16 
17 
18 
19 #include "Benchmark.h"
20 
21 #include <wx/app.h>
22 #include <wx/log.h>
23 #include <wx/textctrl.h>
24 #include <wx/button.h>
25 #include <wx/checkbox.h>
26 #include <wx/choice.h>
27 #include <wx/dialog.h>
28 #include <wx/sizer.h>
29 #include <wx/stattext.h>
30 #include <wx/timer.h>
31 #include <wx/utils.h>
32 #include <wx/valgen.h>
33 #include <wx/valtext.h>
34 #include <wx/intl.h>
35 
36 #include "SampleBlock.h"
37 #include "ShuttleGui.h"
38 #include "Project.h"
39 #include "WaveClip.h"
40 #include "WaveTrack.h"
41 #include "Sequence.h"
42 #include "Prefs.h"
43 #include "ProjectSettings.h"
44 #include "ViewInfo.h"
45 
46 #include "FileNames.h"
48 #include "widgets/wxPanelWrapper.h"
49 
50 // Change these to the desired format...should probably make the
51 // choice available in the dialog
52 #define SampleType short
53 #define SampleFormat int16Sample
54 
55 class BenchmarkDialog final : public wxDialogWrapper
56 {
57 public:
58  // constructors and destructors
59  BenchmarkDialog( wxWindow *parent, AudacityProject &project );
60 
61  void MakeBenchmarkDialog();
62 
63 private:
64  // WDR: handler declarations
65  void OnRun( wxCommandEvent &event );
66  void OnSave( wxCommandEvent &event );
67  void OnClear( wxCommandEvent &event );
68  void OnClose( wxCommandEvent &event );
69 
70  void Printf(const TranslatableString &str);
71  void HoldPrint(bool hold);
72  void FlushPrint();
73 
76 
77  bool mHoldPrint;
78  wxString mToPrint;
79 
80  wxString mBlockSizeStr;
81  wxString mDataSizeStr;
82  wxString mNumEditsStr;
83  wxString mRandSeedStr;
84 
87 
88  wxTextCtrl *mText;
89 
90 private:
91  DECLARE_EVENT_TABLE()
92 };
93 
94 void RunBenchmark( wxWindow *parent, AudacityProject &project )
95 {
96  /*
97  int action = AudacityMessageBox(
98 XO("This will close all project windows (without saving)\nand open the Audacity Benchmark dialog.\n\nAre you sure you want to do this?"),
99  XO("Benchmark"),
100  wxYES_NO | wxICON_EXCLAMATION,
101  NULL);
102 
103  if (action != wxYES)
104  return;
105 
106  for ( auto pProject : AllProjects{} )
107  GetProjectFrame( *pProject ).Close();
108  */
109 
110  BenchmarkDialog dlog{ parent, project };
111 
112  dlog.CentreOnParent();
113 
114  dlog.ShowModal();
115 }
116 
117 //
118 // BenchmarkDialog
119 //
120 
121 enum {
122  RunID = 1000,
129  RandSeedID
130 };
131 
132 BEGIN_EVENT_TABLE(BenchmarkDialog, wxDialogWrapper)
136  EVT_BUTTON( wxID_CANCEL, BenchmarkDialog::OnClose )
138 
140  wxWindow *parent, AudacityProject &project)
141  :
142  /* i18n-hint: Benchmark means a software speed test */
143  wxDialogWrapper( parent, 0, XO("Benchmark"),
144  wxDefaultPosition, wxDefaultSize,
145  wxDEFAULT_DIALOG_STYLE |
146  wxRESIZE_BORDER)
147  , mProject(project)
148  , mSettings{ ProjectSettings::Get(project) }
149 {
150  SetName();
151 
152  mBlockSizeStr = wxT("64");
153  mNumEditsStr = wxT("100");
154  mDataSizeStr = wxT("32");
155  mRandSeedStr = wxT("234657");
156 
157  mBlockDetail = false;
158  mEditDetail = false;
159 
160  HoldPrint(false);
161 
162  MakeBenchmarkDialog();
163 }
164 
165 // WDR: handler implementations for BenchmarkDialog
166 
167 void BenchmarkDialog::OnClose(wxCommandEvent & WXUNUSED(event))
168 {
169  EndModal(0);
170 }
171 
173 {
174  ShuttleGui S(this, eIsCreating);
175 
176  // Strings don't need to be translated because this class doesn't
177  // ever get used in a stable release.
178 
179  S.StartVerticalLay(true);
180  {
181  S.SetBorder(8);
182  S.StartMultiColumn(4);
183  {
184  //
185  S.Id(BlockSizeID)
186  .Validator<wxTextValidator>(wxFILTER_NUMERIC, &mBlockSizeStr)
187  .AddTextBox(XXO("Disk Block Size (KB):"),
188  wxT(""),
189  12);
190 
191  //
192  S.Id(NumEditsID)
193  .Validator<wxTextValidator>(wxFILTER_NUMERIC, &mNumEditsStr)
194  .AddTextBox(XXO("Number of Edits:"),
195  wxT(""),
196  12);
197 
198  //
199  S.Id(DataSizeID)
200  .Validator<wxTextValidator>(wxFILTER_NUMERIC, &mDataSizeStr)
201  .AddTextBox(XXO("Test Data Size (MB):"),
202  wxT(""),
203  12);
204 
206  S.Id(RandSeedID)
207  .Validator<wxTextValidator>(wxFILTER_NUMERIC, &mRandSeedStr)
208  /* i18n-hint: A "seed" is a number that initializes a
209  pseudorandom number generating algorithm */
210  .AddTextBox(XXO("Random Seed:"),
211  wxT(""),
212  12);
213 
214  }
215  S.EndMultiColumn();
216 
217  //
218  S.Validator<wxGenericValidator>(&mBlockDetail)
219  .AddCheckBox(XXO("Show detailed info about each block file"),
220  false);
221 
222  //
223  S.Validator<wxGenericValidator>(&mEditDetail)
224  .AddCheckBox(XXO("Show detailed info about each editing operation"),
225  false);
226 
227  //
228  mText = S.Id(StaticTextID)
229  /* i18n-hint noun */
230  .Name(XO("Output"))
231  .Style( wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH )
232  .MinSize( { 500, 200 } )
233  .AddTextWindow(wxT(""));
234 
235  //
236  S.SetBorder(10);
237  S.StartHorizontalLay(wxALIGN_LEFT | wxEXPAND, false);
238  {
239  S.StartHorizontalLay(wxALIGN_LEFT, false);
240  {
241  S.Id(RunID).AddButton(XXO("Run"), wxALIGN_CENTRE, true);
242  S.Id(BSaveID).AddButton(XXO("Save"));
243  /* i18n-hint verb; to empty or erase */
244  S.Id(ClearID).AddButton(XXO("Clear"));
245  }
246  S.EndHorizontalLay();
247 
248  S.StartHorizontalLay(wxALIGN_CENTER, true);
249  {
250  // Spacer
251  }
252  S.EndHorizontalLay();
253 
254  S.StartHorizontalLay(wxALIGN_NOT | wxALIGN_LEFT, false);
255  {
256  /* i18n-hint verb */
257  S.Id(wxID_CANCEL).AddButton(XXO("Close"));
258  }
259  S.EndHorizontalLay();
260  }
261  S.EndHorizontalLay();
262  }
263  S.EndVerticalLay();
264 
265  Fit();
266  SetSizeHints(GetSize());
267 }
268 
269 void BenchmarkDialog::OnSave( wxCommandEvent & WXUNUSED(event))
270 {
271 /* i18n-hint: Benchmark means a software speed test;
272  leave untranslated file extension .txt */
273  auto fName = XO("benchmark.txt").Translation();
274 
275  fName = FileNames::SelectFile(FileNames::Operation::Export,
276  XO("Export Benchmark Data as:"),
277  wxEmptyString,
278  fName,
279  wxT("txt"),
281  wxFD_SAVE | wxRESIZE_BORDER,
282  this);
283 
284  if (fName.empty())
285  return;
286 
287  mText->SaveFile(fName);
288 }
289 
290 void BenchmarkDialog::OnClear(wxCommandEvent & WXUNUSED(event))
291 {
292  mText->Clear();
293 }
294 
296 {
297  auto s = str.Translation();
298  mToPrint += s;
299  if (!mHoldPrint)
300  FlushPrint();
301 }
302 
304 {
305  mHoldPrint = hold;
306 
307  if (!mHoldPrint)
308  FlushPrint();
309 }
310 
312 {
313  while(mToPrint.length() > 100) {
314  mText->AppendText(mToPrint.Left(100));
315  mToPrint = mToPrint.Right(mToPrint.length() - 100);
316  }
317  if (mToPrint.length() > 0)
318  mText->AppendText(mToPrint);
319  mToPrint = wxT("");
320 }
321 
322 void BenchmarkDialog::OnRun( wxCommandEvent & WXUNUSED(event))
323 {
324  TransferDataFromWindow();
325 
326  if (!Validate())
327  return;
328 
329  // This code will become part of libaudacity,
330  // and this class will be phased out.
331  long blockSize, numEdits, dataSize, randSeed;
332 
333  mBlockSizeStr.ToLong(&blockSize);
334  mNumEditsStr.ToLong(&numEdits);
335  mDataSizeStr.ToLong(&dataSize);
336  mRandSeedStr.ToLong(&randSeed);
337 
338  if (blockSize < 1 || blockSize > 1024) {
340  XO("Block size should be in the range 1 - 1024 KB.") );
341  return;
342  }
343 
344  if (numEdits < 1 || numEdits > 10000) {
346  XO("Number of edits should be in the range 1 - 10000.") );
347  return;
348  }
349 
350  if (dataSize < 1 || dataSize > 2000) {
352  XO("Test data size should be in the range 1 - 2000 MB.") );
353  return;
354  }
355 
356  bool editClipCanMove = true;
357  gPrefs->Read(wxT("/GUI/EditClipCanMove"), &editClipCanMove);
358  gPrefs->Write(wxT("/GUI/EditClipCanMove"), false);
359  gPrefs->Flush();
360 
361  // Remember the old blocksize, so that we can restore it later.
362  auto oldBlockSize = Sequence::GetMaxDiskBlockSize();
363  Sequence::SetMaxDiskBlockSize(blockSize * 1024);
364 
365  const auto cleanup = finally( [&] {
366  Sequence::SetMaxDiskBlockSize(oldBlockSize);
367  gPrefs->Write(wxT("/GUI/EditClipCanMove"), editClipCanMove);
368  gPrefs->Flush();
369  } );
370 
371  wxBusyCursor busy;
372 
373  HoldPrint(true);
374 
375  const auto t =
378  .NewWaveTrack(SampleFormat);
379 
380  t->SetRate(1);
381 
382  srand(randSeed);
383 
384  uint64_t nChunks, chunkSize;
385  //chunkSize = 7500ull + (rand() % 1000ull);
386  chunkSize = 200ull + (rand() % 100ull);
387  nChunks = (dataSize * 1048576ull) / (chunkSize*sizeof(SampleType));
388  while (nChunks < 20 || chunkSize > (blockSize*1024)/4)
389  {
390  chunkSize = std::max( uint64_t(1), (chunkSize / 2) + (rand() % 100) );
391  nChunks = (dataSize * 1048576ull) / (chunkSize*sizeof(SampleType));
392  }
393 
394  // The chunks are the pieces we move around in the test.
395  // They are (and are supposed to be) a different size to
396  // the blocks that make the sample blocks. That way we get to
397  // do some testing of when edit chunks cross sample block boundaries.
398  Printf( XO("Using %lld chunks of %lld samples each, for a total of %.1f MB.\n")
399  .Format( nChunks, chunkSize, nChunks*chunkSize*sizeof(SampleType)/1048576.0 ) );
400 
401  int trials = numEdits;
402 
403  using Samples = ArrayOf<SampleType>;
404  Samples small1{nChunks};
405  Samples block{chunkSize};
406 
407  Printf( XO("Preparing...\n") );
408 
409  wxTheApp->Yield();
410  FlushPrint();
411 
412  int v;
413  int bad;
414  int z;
415  long elapsed;
416  wxString tempStr;
417  wxStopWatch timer;
418 
419  for (uint64_t i = 0; i < nChunks; i++) {
420  v = SampleType(rand());
421  small1[i] = v;
422  for (uint64_t b = 0; b < chunkSize; b++)
423  block[b] = v;
424 
425  t->Append((samplePtr)block.get(), SampleFormat, chunkSize);
426  }
427  t->Flush();
428 
429  // This forces the WaveTrack to flush all of the appends (which is
430  // only necessary if you want to access the Sequence class directly,
431  // as we're about to do).
432  t->GetEndTime();
433 
434  if (t->GetClipByIndex(0)->GetSequence()->GetNumSamples() != nChunks * chunkSize) {
435  Printf( XO("Expected len %lld, track len %lld.\n")
436  .Format(
437  nChunks * chunkSize,
438  t->GetClipByIndex(0)->GetSequence()->GetNumSamples()
439  .as_long_long() ) );
440  goto fail;
441  }
442 
443  Printf( XO("Performing %d edits...\n").Format( trials ) );
444  wxTheApp->Yield();
445  FlushPrint();
446 
447  timer.Start();
448  for (z = 0; z < trials; z++) {
449  // First chunk to cut
450  // 0 <= x0 < nChunks
451  const uint64_t x0 = rand() % nChunks;
452 
453  // Number of chunks to cut
454  // 1 <= xlen <= nChunks - x0
455  const uint64_t xlen = 1 + (rand() % (nChunks - x0));
456  if (mEditDetail)
457  Printf( XO("Cut: %lld - %lld \n")
458  .Format( x0 * chunkSize, (x0 + xlen) * chunkSize) );
459 
460  Track::Holder tmp;
461  try {
462  tmp = t->Cut(double (x0 * chunkSize), double ((x0 + xlen) * chunkSize));
463  }
464  catch (const AudacityException&) {
465  Printf( XO("Trial %d\n").Format( z ) );
466  Printf( XO("Cut (%lld, %lld) failed.\n")
467  .Format( (x0 * chunkSize), (x0 + xlen) * chunkSize) );
468  Printf( XO("Expected len %lld, track len %lld.\n")
469  .Format(
470  nChunks * chunkSize,
471  t->GetClipByIndex(0)->GetSequence()->GetNumSamples()
472  .as_long_long() ) );
473  goto fail;
474  }
475 
476  // Position to paste
477  // 0 <= y0 <= nChunks - xlen
478  const uint64_t y0 = rand() % (nChunks - xlen + 1);
479 
480  if (mEditDetail)
481  Printf( XO("Paste: %lld\n").Format( y0 * chunkSize ) );
482 
483  try {
484  t->Paste((double)(y0 * chunkSize), tmp.get());
485  }
486  catch (const AudacityException&) {
487  Printf( XO("Trial %d\nFailed on Paste.\n").Format( z ) );
488  goto fail;
489  }
490 
491  if (t->GetClipByIndex(0)->GetSequence()->GetNumSamples() != nChunks * chunkSize) {
492  Printf( XO("Trial %d\n").Format( z ) );
493  Printf( XO("Expected len %lld, track len %lld.\n")
494  .Format(
495  nChunks * chunkSize,
496  t->GetClipByIndex(0)->GetSequence()->GetNumSamples()
497  .as_long_long() ) );
498  goto fail;
499  }
500 
501  // Permute small1 correspondingly to the cut and paste
502  auto first = &small1[0];
503  if (x0 + xlen < nChunks)
504  std::rotate( first + x0, first + x0 + xlen, first + nChunks );
505  std::rotate( first + y0, first + nChunks - xlen, first + nChunks );
506  }
507 
508  elapsed = timer.Time();
509 
510  if (mBlockDetail) {
511  auto seq = t->GetClipByIndex(0)->GetSequence();
512  seq->DebugPrintf(seq->GetBlockArray(), seq->GetNumSamples(), &tempStr);
513  mToPrint += tempStr;
514  }
515  Printf( XO("Time to perform %d edits: %ld ms\n").Format( trials, elapsed ) );
516  FlushPrint();
517  wxTheApp->Yield();
518 
519 
520 #if 0
521  Printf( XO("Checking file pointer leaks:\n") );
522  Printf( XO("Track # blocks: %ld\n").Format( t->GetBlockArray()->size() ) );
523  Printf( XO("Disk # blocks: \n") );
524  system("ls .audacity_temp/* | wc --lines");
525 #endif
526 
527  Printf( XO("Doing correctness check...\n") );
528  FlushPrint();
529  wxTheApp->Yield();
530 
531  bad = 0;
532  timer.Start();
533  for (uint64_t i = 0; i < nChunks; i++) {
534  v = small1[i];
535  t->Get((samplePtr)block.get(), SampleFormat, i * chunkSize, chunkSize);
536  for (uint64_t b = 0; b < chunkSize; b++)
537  if (block[b] != v) {
538  bad++;
539  if (bad < 10)
540  Printf( XO("Bad: chunk %lld sample %lld\n").Format( i, b ) );
541  b = chunkSize;
542  }
543  }
544  if (bad == 0)
545  Printf( XO("Passed correctness check!\n") );
546  else
547  Printf( XO("Errors in %d/%lld chunks\n").Format( bad, nChunks ) );
548 
549  elapsed = timer.Time();
550 
551  Printf( XO("Time to check all data: %ld ms\n").Format( elapsed ) );
552  Printf( XO("Reading data again...\n") );
553 
554  wxTheApp->Yield();
555  FlushPrint();
556 
557  timer.Start();
558 
559  for (uint64_t i = 0; i < nChunks; i++) {
560  v = small1[i];
561  t->Get((samplePtr)block.get(), SampleFormat, i * chunkSize, chunkSize);
562  for (uint64_t b = 0; b < chunkSize; b++)
563  if (block[b] != v)
564  bad++;
565  }
566 
567  elapsed = timer.Time();
568 
569  Printf( XO("Time to check all data (2): %ld ms\n").Format( elapsed ) );
570 
571  Printf( XO("At 44100 Hz, %d bytes per sample, the estimated number of\n simultaneous tracks that could be played at once: %.1f\n" )
572  .Format( SAMPLE_SIZE(SampleFormat), (nChunks*chunkSize/44100.0)/(elapsed/1000.0) ) );
573 
574  goto success;
575 
576  fail:
577  Printf( XO("TEST FAILED!!!\n") );
578 
579  success:
580 
581  Printf( XO("Benchmark completed successfully.\n") );
582  HoldPrint(false);
583 }
WaveTrack.h
EVT_BUTTON
EVT_BUTTON(wxID_NO, DependencyDialog::OnNo) EVT_BUTTON(wxID_YES
TranslatableString
Definition: Types.h:290
eIsCreating
@ eIsCreating
Definition: ShuttleGui.h:36
ShuttleGuiBase::StartVerticalLay
void StartVerticalLay(int iProp=1)
Definition: ShuttleGui.cpp:1177
SampleFormat
#define SampleFormat
Definition: Benchmark.cpp:53
BenchmarkDialog::FlushPrint
void FlushPrint()
Definition: Benchmark.cpp:311
BenchmarkDialog::mBlockSizeStr
wxString mBlockSizeStr
Definition: Benchmark.cpp:80
BenchmarkDialog::HoldPrint
void HoldPrint(bool hold)
Definition: Benchmark.cpp:303
gPrefs
FileConfig * gPrefs
Definition: Prefs.cpp:67
RandSeedID
@ RandSeedID
Definition: Benchmark.cpp:129
AudacityMessageBox
int AudacityMessageBox(const TranslatableString &message, const TranslatableString &caption=AudacityMessageBoxCaptionStr(), long style=wxOK|wxCENTRE, wxWindow *parent=NULL, int x=wxDefaultCoord, int y=wxDefaultCoord)
Definition: AudacityMessageBox.h:20
Project.h
Format
Abstract base class used in importing a file.
BenchmarkDialog::mText
wxTextCtrl * mText
Definition: Benchmark.cpp:88
BenchmarkDialog::mProject
AudacityProject & mProject
Definition: Benchmark.cpp:74
RunBenchmark
void RunBenchmark(wxWindow *parent, AudacityProject &project)
Definition: Benchmark.cpp:94
Sequence::GetMaxDiskBlockSize
static size_t GetMaxDiskBlockSize()
Definition: Sequence.cpp:1953
ShuttleGui::MinSize
ShuttleGui & MinSize()
Definition: ShuttleGui.h:740
XO
#define XO(s)
Definition: Internat.h:32
wxPanelWrapper.h
ProjectSettings::Get
static ProjectSettings & Get(AudacityProject &project)
Definition: ProjectSettings.cpp:39
ShuttleGuiBase::EndMultiColumn
void EndMultiColumn()
Definition: ShuttleGui.cpp:1212
ProjectSettings.h
ClearID
@ ClearID
Definition: Benchmark.cpp:124
BenchmarkDialog::mRandSeedStr
wxString mRandSeedStr
Definition: Benchmark.cpp:83
BenchmarkDialog::mNumEditsStr
wxString mNumEditsStr
Definition: Benchmark.cpp:82
Sequence::SetMaxDiskBlockSize
static void SetMaxDiskBlockSize(size_t bytes)
Definition: Sequence.cpp:1948
ShuttleGui::Id
ShuttleGui & Id(int id)
Definition: ShuttleGui.cpp:2248
BlockSizeID
@ BlockSizeID
Definition: Benchmark.cpp:126
SampleBlock.h
BenchmarkDialog::mDataSizeStr
wxString mDataSizeStr
Definition: Benchmark.cpp:81
BenchmarkDialog::OnClear
void OnClear(wxCommandEvent &event)
Definition: Benchmark.cpp:290
AudacityException
Base class for exceptions specially processed by the application.
Definition: AudacityException.h:25
samplePtr
char * samplePtr
Definition: Types.h:737
BenchmarkDialog::OnSave
void OnSave(wxCommandEvent &event)
Definition: Benchmark.cpp:269
XXO
#define XXO(s)
Definition: Internat.h:45
BenchmarkDialog::MakeBenchmarkDialog
void MakeBenchmarkDialog()
Definition: Benchmark.cpp:172
BenchmarkDialog::Printf
void Printf(const TranslatableString &str)
Definition: Benchmark.cpp:295
ShuttleGuiBase::EndHorizontalLay
void EndHorizontalLay()
Definition: ShuttleGui.cpp:1170
Track::Holder
std::shared_ptr< Track > Holder
Definition: Track.h:324
ShuttleGuiBase::StartHorizontalLay
void StartHorizontalLay(int PositionFlags=wxALIGN_CENTRE, int iProp=1)
Definition: ShuttleGui.cpp:1160
SampleType
#define SampleType
Definition: Benchmark.cpp:52
FileNames::TextFiles
AUDACITY_DLL_API const FileType TextFiles
Definition: FileNames.h:77
ShuttleGuiBase::StartMultiColumn
void StartMultiColumn(int nCols, int PositionFlags=wxALIGN_LEFT)
Definition: ShuttleGui.cpp:1203
ShuttleGuiBase::EndVerticalLay
void EndVerticalLay()
Definition: ShuttleGui.cpp:1196
StaticTextID
@ StaticTextID
Definition: Benchmark.cpp:125
BenchmarkDialog::mHoldPrint
bool mHoldPrint
Definition: Benchmark.cpp:77
ShuttleGui::Validator
ShuttleGui & Validator(const Factory &f)
Definition: ShuttleGui.h:685
SampleBlockFactory::New
static SampleBlockFactoryPtr New(AudacityProject &project)
Definition: SampleBlock.cpp:31
ShuttleGui.h
ViewInfo.h
WaveTrackFactory
Used to create or clone a WaveTrack, with appropriate context from the project that will own the trac...
Definition: WaveTrack.h:675
ShuttleGuiBase::AddButton
wxButton * AddButton(const TranslatableString &Text, int PositionFlags=wxALIGN_CENTRE, bool setDefault=false)
Definition: ShuttleGui.cpp:353
ShuttleGui::Name
ShuttleGui & Name(const TranslatableString &name)
Definition: ShuttleGui.h:670
wxDialogWrapper
Definition: wxPanelWrapper.h:81
DataSizeID
@ DataSizeID
Definition: Benchmark.cpp:127
BenchmarkDialog
BenchmarkDialog is used for measuring performance and accuracy of sample block storage.
Definition: Benchmark.cpp:56
FileConfig::Flush
virtual bool Flush(bool bCurrentOnly=false) wxOVERRIDE
Definition: FileConfig.cpp:151
FileNames::SelectFile
AUDACITY_DLL_API FilePath SelectFile(Operation op, const TranslatableString &message, const FilePath &default_path, const FilePath &default_filename, const FileExtension &default_extension, const FileTypes &fileTypes, int flags, wxWindow *parent)
AudacityProject
The top-level handle to an Audacity project. It serves as a source of events that other objects can b...
Definition: Project.h:112
BenchmarkDialog::mSettings
const ProjectSettings & mSettings
Definition: Benchmark.cpp:75
FileNames.h
AudacityMessageBox.h
BenchmarkDialog::BenchmarkDialog
BenchmarkDialog(wxWindow *parent, AudacityProject &project)
Definition: Benchmark.cpp:139
Sequence.h
BenchmarkDialog::mBlockDetail
bool mBlockDetail
Definition: Benchmark.cpp:85
BenchmarkDialog::mToPrint
wxString mToPrint
Definition: Benchmark.cpp:78
Prefs.h
TranslatableString::Translation
wxString Translation() const
Definition: Types.h:337
ShuttleGuiBase::SetBorder
void SetBorder(int Border)
Definition: ShuttleGui.h:497
BenchmarkDialog::OnClose
void OnClose(wxCommandEvent &event)
Definition: Benchmark.cpp:167
Benchmark.h
NumEditsID
@ NumEditsID
Definition: Benchmark.cpp:128
END_EVENT_TABLE
END_EVENT_TABLE()
ArrayOf
This simplifies arrays of arrays, each array separately allocated with NEW[] But it might be better t...
Definition: MemoryX.h:82
SAMPLE_SIZE
#define SAMPLE_SIZE(SampleFormat)
Definition: Types.h:732
ShuttleGui
Derived from ShuttleGuiBase, an Audacity specific class for shuttling data to and from GUI.
Definition: ShuttleGui.h:638
WaveClip.h
RunID
@ RunID
Definition: Benchmark.cpp:122
BenchmarkDialog::OnRun
void OnRun(wxCommandEvent &event)
Definition: Benchmark.cpp:322
ProjectSettings
Holds various per-project settings values, including the sample rate, and sends events to the project...
Definition: ProjectSettings.h:53
BSaveID
@ BSaveID
Definition: Benchmark.cpp:123
BenchmarkDialog::mEditDetail
bool mEditDetail
Definition: Benchmark.cpp:86