Het handboek van Kwave

Transcription

1 Thomas Eschenbacher Nieuwe vertaler: Dit document is nog maar gedeeltelijk vertaald. Wilt u meehelpen, stuur een bericht naar: Vertaler/Nalezer: Freek de Kruijf K

2 2

3 Inhoudsopgave 1 Inleiding Kwave hulpbronnen Revisiegeschiedenis van Kwave Installatie Hoe Kwave te verkrijgen Vereisten Manual Compilation and installation Build options Building RPM packages from tar.bz2 archives With working rpmbuild -ta With broken rpmbuild -ta support Building RPM packages from GIT Checking out the sources Updating fresh sources from GIT Compileren Building a DEB package for testing and personal use Building CPU optimized packages RPM optimizations How to pass optimizer options to the compiler manually Basics about digital audio The analogue world Digitalization Sample Encoding Sample Formats

4 4 Using Kwave User Interface Mode Memory Setup Opdrachtregel List of Files or Commands GUI Type Xt Toolkit options Opstartopties Bestanden openen en opslaan Ondersteunde bestandsformaten Converting to and from.wav Format of ASCII files Een nieuw bestand aanmaken Opnemen Afspelen Bestandseigenschappen Zooming and navigating Zooming in and out Scrolling left and right Using the overview Vertical zoom How to select Selecting channels Selecting samples Klembord Slepen en neerzetten Automization and Scripting with Kwave General Syntax Using the Command Line Script bestanden van Kwave Algemene structuur Comments and Empty Lines Termination Labels Overzicht van de opdrachten a about_kde Syntax: about_kde() add_label Syntax: add_label(pos[,text])

5 Parameters add_track Syntax: add_track() Zie ook c clipboard_flush Syntax: clipboard_flush() close Syntax: close() Zie ook continue Syntax: continue() Zie ook copy Syntax: copy() Zie ook crop Syntax: crop() cut Syntax: cut() d delayed Syntax: delayed( milliseconds, command ) Parameters Zie ook delete Syntax: delete() delete_label Syntax: delete_label(index) Parameters delete_track Syntax: delete_label(index) Parameters dump_metadata Syntax: dump_metadata() e edit_label Syntax: edit_label(index) Parameters expandtolabel Syntax: expandtolabel() f

6 5.9.1 fileinfo Syntax: fileinfo(index) Parameters forward Syntax: forward() Zie ook g goto Syntax: goto(pos) Parameters i insert_at Syntax: insert_at(pos) Parameters Zie ook insert_track Syntax: insert_track(index) Parameters Zie ook l loadbatch Syntax: loadbatch(filename) Parameters loop Syntax: loop() Zie ook m menu Syntax: menu (command, path, [hotkey], [id]) Parameters Sub Commands msgbox Syntax: msgbox(text) Parameters n newsignal Syntax: newsignal( samples, rate, bits, tracks) Parameters next Syntax: next() Zie ook o open

7 Syntax: open([filename]) Parameters Zie ook openrecent Syntax: openrecent(filename) Parameters Zie ook p paste Syntax: paste() Zie ook pause Syntax: continue() Zie ook playback_start Syntax: playback_start() plugin Syntax: plugin(name, [parameter...]) Parameters Zie ook plugin:execute Syntax: plugin:execute(name, [parameter...]) Parameters plugin:setup Syntax: plugin:setup(name, [parameter...]) Parameters prev Syntax: prev() Zie ook q quit Syntax: quit() Zie ook r redo Syntax: redo() Zie ook redo_all Syntax: redo_all() Zie ook reenable_dna

8 Syntax: reenable_dna() reset_toolbars Syntax: reset_toolbars() revert Syntax: revert() rewind Syntax: rewind() Zie ook s save Syntax: save() Zie ook saveas Syntax: saveas([filename]) Parameters saveselect Syntax: saveselect() Zie ook select_gui_type Syntax: select_gui_type(mode) Parameters select_track:all Syntax: select_track:all() Zie ook select_track:invert Syntax: select_track:all() Zie ook select_track:none Syntax: select_track:none() Zie ook select_track:off Syntax: select_track:off(index) Parameters select_track:on Syntax: select_track:on(index) Parameters select_track:toggle Syntax: select_track:toggle(index) Parameters selectall Syntax: selectall() selectnext

