The header of a 2.2 frame consists of three bytes that encode a three-character ISO 8859-1 string followed by a three-byte unsigned integer, which specifies the size of the frame in bytes, excluding the six-byte header. The string identifies what type of frame it is, which determines how you parse the data following the size. This is exactly the kind of situation for which you defined the macro. You can define a tagged class that reads the frame header and then dispatches to the appropriate concrete class using a function that maps IDs to a class names.

Now you’re ready to start implementing concrete frame classes. However, the specification defines quite a few—63 in version 2.2 and even more in later specs. Even considering frame types that share a common structure to be equivalent, you’ll still find 24 unique frame types in version 2.2. But only a few of these are used “in the wild.” So rather than immediately setting to work defining classes for each of the frame types, you can start by writing a generic frame class that lets you read the frames in a tag without parsing the data within the frames themselves. This will give you a way to find out what frames are actually present in the MP3s you want to process. You’ll need this class eventually anyway because the specification allows for experimental frames that you’ll need to be able to read without parsing.

(define-binary-class generic-frame (id3-frame)
  ((data (raw-bytes :size size))))

The type of the data field, raw-bytes, just needs to hold an array of bytes. You can define it like this:

For the time being, you’ll want all frames to be read as generic-frames, so you can define the find-frame-class function used in id3-frame‘s :dispatch expression to always return generic-frame, regardless of the frame’s .

(defun find-frame-class (id)
  'generic-frame)

To handle this, you can define a binary type, id3-frames, that will be responsible for reading the remainder of a tag, creating frame objects to represent all the frames it finds, and then skipping over any padding. This type will take as a parameter the tag size, which it can use to avoid reading past the end of the tag. But the reading code will also need to detect the beginning of the padding that can follow the tag’s frame data. Rather than calling read-value directly in id3-frames :reader, you should use a function read-frame, which you’ll define to return **NIL** when it detects padding, otherwise returning an id3-frame object read using . Assuming you define read-frame so it reads only one byte past the end of the last frame in order to detect the start of the padding, you can define the id3-frames binary type like this:

You can use this type to add a frames slot to id3-tag.

(define-binary-class id3-tag ()
  ((identifier     (iso-8859-1-string :length 3))
   (revision       u1)
   (flags          u1)
   (size           id3-tag-size)