anchor.diff:                                (= (the fixnum e) (the fixnum +emphasis-50-15+))
                                 (= (the fixnum e) (the fixnum +emphasis-ccit+))))
   
  +;;; the modes
   (defconstant +mode-extension-0+ 0)
   (defconstant +mode-extension-1+ 1)
   (defconstant +mode-extension-2+ 2)
   (defconstant +mode-extension-3+ 3)
  -
   (defun get-mode-extension-string (channel-mode layer mode-extension)
     (if (not (= channel-mode +channel-mode-joint+))
         ""
  
positive.code:           nil)))))
  
  (defmethod parse-header ((me frame))
    (fastest
      (log5:with-context "parse-header"
        (with-frame-slots (me)
          (setf (ldb (byte 8 8) sync) (ldb (byte 8 24) hdr-u32))
          (setf (ldb (byte 3 5) sync) (ldb (byte 3 5) (ldb (byte 8 16) hdr-u32)))
          (when (not (= sync +sync-word+))
            (log-mpeg-frame "bad sync ~x/~x" sync hdr-u32)
            (return-from parse-header nil))
  
          (setf version (ldb (byte 2 3) (ldb (byte 8 16) hdr-u32)))
          (when (not (valid-version version))
            (log-mpeg-frame "bad version ~d" version)
            (return-from parse-header nil))
  
          (setf layer (ldb (byte 2 1) (ldb (byte 8 16) hdr-u32)))
          (when (not (valid-layer layer))
            (log-mpeg-frame "bad layer ~d" layer)
            (return-from parse-header nil))
  
          (setf protection (ldb (byte 1 0) (ldb (byte 8 16) hdr-u32)))
          (setf samples (get-samples-per-frame version layer))
  
          (let ((br-index (the fixnum (ldb (byte 4 4) (ldb (byte 8 8) hdr-u32)))))
            (when (not (valid-bit-rate-index br-index))
              (log-mpeg-frame "bad bit-rate index ~d" br-index)
              (return-from parse-header nil))
            (setf bit-rate (get-bit-rate version layer br-index)))
  
          (let ((sr-index (the fixnum (ldb (byte 2 2) (ldb (byte 8 8) hdr-u32)))))
            (when (not (valid-sample-rate-index sr-index))
              (log-mpeg-frame "bad sample-rate index ~d" sr-index)
              (return-from parse-header nil))
            (setf sample-rate (get-sample-rate version sr-index)))
  
          (setf padded (ldb (byte 1 1) (ldb (byte 8 8) hdr-u32)))
          (setf private (ldb (byte 1 0) (ldb (byte 8 8) hdr-u32)))
  
          (setf channel-mode (ldb (byte 2 6) (ldb (byte 8 0) hdr-u32)))
          (setf mode-extension (ldb (byte 2 4) (ldb (byte 8 0) hdr-u32)))
          (setf copyright (ldb (byte 1 3) (ldb (byte 8 0) hdr-u32)))
          (setf original (ldb (byte 1 2) (ldb (byte 8 0) hdr-u32)))
          (setf emphasis (ldb (byte 2 0) (ldb (byte 8 0) hdr-u32)))
          (when (not (valid-emphasis emphasis))
            (log-mpeg-frame "bad emphasis ~d" emphasis)
            (return-from parse-header nil))
  
negative.code:         nil))))
  
  (defmethod next-frame ((me frame) &key instream read-payload)
    "Get next frame.  If READ-PAYLOAD is true, read in contents for frame, else, seek to next frame header."
    (fastest
      (log5:with-context "next-frame"
        (let ((nxt-frame (make-instance 'frame)))
  