9 Syntax: selectnext() Zie ook selectnextlabels Syntax: selectnextlabels() Zie ook selectnone Syntax: selectnone() selectprev Syntax: selectprev() Zie ook selectprevlabels Syntax: selectprevlabels() Zie ook selecttoleft Syntax: selecttoleft() Zie ook selecttoright Syntax: selecttoright() Zie ook selectvisible Syntax: selectvisible() start Syntax: start() Zie ook stop Syntax: stop() Zie ook sync Syntax: sync() Zie ook u undo Syntax: undo() Zie ook undo_all Syntax: undo_all() Zie ook v view:scroll_end Syntax: view:scroll_end() Zie ook view:scroll_left

10 Syntax: view:scroll_left() Zie ook view:scroll_next Syntax: view:scroll_next() Zie ook view:scroll_next_label Syntax: view:scroll_next_label() Zie ook view:scroll_prev Syntax: view:scroll_prev() Zie ook view:scroll_prev_label Syntax: view:scroll_prev_label() Zie ook view:scroll_right Syntax: view:scroll_right() Zie ook view:scroll_start Syntax: view:scroll_start() Zie ook view:zoom_all Syntax: view:zoom_all() view:zoom_in Syntax: view:zoom_in([position]) Parameters Zie ook view:zoom_normal Syntax: view:zoom_normal() view:zoom_out Syntax: view:zoom_out([position]) Parameters Zie ook view:zoom_selection Syntax: view:zoom_selection() w window:activate Syntax: window:activate(titel]) Parameters window:cascade Syntax: window:cascade() window:click Syntax: window:click( klasse, x, y )

11 Parameters window:close Syntax: window:close( klasse ) Parameters window:minimize Syntax: window:minimize window:mousemove Syntax: window:resize( klasse, x, y ) Parameters window:next_sub Syntax: window:next_sub() window:prev_sub Syntax: window:prev_sub() window:resize Syntax: window:resize( class, width, height ) Parameters window:screenshot Syntax: window:screenshot( class, filename ) Parameters window:sendkey Syntax: window:sendkey( class, key code ) Parameters Zie ook window:tile Syntax: window:tile() window:tile_vertical Syntax: window:tile_vertical() Plug-ins Plugin Reference about (About Kwave) amplifyfree (Amplify Free) band_pass (Band Pass Filter) codec_ascii (ASCII Codec) codec_audiofile (Audiofile Codec) codec_flac (FLAC Codec) codec_mp3 (MP3-codec) codec_ogg (Ogg Codec) codec_wav (WAV-codec) debug (Debugfuncties) fileinfo (Bestandsinformatie) goto (Ga naar positie)

12 6.14 insert_at (Invoegen op) lowpass (Low Pass Filter) memory (Memory Settings) newsignal (New Signal) noise (Noise Generator) normalize (Normalisatie) notch_filter (Notch-filter) pitch_shift (Pitch Shift) playback (Afspelen) record (Opnemen) reverse (Omdraaien) samplerate (Conversie van samplesnelheid) saveblocks (Save Blocks) selectrange (Select Range) sonagram (Sonagram) stringenter (Voer commando in) volume (Volume) zero (Nulgenerator) Developer s Guide to Kwave Creating API documentation Starting in a test environment Vragen en antwoorden 99 9 Dankbetuigingen en licentie Belangrijkste auteurs Belangrijke medewerkers Kleine bijdragen, houders van copyright en anderen Met dank aan A Bestandsinformatie

13 Lijst van tabellen 5.1 Vertaaltabel voor URL-codering A.1 List of File Info Identifiers

14 Samenvatting Kwave is een eenvoudige geluidsbewerker voor KDE.

