libextractor

id3_extractor.c (57011B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2026 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      General Public License for more details.
 
      You should have received a copy of the GNU General Public License
      along with libextractor; see the file COPYING.  If not, write to the
      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
  */
 /**
  * @file plugins/id3_extractor.c
  * @brief plugin to support MPEG audio with ID3v2 and ID3v1 tags
  * @author Christian Grothoff
  *
  * There is an unported `plugins/old/mp3_extractor.c' in this tree that
  * covers part of the same ground.  It got the MPEG frame header tables
  * right and they are reused here, but its strategy -- walk every frame
  * in the file, up to 31 MB, to decide whether the file is an MP3 --
  * is the opposite of what a first pass over a volume wants, so the
  * rest is written fresh.
  *
  * What we are after is not the song title.  It is the provenance: who
  * encoded the file (TENC), with what (TSSE and the LAME tag), who
  * owned it (TOWN), which player stamped it (PRIV) and which catalogue
  * it came from (UFID).  The LAME tag in particular is a fingerprint of
  * the exact ripping software and its settings.
  *
  * References: the ID3v2.2/2.3/2.4 specifications from id3.org, and the
  * Xing/Info and LAME tag layout as documented at
  * gabriel.mp3-tech.org/mp3infotag.html.
  */
 #include "platform.h"
 #include "extractor.h"
 #include "forensics.h"
 
 #include <stdarg.h>
 
 
 /**
  * Name we report our meta data under.
  */
 #define ID3_PLUGIN "id3"
 
 /**
  * MIME type we claim.
  */
 #define ID3_MIME "audio/mpeg"
 
 /**
  * Most of an ID3v2 tag we are willing to pull into memory.  Parsing
  * from a buffer rather than by seeking is what makes the
  * unsynchronisation scheme tractable; the price is this read.  Real
  * tags are a few kilobytes, or a few tens of kilobytes with cover art;
  * beyond this bound we parse the frames that fit and stop.
  */
 #define ID3_MAX_TAG_READ (256 * 1024)
 
 /**
  * Upper bound on the number of frames we walk.
  */
 #define ID3_MAX_FRAMES 128
 
 /**
  * Longest decoded string we build.
  */
 #define ID3_MAX_TEXT 1024
 
 /**
  * Largest embedded picture we hand on.  Anything bigger is skipped
  * rather than copied through the IPC channel.
  */
 #define ID3_MAX_PICTURE (100 * 1024)
 
 /**
  * Bytes we scan for the first MPEG audio frame.
  */
 #define ID3_SYNC_WINDOW 8192
 
 /**
  * How many TXXX frames we report as unknown user text.
  */
 #define ID3_MAX_USER_TEXT 8
 
 
 /**
  * Bitrates in kbit/s.  The row is picked from the MPEG version and the
  * layer, the column is the four bit field in the frame header.
  */
 static const unsigned int bitrate_table[5][16] = {
   /* MPEG 1 Layer I */
   { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0 },
   /* MPEG 1 Layer II */
   { 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0 },
   /* MPEG 1 Layer III */
   { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0 },
   /* MPEG 2 / 2.5 Layer I */
   { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },
   /* MPEG 2 / 2.5 Layer II and III */
   { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 }
 };
 
 
 /**
  * Sampling rates in Hz, indexed by version (0 = MPEG 1, 1 = MPEG 2,
  * 2 = MPEG 2.5) and by the two-bit field in the header.
  */
 static const unsigned int samplerate_table[3][3] = {
   { 44100, 48000, 32000 },
   { 22050, 24000, 16000 },
   { 11025, 12000, 8000 }
 };
 
 
 /**
  * Channel modes, in the order the header field numbers them.
  */
 static const char *const channel_modes[4] = {
   "stereo",
   "joint stereo",
   "dual channel",
   "mono"
 };
 
 
 /**
  * The ID3v1 genre numbers, as fixed by the original specification and
  * extended by Winamp.  ID3v2 `TCON' frames also refer to these by
  * number, in the "(52)" spelling.
  */
 static const char *const id3_genres[] = {
   "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk",
   "Grunge", "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies",
   "Other", "Pop", "R&B", "Rap", "Reggae", "Rock",
   "Techno", "Industrial", "Alternative", "Ska", "Death Metal", "Pranks",
   "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal",
   "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental", "Acid",
   "House", "Game", "Sound Clip", "Gospel", "Noise", "Alternative Rock",
   "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
   "Instrumental Rock", "Ethnic", "Gothic", "Darkwave",
   "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream",
   "Southern Rock", "Comedy", "Cult", "Gangsta", "Top 40",
   "Christian Rap", "Pop/Funk", "Jungle", "Native US", "Cabaret",
   "New Wave", "Psychedelic", "Rave", "Showtunes", "Trailer", "Lo-Fi",
   "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical",
   "Rock & Roll", "Hard Rock", "Folk", "Folk-Rock", "National Folk",
   "Swing", "Fast Fusion", "Bebop", "Latin", "Revival", "Celtic",
   "Bluegrass", "Avantgarde", "Gothic Rock", "Progressive Rock",
   "Psychedelic Rock", "Symphonic Rock", "Slow Rock", "Big Band",
   "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
   "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony",
   "Booty Bass", "Primus", "Porn Groove", "Satire", "Slow Jam", "Club",
   "Tango", "Samba", "Folklore", "Ballad", "Power Ballad",
   "Rhythmic Soul", "Freestyle", "Duet", "Punk Rock", "Drum Solo",
   "A Cappella", "Euro-House", "Dance Hall"
 };
 
 
 /**
  * An ID3v2 text frame identifier and the meta data type it maps to.
  */
 struct FrameMap
 {
   /**
    * Four character frame identifier.
    */
   const char *id;
 
   /**
    * Type to report the frame's text as.
    */
   enum EXTRACTOR_MetaType type;
 };
 
 
 /**
  * Text frames we understand.  The first block is the ordinary
  * descriptive tagging; the second is what tells us where the file came
  * from.
  */
 static const struct FrameMap text_frames[] = {
   { "TIT1", EXTRACTOR_METATYPE_GROUP },
   { "TIT2", EXTRACTOR_METATYPE_TITLE },
   { "TIT3", EXTRACTOR_METATYPE_SUBTITLE },
   { "TALB", EXTRACTOR_METATYPE_ALBUM },
   { "TPE1", EXTRACTOR_METATYPE_ARTIST },
   { "TPE2", EXTRACTOR_METATYPE_PERFORMER },
   { "TPE3", EXTRACTOR_METATYPE_CONDUCTOR },
   { "TPE4", EXTRACTOR_METATYPE_INTERPRETATION },
   { "TCOM", EXTRACTOR_METATYPE_COMPOSER },
   { "TEXT", EXTRACTOR_METATYPE_WRITER },
   { "TRCK", EXTRACTOR_METATYPE_TRACK_NUMBER },
   { "TPOS", EXTRACTOR_METATYPE_DISC_NUMBER },
   { "TYER", EXTRACTOR_METATYPE_PUBLICATION_DATE },
   { "TDRL", EXTRACTOR_METATYPE_PUBLICATION_DATE },
   { "TDRC", EXTRACTOR_METATYPE_CREATION_DATE },
   { "TPUB", EXTRACTOR_METATYPE_PUBLISHER },
   { "TCOP", EXTRACTOR_METATYPE_COPYRIGHT },
   { "TLAN", EXTRACTOR_METATYPE_LANGUAGE },
   { "TBPM", EXTRACTOR_METATYPE_BEATS_PER_MINUTE },
   { "TSRC", EXTRACTOR_METATYPE_ISRC },
   { "TMOO", EXTRACTOR_METATYPE_MOOD },
   { "TOAL", EXTRACTOR_METATYPE_ORIGINAL_TITLE },
   { "TOPE", EXTRACTOR_METATYPE_ORIGINAL_PERFORMER },
   { "TOLY", EXTRACTOR_METATYPE_ORIGINAL_WRITER },
   { "TORY", EXTRACTOR_METATYPE_ORIGINAL_RELEASE_YEAR },
   /* provenance */
   { "TENC", EXTRACTOR_METATYPE_ENCODED_BY },
   { "TSSE", EXTRACTOR_METATYPE_ENCODER_SETTINGS },
   { "TOWN", EXTRACTOR_METATYPE_OWNER_USER },
   { "TFLT", EXTRACTOR_METATYPE_SOURCE_DEVICE },
   { "TMED", EXTRACTOR_METATYPE_SOURCE_DEVICE },
   { NULL, EXTRACTOR_METATYPE_RESERVED }
 };
 
 
 /**
  * A three character ID3v2.2 frame identifier and the 2.3 identifier
  * that means the same thing.
  */
 struct FrameAlias
 {
   /**
    * ID3v2.2 identifier.
    */
   const char *old_id;
 
   /**
    * Equivalent ID3v2.3 identifier.
    */
   const char *new_id;
 };
 
 
 /**
  * ID3v2.2 used three character frame identifiers.  Rather than a
  * second dispatcher we translate them to their 2.3 equivalents and run
  * the same code.  `PIC' is deliberately absent: its payload names the
  * image format in three characters where `APIC' carries a MIME string,
  * so it cannot share the handler, and an attached picture is not worth
  * a second one.
  */
 static const struct FrameAlias v22_aliases[] = {
   { "TT1", "TIT1" }, { "TT2", "TIT2" }, { "TT3", "TIT3" },
   { "TAL", "TALB" }, { "TP1", "TPE1" }, { "TP2", "TPE2" },
   { "TP3", "TPE3" }, { "TP4", "TPE4" }, { "TCM", "TCOM" },
   { "TXT", "TEXT" }, { "TRK", "TRCK" }, { "TPA", "TPOS" },
   { "TYE", "TYER" }, { "TPB", "TPUB" }, { "TCR", "TCOP" },
   { "TLA", "TLAN" }, { "TBP", "TBPM" }, { "TRC", "TSRC" },
   { "TOT", "TOAL" }, { "TOA", "TOPE" }, { "TOL", "TOLY" },
   { "TOR", "TORY" }, { "TEN", "TENC" }, { "TSS", "TSSE" },
   { "TFT", "TFLT" }, { "TMT", "TMED" }, { "TCO", "TCON" },
   { "COM", "COMM" }, { "ULT", "USLT" }, { "UFI", "UFID" },
   { "TXX", "TXXX" }, { "WAF", "WOAF" }, { "WAR", "WOAR" },
   { "WCM", "WCOM" }, { "WPY", "WPAY" },
   { NULL, NULL }
 };
 
 
 /**
  * TXXX descriptions that name a store account.  The Apple ID of a
  * purchase normally lives in an M4A `----:com.apple.iTunes:...' atom
  * rather than in ID3, but transcoders copy it across under these
  * descriptions, and other stores stamp their own.
  */
 static const char *const purchase_descriptions[] = {
   "apid",
   "apple id",
   "purchase account",
   "purchased by",
   "itunes account",
   "itunes_purchase_account",
   NULL
 };
 
 
 /**
  * What we have already reported, so that the ID3v1 tag at the end of
  * the file can fill gaps without contradicting the ID3v2 tag in front
  * of it.
  */
 struct Id3Context
 {
   /**
    * Extraction context.
    */
   struct EXTRACTOR_ExtractContext *ec;
 
   /**
    * Number of TXXX frames reported so far.
    */
   unsigned int user_text;
 
   /**
    * Indexed by meta data type: 1 once we have emitted one.
    */
   unsigned char seen[EXTRACTOR_METATYPE_LAST];
 };
 
 
 /**
  * Emit a NUL-terminated string and remember that we did.
  *
  * @param ctx our state
  * @param type meta data type
  * @param s the string
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 id3_emit (struct Id3Context *ctx,
           enum EXTRACTOR_MetaType type,
           const char *s)
 {
   /* An empty value is dropped by the emit helper, so it must not
      count as having covered this type: the ID3v1 tag may still have
      something real to say about it. */
   if ( ('\0' != s[0]) &&
        (0 < type) &&
        (type < EXTRACTOR_METATYPE_LAST) )
     ctx->seen[type] = 1;
   return EXTRACTOR_forensic_emit_text_ (ctx->ec,
                                         ID3_PLUGIN,
                                         type,
                                         s,
                                         strlen (s));
 }
 
 
 /**
  * Convert an ISO-8859-1 string to UTF-8.  The bytes cannot simply be
  * passed through: every code point from 0x80 up needs two bytes in
  * UTF-8, and handing the raw bytes to the caller would produce invalid
  * UTF-8 for exactly the accented characters that make a tag
  * interesting.
  *
  * @param in the Latin-1 bytes
  * @param len number of bytes in @a in
  * @param[out] out where to write the NUL-terminated UTF-8
  * @param out_size size of @a out in bytes
  * @return 1 on success, 0 if the result does not fit
  */
 static int
 latin1_to_utf8 (const unsigned char *in,
                 size_t len,
                 char *out,
                 size_t out_size)
 {
   size_t o = 0;
 
   for (size_t i = 0; i < len; i++)
   {
     if (0 == in[i])
       break;
     if (o + 2 >= out_size)
       return 0;
     if (in[i] < 0x80)
     {
       out[o++] = (char) in[i];
     }
     else
     {
       out[o++] = (char) (0xC0 | (in[i] >> 6));
       out[o++] = (char) (0x80 | (in[i] & 0x3F));
     }
   }
   out[o] = '\0';
   return 1;
 }
 
 
 /**
  * Convert a UTF-16 string to UTF-8.
  *
  * @param in the UTF-16 bytes
  * @param len number of bytes in @a in
  * @param big_endian 1 for UTF-16BE, 0 for UTF-16LE
  * @param[out] out where to write the NUL-terminated UTF-8
  * @param out_size size of @a out in bytes
  * @return 1 on success, 0 if the input is malformed or does not fit
  */
 static int
 utf16_to_utf8 (const unsigned char *in,
                size_t len,
                int big_endian,
                char *out,
                size_t out_size)
 {
   size_t o = 0;
   size_t i = 0;
 
   while (i + 1 < len)
   {
     uint32_t cp = big_endian
                   ? EXTRACTOR_forensic_be16_ (&in[i])
                   : EXTRACTOR_forensic_le16_ (&in[i]);
 
     i += 2;
     if (0 == cp)
       break;
     if ( (0xD800 <= cp) && (cp <= 0xDBFF) )
     {
       uint32_t lo;
 
       if (i + 1 >= len)
         return 0;
       lo = big_endian
            ? EXTRACTOR_forensic_be16_ (&in[i])
            : EXTRACTOR_forensic_le16_ (&in[i]);
       if ( (lo < 0xDC00) || (lo > 0xDFFF) )
         return 0;
       i += 2;
       cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00);
     }
     else if ( (0xDC00 <= cp) && (cp <= 0xDFFF) )
     {
       return 0;
     }
     if (o + 4 >= out_size)
       return 0;
     if (cp < 0x80)
     {
       out[o++] = (char) cp;
     }
     else if (cp < 0x800)
     {
       out[o++] = (char) (0xC0 | (cp >> 6));
       out[o++] = (char) (0x80 | (cp & 0x3F));
     }
     else if (cp < 0x10000)
     {
       out[o++] = (char) (0xE0 | (cp >> 12));
       out[o++] = (char) (0x80 | ((cp >> 6) & 0x3F));
       out[o++] = (char) (0x80 | (cp & 0x3F));
     }
     else
     {
       out[o++] = (char) (0xF0 | (cp >> 18));
       out[o++] = (char) (0x80 | ((cp >> 12) & 0x3F));
       out[o++] = (char) (0x80 | ((cp >> 6) & 0x3F));
       out[o++] = (char) (0x80 | (cp & 0x3F));
     }
   }
   out[o] = '\0';
   return 1;
 }
 
 
 /**
  * Decode a string in the encoding an ID3v2 text frame declares in its
  * first byte.
  *
  * @param enc 0 = ISO-8859-1, 1 = UTF-16 with byte order mark,
  *        2 = UTF-16BE, 3 = UTF-8
  * @param in the encoded bytes
  * @param len number of bytes in @a in
  * @param[out] out where to write the NUL-terminated UTF-8
  * @param out_size size of @a out in bytes
  * @return 1 on success, 0 if the encoding is unknown or the input is
  *         malformed
  */
 static int
 decode_text (unsigned int enc,
              const unsigned char *in,
              size_t len,
              char *out,
              size_t out_size)
 {
   switch (enc)
   {
   case 0:
     return latin1_to_utf8 (in,
                            len,
                            out,
                            out_size);
   case 1:
     if (len < 2)
       return 0;
     if ( (0xFF == in[0]) && (0xFE == in[1]) )
       return utf16_to_utf8 (&in[2],
                             len - 2,
                             0,
                             out,
                             out_size);
     if ( (0xFE == in[0]) && (0xFF == in[1]) )
       return utf16_to_utf8 (&in[2],
                             len - 2,
                             1,
                             out,
                             out_size);
     /* no byte order mark although the encoding byte promised one;
        little endian is what the taggers that get this wrong write */
     return utf16_to_utf8 (in,
                           len,
                           0,
                           out,
                           out_size);
   case 2:
     return utf16_to_utf8 (in,
                           len,
                           1,
                           out,
                           out_size);
   case 3:
     {
       size_t n = len;
 
       for (size_t i = 0; i < len; i++)
         if (0 == in[i])
         {
           n = i;
           break;
         }
       if (n >= out_size)
         return 0;
       if (! EXTRACTOR_forensic_utf8_valid_ ((const char *) in,
                                             n))
         return 0;
       memcpy (out,
               in,
               n);
       out[n] = '\0';
       return 1;
     }
   default:
     return 0;
   }
 }
 
 
 /**
  * Find the terminator of the string at the start of @a in.
  *
  * @param enc text encoding as in #decode_text()
  * @param in the bytes
  * @param len number of bytes in @a in
  * @param[out] next offset of the byte after the terminator
  * @return length of the string in bytes, excluding the terminator;
  *         @a len (and @a next set to @a len) if there is none
  */
 static size_t
 string_end (unsigned int enc,
             const unsigned char *in,
             size_t len,
             size_t *next)
 {
   if ( (1 == enc) || (2 == enc) )
   {
     for (size_t i = 0; i + 1 < len; i += 2)
       if ( (0 == in[i]) && (0 == in[i + 1]) )
       {
         *next = i + 2;
         return i;
       }
     *next = len;
     return len;
   }
   for (size_t i = 0; i < len; i++)
     if (0 == in[i])
     {
       *next = i + 1;
       return i;
     }
   *next = len;
   return len;
 }
 
 
 /**
  * Report a genre, resolving the numeric references ID3 allows.
  * `TCON' may hold "(52)", "52" or "Electronic"; only the last is
  * useful to a human.
  *
  * @param ctx our state
  * @param text the frame's text
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 emit_genre (struct Id3Context *ctx,
             const char *text)
 {
   const char *p = text;
   char *endp;
   unsigned long n;
 
   if ('(' == p[0])
     p++;
   if ( ('0' <= p[0]) && (p[0] <= '9') )
   {
     n = strtoul (p,
                  &endp,
                  10);
     if ( ( (')' == *endp) || ('\0' == *endp) ) &&
          (n < sizeof (id3_genres) / sizeof (id3_genres[0])) )
       return id3_emit (ctx,
                        EXTRACTOR_METATYPE_GENRE,
                        id3_genres[n]);
   }
   return id3_emit (ctx,
                    EXTRACTOR_METATYPE_GENRE,
                    text);
 }
 
 
 /**
  * Handle one ID3v2 frame.
  *
  * @param ctx our state
  * @param id the four character frame identifier, NUL-terminated
  * @param data the frame's payload
  * @param len number of bytes in @a data
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 handle_frame (struct Id3Context *ctx,
               const char *id,
               const unsigned char *data,
               size_t len)
 {
   char text[ID3_MAX_TEXT];
 
   if (0 == len)
     return 0;
   if ( ('T' == id[0]) &&
        (0 != strcmp (id,
                      "TXXX")) )
   {
     if (! decode_text (data[0],
                        &data[1],
                        len - 1,
                        text,
                        sizeof (text)))
       return 0;
     if (0 == strcmp (id,
                      "TCON"))
       return emit_genre (ctx,
                          text);
     for (unsigned int i = 0; NULL != text_frames[i].id; i++)
       if (0 == strcmp (id,
                        text_frames[i].id))
         return id3_emit (ctx,
                          text_frames[i].type,
                          text);
     return 0;   /* a text frame we do not care about */
   }
   if (0 == strcmp (id,
                    "TXXX"))
   {
     char value[ID3_MAX_TEXT];
     size_t dlen;
     size_t next;
 
     dlen = string_end (data[0],
                        &data[1],
                        len - 1,
                        &next);
     if (! decode_text (data[0],
                        &data[1],
                        dlen,
                        text,
                        sizeof (text)))
       return 0;
     if (next >= len - 1)
       return 0;
     if (! decode_text (data[0],
                        &data[1 + next],
                        len - 1 - next,
                        value,
                        sizeof (value)))
       return 0;
     for (unsigned int i = 0; NULL != purchase_descriptions[i]; i++)
     {
       size_t n = strlen (purchase_descriptions[i]);
       size_t k;
 
       if (strlen (text) != n)
         continue;
       for (k = 0; k < n; k++)
         if (tolower ((unsigned char) text[k]) != purchase_descriptions[i][k])
           break;
       if (k == n)
         return id3_emit (ctx,
                          EXTRACTOR_METATYPE_PURCHASE_ACCOUNT,
                          value);
     }
     if (ctx->user_text >= ID3_MAX_USER_TEXT)
       return 0;
     ctx->user_text++;
     return (0 != EXTRACTOR_forensic_emit_ (ctx->ec,
                                            ID3_PLUGIN,
                                            EXTRACTOR_METATYPE_UNKNOWN,
                                            "%s: %s",
                                            text,
                                            value)) ? 1 : 0;
   }
   if ( ('W' == id[0]) &&
        (0 != strcmp (id,
                      "WXXX")) )
   {
     /* the plain URL frames carry no encoding byte; they are always
        ISO-8859-1 */
     if (! latin1_to_utf8 (data,
                           len,
                           text,
                           sizeof (text)))
       return 0;
     return id3_emit (ctx,
                      EXTRACTOR_METATYPE_URL,
                      text);
   }
   if (0 == strcmp (id,
                    "WXXX"))
   {
     size_t next;
 
     (void) string_end (data[0],
                        &data[1],
                        len - 1,
                        &next);
     if (next >= len - 1)
       return 0;
     if (! latin1_to_utf8 (&data[1 + next],
                           len - 1 - next,
                           text,
                           sizeof (text)))
       return 0;
     return id3_emit (ctx,
                      EXTRACTOR_METATYPE_URL,
                      text);
   }
   if ( (0 == strcmp (id,
                      "COMM")) ||
        (0 == strcmp (id,
                      "USLT")) )
   {
     size_t next;
 
     /* encoding byte, three character language code, a short content
        descriptor and then the text */
     if (len < 5)
       return 0;
     (void) string_end (data[0],
                        &data[4],
                        len - 4,
                        &next);
     if (next >= len - 4)
       return 0;
     if (! decode_text (data[0],
                        &data[4 + next],
                        len - 4 - next,
                        text,
                        sizeof (text)))
       return 0;
     return id3_emit (ctx,
                      (0 == strcmp (id, "COMM"))
                      ? EXTRACTOR_METATYPE_COMMENT
                      : EXTRACTOR_METATYPE_LYRICS,
                      text);
   }
   if (0 == strcmp (id,
                    "UFID"))
   {
     char owner[256];
     size_t next;
     size_t olen;
     int printable = 1;
 
     olen = string_end (0,
                        data,
                        len,
                        &next);
     if ( (0 == olen) ||
          (next >= len) )
       return 0;
     if (! latin1_to_utf8 (data,
                           olen,
                           owner,
                           sizeof (owner)))
       return 0;
     for (size_t i = next; i < len; i++)
       if ( (data[i] < 0x20) || (data[i] > 0x7E) )
       {
         printable = 0;
         break;
       }
     if (printable)
     {
       size_t n = len - next;
 
       if (n > sizeof (text) / 2)
         n = sizeof (text) / 2;
       memcpy (text,
               &data[next],
               n);
       text[n] = '\0';
       ctx->seen[EXTRACTOR_METATYPE_SERIAL] = 1;
       return (0 != EXTRACTOR_forensic_emit_ (ctx->ec,
                                              ID3_PLUGIN,
                                              EXTRACTOR_METATYPE_SERIAL,
                                              "%s: %s",
                                              owner,
                                              text)) ? 1 : 0;
     }
     {
       static const char hex[] = "0123456789abcdef";
       size_t n = len - next;
       size_t o;
 
       if (n > 32)
         n = 32;
       o = strlen (owner);
       if (o + 2 + 2 * n + 1 > sizeof (text))
         return 0;
       memcpy (text,
               owner,
               o);
       text[o++] = ':';
       text[o++] = ' ';
       for (size_t i = 0; i < n; i++)
       {
         text[o++] = hex[data[next + i] >> 4];
         text[o++] = hex[data[next + i] & 0x0F];
       }
       text[o] = '\0';
     }
     return id3_emit (ctx,
                      EXTRACTOR_METATYPE_SERIAL,
                      text);
   }
   if (0 == strcmp (id,
                    "PRIV"))
   {
     size_t next;
     size_t olen;
 
     /* the owner identifier names the application that stamped the
        file -- iTunes, Windows Media Player, a shop's downloader.  The
        payload behind it is opaque binary and stays where it is. */
     olen = string_end (0,
                        data,
                        len,
                        &next);
     if (0 == olen)
       return 0;
     if (! latin1_to_utf8 (data,
                           olen,
                           text,
                           sizeof (text)))
       return 0;
     return id3_emit (ctx,
                      EXTRACTOR_METATYPE_APPLICATION_ID,
                      text);
   }
   if (0 == strcmp (id,
                    "APIC"))
   {
     char mime[128];
     size_t next;
     size_t mlen;
     size_t pos;
 
     mlen = string_end (0,
                        &data[1],
                        len - 1,
                        &next);
     if (! latin1_to_utf8 (&data[1],
                           mlen,
                           mime,
                           sizeof (mime)))
       return 0;
     pos = 1 + next;
     if (pos + 1 >= len)
       return 0;
     pos++;   /* picture type byte */
     (void) string_end (data[0],
                        &data[pos],
                        len - pos,
                        &next);
     pos += next;
     if (pos >= len)
       return 0;
     if (len - pos > ID3_MAX_PICTURE)
       return 0;   /* too big to be worth copying through the pipe */
     if ('\0' == mime[0])
       strcpy (mime,
               "image/jpeg");
     ctx->seen[EXTRACTOR_METATYPE_COVER_PICTURE] = 1;
     return (0 != ctx->ec->proc (ctx->ec->cls,
                                 ID3_PLUGIN,
                                 EXTRACTOR_METATYPE_COVER_PICTURE,
                                 EXTRACTOR_METAFORMAT_BINARY,
                                 mime,
                                 (const char *) &data[pos],
                                 len - pos)) ? 1 : 0;
   }
   return 0;
 }
 
 
 /**
  * Undo the ID3v2 unsynchronisation scheme in place: every 0xFF byte
  * that was followed by an inserted 0x00 loses that 0x00.
  *
  * @param[in,out] buf the tag data
  * @param len number of bytes in @a buf
  * @return number of bytes after the transformation
  */
 static size_t
 deunsynchronise (unsigned char *buf,
                  size_t len)
 {
   size_t o = 0;
 
   for (size_t i = 0; i < len; i++)
   {
     buf[o++] = buf[i];
     if ( (0xFF == buf[i]) &&
          (i + 1 < len) &&
          (0x00 == buf[i + 1]) )
       i++;
   }
   return o;
 }
 
 
 /**
  * Walk the frames of an ID3v2 tag that has already been read into
  * memory.
  *
  * @param ctx our state
  * @param major ID3v2 minor version: 2, 3 or 4
  * @param tag_unsync 1 if the tag header set the unsynchronisation flag
  * @param buf the tag body, after the ten byte header
  * @param len number of bytes in @a buf
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 walk_frames (struct Id3Context *ctx,
              unsigned int major,
              int tag_unsync,
              unsigned char *buf,
              size_t len)
 {
   size_t pos = 0;
   unsigned int count = 0;
   const size_t hdr = (2 == major) ? 6 : 10;
   const size_t idlen = (2 == major) ? 3 : 4;
 
   while ( (pos + hdr <= len) &&
           (count < ID3_MAX_FRAMES) )
   {
     char id[5];
     size_t size;
     unsigned char *body;
     size_t blen;
     unsigned char flags2 = 0;
     int frame_unsync = tag_unsync;
 
     if (0 == buf[pos])
       break;   /* padding */
     for (size_t i = 0; i < idlen; i++)
     {
       unsigned char c = buf[pos + i];
 
       if ( ( (c < 'A') || (c > 'Z') ) &&
            ( (c < '0') || (c > '9') ) )
         return 0;   /* not a frame identifier; the tag ends here */
       id[i] = (char) c;
     }
     id[idlen] = '\0';
     if (2 == major)
     {
       size = ((size_t) buf[pos + 3] << 16)
              | ((size_t) buf[pos + 4] << 8)
              | (size_t) buf[pos + 5];
     }
     else if (4 == major)
     {
       /* In 2.4 the frame size is synchsafe -- seven bits per byte --
          while in 2.3 it is a plain big-endian integer.  Getting this
          backwards is the classic ID3 bug: it only shows up for frames
          of 128 bytes or more, so a tagger tested on short titles looks
          fine and falls apart on the first embedded picture.  Taggers
          that write 2.4 headers with 2.3 sizes exist, and they give
          themselves away by setting the high bit of a size byte, which
          a synchsafe integer never does. */
       if ( (0 != (buf[pos + 4] & 0x80)) ||
            (0 != (buf[pos + 5] & 0x80)) ||
            (0 != (buf[pos + 6] & 0x80)) ||
            (0 != (buf[pos + 7] & 0x80)) )
         size = (size_t) EXTRACTOR_forensic_be32_ (&buf[pos + 4]);
       else
         size = (((size_t) buf[pos + 4]) << 21)
                | (((size_t) buf[pos + 5]) << 14)
                | (((size_t) buf[pos + 6]) << 7)
                | ((size_t) buf[pos + 7]);
     }
     else
     {
       size = (size_t) EXTRACTOR_forensic_be32_ (&buf[pos + 4]);
     }
     if (0 == size)
       break;   /* a zero length frame cannot be followed by anything */
     if (size > len - pos - hdr)
       break;   /* runs past the end of the tag */
     if (2 != major)
       flags2 = buf[pos + 9];
     body = &buf[pos + hdr];
     blen = size;
     pos += hdr + size;
     count++;
     if (3 == major)
     {
       if (0 != (flags2 & 0xC0))
         continue;   /* compressed or encrypted */
       if (0 != (flags2 & 0x20))
       {
         if (0 == blen)
           continue;
         body++;
         blen--;   /* group identifier */
       }
     }
     else if (4 == major)
     {
       if (0 != (flags2 & 0x0C))
         continue;   /* compressed or encrypted */
       if (0 != (flags2 & 0x40))
       {
         if (0 == blen)
           continue;
         body++;
         blen--;   /* group identifier */
       }
       if (0 != (flags2 & 0x02))
         frame_unsync = 1;
       if (0 != (flags2 & 0x01))
       {
         if (blen < 4)
           continue;
         body += 4;
         blen -= 4;   /* data length indicator */
       }
     }
     if (frame_unsync)
       blen = deunsynchronise (body,
                               blen);
     if (2 == major)
     {
       unsigned int a;
 
       for (a = 0; NULL != v22_aliases[a].old_id; a++)
         if (0 == strcmp (id,
                          v22_aliases[a].old_id))
           break;
       if (NULL == v22_aliases[a].old_id)
         continue;   /* a 2.2 frame we do not handle */
       if (handle_frame (ctx,
                         v22_aliases[a].new_id,
                         body,
                         blen))
         return 1;
       continue;
     }
     if (handle_frame (ctx,
                       id,
                       body,
                       blen))
       return 1;
   }
   return 0;
 }
 
 
 /**
  * A decoded MPEG audio frame header.
  */
 struct MpegHeader
 {
   /**
    * 1, 2 or 25 for MPEG 1, MPEG 2 and MPEG 2.5.
    */
   unsigned int version;
 
   /**
    * 1, 2 or 3.
    */
   unsigned int layer;
 
   /**
    * Bitrate in bits per second.
    */
   unsigned int bitrate;
 
   /**
    * Sampling rate in Hz.
    */
   unsigned int sample_rate;
 
   /**
    * Channel mode, 0 to 3, indexing #channel_modes.
    */
   unsigned int mode;
 
   /**
    * Number of samples this frame encodes.
    */
   unsigned int samples;
 
   /**
    * Length of the frame in bytes, including the header.
    */
   unsigned int frame_len;
 
   /**
    * 1 if a CRC follows the header.
    */
   int protected_frame;
 };
 
 
 /**
  * Decode and validate a four byte MPEG audio frame header.
  *
  * Every reserved combination is rejected: without that, one byte in
  * every 2048 of arbitrary binary starts something that looks like a
  * frame.
  *
  * @param h the four bytes
  * @param[out] f the decoded header
  * @return 1 if @a h is a valid header, 0 if not
  */
 static int
 parse_mpeg_header (const unsigned char *h,
                    struct MpegHeader *f)
 {
   unsigned int vbits;
   unsigned int lbits;
   unsigned int brindex;
   unsigned int srindex;
   unsigned int column;
   unsigned int vrow;
   unsigned int padding;
 
   if (0xFF != h[0])
     return 0;
   if (0xE0 != (h[1] & 0xE0))
     return 0;
   vbits = (h[1] >> 3) & 0x03;
   lbits = (h[1] >> 1) & 0x03;
   if (1 == vbits)
     return 0;   /* reserved version */
   if (0 == lbits)
     return 0;   /* reserved layer */
   brindex = (h[2] >> 4) & 0x0F;
   srindex = (h[2] >> 2) & 0x03;
   if ( (0 == brindex) ||
        (15 == brindex) )
     return 0;   /* "free" and "bad" are both unusable to us */
   if (3 == srindex)
     return 0;   /* reserved */
   if (3 == (h[3] & 0x03))
     return 0;   /* reserved emphasis */
   f->layer = 4 - lbits;
   switch (vbits)
   {
   case 0:
     f->version = 25;
     vrow = 2;
     break;
   case 2:
     f->version = 2;
     vrow = 1;
     break;
   default:
     f->version = 1;
     vrow = 0;
     break;
   }
   if (1 == f->version)
     column = f->layer - 1;
   else
     column = (1 == f->layer) ? 3 : 4;
   f->bitrate = 1000 * bitrate_table[column][brindex];
   f->sample_rate = samplerate_table[vrow][srindex];
   f->mode = (h[3] >> 6) & 0x03;
   f->protected_frame = (0 == (h[1] & 0x01)) ? 1 : 0;
   padding = (h[2] >> 1) & 0x01;
   if (1 == f->layer)
     f->samples = 384;
   else if (2 == f->layer)
     f->samples = 1152;
   else
     f->samples = (1 == f->version) ? 1152 : 576;
   if (1 == f->layer)
     f->frame_len = (12 * f->bitrate / f->sample_rate + padding) * 4;
   else
     f->frame_len = (f->samples / 8) * f->bitrate / f->sample_rate + padding;
   if (f->frame_len < 24)
     return 0;
   return 1;
 }
 
 
 /**
  * Report the ReplayGain field at @a p, if it holds one.
  *
  * @param ctx our state
  * @param type meta data type to report it as
  * @param p the two bytes
  * @param want_name the name code this field must carry (1 = track,
  *        2 = album)
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 emit_replay_gain (struct Id3Context *ctx,
                   enum EXTRACTOR_MetaType type,
                   const unsigned char *p,
                   unsigned int want_name)
 {
   uint16_t v = EXTRACTOR_forensic_be16_ (p);
   unsigned int name = (v >> 13) & 0x07;
   unsigned int value = v & 0x01FF;
 
   if (name != want_name)
     return 0;
   if (0 == value)
     return 0;
   ctx->seen[type] = 1;
   return (0 != EXTRACTOR_forensic_emit_ (ctx->ec,
                                          ID3_PLUGIN,
                                          type,
                                          "%s%u.%u dB",
                                          (0 != ((v >> 9) & 0x01)) ? "-" : "+",
                                          value / 10,
                                          value % 10)) ? 1 : 0;
 }
 
 
 /**
  * Append a comma separated fragment to the encoder settings summary,
  * never running past the end of @a buf.
  *
  * @param buf where to build the summary
  * @param size size of @a buf in bytes
  * @param[in,out] off current length of the summary
  * @param fmt printf format string for the fragment
  */
 static void
 append_setting (char *buf,
                 size_t size,
                 size_t *off,
                 const char *fmt,
                 ...)
 __attribute__ ((format (printf, 4, 5)));
 
 static void
 append_setting (char *buf,
                 size_t size,
                 size_t *off,
                 const char *fmt,
                 ...)
 {
   va_list ap;
   int n;
 
   if (*off + 3 >= size)
     return;
   if (0 != *off)
   {
     buf[(*off)++] = ',';
     buf[(*off)++] = ' ';
     buf[*off] = '\0';
   }
   va_start (ap, fmt);
   n = vsnprintf (&buf[*off],
                  size - *off,
                  fmt,
                  ap);
   va_end (ap);
   if (0 >= n)
     return;
   if (((size_t) n) >= size - *off)
     *off = size - 1;
   else
     *off += (size_t) n;
 }
 
 
 /**
  * Read the Xing/Info header and the LAME tag that may sit inside the
  * first audio frame.
  *
  * The LAME tag is the most identifying thing in an MP3: it names the
  * encoder build and the settings it ran with, which together pin down
  * the ripping software far more precisely than any text frame.
  *
  * @param ctx our state
  * @param f the decoded frame header
  * @param frame the frame's bytes
  * @param len number of bytes of the frame we have
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 extract_xing (struct Id3Context *ctx,
               const struct MpegHeader *f,
               const unsigned char *frame,
               size_t len)
 {
   size_t xo;
   size_t p;
   uint32_t flags;
   uint32_t frames = 0;
   uint32_t nbytes = 0;
   uint32_t quality = 0;
   int have_quality = 0;
   int vbr;
   char settings[ID3_MAX_TEXT];
   size_t so = 0;
 
   /* The tag sits just past the side information, whose size depends on
      the version and on whether the frame is mono.  A CRC, if present,
      takes two more bytes right after the header. */
   if (1 == f->version)
     xo = (3 == f->mode) ? 21 : 36;
   else
     xo = (3 == f->mode) ? 13 : 21;
   if (f->protected_frame)
     xo += 2;
   if (xo + 8 > len)
     return 0;
   if (0 == memcmp (&frame[xo],
                    "Xing",
                    4))
   {
     vbr = 1;
   }
   else if (0 == memcmp (&frame[xo],
                         "Info",
                         4))
   {
     vbr = 0;
   }
   else
   {
     return 0;
   }
   flags = EXTRACTOR_forensic_be32_ (&frame[xo + 4]);
   p = xo + 8;
   if (0 != (flags & 0x01))
   {
     if (p + 4 > len)
       return 0;
     frames = EXTRACTOR_forensic_be32_ (&frame[p]);
     p += 4;
   }
   if (0 != (flags & 0x02))
   {
     if (p + 4 > len)
       return 0;
     nbytes = EXTRACTOR_forensic_be32_ (&frame[p]);
     p += 4;
   }
   if (0 != (flags & 0x04))
   {
     if (p + 100 > len)
       return 0;
     p += 100;   /* seek table */
   }
   if (0 != (flags & 0x08))
   {
     if (p + 4 > len)
       return 0;
     quality = EXTRACTOR_forensic_be32_ (&frame[p]);
     have_quality = 1;
     p += 4;
   }
   if ( (0 != frames) &&
        (frames < 100000000u) &&
        (0 != f->sample_rate) )
   {
     uint64_t samples = (uint64_t) frames * f->samples;
     unsigned int secs = (unsigned int) (samples / f->sample_rate);
 
     if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                   ID3_PLUGIN,
                                   EXTRACTOR_METATYPE_DURATION,
                                   "%u:%02u:%02u",
                                   secs / 3600,
                                   (secs / 60) % 60,
                                   secs % 60))
       return 1;
     ctx->seen[EXTRACTOR_METATYPE_DURATION] = 1;
     if (0 != nbytes)
     {
       uint64_t avg = ((uint64_t) nbytes) * 8 * f->sample_rate / samples;
 
       if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                     ID3_PLUGIN,
                                     EXTRACTOR_METATYPE_BITRATE,
                                     "%llu",
                                     (unsigned long long) avg))
         return 1;
       ctx->seen[EXTRACTOR_METATYPE_BITRATE] = 1;
     }
   }
   /* The LAME extension follows the Xing fields.  36 bytes: a nine
      character encoder string, then the settings it ran with. */
   if (p + 36 > len)
   {
     /* no room for the extension; still report what the magic said */
     return id3_emit (ctx,
                      EXTRACTOR_METATYPE_BITRATE_MODE,
                      vbr ? "VBR" : "CBR");
   }
   {
     const unsigned char *l = &frame[p];
     char version[10];
     unsigned int method = l[9] & 0x0F;
     unsigned int lowpass = l[10];
     unsigned int abr = l[20];
     unsigned int delay = ((unsigned int) l[21] << 4) | (l[22] >> 4);
     unsigned int padding = ((unsigned int) (l[22] & 0x0F) << 8) | l[23];
     unsigned int preset = EXTRACTOR_forensic_be16_ (&l[26]) & 0x07FF;
     const char *mode;
     int printable = 0;
 
     /* We do not check the tag's own CRC-16.  The field exists, but the
        encoders that write this tag do not agree on what it covers --
        LAME and ffmpeg produce different values for the same layout --
        so a mismatch would say more about the writer than about the
        data, and rejecting on it would lose real metadata.  The nine
        character encoder string is self-validating enough: it has to be
        printable ASCII with something in it. */
     for (unsigned int i = 0; i < 9; i++)
     {
       if ( (l[i] < 0x20) || (l[i] > 0x7E) )
       {
         printable = 0;
         break;
       }
       if (' ' != l[i])
         printable++;
     }
     if (printable < 4)
       return id3_emit (ctx,
                        EXTRACTOR_METATYPE_BITRATE_MODE,
                        vbr ? "VBR" : "CBR");
     memcpy (version,
             l,
             9);
     version[9] = '\0';
     switch (method)
     {
     case 1:
       mode = "CBR";
       break;
     case 2:
       mode = "ABR";
       break;
     case 8:
       mode = "CBR (2 pass)";
       break;
     case 9:
       mode = "ABR (2 pass)";
       break;
     case 0:
       mode = vbr ? "VBR" : "CBR";
       break;
     default:
       mode = "VBR";
       break;
     }
     if (id3_emit (ctx,
                   EXTRACTOR_METATYPE_BITRATE_MODE,
                   mode))
       return 1;
     if (id3_emit (ctx,
                   EXTRACTOR_METATYPE_ENCODER,
                   version))
       return 1;
     for (unsigned int i = 0; i < 9; i++)
       if ( ('0' <= version[i]) && (version[i] <= '9') )
       {
         if (id3_emit (ctx,
                       EXTRACTOR_METATYPE_ENCODER_VERSION,
                       &version[i]))
           return 1;
         break;
       }
     settings[0] = '\0';
     if (0 != lowpass)
       append_setting (settings,
                       sizeof (settings),
                       &so,
                       "lowpass %u Hz",
                       100 * lowpass);
     if ( (have_quality) &&
          (quality <= 100) )
       append_setting (settings,
                       sizeof (settings),
                       &so,
                       "quality %u",
                       (unsigned int) quality);
     append_setting (settings,
                     sizeof (settings),
                     &so,
                     "VBR method %u",
                     method);
     if (0 != abr)
       append_setting (settings,
                       sizeof (settings),
                       &so,
                       "min bitrate %u kbit/s",
                       abr);
     if (0 != preset)
       append_setting (settings,
                       sizeof (settings),
                       &so,
                       "preset %u",
                       preset);
     append_setting (settings,
                     sizeof (settings),
                     &so,
                     "delay %u, padding %u",
                     delay,
                     padding);
     if (id3_emit (ctx,
                   EXTRACTOR_METATYPE_ENCODER_SETTINGS,
                   settings))
       return 1;
     if (emit_replay_gain (ctx,
                           EXTRACTOR_METATYPE_TRACK_GAIN,
                           &l[15],
                           1))
       return 1;
     if (emit_replay_gain (ctx,
                           EXTRACTOR_METATYPE_ALBUM_GAIN,
                           &l[17],
                           2))
       return 1;
   }
   return 0;
 }
 
 
 /**
  * Find and describe the first MPEG audio frame at or after @a start.
  *
  * @param ctx our state
  * @param start where the audio should begin
  * @param size size of the file
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 extract_audio (struct Id3Context *ctx,
                uint64_t start,
                uint64_t size)
 {
   unsigned char window[ID3_SYNC_WINDOW];
   struct MpegHeader f;
   size_t wlen;
   size_t at = 0;
   int have = 0;
 
   if (start >= size)
     return 0;
   wlen = ((size - start) < sizeof (window))
          ? (size_t) (size - start)
          : sizeof (window);
   if (wlen < 4)
     return 0;
   if (! EXTRACTOR_forensic_read_ (ctx->ec,
                                   (int64_t) start,
                                   window,
                                   wlen))
     return 0;
   for (size_t i = 0; i + 4 <= wlen; i++)
   {
     struct MpegHeader next;
 
     if (0xFF != window[i])
       continue;
     if (! parse_mpeg_header (&window[i],
                              &f))
       continue;
     /* Confirm with the frame after this one where we can: a single
        header pattern turns up in arbitrary data often enough that it
        is not evidence on its own. */
     if (i + f.frame_len + 4 <= wlen)
     {
       if (! parse_mpeg_header (&window[i + f.frame_len],
                                &next))
         continue;
       if ( (next.version != f.version) ||
            (next.layer != f.layer) ||
            (next.sample_rate != f.sample_rate) )
         continue;
     }
     at = i;
     have = 1;
     break;
   }
   if (! have)
     return 0;
   if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                 ID3_PLUGIN,
                                 EXTRACTOR_METATYPE_CODEC,
                                 "MPEG %s Layer %s",
                                 (1 == f.version) ? "1"
                                 : ((2 == f.version) ? "2" : "2.5"),
                                 (1 == f.layer) ? "I"
                                 : ((2 == f.layer) ? "II" : "III")))
     return 1;
   if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                 ID3_PLUGIN,
                                 EXTRACTOR_METATYPE_FORMAT,
                                 "MPEG %s Layer %s, %s",
                                 (1 == f.version) ? "1"
                                 : ((2 == f.version) ? "2" : "2.5"),
                                 (1 == f.layer) ? "I"
                                 : ((2 == f.layer) ? "II" : "III"),
                                 channel_modes[f.mode]))
     return 1;
   if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                 ID3_PLUGIN,
                                 EXTRACTOR_METATYPE_SAMPLE_RATE,
                                 "%u",
                                 f.sample_rate))
     return 1;
   if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                 ID3_PLUGIN,
                                 EXTRACTOR_METATYPE_CHANNELS,
                                 "%u",
                                 (3 == f.mode) ? 1 : 2))
     return 1;
   if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                 ID3_PLUGIN,
                                 EXTRACTOR_METATYPE_NOMINAL_BITRATE,
                                 "%u",
                                 f.bitrate))
     return 1;
   if (extract_xing (ctx,
                     &f,
                     &window[at],
                     wlen - at))
     return 1;
   if (! ctx->seen[EXTRACTOR_METATYPE_BITRATE])
   {
     if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                   ID3_PLUGIN,
                                   EXTRACTOR_METATYPE_BITRATE,
                                   "%u",
                                   f.bitrate))
       return 1;
     ctx->seen[EXTRACTOR_METATYPE_BITRATE] = 1;
   }
   return 0;
 }
 
 
 /**
  * Report a field of the ID3v1 tag, unless the ID3v2 tag already
  * supplied one of the same kind.
  *
  * @param ctx our state
  * @param type meta data type
  * @param data the fixed width field
  * @param len width of the field
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 emit_v1_field (struct Id3Context *ctx,
                enum EXTRACTOR_MetaType type,
                const unsigned char *data,
                size_t len)
 {
   char text[128];
 
   if (ctx->seen[type])
     return 0;
   len = EXTRACTOR_forensic_trim_ ((const char *) data,
                                   len);
   if (0 == len)
     return 0;
   if (! latin1_to_utf8 (data,
                         len,
                         text,
                         sizeof (text)))
     return 0;
   return id3_emit (ctx,
                    type,
                    text);
 }
 
 
 /**
  * Read the ID3v1 tag in the last 128 bytes of the file.  It only ever
  * fills gaps: where an ID3v2 tag said anything, it wins, because the
  * v1 fields are truncated to 30 bytes and have no declared character
  * set.
  *
  * @param ctx our state
  * @param tag the 128 bytes
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 extract_v1 (struct Id3Context *ctx,
             const unsigned char *tag)
 {
   if (emit_v1_field (ctx,
                      EXTRACTOR_METATYPE_TITLE,
                      &tag[3],
                      30))
     return 1;
   if (emit_v1_field (ctx,
                      EXTRACTOR_METATYPE_ARTIST,
                      &tag[33],
                      30))
     return 1;
   if (emit_v1_field (ctx,
                      EXTRACTOR_METATYPE_ALBUM,
                      &tag[63],
                      30))
     return 1;
   if (emit_v1_field (ctx,
                      EXTRACTOR_METATYPE_PUBLICATION_DATE,
                      &tag[93],
                      4))
     return 1;
   /* ID3v1.1 stole the last two bytes of the comment for a track
      number: a NUL in the second to last byte marks it */
   if ( (0 == tag[125]) &&
        (0 != tag[126]) )
   {
     if (emit_v1_field (ctx,
                        EXTRACTOR_METATYPE_COMMENT,
                        &tag[97],
                        28))
       return 1;
     if (! ctx->seen[EXTRACTOR_METATYPE_TRACK_NUMBER])
     {
       if (EXTRACTOR_forensic_emit_ (ctx->ec,
                                     ID3_PLUGIN,
                                     EXTRACTOR_METATYPE_TRACK_NUMBER,
                                     "%u",
                                     (unsigned int) tag[126]))
         return 1;
       ctx->seen[EXTRACTOR_METATYPE_TRACK_NUMBER] = 1;
     }
   }
   else if (emit_v1_field (ctx,
                           EXTRACTOR_METATYPE_COMMENT,
                           &tag[97],
                           30))
   {
     return 1;
   }
   if ( (! ctx->seen[EXTRACTOR_METATYPE_GENRE]) &&
        (tag[127] < sizeof (id3_genres) / sizeof (id3_genres[0])) )
     return id3_emit (ctx,
                      EXTRACTOR_METATYPE_GENRE,
                      id3_genres[tag[127]]);
   return 0;
 }
 
 
 /**
  * Read and parse the ID3v2 tag at the start of the file.
  *
  * @param ctx our state
  * @param head the ten byte tag header
  * @param tag_size size of the tag body, from the header
  * @return 1 if the caller should stop extracting, 0 to continue
  */
 static int
 extract_v2 (struct Id3Context *ctx,
             const unsigned char *head,
             uint64_t tag_size)
 {
   unsigned char *buf;
   size_t len;
   size_t skip = 0;
   unsigned int major = head[3];
   int tag_unsync = (0 != (head[5] & 0x80)) ? 1 : 0;
   int ret;
 
   len = (tag_size < ID3_MAX_TAG_READ)
         ? (size_t) tag_size
         : ID3_MAX_TAG_READ;
   if (len < 10)
     return 0;
   buf = malloc (len);
   if (NULL == buf)
     return 0;
   if (! EXTRACTOR_forensic_read_ (ctx->ec,
                                   10,
                                   buf,
                                   len))
   {
     free (buf);
     return 0;
   }
   if ( (tag_unsync) &&
        (4 > major) )
   {
     /* up to 2.3 the whole tag body is unsynchronised as one unit; from
        2.4 it is a per-frame property, handled in walk_frames() */
     len = deunsynchronise (buf,
                            len);
     tag_unsync = 0;
   }
   if (0 != (head[5] & 0x40))
   {
     /* extended header; 2.3 states a size that excludes its own four
        byte field, 2.4 a synchsafe size that includes it */
     if (len < 4)
     {
       free (buf);
       return 0;
     }
     if (4 == major)
       skip = (((size_t) buf[0]) << 21)
              | (((size_t) buf[1]) << 14)
              | (((size_t) buf[2]) << 7)
              | ((size_t) buf[3]);
     else
       skip = (size_t) EXTRACTOR_forensic_be32_ (buf) + 4;
     if (skip >= len)
     {
       free (buf);
       return 0;
     }
   }
   ret = walk_frames (ctx,
                      major,
                      tag_unsync,
                      &buf[skip],
                      len - skip);
   free (buf);
   return ret;
 }
 
 
 /**
  * Decide whether the file opens with MPEG audio.
  *
  * A single frame header is not enough evidence.  The pattern is four
  * bytes with eleven set bits at the front, and although rejecting
  * every reserved field value cuts the false positive rate a long way,
  * arbitrary binary still produces one now and then.  Requiring the
  * next frame to follow exactly where this one says it will, with the
  * same version, layer and sampling rate, is what makes it evidence.
  *
  * @param ec extraction context
  * @param head the first four bytes of the file
  * @param size size of the file
  * @return 1 if the file begins with a confirmed frame, 0 if not
  */
 static int
 confirm_sync (struct EXTRACTOR_ExtractContext *ec,
               const unsigned char *head,
               uint64_t size)
 {
   struct MpegHeader first;
   struct MpegHeader next;
   unsigned char raw[4];
 
   if (! parse_mpeg_header (head,
                            &first))
     return 0;
   if (((uint64_t) first.frame_len) + 4 > size)
     return 0;
   if (! EXTRACTOR_forensic_read_ (ec,
                                   (int64_t) first.frame_len,
                                   raw,
                                   sizeof (raw)))
     return 0;
   if (! parse_mpeg_header (raw,
                            &next))
     return 0;
   return ( (next.version == first.version) &&
            (next.layer == first.layer) &&
            (next.sample_rate == first.sample_rate) ) ? 1 : 0;
 }
 
 
 /**
  * Main entry method for the 'audio/mpeg' extraction plugin.
  *
  * @param ec extraction context provided to the plugin
  */
 void
 EXTRACTOR_id3_extract_method (struct EXTRACTOR_ExtractContext *ec);
 
 void
 EXTRACTOR_id3_extract_method (struct EXTRACTOR_ExtractContext *ec)
 {
   struct Id3Context ctx;
   unsigned char head[10];
   unsigned char v1[128];
   uint64_t size;
   uint64_t tag_size = 0;
   uint64_t audio_start = 0;
   int have_v2 = 0;
   int have_v1 = 0;
 
   size = ec->get_size (ec->cls);
   if ( (UINT64_MAX == size) ||
        (size < 128) )
     return;
   if (! EXTRACTOR_forensic_read_ (ec,
                                   0,
                                   head,
                                   sizeof (head)))
     return;
   if ( (0 == memcmp (head,
                      "ID3",
                      3)) &&
        (head[3] >= 2) &&
        (head[3] <= 4) &&
        (0xFF != head[4]) &&
        (0 == (head[6] & 0x80)) &&
        (0 == (head[7] & 0x80)) &&
        (0 == (head[8] & 0x80)) &&
        (0 == (head[9] & 0x80)) )
   {
     /* the tag size is synchsafe: seven bits per byte, so that no run
        of bytes in the header can be mistaken for a frame sync */
     tag_size = (((uint64_t) head[6]) << 21)
                | (((uint64_t) head[7]) << 14)
                | (((uint64_t) head[8]) << 7)
                | ((uint64_t) head[9]);
     audio_start = 10 + tag_size;
     if (0 != (head[5] & 0x10))
       audio_start += 10;   /* footer */
     if (audio_start <= size)
       have_v2 = 1;
   }
   if (! have_v2)
   {
     /* No tag in front.  Either the audio starts right here, or this is
        one of the files that carry nothing but an ID3v1 tag at the very
        end -- the only case in which we look at the tail of a file we
        have not yet identified, and the reason for the read below. */
     if (! confirm_sync (ec,
                         head,
                         size))
     {
       if (! EXTRACTOR_forensic_read_ (ec,
                                       (int64_t) (size - 128),
                                       v1,
                                       sizeof (v1)))
         return;
       if (0 != memcmp (v1,
                        "TAG",
                        3))
         return;
       have_v1 = 1;
     }
   }
   if (! have_v1)
   {
     if (EXTRACTOR_forensic_read_ (ec,
                                   (int64_t) (size - 128),
                                   v1,
                                   sizeof (v1)))
       have_v1 = (0 == memcmp (v1,
                               "TAG",
                               3)) ? 1 : 0;
   }
   memset (&ctx,
           0,
           sizeof (ctx));
   ctx.ec = ec;
   if (EXTRACTOR_forensic_emit_text_ (ec,
                                      ID3_PLUGIN,
                                      EXTRACTOR_METATYPE_MIMETYPE,
                                      ID3_MIME,
                                      strlen (ID3_MIME)))
     return;
   if (have_v2)
   {
     if (EXTRACTOR_forensic_emit_ (ec,
                                   ID3_PLUGIN,
                                   EXTRACTOR_METATYPE_FORMAT_VERSION,
                                   "ID3v2.%u.%u",
                                   (unsigned int) head[3],
                                   (unsigned int) head[4]))
       return;
     if (extract_v2 (&ctx,
                     head,
                     tag_size))
       return;
   }
   if (extract_audio (&ctx,
                      audio_start,
                      have_v1 ? (size - 128) : size))
     return;
   if (have_v1)
     (void) extract_v1 (&ctx,
                        v1);
 }
 
 
 /* end of id3_extractor.c */