Customer Reviews

Maximum MIDI : Music Applications in C++

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

 

 

The book is great for someone who wishes to use the Author's DLLs to write MIDI programs. Unfortunately, I bought it to learn how to write MIDI programs using the Microsoft Multimedia SDK functions and this book was not adequate for my needs. Note that some of the things his DLLs require (such as transmitting SysEx one byte at a time) is, at best, a kludge and surely not to be looked upon as elegant coding.

You can find out a lot more about Windows MIDI functions by reading Microsoft's SDK, as poorly written as they are. For instance, no mention is made at all in this book about an entire section of MIDI functions, those which deal with using MIDI streams.

It wouldn't have been so bad if the author had at least spent time going over the code in his DLLs and explaning how he did what and why. But, I don't feel enough of that was done.

Unfortunately, there is still not one good book available detailing how to write MIDI apps using the Microsoft Multimedia SDK.

This book hovers between three and four stars in usefulness, but ultimately I decided to give it four stars because it is the only one of its kind. As you probably already know, MIDI is an industry-standard electronic communications protocol that defines each musical note in an electronic musical instrument such as a synthesizer, precisely and concisely, allowing electronic musical instruments and computers to exchange data, or "talk", with each other. MIDI does not transmit audio - it simply transmits digital information about a music performance.
This book is not a MIDI primer, nor is it about how to use existing MIDI applications. It is about how to program applications in C++ that use MIDI. It does begin with an in-depth explanation of how MIDI works in chapters one and two, but then proceeds into the nuts and bolts of programming.
Both the book and the toolkit are in desperate need of another edition, since both concentrate on Windows 95 pre-DirectX style-programming. In fact, the author's toolkit is very entrenched in Windows 95. This to me is the book's largest shortcoming. The author does go into great detail to show you how to do common MIDI tasks using his toolkit, including fundamental algorithms for musical timing, toolkit-based synchronization, recording and playing MIDI events, and finally writing sequencers. Complete sourcecode for the toolkit is included on the accompanying CDROM. The author does a very good job of documenting his code and his method, which makes it ideal for what I am trying to do with it, which is adding some additional MIDI functionality to a Java program I am writing above and beyond what Java Sound does. Most of the work involves crow-barring the code's algorithms loose from all of the Windows-centric stuff. If you have similar needs, there just isn't a better or more detailed source in print, and with the advent of full-fledged music applications like Mac's GarageBand, there is not likely to be.

I hate computer books. They are all over two inches thick, and cost their weight in gold, but most of them are only worth their weight in paper.

However, there is always an exception, and Paul Messick's 'Maximum Midi' is it. It's a GOOD book. You know, like Citizen Kane is a GOOD film.

I can now write MIDI applications in Windows. I feel like a bit of an expert. My first sequencer already loads, saves, plays and records. I've got time to concentrate on making it highly usable.

The author assumes that you or I, the reader, is intelligent. There's no assumption that you are a C++ whizz, or an electronics genius; just intelligent, and consequently ideas are explained from first principles by a writer who obviously knows his stuff well enough that he doesn't have to prove it by using long words and big ideas.

But from first priciples comes lasting knowledge, and by the time the author moves on to explain the less pretty bits of MIDI implementation you realise that you UNDERSTAND everything that's gone before. The learning curve is so smooth, you don't realise you're climbing.