15 Hoofdstuk 1 Inleiding Dit is Kwave, een eenvoudige geluidsbewerker voor KDE-4. zijn functies omvatten: een gebruikersinterface dat omgeschakeld kan worden naar SDI-, MDI- of tabbladmodus eenvoudige functies voor knippen, kopiëren en plakken ongedaan maken/opnieuw op meerdere niveaus labeling van signalen Functies voor opnemen, inclusief vooraf opnemen Afspelen via ALSA en OSS Opnemen via ALSA en OSS Importeren/exporteren van/naar MP3 Importeren/exporteren van/naar Ogg/Vorbis Importeren/exporteren van/naar FLAC enige functies voor analyse zoals Sonagram gebruikt intern 24 bits vaste precisie voor gegevens in samples vrij te selecteren samplesnelheden ondersteuning voor bewerking van multikanaal bestanden afspelen van geluidsbestanden met meerder kanalen (geluidsuitvoer zal gemixt worden tot mono of stereo) uitbreidbaar via een gemakkelijk te gebruiken interface met plug-ins importeren/exporteren van andere audio-formaten via audiofile Als u geïnteresseerd bent in wat is gedaan en wat nog gedaan moet worden, kijk dan naar de bestanden CHANGES en TODO in het broncodepakket. Hulp en constructieve opmerkingen zijn altijd welkom. 15

16 1.1 Kwave hulpbronnen Dus als u in contact wilt komen met de ontwikkelaars, enige verdere hulp nodig heeft bij het gebruik van Kwave, patches, bugrapporten of andere zaken wilt bijdragen, dan kunnen de volgende hulpbronnen interessant voor u zijn: Homepagina van het project Voor informatie over nieuwe bijgewerkte uitgaven of andere informatie over dit project, neem een kijkje op de Kwave homepagina lijst Als u enige hulp bij het gebruik van Kwave nodig hebt of mee wilt doen in het ontwikkelen, wordt dan lid van de ijst van de ontwikkelaars van Kwave GIT-repository Er is ook een GIT-repository, gehost door SourceForge waar u de broncode van de laatste ontwikkelversie kunt vinden. Voor instructies over hoe toegang te krijgen tot de repository, lees in het hoofdstuk over bouwen vanuit GIT of kijk op Er is ook een goed webinterface dat u kunt gebruiken om door de broncode te bladeren. 1.2 Revisiegeschiedenis van Kwave Dit project is gestart door Martin Wilz in de zomer van 1998 en is ontwikkeld en verbeterd door hem en enige andere mensen. In november 1999 is Thomas Eschenbacher hier en daar gestart met de reparatie van enige kleine bugs en steeds dieper in de broncode van het programma gestapt. Tot vandaag heeft hij bijna elke component van het programma uitgebreid, herschreven od herzien en veel tijd gestopt in de verbetering. Sinds Kwave v0.8.0 is de log met wijzigingen niet langer in deze handleiding ingevoegd. Dus als u geïnteresseerd bent in een complete lijst met wijzigingen, dan kunt u de volledige geschiedenis hier vinden: of zelf door de broncode bladeren in het GIT webinterface. 16

17 Hoofdstuk 2 Installatie 2.1 Hoe Kwave te verkrijgen Kwave heeft een eigen homepagina onder Hier kunt u verdere informatie vinden over het project, evenals informatie over de huidige stabiele en bijgewerkte ontwikkelversies. Als u een Kwave uitgave wilt hebben kunt u kiezen uit een bezoek aan en een binair pakket met de laatste stabiele versie downloaden, als er een is voor uw distributie, een broncode RPM-pakket van de laatste stabiele versie downloaden, uw eigen versie compileren uit een.tar.bz2 archief met de broncode van de laatste stabiele versie, uw eigen versie compileren uit uit de laatste GIT-broncode. Wees niet bang, compileren van Kwave is tamelijk eenvoudig zelfs als u geen programmeur bent. Er zijn gewoon enige ontwikkelpakketten nodig om te worden geïnstalleerd. 2.2 Vereisten Om Kwave met succes te kunnen gebruiken hebt u nodig: een computer met Linux (Kwave kan ook werken onder een ander besturingssysteem, maar dat hebben we nooit getest, laat het ons weten als u dat hebt werken op een ander platform / besturingssysteem) werkend geluid afspelen (niet echt vereist voor gebruik maar wat zou u willen doen met een geluidsbewerker als u het resultaat van uw werk niet kan horen?) KDE-4.5 of hoger (minstens de bibliotheken, als u een fan van gnome bent, dan kunt u Kwave ook gebruiken als de juiste bibliotheken zijn geïnstalleerd). Qt-4.7 of hoger (komt normaal met KDE4) ALSA of hoger (voor opnemen/afspelen) PulseAudio 4.0 of hoger (voor opnemen/afspelen) 17

