Customer Reviews

A Programmer's Guide to Sound

5 star:		(1)
4 star:		(6)
3 star:		(1)
2 star:		(3)
1 star:		(3)

 

 

WHAT THIS BOOK DOES WELL:

* Explains audio signals, frequency, pitch, and Fourier transforms at a level suitable for anyone who understands trig, and in a highly readable way

* Explains file formats (WAV, AU, AIFF, MPEG formats, MIDI, MOD formats, etc.), and compression schemes, complete with tested implementation code

* Explains basic frequency filtering (with code)

* Implements readable, usable c++

WHAT'S BEYOND THE SCOPE OF THIS BOOK:

* In depth DSPs, physics, acoustics, or mathematics

* More complex transforms, like pitchbending without changing the length, noise reduction, adding reverb, flanging, etc.

* Highly optimized numerical algorithms

IN SHORT: if you need an introduction to the subject or just want a royalty-free code base for file format handling, this is an excellent book. If you already know all the basics, you won't learn very much.

This book is pretty decent, pretty much what I was expecting, except the publisher, Addison-Wesley, has stopped shipping the book with a CD. Instead there is a note in the book instructing you to go to their website for a downloadable version of the CD.

Surpise! No downloads available for this title!

The CD contains all of the code from the book, project files, sample sounds, and code that is not in the book, so in my opinion, the CD contents are pretty necessary.

So far I have written them several times (very politely) with no response and I've spent hours on the phone trying to get this problem resolved, only to get transferred to four or five people and eventually transferred to a recorded message saying that they "cannot take my call at this time" and to call back.

So... do not buy this book unless you don't mind not getting the CD.

This book can be used as a reference toward file formats as applied to sounds. However, I found the software and code examples within the book to be unnecessarily complicated. For instance, the author has a clear obsession to add unnecessary functions toward the API, such as "negotiation" and various levels of abstraction. Under normal circumstances, all parameters (sampling frequency, bits per sample, etc) are known in advance and hence "negotiation" among various sound objects is absurd. I have also found numerious inconsistencies and omissions in the code provided. In Page 42 - Listing 4.6, the author suggests a recursive way to read bytes; nonetheless, if the previous pointer is NULL the code will get into real trouble. In the CD-ROM provided, in order to compile the window player, a key header file is missing: "audiolib.h", I couldn't find it after searching several times. My recommendation is that the material can be used for a quick browse of file formats, but do not get serious in the software solutions because they are not useful.

This is the only book that I've come across that covers any of the trivialities of cross-platform sound programming. Sure there are better books on the various platform APIs, but they don't cover the differences between playing sound on Windows vs Mac. Small things like signed and unsigned data and byte swapping for 16 bit data are covered here. You won't find these things in Petzold's book. I did find a few small problems in the example code, but if you actually read the book, they're easy to spot. If you're writing cross-platform sound code, this book will be very helpful.

I am SO disappointed in this book! I am a programmer who wants to record .wav files, and from the title you would think this would get at least cursory coverage! But be warned, this book has NOTHING, absolutely zero, about recording!

I am keeping the book because of its information on Fourier Transforms, but am back to square one in search of a true programmer's reference book on sound!!

Amazon, warn your potential buyers, please!

Covers basics of the generation and perception of sound, then shifts into discussion of the various formats in common use by software engineers and hackers. Every programming concept is illustrated with C++ example code, from which Kientzle builds a reusable framework. This framework is available on a CD that is included with the book. This book serves well as a compendium of audio knowledge scattered around in specs, standards, and papers.

I would love to see a future edition with Java bindings to the C++ framework.

The CD included with this book will get you started programming *fast*. But be forewarned, the style of C++ used is written using the latest standard which includes namespaces and STL. You'll need a current C++ compiler with libraries.

Kietzle really just tries to plow through the theory so he can cut to describing the included code. And I don't blame him. The inheritence and polymorphism used allows *extreme* flexibility and takes some patience to understand.

If you want to *really* understand antialising, sample rates and the Nyquist frequency, then you'd be better off with "The Computer Music Tutorial" (Roads).

The book delivers as advertised and makes a great resource for all programmers who have an interest in audio.

I have spent a lot of time trying to find information on many of the topics covered and to find 1 resource that has all information and is well tested is a gold mine. I have recommended that professors use the book in their DSP classes. The source code is easy to follow and compiles without a hitch. It is an excellent resource.

Since this book was written almost ten years ago, you really have to ignor it when it talks about platform-specific code. However, this book is still valuable because it includes the details of many audio-specific algorithms you can't find in other books.

Part one is an overview of audio basics, and is a worthwhile overview if you are a novice. Part two, on system specifics, can be skipped since it is completely out of date. It mainly talks about audio on specific computing platforms. Part three, on compression, does a good job of explaining and implementing various basic compression algorithms such as uLaw and PCM. Even the chapter on MPEG compression is pretty good, with a pretty complete description of MPEG-1 audio coding and decoding. Likewise, part 4 on General File Formats is very complete for the file formats that are described. Again, the age of the book comes into play since the file formats covered are AU, Creative Labs' VOC format, Microsoft Windows' WAVE format, Apple's AIFF and AIFF-C formats, and Electronic Arts' IFF format that was primarily used on the long defunct Commodore Amiga. The coverage is complete, it is just, unfortunately, covering mainly dated formats.

Part five covers the musical file formats of the MIDI event-based format and the more obscure MOD beat-based format. I especially liked the section on MIDI, since it has a software-based explanation rather than an electronic device interconnection explanation that you find in so many books. Part six, Audio Processing, is less thorough than other sections. The algorithms in the code do work, but if you've never seen filtering and signal processing concepts explained before, you'll likely get lost as to what is going on in this section. Also, don't expect to see special effects such as chorus explained here either. Part seven, which consists of the appendices is helpful for understanding what is on the accompanying CD, but the section on C++ should have been omitted. It is too short to help a novice and pretty much useless for the experienced programmer.

If you are looking for the specific audio algorithms I've mentioned, you already know C++ and something about audio, and you don't mind digging into the accompanying code to get to the heart of the algorithms included, this is the book for you. If you just want code you can drag and drop into either a Mac or a Windows based machine, you should look elsewhere.

I used this book as the basis for a real time speech program and I found that although the book gave a good overview of the way that Win95 uses sound playback, the code was too complicated. The object oriented nature of the code was a good idea except that it seemed that there was a lot of uneeded code, for example queue implementations were too complex. Also there could have been better coverage given to synchronisation objects like semaphores in the code. Overall quite helpful but the code can be optimised in some places.