--- THINGS TO DO FOR SURE ---

	- Create an implementation of CRWLock (rename to CRWMutex) that doesn't use rwlock's when they're unavailable (netbsd)

	- need a prefix flag for fftw libs in configure.ac
		- or see if there's an .m4 that comes with the lib


	- Create a crossfade feature when pasting and a gain parameter.

	- change --with-FOX-path and include to just --with-FOX-prefix like the rest

	- When they're all implemented, I need to update the description to something like: 
		... Including features such as: Recording, Effects Previews, Realistic Reverbs, Convolution, Custom FIR Filters, Several IIR Filters, Many Supported Audio Formats, LADSPA Support, Undo/Redo, Level Meters & Frequency Analyzer, Seek Shuttle Wheel, Loads of Editing Tools, Dynamic Range Compressor, and Many Other Tools
			- and decide on the best ordering of this listing
			- I'm also trying to negotiate some noise removal actions

	- Implement createKey and getValue methods in CNestedData file and use them properly so I'm not doing string conversions everywhere in there

	- Make a links section on the homepage about who is/has-used ReZound

	- I might want to make sure that gcc is some minimum version in configure.in.. I really don't think gcc2.8 will cut it

	- if any problem shows up with reswrap not being found causing problems... then it would be quite simple to write a very simple .c file that for every argument outputs stdout the array definition

	- create a effects->gapper/cutter/muter action which either inserts a gap, mutes, or deletes small sections of sound based on a setting which says how often to do it, and how long to do it when it happens
		- the frequency and length parameters should be LFOs... this would be a good time to demonstrate this functionality of choosing an LFO
		- also two parameters, attack and release should say 

	- go to each dialog and make at least some presets for each that could use it
		- crossfading could use it

	- eventually need to go through and remove all the unneeded commented code

	- HMM... I've been thinking about a decision I made a long time ago about selected regions...
		- I decided back then that I would have a start and a stop postion int stored internally
		- However, if there's one thing C teaches you, it's that for a region, a start/length combination is better.
		- In many places I have to have a +1, -1, max(1,...) etc.. also, the stop could wind up being less than the start
		- if I used a start/length combination, I would have a fair amount of code to modify, but I think border conditions would be less of a problem.
		- I could still have the getStart/Stop setStart/Stop methods in channel
		- also, this should allow me to have zero length sounds with no trouble... I shouldn't have to make an exception; I just make it a rule to draw the selection carefully on screen
		

	- Is there any way while recording we could know if data was dropped?
		- perhaps OSS can give a sequence number?  Then if one's missing it dropped something?

	- create an action under remaster called prepare-as-CD-track
		- this action should assume that the entire sound is going to be a track on a CD
			- I need to figure out how actionSound.start and stop are going to get set to the very endpoints automatically.... perhaps a flag to AAction to ignore the channel's positions
		- it should use an amplitude finder to trim all the silence from the end-points and then add the user-specified amount of space at the beginning and end.. 
			- or perhaps it should just use trim for any data that exceeds these amounts and add more space if necessary
		- the silence margins on the ends should also fade in and out to/from 0

	- When it's up on sourceforge (and ready to debut) announce to:
		- demudi
		- demudi-users
		- sox-users
		- foxgui-users
		- kurzlist [OT]
		- http://www.futureforums.co.uk/computermusic/default.asp
		- the individuals who emailed me from kurzlist: "any linux users out there"
		- the few individuals that reponded to my developer call on demudi

		- note: (something like this)
			   I'm annoucing the release of my sound editor, ReZound, on sourceforge now.  This message is going to many people
			and lists which I posted messages concerning it over the past few months.  Any developers out there interested in
			developing for it, I have written a document which explains the basics of creating new actions for it.  And any 
			one else out there willing to run it, please do.  However, you can make a personal note of any bugs, but I have
			compiled a list of the most obvious ones here: _url_ .  

			   Please enjoy it, and I hope that ReZound blossoms into a popular sound editing tool primarily for, but not
			limited to, linux.

		- also, put up on IOTD on flipcode and other announcement places like that
		- comp.dsp
		- freshmeat

	- Create a little description of how to make some interesting sound from a sample I give them.. show them how to take a small piece of it.. make it loop able.. then slow it down.. filter.. etc.. 
		- post several examples of my _alt# files

	- XXX I've been in contact with the libsndfile maintainer and the library looks quite good.  He's working on a few features like cues and user notes so that I can put it in without loosing functionality
		- I've said that I want to support another audio file libary in the future, but I did find that libaudiofile's API at least has support for loop points, cues, notes and arbitrary data, but it doesn't seem to even be implemented on wave save.
			- DONE Perhaps I will work to patch libaudiofile to get this functionality working.  Because SOX's lib form is far from existing
			- libsndfile has more formats than libaudiofile but has no API provisions for arbitrary data. AND it isn't packaged on hardly any distroes
			- Now another possiblity for at least giving a decent effort toward being able to load and save numerous other formats could be done by making a CSOXSoundTranslator : ASoundTranslator and have it shell out and actually run the sox command.  Maybe sox can even read and write to std i/o so I could avoid intermediate copies by sending it and receiving from it raw PCM data.
				- This would be under an explicit import/export set of buttons under the file actions because it would probably support no form of saving the cues and notes and such and the user could be warned that none of this information will be preserved.
				- configure should test for `sox` being valid and make it a depenancy... If it's not found, then the import and export file operations will be disabled
					- the configure script should make a big note of this on screen that import/export will be disabled
			- But I should still use libaudiofile to load and save wav, aiff, (ogg and mp3 if/when it's available)

	- always make sure that the actions accessers are const so that it's not causing the data to be written back to disk
		- infact, grep for Accesser and make sure than any are const whenever possible to avoid writing that data back to disk

	- in ddd, step thru a copy/insert action to make sure nothing unexpected is happening
		- when I was taking a file up above 2gb, I copied a 1.2g selection and it seemed to do something for a long time before growing the clipboard file during the copy action

	- write a little document in PoolFile that explains simply the layout of how PoolFileAccessors do their thing and perhaps a very simplified explination of how TPoolFile does what it does

	- Need someone like a sound engineer/hobbiest who can create interesting names and settings for presets of the effect
		- He would also be good to suggest new parameters for the effects

	- I want to add a gain or volume parameter for pasting data... Be able to apply that gain to the sound... 
		- it'd probably come up when you right click on the paste buttons



--- POSSIBLE THINGS TO DO ---

	- at some point I need to decide on a rounding function to use everywhere instead of using rint, round or nearbyint arbitrarily
		- make a define in platform or something

	- Now in at least two modules (LADSPA and CSoundPlayerChannel) and then perhaps in more than one place in each module I iterate over the sound in either looped or non-looped mode
		- I could create an iterator for a CSound object that would return data in the native format
		- In LADSPA where I might produce silence, I could either have the iterator that doesn't loop return zeros, or just check for end and produce zeros in the LADSPA code itself
		- If I implemented the pause before looping and durring selection I could even theoretically use that in LADSPA actions (although I don't know why)

	- There is a project called 'audiere' which I might be able to use to load .s3m, .it, .mod, etc if it was found.  I couldn't save, but I could at least load.

	- add a draw function so that if the user is zoomed in full, he can use the mouse to draw in the values he wants
		- it's probably a good idea to actually add random values to what is drawn so that you don't get quanitization
		- I could either implement this as something in FXWaveCanvas or maybe in a frontend dialog for an action, and it sends it to the backend to actually insert the data
			- this would be better, because after I work out preview the user will be able to hear the results
				- because if I did it in FXWaveCanvas I would probably want to allow undo each time the user let's go of the mouse button or something..
				- so the frontend could handle all this in one action to be undone

	- since I use my DAT to record long concerts, it would be nice if either while dumping after dumping, to have it create multiple sounds each time a certain length of silence has been encountered
		- then I wouldn't have to go find the tracks myself
		- OR, I could just have the record function automatically add markers after a what it thinks is a track delimeter
			- then I could create an action that says to cut/copy-to-new the selection as a new sound file... so the user would select the beginning, then snap to the next cue, then to the cut/copy-to-new action, then select the stop to the next cue and repeat
				- the user is going to have to choose a name for each track anyway.. so it can never really be fully automatic.. the user in this case just has an extra mouse click and menu click before typing in each name

	- add a feature which allows the user to have it save the selection to a file, runs a given or predefined command line on that file and loads it back in and replaces the region
		- these could be predefined in a CNestedDataFile somewhere 
			- potentially, the definition could include how to show and label input widgets (sliders, text entries, etc)
			- I could predefine some to support sox functionality
			- the user should be able to define their own and them appear in a "Custom" menu

	- allow displaying of rulers input widgets in other units... after implementing more stuff, I should be able to determine that there are just a handleful of paramter classes, some that determine length or amplitude or time etc.. so these classes of parameter types could have changable units on the frontend, but the backend would always be dealing with a single unit type

	- add an edit->enter-selection which brings up a dialog for the user to type in exactly the selection to make.. the start would be typed in and the stop would either be typed in, or a length beyond the start would be typed in

	- Create sliders or knobs next to the VU meters in the record dialog to be able to set a gain on the recording source per channel

	- If CActionParameters could have a getText() method, then I could log all of the actions on the sound incase someone wanted to know

	- If I really create some decent FFT actions and a filter toolkit of some kind, then it would be nice to have the backend somehow interact more actively with the frontend while selecting parameters like the cutoff frequency and ripple parameters of the filters, etc...

		- Perhaps the backend could render a pixel array as an image to display for whatever frontend there is.
		- along these lines I'm thinking that the AAction system could work as follows:
			- as is except, the AActionDialog would get passed a pointer to the factory.  Then the frontend derivation could ask the AActionFactory object for information on the action's would-be behavior based on a given CActionParameters from the current settings of the frontend.
				- for example, some FFT filter's dialog could have 3 sliders for parameters, each time the user moves the slider (let's go after dragging) the AActionDialog's derived class calls void *AActionFactory::getFrontendFeedback(CActionParameters *)... 
				- so the front end would create a quick CActionParameters object an construct the actual action class and ask it for the frontend feedback data... 
				- for now I have a void * as what is returned.. I suppose it could be more structured.. but I don't know right now what might be required for the frontend to show.
				- I could imaging that a pixel area which would be the filter's various responses might be nice... 
				- but other actions may need different informations... PERHAPS a little preview of the sound could be returned as well
				- perhaps I could return a CActionParameters which may contain images, or audio or many things as long as I added these types to CActionParameters.
				- I may then want to make CActionParameters accessed by name instead of index so that in development it would be easier to know what parameter failed and also the order wouldn't matter at all ... 
					- because at the moment, the order of the sliders totally matters because the backend has to know the order of the frontend sliders
						- I should do this first.. then attempt to allow an action to give feedback to the frontend

	- DONE A simple thing that could avoid errors later... create a template class that is used that locks a given mutex on construction and unlock on deconstruction... this would let me remove the try catchs that are just there to unlock the mutex and would keep me from having to remember to write code later that will unlock the mutex... just declare local variable of one of these and it will do it
		- need to use it more through out the code

	- After reading more of the DSP book about filters
		- create a data type in CActionParameters which is the filter to apply to the sound
		- then this filter data should be convolved with a selected region
		- or this filter data should be applied to the data in a windowed fasion...  As far as I know, it has no name.. but say I wanted to set every 8th sample to zero to add a ringing noise... then I would create a filter window of width 8 where the first sample is 0 and the rest are 1.0... then I would apply this window to the first 8 samples [0..7], then apply it to the next 8, [8..15] and so on
			- maybe this is possible with the convolution method
		- see what it sounds like to apply a lowpass or highpass filter on the frequency domain's magnitude and/or phase buffers

		- could static noise reduction be achieved by subtracting a constant value from the frequency magnitude graph?
			- perhaps by finding the average of the frequency spectrum of all frequencies greater than something near 0 and with values less than some threshold

		- right now, I see little use for having a frequency domain view of the data... but, if after reading this DSP book I see a good reason for having it, implement it, and explain in a document the good reason for having it.

	- create a feature on the record dialog which is only present when using the dialog which says to play some X seconds of a given CLoadedSound before starting to record all when the record button is pressed
		- this would require low latency recording buffers and playback buffers.. OR just know that latency exactly and account for it.
		- the controls for this feature should show up if no sound was given to play X seconds for... and this sound shouldn't be given for new recordings and probably not for paste-insert

	- make a place where people can submit a preset to be added into the main release if it's a good one

	- There is a something which exists called LADSPA for writing reusable plugins for linux audio applications
		- http://www.ladspa.org/ 
		- I could probably support it pretty easily

	- I thought of a cool way to do hints and warnings... If it's not an error where we want the user to really acknowledge the message, and it's not a question requiring feedback from the user.
		- We could have Warning() and Note(), accept an optional MSG_ID where there would be a sound file associated with that ID, and we would play that warning message or note message out of the speakers... Temporarily, the ASoundPlayerChannel should know that if one of these is playing then it should cut the volume by 50%, by including that in the amplitude parameter

	- AAction would need some more availability to ASoundFileManager, because it would be neat if I could create an action which could break a long sound into multiple tracks when there is silence for a given amount of time... Each track would be opened as a new file based on an initial filename

	- could easily make the play buttons stop if playing and then do their action so that they don't do nothing while it's playing
		- plus you have to hit stop and play to make it do something else... stop needs to be nice and big anyway

	- it may be more intutive/user-friendly/athetically-pleasing to have the channel select dialog start out all unchecked so I acutally click on the channels I want to apply the action to, rather than the inverse of the channels...
		DONE - I should also probably add a button that selects all channels or unselects all channels
			- this would be stupid right now, but more useful if I support 5 channel sounds or something
		DONE - I should put a button on the channel select dialog (and paste channel dialog) which set it to a normal state

	- DONE I did create this: TPoolFileAccessor::copyData -- but I haven't made it actually use memmove() yet
		- I could create a method in TPoolFileAccessor that can copy from another TPoolFileAccessor of the same type... It could do memcpys from the cachedBuffers instead of manually having to do a for loop calling operator[] and being enefficient
			- do some timing tests before and after to see the speed increase

			- places to use it epecially are:
				- AAction::backup/restoreUndoSelection
				- CCopyCutDeleteEdit::doActionSizeSafe

	- probably want to add a bool AAction::showAllDataCheckbox() so that the channel select dialog may or may not have that checkbox if it's an action like crop, or trim

	- perhaps make pool file have a readonly mode where it won't create SAT files and modify it in any way, then even a copy wouldn't need to be made

	- perhaps actions that change the length of the sound could possibly know how much to change the play position if it's playing just so when the action returns it continues at roughly the same place

	- maybe change fox's built in icons for the standard file dialog, they don't fit the rest of fox's theme
		- this will probably be a patch submitted to them
		- or I can wait until fox is themeable and this might be fixed because the theme would supply these icons

	- a very nice project called 'ardour' on sourceforge.net has setup a paypal account to receive donations, perhaps I should do the same

	- I think it's fine for now, but gWhichClipboard is essentially a global which specifies which clipboard to use from the time the pasteChannelSelect dialog shows, to the time the factory is constructed, to the time the action runs
		- it would be better if this were something passed on the action parameters or action sound to make SURE it would be consitant through out each stage



--- KNOWN BUGS/GLITCHES ---
	- OUTSTANDING -
		- I've seen it once hang when closing the application... I attached to the process with the debugger and it was stuck waiting on a mutex of loaded->getSound()->lockForResize() in ASoundFileManager::close ... so perhaps some condition happened which left a mutex unlocked

		- I accidently recorded for 8.5 hours and when I stopped it it it segfaulted... 
			- I'm sure that most of the problem was that I only had 32bit address space compiled in...
			- When I add the length limit based on the address space this wouldn't have been a problem

		- It segfaulted while I defragged an 800 meg file after having deleted some at the beginning and some at the end
			- load in debugger and watch what happend.. it could have been a stack overflow.. if so, then I need to simulate the recursion instead of using real recursion

		- There's a slight drawing glitch in the wave form: if you zoom all the way in, then select just one sample about 3 or 4 samples from then end.. then proceed to slowly zoom out, the one selected sample region will blink in and out occasionally
			- what's happening is that in drawPortion() on the last drawn position with data, it's saying that dataPostition is >= the sound's length, so it skips down to the section where it just draws blank background
			- I (temporarily) solved that by just also conditionally setting the background color in the else part of that if statment just like I conditionally set it in the drawing-wave
			- but then, I set the last selected sample to a gain of 100x or so, so it would draw pink (clipped), but then when I would zoom out, the pink would also flicker because that last drawn sample position thought it was beyond the sound's length after offseting and scaling the pixel position to a data position
			- so if I fixed the problem well, it would probably look smoother altogether while zooming
			- this must have something to do with floating point or integer truncation or rounding error


	- FIXED - 
		- glitches occur at the beginning and/or end of a CChangeRateEffects... 
		- determining the 'active' window has not been resolved yet... For now, it's just the last sound that was loaded... and if you close that sound... there is no active window until you open another sound... Hence there is no advantage at the moment of having more than one sound loaded
		- closing sound windows with the top left button doesn't work right yet... it simply hides the window
		- clicking the right button while dragging a node after creation of the FXGraphParamValue widget messing things up... I think it's a bug in FOX 
		- goofy stuff happens with the graph param value widget... orphaned nodes and stuff
		- pressing the space bar key on the loaded sound listbox while it's empty causes a segfault.. I think it's a problem with fox itself
			- I think it's trying to focus an item that doesn't exist (Jeroen fixed it in fox)
		- It's not reproducable, but I've seen Xlib return something which causes the application to lock up; fox even prints an 'unexpected ...' message, VERY seldom though
			- I think this is because I'm modifying FOX widgets in the play/pause triggers in CSoundWindow

		- fixed by grouping metadata writes into a memory chunk and writing all that all at once
			- I didn't notice this being a problem until I upgraded to Mandrake 8.2 with the 2.4.18 kernel, but when closing a large (80megs) file it would write all the meta data to end of the file.  Each write caused a call to ftruncate to make the file a little bigger each write.  ftruncate seemed to be taking quite a longer time than before because the program would seem to have on closing the file.
				- However, I have avoided the problem for now by change TPoolFile::closeFile to not write the meta data if the file is about to be removed.  
				- I should test this with a later kernel in a few weeks and see if the problem is still there.  If so, I should avoid calling ftruncate so often by preallocating some space.





--- EXPERIMENTS THAT MIGHT LEAD TO SOMETHING COOLER ---
	- try a little effect that reverse little chunks of data ... say every x samples... what would that sound like?

	- see if I could determine the tempo of a selection from an impulse analysis
		- I could already know that it's most likely in the range of 40 to 250 or so
		- perhaps it could even just figure out the quarter notes and add a metranome which could deviate from a constant value





--- FUTURE IDEAS ---
	- if pool file is 64bit and just that stable, I could load all sounds into a single pool file each with they're different pools and some how have that as an advantage for being able to move data from one pool to another instantaneously
		- but that may not be much of an advantage

	- I could create an event manager that could act as a multitrack editor, by just knowing when and where to stop and start sounds
		- then how to scale their volume... or more generally, what filter(s) to sent the data-buffers thru before playing
			- the filters should be instantiated AFilter objects that are attatched to the sound, in a chain and they were instantiated with parameters on how to do their realtime processing
			- if I thought it would be that beneficial, I could make all the non-realtime actions use the filters to do their work
		- it would then be just a matter of GUI creation to have ReZound act something like audacity

		- for multi-track editing, I could create a derivation of CSound that wraps around a given CSound that returns peak data according to the volume envelopes
			- I would need to address how real-time effects get inserted into the play queue, perhaps CSoundPlayerChannel would pull data from a module chain
				- then different playback rates and formats could be handled by just having an initial sample rate conversion module to the native sample rate
		- either have an option to render a click track, or make a feature that just plays one while recording

		- or for multi-track editing, I could create a derivation of CSoundPlayerChannel that overrides prebufferChunk() so that it reads from all the sounds that are in the multitrack sound for that chunk period and apply any real-time alterations

	- I could determine the most recent cue passed while playing at the beginning of each time I go to mix some sound... and set just an integer index in the ASoundPlayerChannel object for the frontend to read and display the current playing cue name in a status bar
		- I'm not implementing this right away because I don't know how useful it would be... But there were lots of off screen cues, it could be useful to have an idea of where the sound was playing 
		- If I do implement this, I should create a method in ASound which returns the most recent cue, and call it at each mix buffer call... This method should use the cue index in ASound for effient finding of this value

	- I could have copy and cut's copy to the clipboard delayed until a non-paste function and a not a paste function to the same range and sound that we cut/copied from
		- that way, a copy from one sound and an immediate paste into another would not require but one copy
		- if multiple clipboards are supported, I should maintain different state information per clipboard
			- where basically the clipboard object doesn't do it's task until AAction tells it to... and AAction doesn't tell it to until a non-paste action is performed
				- and two consecutive copies to the same clipboard should just overwrite the previous information, that way one accidental copy is not costly (it would happen if the second action was a non paste tho)

	- put on the website a wish list of features
		- I could allow people to request new idea's for features where they explain their idea
		- and also vote on existing ideas that I would explain (like multi-track editing, however there is already audacity out there)
		- also give a relative expense to implementing such a feature

	- if a button like: undo, play, stop, etc does not perform its action (make return value bool) then call a method, incompleteAction() that either beeps or buzzes just to let the user know that there was no action take...

	- one cool set of plugins might be ones that have tools for doing manipulations that loop symetrically, for example:
		- copy the selection, reverse the original, insert the copy in front, the we have a loop-able sound
		- some variations on the previous that break the selection into smaller peices of size X to which it does this action where where X is a parameter set in a dialog
			- or breaks the selection into N peices
		- apply some symetric envelope to the sound (i.e. /|_|\, /\, /W\, \/, \M/, etc)
		- apply some envelope that gives the sound a beat (i.e. ||_|_|_|_ or //_/_/_/_ or \\_\_\_\_  (that is, an accent on the first beat))
		- vibrato

	- develop or more likely use an existing DSP library in actions

	- 'vinyl record' operations
		- predefined scratches for the CChangeRateEffect (that means it probably needs to be able to play backwards)
		- add the pop,scratch,snap,ca-pop sound to a selection
			- the rpm setting would have also probably affected this
		- be able to add that 'bah-domp' sound when you put the needle to the record
		- add a repeat that makes it sound like a broken record... input should be how many times.. then perhaps a 'errrtt, and continue'
		- add a tube amp filter
		- be able to make it sound like it's at the end of a record
		- perhaps there are some EQ settings that were characteristic of old vinyl recordings
		- adjust pitch to rpms 33, 45, 78
		- some of these could probably most easily be created by using real samples of record sounds, just mixing them into the sound

	- 'censor' operations
		- have a set of buttons that place a tone or other sample over the selected sound
		- or one that quickly fade out and in the selection

	- be able to stream CActionParameters to a file and then be able to recall them in a batch type fasion...

	- I could conceive of a dialog for rate and/or pitch changes that has a place for you to enter the original frequency of the sound (could be detected with fft), and then allow you do select a particular pitch/freq/note value (i.e. Bb) to transpose it to
		- this would be useful for making sampled patches for a synthesizer
		- same could go for a drum loop and BPMs... have an original BPM, and then select a new BPM







--- DONE ---

	- perhaps if the undo information were in the CPoolFile of the loaded sound, we could handle undo of deletes very quickly by simpling moving those blocks to the undo pool

	- I need to give options of:
		- when a pool file was detected upon loading... ask the user if they want to use that "Would you like to resume editing ... ?" or delete it

	- I really need to create peak data and render that, because it takes forever to redraw the screen for a big file when the waveform is 'fit' into the window
		- I should probably show a status bar whenever I'm recalculating render data

	- fix any problems with zero or 1 length sounds
		- very small sounds attempt to set the range of the horz zoom control where the hi is less than the lo
		- FIXED by never allowing an ASound object to become less than one sample in length

	- well.. I went to all the trouble of creating CPoolFile which quickly adds and remove space from th emiddle of the data... but
		- ...but doing undo requires me to copy the data when deleting or cuting...
		- if the undo information was in the same CPoolFile as the sound itself.. then perhaps CPoolFile could make a moveData method which just moves data from one pool to another
		- this would at least speed up delete and cut

	- I could put a defrag button just like there is a redraw button

	- need to do two very important but unfun things before continuing much further
		- typedef the sizes and positions for accessing audio so that 64bit sizes will be no problem
			- need type for integral sample position
			- need type for decimal sample position
			- need a type for integal sample count
		- create a MIX_SAMPLE_TYPE (or CALC_SAMPLE_TYPE) which can hold multiple mixed SAMPLE_TYPES for use when holding values while processing that will later be truncated when written to the real audio output
			- I could probably rename it to sample_t and mix_sample_t

	- need to make an isModified flag in the CLoadedSound structure.. perhaps actually in the ASound class... then AAction will set it to true while saveSound will set it to false
	- right now, I always ask if to save the file... I should have a flag in CLoadedSound which is set whenever an AAction does something to that file

	- test a *.rez file with an invalid signature and see what happens
		- it threw an exception as it should have, however when I compiled on my machine at work, the throwing of an except cause a segfault.. but I believe it was compiler/library problems and not my fault

	- make progress bar when loading a sound, because a copy is always made, unless it's opened as read only

	- add status bars to all the actions.. use CStatusComm to communicate with a front end status bar
		- on copy/cut actions, when I'm using TPoolAccesser::copyData or TPoolAccesser::zeroData, divide the length to do into 100 parts and call the copyData or zeroData methods 100 times... but don't divide it into sections smaller than say 1 million samples or so

	- put some 'mute channel' check boxes for each channel of a loaded sound in the frontend and and be able to mute channels within CSoundPlayerChannel

	- create TStaticPoolAccesser::copyData(from another accesser of same alignement) and TStaticPoolAccesser::zeroData() 
		- which will use memcpy to speed up data copying and initialization by removing the overhead of calling operator[] so much

	- I should also probably have a 'clear undo history' button that frees up used space in the pool file... 

	- CPoolFile may need a flush method.. (if it doesn't already have one.. ) then after every action, we should flush the pool file incase of a subsequent crash

	- it segfaulted once upon closing while playing... but calling deinitialize should fix that 

	- there are some unfortunate side effects of the way I currently do peak chunk rendering
		- either there is a flaw in my idea
		- or I didn't implement my idea quite correctly
			- perhaps the implementation of ASound::addSpaceToChannel,removeSpaceFromChannel,moveSpaceOutOfChannel where it handles the peak chunk accessers isn't quite right
		- but I suspect that it has to do with my not recalculating all the peak chunks
		XXX - sometimes if you delete data from a sound, then hit redraw, the rendering changes slightly
		XXX - also, when I mute some space, then have that muted space at the end of a crop, there is sometimes a sample that shows up at the end of the new selection that will go away if I just hit redraw, so it's a peak chunk data inconsistancy rather than non-muted audio data being there

	- use home directory / .rezound instead of the current directory for settings registry

	- When it's on sourceforge put out a call for icon artists and for someone to autoconfiscate it

	- When it's on sourceforge create mailing lists or forums for:
		- bugs
		- feature requests
		- users
		- developers


	- make sure I've run dos2unix on all the code before checking it into any version control system

	- for additional bookmark niceness... make a way to set either the start or stop position to a bookmark choosen from a drop down menu
		- also make a seek button that cycles to the next nearest book bark forward or backward from the current play position

	- need a shuttle control

	- the right click on the horz ruler bar should have
		- start pos, stop pos, start, end, AND play pos
		- and perhaps all the markers too


	- make sure you can't open the same file twice
		- what about hardlinks?

	- have seek buttons that move the play pointer, start and stop positions to the markers set within the audio...
		- the play position seek should:
			- on forward, go to the nearest marker forward
			- on backward go to the nearest marker backward if the play position is more than .25 secs from it.. or 2 markers back if more

	- Need a hot key or event that keeps the play position on screen.. only do something if it's not on screen

	- List in the documentation (which isn't the most obvious feature) that in the recording dialog, one can use start/stop multiple times as in pausing the recording, resuming, pausing, resuming, etc

	- I could probably move most of initializeReZound into the backend

	- I need to profile to look into pool file's performance and figure out why a 300 meg file loaded takes even as long as it does to delete or insert data... roughly 4000 modifications to the SAT wouldn't seem like a lot

	- Not only should there be a record button that creates a new file, but I should create an action called 'insert record' that can be undone and inserts recorded data at the select start position, I suppose 'replace record' would delete the selection and insert there, and then overlay record which doesn't relace all the selection, but replaces audio until recording stops
		DONE - and just like the other paste methods, a short cross fade should be used when transitioning
		- to do this, I should go ahead and abstract clipboard into a base class and have the paste methods use this base class
			- I would then create several derivations:
				- system clipboard
				- application clipboard (of which I would probably have 3, A B C) or something
				- record clipboard --  when it got asked for data (or asked to put the data to some where(explained below)) it would pop up the record dialog, record, then would supply that data to read from
					- it would be invalid to copy into the record clipboard, just throw an exception
					- for efficiency's sake, perhaps let a clipboard have a method which copies the data for the user of the clipboard (given an ASound and location and length).  Then for record, we could speed things up by having recorded into the same pool file and then just do a move data method on the pool file.
						- the other implementations would just behave as normal.

	- I could add an advanced mode for copy/cut/paste where the user can choose from multiple clipboards
		- perhaps one way to implement this would be to have multiple instantiated ASoundClipboard objects in an array one may point to a system clipboard and others to TPoolFile clipboard
		- interface:
			- either advanced mode for copy/cut/paste
			- or a dropdown list somewhere on the mainform
		- even a clipboard with is a recording source is quite feasible

	- right now, if you copy/cut from not all the channels, (by hitting ctrl-cut/copy and deselecting some checkboxes)
		- then when you ctrl-click to paste, the pasteChannels dialog shows up with all the channels that were cut/copied shifted down to lower channel numbers 
		- perhaps I could create pools but not put data into them, for the un-included copy/cut channels, but know to disable the check boxes in the GUI if the pool is zero length

	- need to make front and backend provisions for letting the user specify the export format parameters... some of the parameters depend on the export format... Perhaps I could have a dialog with a tabbed bar which has different parameters on each... which ever bar was activated would be the export format type... Either use the tabbar or radio buttons (real buttons) and a switcher like the switcher test that comes with fox
		- should be somewhat easier now with the code reorganization
		- I should quite easily be able to do with with the existance of AFrontendHooks

	- it is evidently invalid to call ftruncate to make a file bigger if it's on a fat32 mounted device
		- There is a specific errno that comes back from this, I should test for it and fwrite zeros to make the file bigger
		- this would be fixed in src/PoolFile/CMultiFile.cpp

	- should put a "swap audio between two channels" in the edit menu which would not allow showing the  channel select dialog, but would have a normal dialog allowing the user to selection which two channels to swap data for.. moveData should work as a means of swapping data

	- Add a "fit paste mix" which stretches the clipboard contents to fit within the selected region and mixes it on top.. I should allow two modes, one that uses changing the rate and one that uses changing the speed (without the pitch)
		- ??? still would need to implement changing the speed without the pitch

	- um.. if you make 3 edits.. then save the file.. then undo 3 times.. it still needs to be marked as modified
		- I'd say to iterate to the bottom of the action stack and modify it's 'saved state' value whenever you save and set it to not saved
		- ??? this might affect redo in some way

	- needs some compressor action(s)
		- need a "link-channels" toggle parameter which causes all the channels to be compressed if any channel needs to be compressed
			- I have to implement a frontend checkbox action dialog widget for this
			- the backend already supports this behavior
			??? - selecting hard or soft knee may be a useful parameter if someone could tell me exactly what it is
			??? - I also could make a parameter for selecting whether to use RMS or Peak-Level for the level detecting

	- add a 'Resampling' action where it's basically just a rate change with a constant value, but also sets the sample rate to a new value afterwards

	- add a "sync channels" for noise gate just like the compressor.. probably have it gate only when both channels are below the treshold or maybe a radio button for "gate when all are below threshold.. or any is below threshold"

	- Make sure to have the configure script check for the minimal version of libaudiofile

	- There needs to be a dialog for choosing the mix method for mix pasting

	- I could create an adaptive remove-DC action which looks at a window at a time of data  (window-time given by the user) and the DC offset determined for each window would form a set of line segments to be the subtraction from the sound.
		- This should/might remove any very long trend in the data that causes a slow shift rather than a constant offset
		- Perhaps, I could let this window time go from 1 to the length of the sound, and some interesting effects could be produced with very small values

	- Possibly remove the concept of 'advanced mode' stuff for actions
		- so far, I've only used it in two actions and don't see any reason to add it to more
		- for gain and rate change I should just make two factories, but still use the same action code.. and I can make the procedure for adding new actions a bit more easy to understand without getting confused by the 'advanced mode' code

	- create a 'paste as new', 'copy to new' and 'cut to new' edit actions

	- create a "monoize" action under remaster that says: mix X% of left onto the right and X% of the right onto the left or any channel configuration for that matter
		- the backend factory could probably make sure it's at least 2 channel sound before continuing ( override AActionFactory::doPreActionSetup() and return true or false or throw an EUserMessage )
		- this would fall under the pan function probably

	- create selection edits which:
		- grow or shrink the selection by a given duration
			- either symetically
			- by moving the start position
			- by moving the stop position

		- grow or shrink the selection by detecting with the audio level rises above or falls below a threshold
			- either symetrically 
			- by moving the start position
			- by moving the stop position

			- and be able to set the window width of the moving average which detects the audio level

		- slide selection to the left or right by a given amount

		- frontend: 
			- grow/shrink(radio buttons)     
			- symtetrically/start/stop(radio buttons)
			- time duration with seconds as the unit (editable slider)
			- threshold with percent as the unit (editable slider)
			- window size in ms as the unit (editable slider)
			

	- when making loops, it may be cool to have a play button that loops the selection, but skips the bulk of the middle for time's sake
	- when editing large files it would be nice to have play selection buttons (once and looped), but it plays a few seconds before the start to a few seconds after the stop so that you don't have to play from the beginning and seek forward to or play the selection and seek backwards a little bit

	- Put in the documentation or application help somewhere a brief description about how recording works in linux (you have a recording source selected, then igain which is the recording gain of that source)
		- mention somewhere that people will surely read that the playback on a not-so-fast computer or cheap sound card may exhibit occational clicks or pops and that this is because of the low latency requirements that ReZound has right now... This requirement may go away and it may not be a problem at all with ALSA

	- I discovered that the M_PI (and others) #defines are not in the C/C++ specification... So I might want to test for them in configure.in and define them if they're not found in common.h ( M_PI=atan(1)*4; )
		NAH - I'll just fix this when/if it becomes a problem since just about every system I can think that I might want to compile on has it

	- Change all the status bars to say "Channel X/Y" so that they know how many iterations to expect (and 'i' will have to be a count instead of literally 'i')