18 id3lib of hoger (voor ID3 tags) mad-0.15 of hoger (optioneel voor MP3 importeren/exporteren) flac of hoger (voor FLAC importeren/exporteren) libsamplerate of hoger (conversie van samplesnelheid) For a more complete and up-to-date list, please consult the README file that is included in the source distribution. This file also contains some special hints for getting Kwave running and/or building Kwave under some distributions. Als u Kwave wilt compileren uit de broncode hebt u minstens nodig: cmake of nieuwer A recent C/C++ compiler. GCC-4.x works fine, some older and any newer version (like gcc- 5.0) may work too. The glibc2 (libc-6) development environment. On SuSE systems the package is called libc, on other systems it might be called libc-devel. The KDE4 development environment: kdelibs4-devel, kdemultimedia4-devel, kdesdk4. The Qt4 development environment, the package is normally called qt4-devel or similar. pulseaudio or newer id3lib-devel or newer fftw-3.0 or newer mad-devel-0.15 or newer (if you have the permission to use MP3 code) flac-devel newer If you intend to get the Kwave sources via GIT, you will also need a current git package....many other packages, please take a look at the README file included in the source package. 2.3 Manual Compilation and installation Since version Kwave uses cmake, a make system that is also used by KDE itself. So if you know how to build other KDE applications, you should not have any difficulties in building Kwave. If you run into problems please report them to the Kwave mailing list. In order to compile and install Kwave on your system, it is best practice to do a out-of-tree build. This means that you hold the sources of Kwave in one directory and build the package in another (temporary) directory. For example, assuming that your sources are already unpacked in $HOME/src/kwave-0.9.0, you can do the following: % mkdir /tmp/kwave -build % cd /tmp/kwave -build % cmake $HOME/ src/ kwave [ build options] % make % su root -c " make install" (Specifying build options is a way to enable or disable specific features. See the following section for descriptions) 18

19 2.4 Build options By specifying build options, you can enable or disable some features of Kwave, like excluding some components or plugins from the generated package. Here is a list of the available options: WITH_ALSA enable playback/recording via ALSA [on/off, default=on] WITH_DEBUG build a debug version [on/off, default=off] WITH_DOC build online documentation [on/off, default=on] WITH_FLAC enable support for FLAC files [on/off, default=on] WITH_MP3 enable support for mp3 files [on/off, default=off] Please note that you need the permission to use code covered by the MP3 software patents! WITH_OGG_OPUS enable support for Ogg/Opus files [on/off, default=on] WITH_OGG_VORBIS enable support for Ogg/Vorbis files [on/off, default=on] WITH_OPTIMIZED_MEMCPY use an optimized version of memcpy, available for X86, X86_64 and PPC platforms [on/off, default=on] WITH_OSS enable playback/recording via OSS [on/off, default=on] WITH_PHONON enable playback via Phonon (for testing only) [on/off, default=off] WITH_PULSEAUDIO enable playback/recording via PulseAudio [on/off, default=on] These options can be passed to cmake with -Doption=value. For example, if you want to enable MP3 support, you can pass the corresponding option as follows: % cmake [ source directory ] - DWITH_MP3 =ON [ other options...] 2.5 Building RPM packages from tar.bz2 archives With working rpmbuild -ta If you are running a system with RPM support, the preferred way to install Kwave on your system will be the creation of a nice RPM package. First you should get the current source of Kwave, either as a tar.bz2 archive from the Kwave download page or check out an up-to-date copy via GIT (like described in the chapter about GIT) and read the next chapter. If you have downloaded tar.bz2 archives of Kwave, create and install the RPMs just by doing the following steps (where [arch] stands for the platform you have built the package and might be something like i586, i686, sparc or whatever, XXX stands for the version number you have downloaded). To build the Kwave package and install it do: % rpmbuild -ta kwave -XXX.tar.bz2 % rpm -i /usr/src/redhat/rpms /[ arch ]/kwave -XXX.[ arch ]. rpm OPMERKING Note for SuSE users: you have to specify the directory /usr/src/packages instead of /usr/src/r edhat! If you haven t seen any errors, then that s it and you can skip the rest of this chapter. If rpm was unable to build the packages and says something like spec file not found, then go on and read the rest of this section. 19