But you are climbing, and quite rapidly at that. If ,like me, you read the book from cover to cover (some books just make you want to do that, don't they) by half-way through you KNOW what Sysex is, and how it works, and what's good about it, and why you have to be careful with it. You KNOW why Windows 95 makes timing algorithms difficult, and how to get around it. By this stage you also know that on the CD of the book, there is a toolkit.

The toolkit contains functions that allow you to use MIDI in your programs, without also having to care about 'callbacks', 'thunks' or anything else that gives you a headache. (They are explained lucidly, but kept at a safe distance). Midi Input/Output, synchronisation and reading and writing of standard MIDI files are all introduced, fully explained and, finally, implemented in the toolkit. Although you now feel that could write your sequencer, or patch editor, or desk automator from the bottom up, it's nice to know you don't have to. The toolkit is there, it's tested, it works and it's royalty free. There is no reason not to use it. (It's provided as a pair of DLLs, so you can use it from any language. I'm now calling it from Delphi, and hardly knew what a DLL was before reading this book. A set of C++ classes encapsulate the toolkit's functions into a higher level, and very useful form).

Don't you just loathe getting to page 800 of 'Mastering your Scroll-Lock key' and realising you learned as much from the introductory chapter as you have from the rest of the book. Well, Mr Messick's book (a mere 1.3 inches thick, if that's important to you!) is full of new knowledge from cover to cover, even the margins are sometimes used for 'by the way...' type information. For once, a publisher has realised that their readers are not fooled by the 'never mind the quality, feel the width' spin.

Any useful book review has balance, so here it is: 'Silicon Etching for Dummies' and 'Adjusting your Windows Colour scheme in 21 days' are very bad. 'Maximum Midi' is very good. Is that balanced enough for you?

Paul Spbm Clarke

The author explains well the inner workings of programming MIDI with Microsoft's Visual C++ 4.0, although it doesn't cover the DirectX thing. That is, of course, because it was written before the DirectX specification was developed. However, he explains very well why Windows 95 (without DirectX) is NOT a terrific system for making useful MIDI programs, and his solution to this is well implemented and explained. It explains the Thunking concept and process, and explores the heart of the system's Multimedia processes phylosophy and design.

It is, therefore, a good starting point for anyone having a Microsoft Visual C++ 4.0 (or later) that wants to know how to make a Rock-Solid MIDI App within the 32 bit world. Then, once you have a feeling of what will it take if you want to make it from scratch, you can see the documentation of your compiler and see how DirectX works and actually evaluate its pros&cons and what solution is the best for your particular interests and needs.

I really recommend it.

The author does know about this kind of stuff and the online forum is a very useful source of information.

It is too bad that a book so carefully written and well explained as this one is plagued by two major flaws:

1) the reader/user is forced to use Messick's toolkit. It has to be said that it works: everything in the companion CD runs and compiles, including the example sequencer. But that's not what I, among others, expected: I expected an in-depth treatment of the standard VC/C++ MIDI primitives and functions, out of which to build my own applications. I could show that it's possible to do so, I have started with a few examples. Hence the book is not useful for someone who wants to start from scratch.

2) The method for the timing is a kludge. I follow Messick's reasoning that multitasking systems like Windows do not garantee precise timing, but not his solution to use 16-bit, Win3.x thunks. That is a non-universal trick - which e.g. won't work for NT. Now I am not familiar enough with the innards of Microsoft systems to suggest an alternative solution, but I am sure there is a better one. After all, there are plenty of other sequencers (Cakewalk?) that work under all of them. In UNIX, you'd write a driver with sections of code that are shielded from any interrupt and run in real time - in addition, 2.9 BSD has the ``rtp'' (real time process) system call that locks a process, and earlier machines allowed direct access to the clock from a C program.

To conclude, the book is great if one wants to follow what Messick has done - one may suspect he developed that toolkit for some other reason and then decided to make an extra buck by plublishing it - but it's not " the programmer's definitive source of information for developing MIDI-based Windows 95 applications." And that's too bad because, given the scant documentation by Microsoft, there is ample need for such a book.

I don't recommend this book for the novice. Like others who have reviewed this book, it seems more of an explanation of how to use Paul's higher level routines than a down to earth book on how to understand or write your own MIDI program.
But it's still probably the best book of it's kind out there, if you can even find another one. Getting any information out of those who know how to write a MIDI program is like pulling teeth. They either don't have the ability to explain it to anyone else, or they're hording the knowledge to keep down any competition. (kind of like an economist, no one can understand them...remember Economics class?)

First a note. The main purpose of this book is twofold. It's a good introduction to MIDI and using it in windows 95/98, but it doesn't go into detail of how windows does everything. Rather its a documentation for a library of functions that do all the hard work for you and let you get on with writing good MIDI applications. The source code is provided and the author leaves a VERY generous lisence on the software, allowing you to do nearly anything with it!

Now a word on the writing. This book is perfect, the author uses subtle humor to keep the reading light, but not so much as to make it pathetic. He keeps the tone of the book informal, more as a friend explaining something than a professor lecturing. Despite being filled with facts and details and source code, the book reads like a novel.

The chapter that simply describes an overview of the MIDI spec. makes for a great intro to MIDI, even for people who have been using it for years. If you ever plan on learning anything about MIDI and how to write computer programs that use it, buy this book.

The Good: Includes well written source code. 'C' source code is included as well as C++. HTML version of book included on CD. A variety of example applications are included to get you started. Paul Messick is vigilant in making bug fixes and does a good job hosting a private users group on the Internet.

The Bad: Included source code has a few bugs. You have to download the latest libraries and patches.

The Ugly: Nothing ugly... :-)

Comments: Paul Messick is extremely skilled at low level programming and understands the zero tolerance for latencies in music and MIDI. I kept away from the MFC implementations simply because I felt this was too much overhead.

The C++ "objects" are really just wrappers for the 'C' code. The aggregation helps to keep things organized, but his architecture doesn't mandate using OO design unless you're looking to create an application fast (but not a *fast* application;-) using MFC and MSVC wizards.

There is no better book on the market for Windows programmers of *all* skills who have an interest in MIDI.

This is a book that's destined to become a MIDI how-to classic.I've waited for quite a while to find a book that not only explains MIDI programming in detail,but also provides source code,a well done and documented companion disk ,many book examples in C and C++,online support and forum for the book(big plus!).I would have given a perfect rating ,but I specialize in using a different programming language-but I understand how to convert the code to C/C++ .As the title indicates,applications in C++.Kudos to Paul Messick!

This book will precisely show you how to implement MIDI functionality using MFC and C++. The author knows his stuff and doesn't shy away from the subtleties of 16-bit thunking (to get the best timing) and other techniques necessary for the best results.

As if that wasn't enough, you get a working toolkit of MFC C++ classes ready to implement in your own projects.