20 2.5.2 With broken rpmbuild -ta support If you cannot get rpmbuild -ta working, here are the steps for making that manually (the hard way): 1. Go to your RPM topdir. This normally is /usr/src/redhat for the redhat distribution or /usr/src/packages if you have the SuSE distribution. % cd /usr/src/redhat 2. Put the tar.bz2 archive into the SOURCES subdirectory (you have to replace somewhere with the real directory where the files are, of course). % cp / somewhere /kwave -XXX.tar.bz2 SOURCES 3. Extract the spec file from the archives and put it into the SPEC subdirectory. % tar -xojf SOURCES/kwave -XXX.tar.bz2 \*. spec > SPECS/kwave.spec 4. Let rpm do the compile job and generate the rpm of Kwave. If you only want to make a binary package, you can specify -bb instead of -ba, or just -bs to build only a source package. % rpmbuild -ba SPECS/ kwave. spec 5. If everything was ok, you can install the binary rpm of Kwave, it will be in the BUILD directory. If you already have a version of Kwave installed, please remove it first or use the parameter -U instead of -i for upgrading instead of installing. % rpm -ivh BUILD /[ arch ]/kwave -XXX.[ arch ]. rpm 2.6 Building RPM packages from GIT Checking out the sources For initially checking out the sources you will need some disk space (about 25 megabytes) in a directory of your choice, the git package of your favorite distribution and full access to the Internet. If you get error messages about rejected connections you either have typed something wrong or your provider doesn t give you full access. A good place for the source files will be $HOME/src. 1. First create the directory that will receive the subdirectory with Kwave sources and change into it: % mkdir -p $HOME/ src % cd $HOME/ src 2. Then check out the latest sources from the GIT server: % git clone git :// git.code.sf.net/p/kwave/code kwave or you can check out a specific release with the following commands: 20

21 % git clone git :// git.code.sf.net/p/kwave/code kwave % cd kwave % git checkout tags /[ release - tag] You can look up the names of the release tags in the git web page at p/kwave/code/ref/master~/tags/. The release tags are always built out of the word Rel ease- and the version number of the release, with underscores instead of dots. For example Release-0_9_0 for v WAARSCHUWING There must not be a directory named kwave under the directory you want to check out. Otherwise the git program will complain about already existing files and the checkout will not work Updating fresh sources from GIT The procedure described in the previous section is only necessary once. For further updates it is much easier. Just change into the directory where you have the checked out sources and do the following to update to the latest version: % git pull Then go on to the next section and compile as usual. OPMERKING If you think that you have messed up your local source tree or if there are conflicts during updating and you want to start through from a clean state, you can do the following to discard all local changes and switch back to the latest version from the master branch: % git clean -- force -d % git reset -- hard % git checkout master Compileren Building rpm package from a GIT snapshot is quite simple. The procedure is nearly the same as described in the last section, so it unhappily also has the same problem with the rpmbuild -ta command our method internally uses. Like in the previous chapter, [arch] stands for the platform you have built the package and might be something like i386, i586, sparc or whatever, XXX stands for the version number you have checked out. OPMERKING Note for SuSE users: here you have to specify the directory /usr/src/packages instead of /usr/s rc/redhat too! Assuming that you are in the root of where you checked out from GIT, do the following to create a Makefile, the Kwave package and install it. If you already have a version of Kwave installed, please remove it first or use rpm -U instead of rpm -i for updating instead of installing. 21

22 % mkdir /tmp/kwave -build % cd /tmp/kwave -build % cmake $HOME/ src/ kwave % make rpm % rpm -ivh /usr/src/redhat/build /[ arch ]/kwave -XXX.[ arch ]. rpm OPMERKING If you still have problems with make rpm, you will find the tar.bz2 archive that was produced in /tmp. Please follow the instructions in the previous chapter. 2.7 Building a DEB package for testing and personal use If you want to create a deb package of Kwave, bijv. for testing a version that is not yet available via official package repositories, then you can create your own package quite easily. First of all, you need to install some required tools: % sudo apt - get install build - essential checkinstall Then you can install the required build dependencies by pretending to install the dependencies of the official Kwave version: % sudo apt - get build - dep kwave After installing the required packages, you can build Kwave as described in the chapters before. After building you can type this to get a.deb file in your current build directory: % make deb OPMERKING The.deb file you get from this step will not have the quality that a package from your official distribution has - it is just good enough for installing and safely uninstalling Kwave for testing purposes and for personal use. 2.8 Building CPU optimized packages If you are owner of a Pentium, an AMD K6, Athlon or Athlon-XP CPU, you might want to use compiler optimizations to compile your version of Kwave that is running some percents faster. The gain in speed will be up to 30% on some systems, whereas the functions dealing with signal manipulation and all functions that do complex time-frequency operations (like FFT and Sonagram) will profit most from it. You do not need to understand much about programming for using an optimized compiler to compile Kwave, but maybe you will need some time to get the compiler itself working and installed. 22

23 2.8.1 RPM optimizations You can easily compile the RPM package optimized for Athlon, Athlon-XP, Pentium and Pentium Pro (and some other CPUs) by using some defines in your rpmrc file. You can either modify your system s rpmrc file in /usr/lib/rpm or the.rpmrc file in your home directory. There you can specify option lines like these: optflags : i586 -O2 - march = pentium - DNDEBUG - fomit - frame - pointer optflags : i686 -O2 - march = pentiumpro - DNDEBUG - fomit - frame - pointer optflags : athlon -O2 - march = athlon - DNDEBUG - fomit - frame - pointer optflags : k6 -O3 - march =k6 - DNDEBUG - fomit - frame - pointer optflags : k7 -O3 -march=athlon -xp -DNDEBUG -fomit -frame -pointer (I found those nice tricks at Thanks to Matthias Düsterhöft!). This means that on a k7 architecture the rpm package will be compiled using -O3 -march=at hlon-xp -DNDEBUG -fomit-frame-pointer as compiler option and so on, you might extend or adapt these to your own needs. The settings apply to all of the sections before in all places where rpmbuild -ta is used or where a binary RPM is to be created out of a source rpm using rpmbuild --rebuild. OPMERKING If rpm refuses to install your package because it seems not to fit to your computer s architecture, you can normally just install an optimized package by specifying the additional parameter --ignorearch and don t care How to pass optimizer options to the compiler manually The invocation of the compiler is quite simple. It normally is sufficient to set the environment variables CFLAGS and CXXFLAGS in the correct way and then compile as usual. For the best settings please consult the documentation or homepage of the corresponding compiler. If you build Kwave from a source tree (unpacked tar.bz2 or from GIT) the flags need to be specified before the call. For example: % CFLAGS ="-O4 -march=athlon -xp -mcpu=athlon -xp -pipe" \ CXXFLAGS ="-O4 -march=athlon -xp -mcpu=athlon -xp -pipe" \ cmake [ source directory ] If you re-build Kwave from a source rpm package, please follow the instruction in the previous section. 23

24 Hoofdstuk 3 Basics about digital audio This chapter should give a short introduction about the basics of digital audio processing, without going too much into details. Of course this might be a bit incomplete, but if you have questions, you can ask at the Kwave mailing list or consult some further literature. 3.1 The analogue world First of all, one must know that the world is analogue - but computers work digitally. So there are several ways to convert analogue audio to digital audio and back again. As the way from digital to analogue normally is the reversion of the way from analogue to digital, we only describe the way from analogue to digital. Conversion from sound to bits Before continuing, analogue audio has to be transformed into electronic signals in order to find its way into a computer. One common way to do this is by using a microphone and an amplifier. This combination gets sound (changes of air pressure) at its input and a voltage at its output. Higher amplitude of the pressure changes will be represented by higher voltages at the amplifier s output. This output is also called a signal. Instead of a microphone you can of course also imagine other sources of audio. And the amplifier can be the one that is integrated into your sound card, where you normally cannot see it. 24

25 Conversion to electronic signal At this stage, the electrical signal has three limitations that one should keep in mind: 1. The amplitude (volume) is limited to some maximum level. This is a consequence of the electronic (amplifiers) that are only able to handle voltages within some specific range. That s no problem as long as sounds are not too loud. In that case the signal would be clipped, which means that the electrical signal will run against its margins and the result will be disturbed. 2. The frequency range is also limited. Due to the mechanical constrains of microphones and the limited frequency range of amplifiers, a signal s frequency range is limited. There are no hard borders besides which the sound abruptly disappears, but below some low and above some higher frequency the amplitude of the signal starts to decrease more and more. The existence of a maximum frequency can be easily understood as a limited speed of the electrical signal to rise and fall. By using high quality amplifiers and microphones, the limits can be spread into ranges where the human ear is no longer able to hear their results and thus get out of interest. The human ear normally is not able to hear sound above 20 khz. 3. The signal contains noise. Noise is the most ugly enemy of everyone who has to handle audio signals in any way. Noise is a typical analogue effect, that makes the audio signal unsharp and disturbed, it is always present and cannot be avoided. One can only try to use high quality components that produce as low noise as possible, so that one cannot hear it. Normally noise has a certain volume, so that the interesting sound should be much louder in comparison to the noise. This is called the signal to noise ratio (SNR), the higher it is the better the sound s quality will be. Sounds that have lower volume than the noise cannot be heart. 3.2 Digitalization When we want to store and play audio in a computer, we must convert the analogue sound into digital data first. This process is called digitalization. It converts an electronic signal into a sequence of digital values. Digitalization of the electronic signal The conversion can be understood as a repetitive measurement of the electronic signal s value at certain time, thus taking a sample of the signal. The result is then encoded as a digital value. The sampling could be done in arbitrary distances or in constant intervals. The later method is much easier to handle, and thus it is normally used, with a constant rate - the so-called sample rate. Usual sample rates are 8000, 11025, 22050, and samples per second. In practice sample rates are also given as frequencies, in Hz or khz. The sample rate limits the highest frequency a digitized signal can represent. Due to Shannon s theorem the highest usable frequency is half of the sample rate, so with 44.1 khz sample rate you cannot sample signals with more than 22 khz. To avoid a violation of that half-sample rate rule, 25

26 your soundcard already has built-in filters that filter away frequencies that are higher than half of the used sample rate. Sampled signal 3.3 Sample Encoding The result of the digital sampling process is a sequence of single samples. One sample is a digital representation of a signal s value at a certain time. The value of a sample can be interpreted and encoded in several ways. The simplest one is linear encoding. This means that each sample s value directly represents the analogue signal s value multiplied with a constant factor. This is easy to handle, but has the disadvantage that noise will be audible especially on low amplitudes, where it disturbs most, and less audible on high amplitudes, where it is less audible. One way to reduce the influence of noise is non-linear encoding. This means that lower amplitudes are amplified before processing. As lower amplitudes are amplified, their distance from noise increases and the quality improves. The most common methods for this are A-Law and U-Law encoding - some standardized logarithmic amplification curves, used in digital telephony (ITU G.711 standard). Nonlinear Encoding 3.4 Sample Formats Samples can be stored in different formats and precisions. The most common ones are integer (fixed-point) formats, that store values with fixed quantisations. Depending on where the zero line is defined, it has to be destinguished between unsigned (only positive values, zero line is at half of the numeric range) and signed (positive and negative values) integer formats. 26

27 Signed Format Unsigned Format As the quantisation loses some accuracy, it produces noise, the so-called quantisation noise. That kind of noise has more effect on low amplitudes, so this method of storing samples is not optimal, but quite easy and very fast to handle (computers are fast in calculating with fixed point numbers). The second way of encoding samples is with floating point numbers. With floating point numbers, noise is spread nearly equal over all ranges of amplitudes and has advantages especially on low amplitudes. However, this format is much slower when used for processing (computers are much slower on calculating with floating point values in comparison to fixed point numbers). OPMERKING Kwave internally uses signed integer format with 24 bit precision, stored in 32 bit integers. This has the disadvantage of higher memory consumption when processing files with lower precision (bijv. 8 bits), but processing 32 bit numbers is very fast and also leaves some reserves for internal calculations, as only 24 bits are normally used. 27

28 Hoofdstuk 4 Using Kwave Here is a little screenshot of the Kwave main window, so that you get an impression what Kwave looks like User Interface Mode Depending on your personal preferences or use cases you can configure how Kwave handles multiple open files. You can switch this setting on the fly through the menu Settings Show Files in... The three possible settings are: Separate Windows (SDI): When using the Single Document Interface (SDI), each file will be shown in a separate main window. 28

29 Same Window (MDI): When using the Multi Document Interface (MDI), there is only one Kwave main window, but within this window you have an area which shows sub windows, which can be resized, moved, tiled, cascaded or minimized. You can select a window from the Windows menu or cycle through the sub windows with Ctrl-Tab. Tabs: This is a variant of the MDI interface, where files are shown within separate tabs. You may know this mode from some popular Internet browsers. You can activate a tab via the Windows menu or cycle through the tabs with Ctrl-Tab. 29

30 4.2 Memory Setup When using Kwave for the first time, you should go to the memory setup dialog and modify the settings to be suitable for your needs and the installed memory of your computer. You can reach it under Settings Memory... Kwave is able to use two types of memory: physical and virtual memory. Physical memory is the memory (RAM) that is installed in your computer. You should limit the usage of physical memory to some reasonable size, as a rule of thumb, half of the installed me- 30

31 mory should be ok. If you set the limit too high, Linux will take memory from other applications, which means that it swaps out memory of other programs to the hard disk (swap), which is rather slow. If you set the limit too low, you might lose some performance when working with big files, because you use less of the fast physical memory than you could. If you enable virtual memory, Kwave is able to load and process files that are bigger than the amount of real installed physical memory. Kwave does this by using temporary files in a configurable directory, which is much faster and more cooperative to other applications than using the operating system s swapping. The directory that you configure should be on your local hard disk. 4.3 Opdrachtregel List of Files or Commands If you start Kwave from the command line, you can specify a list of files that should be opened. The first specified file will be opened first, then the other files. Each file will be opened in an own new window or sub window of the same Kwave instance. If you specify wildcards, you can open a large number of files at once. For example, the following command starts a Kwave and opens all sounds of the KDE window manager, each in a new window or sub window: % kwave /usr/share/sounds/kde_window *. wav It is also possible to pass Kwave text commands, encoded as a special URI 1, this will be described in a later section GUI Type The parameter --gui-type=sdi MDI TAB lets Kwave start in one of the three possible GUI modes: SDI, MDI or TAB Xt Toolkit options In addition to a list of files, you can specify a list of Xt toolkit options like -geometry for specifying the size and/or position of the first opened Kwave window and/or -display for starting the Kwave on a different display. For example, the following command starts a Kwave window with an initial width of 600 pixels and a height of 400 pixels, with the right border positioned 30 pixels away from the right and 0 pixels away from the top of the screen. % kwave - geometry 600 x Opstartopties With the option --disable-splashscreen you can disable the splash screen that comes up when starting Kwave. This might be useful when you start Kwave from a script. 1 universal resource identifier 31