id3.h File Reference

#include "frame.h"

Include dependency graph for id3.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	init_id3 (mpg123_handle *fr)
void	exit_id3 (mpg123_handle *fr)
void	reset_id3 (mpg123_handle *fr)
void	id3_link (mpg123_handle *fr)
int	parse_new_id3 (mpg123_handle *fr, unsigned long first4bytes)
void	id3_to_utf8 (mpg123_string *sb, unsigned char encoding, const unsigned char *source, size_t source_size, int noquiet)

Function Documentation

exit_id3()

void exit_id3

(

mpg123_handle *

fr

)

Definition at line 284 of file id3.c.

{
    free_picture(fr);
    free_comment(fr);
    free_extra(fr);
    free_text(fr);
}

id3_link()

void id3_link

(

mpg123_handle *

fr

)

Definition at line 299 of file id3.c.

{
    size_t i;
    mpg123_id3v2 *v2 = &fr->id3v2;
    debug("linking ID3v2");
    null_id3_links(fr);
    for(i=0; i<v2->texts; ++i)
    {
        mpg123_text *entry = &v2->text[i];
        if     (!strncmp("TIT2", entry->id, 4)) v2->title  = &entry->text;
        else if(!strncmp("TALB", entry->id, 4)) v2->album  = &entry->text;
        else if(!strncmp("TPE1", entry->id, 4)) v2->artist = &entry->text;
        else if(!strncmp("TYER", entry->id, 4)) v2->year   = &entry->text;
        else if(!strncmp("TCON", entry->id, 4)) v2->genre  = &entry->text;
    }
    for(i=0; i<v2->comments; ++i)
    {
        mpg123_text *entry = &v2->comment_list[i];
        if(entry->description.fill == 0 || entry->description.p[0] == 0)
        v2->comment = &entry->text;
    }
    /* When no generic comment found, use the last non-generic one. */
    if(v2->comment == NULL && v2->comments > 0)
    v2->comment = &v2->comment_list[v2->comments-1].text;
}

id3_to_utf8()

void id3_to_utf8	(	mpg123_string *	sb,
		unsigned char	encoding,
		const unsigned char *	source,
		size_t	source_size,
		int	noquiet
	)

Definition at line 374 of file id3.c.

{
    unsigned int bwidth;
    if(sb)
        sb->fill = 0;
    debug1("encoding: %u", encoding);
    /* A note: ID3v2.3 uses UCS-2 non-variable 16bit encoding, v2.4 uses UTF16.
       UTF-16 uses a reserved/private range in UCS-2 to add the magic, so we just always treat it as UTF. */
    bwidth = encoding_widths[encoding];
    /* Hack! I've seen a stray zero byte before BOM. Is that supposed to happen? */
    if(encoding != mpg123_id3_utf16be) /* UTF16be _can_ beging with a null byte! */
    while(source_size > bwidth && source[0] == 0)
    {
        --source_size;
        ++source;
        debug("skipped leading zero");
    }
    if(source_size % bwidth)
    {
        /* When we need two bytes for a character, it's strange to have an uneven bytestream length. */
        if(noquiet) warning2("Weird tag size %d for encoding %u - I will probably trim too early or something but I think the MP3 is broken.", (int)source_size, encoding);
        source_size -= source_size % bwidth;
    }
    text_converters[encoding](sb, source, source_size, noquiet);
}

init_id3()

void init_id3

(

mpg123_handle *

fr

)

Definition at line 129 of file id3.c.

{
    fr->id3v2.version = 0; /* nothing there */
    null_id3_links(fr);
    fr->id3v2.comments     = 0;
    fr->id3v2.comment_list = NULL;
    fr->id3v2.texts    = 0;
    fr->id3v2.text     = NULL;
    fr->id3v2.extras   = 0;
    fr->id3v2.extra    = NULL;
    fr->id3v2.pictures   = 0;
    fr->id3v2.picture    = NULL;
}

parse_new_id3()

int parse_new_id3	(	mpg123_handle *	fr,
		unsigned long	first4bytes
	)

Definition at line 845 of file id3.c.

{
    #define UNSYNC_FLAG 128
    #define EXTHEAD_FLAG 64  /* ID3v2.3+ */
    #define COMPRESS_FLAG 64 /* ID3v2.2 */
    #define EXP_FLAG 32
    #define FOOTER_FLAG 16
    #define EXT_UPDATE_FLAG 64 /* ID3v2.4 only: extended header update flag */
    #define UNKNOWN_FLAGS 15 /* 00001111*/
    unsigned char buf[6];
    unsigned long length=0;
    unsigned char flags = 0;
    int ret = 1;
    off_t ret2;
    int storetag = 0;
    unsigned int footlen = 0;
#ifndef NO_ID3V2
    int skiptag = 0;
#endif
    unsigned char major = first4bytes & 0xff;
    debug1("ID3v2: major tag version: %i", major);
 
    if(major == 0xff) return 0; /* Invalid... */
    if((ret2 = fr->rd->read_frame_body(fr, buf, 6)) < 0) /* read more header information */
    return ret2;
 
    if(buf[0] == 0xff) return 0; /* Revision, will never be 0xff. */
 
    if(fr->p.flags & MPG123_STORE_RAW_ID3)
        storetag = 1;
    /* second new byte are some nice flags, if these are invalid skip the whole thing */
    flags = buf[1];
    debug1("ID3v2: flags 0x%08x", flags);
    /* use 4 bytes from buf to construct 28bit uint value and return 1; return 0 if bytes are not synchsafe */
    #define synchsafe_to_long(buf,res) \
    ( \
        (((buf)[0]|(buf)[1]|(buf)[2]|(buf)[3]) & 0x80) ? 0 : \
        (res =  (((unsigned long) (buf)[0]) << 21) \
             | (((unsigned long) (buf)[1]) << 14) \
             | (((unsigned long) (buf)[2]) << 7) \
             |  ((unsigned long) (buf)[3]) \
        ,1) \
    )
    /* id3v2.3 does not store synchsafe frame sizes, but synchsafe tag size - doh! */
    /* Remember: bytes_to_long() can yield ULONG_MAX on 32 bit platforms! */
    #define bytes_to_long(buf,res) \
    ( \
        major == 3 ? \
        (res =  (((unsigned long) (buf)[0]) << 24) \
             | (((unsigned long) (buf)[1]) << 16) \
             | (((unsigned long) (buf)[2]) << 8) \
             |  ((unsigned long) (buf)[3]) \
        ,1) : synchsafe_to_long(buf,res) \
    )
    /* for id3v2.2 only */
    #define threebytes_to_long(buf,res) \
    ( \
        res =  (((unsigned long) (buf)[0]) << 16) \
             | (((unsigned long) (buf)[1]) << 8) \
             |  ((unsigned long) (buf)[2]) \
    )
 
    /* length-10 or length-20 (footer present); 4 synchsafe integers == 28 bit number  */
    /* we have already read 10 bytes, so left are length or length+10 bytes belonging to tag */
    /* Note: This is an 28 bit value in 32 bit storage, plenty of space for */
    /* length+x for reasonable x. */
    if(!synchsafe_to_long(buf+2,length))
    {
        if(NOQUIET) error4("Bad tag length (not synchsafe): 0x%02x%02x%02x%02x; You got a bad ID3 tag here.", buf[2],buf[3],buf[4],buf[5]);
        return 0;
    }
    if(flags & FOOTER_FLAG)
        footlen = 10;
    debug1("ID3v2: tag data length %lu", length);
#ifndef NO_ID3V2
    if(VERBOSE2) fprintf(stderr,"Note: ID3v2.%i rev %i tag of %lu bytes\n", major, buf[0], length);
    /* skip if unknown version/scary flags, parse otherwise */
    if(fr->p.flags & MPG123_SKIP_ID3V2)
    {
        if(VERBOSE3)
            fprintf(stderr, "Note: Skipping ID3v2 tag per user request.\n");
        skiptag = 1;
    }
    if((flags & UNKNOWN_FLAGS) || (major > 4) || (major < 2))
    {
        if(NOQUIET)
            warning2( "ID3v2: Won't parse the ID3v2 tag with major version"
                " %u and flags 0x%xu - some extra code may be needed"
            ,   major, flags );
        skiptag = 1;
    }
    // Standard says that compressed tags should be ignored as there isn't an agreed
    // compressoion scheme.
    if(major == 2 && flags & COMPRESS_FLAG)
    {
        if(NOQUIET)
            warning("ID3v2: ignoring compressed ID3v2.2 tag");
        skiptag = 1;
    }
    if(length < 10)
    {
        if(NOQUIET)
            warning1("ID3v2: unrealistic small tag lengh %lu, skipping", length);
        skiptag = 1;
    }
    if(!skiptag)
        storetag = 1;
#endif
    if(storetag)
    {
        /* Stores whole tag with footer and an additonal trailing zero. */
        if((ret2 = store_id3v2(fr, first4bytes, buf, length+footlen)) <= 0)
            return ret2;
    }
#ifndef NO_ID3V2
    if(skiptag)
    {
        if(VERBOSE3)
            fprintf(stderr, "Note: skipped tag clearing possibly existing ID3v2 data");
        reset_id3(fr); // Old data is invalid.
#endif
        if(!storetag && (ret2=fr->rd->skip_bytes(fr,length+footlen))<0)
            ret=ret2;
#ifndef NO_ID3V2
    }
    else
    {
        unsigned char* tagdata = fr->id3v2_raw+10;
        /* try to interpret that beast */
        debug("ID3v2: analysing frames...");
        if(length > 0)
        {
            unsigned char extflags = 0;
            unsigned long tagpos = 0;
            /* bytes of frame title and of framesize value */
            unsigned int head_part = major > 2 ? 4 : 3;
            unsigned int flag_part = major > 2 ? 2 : 0;
            /* The amount of bytes that are unconditionally read for each frame: */
            /* ID, size, flags. */
            unsigned int framebegin = head_part+head_part+flag_part;
            debug1("ID3v2: have read at all %lu bytes for the tag now", (unsigned long)length+6);
            if(flags & EXTHEAD_FLAG)
            {
                debug("ID3v2: extended header");
                if(!bytes_to_long(tagdata, tagpos) || tagpos >= length)
                {
                    ret = 0;
                    if(NOQUIET)
                        error4( "Bad (non-synchsafe/too large) tag offset from extended header:"
                            "0x%02x%02x%02x%02x"
                        ,   tagdata[0], tagdata[1], tagdata[2], tagdata[3] );
                } else if(tagpos < 6)
                {
                    ret = 0;
                    if(NOQUIET)
                        merror("Extended header too small (%lu).", tagpos);
                }
                if(major == 3)
                {
                    tagpos += 4; // The size itself is not included.
                    if(tagpos >= length)
                    {
                        ret = 0;
                        if(NOQUIET)
                            error("Too much extended v2.3 header.");
                    }
                } else if(ret) // v2.4 and at least got my 6 bytes of ext header
                {
                    // Only v4 knows update frames, check for that.
                    // Need to step back. Header is 4 bytes length, one byte flag size,
                    // one byte flags. Flag size has to be 1!
                    if(tagdata[4] == 1 && tagdata[5] & EXT_UPDATE_FLAG)
                    {
                        if(VERBOSE3)
                            fprintf(stderr, "Note: ID3v2.4 update tag\n");
                        extflags |= EXT_UPDATE_FLAG;
                    }
                }
            }
            if(!(extflags & EXT_UPDATE_FLAG))
            {
                if(VERBOSE3)
                    fprintf(stderr, "Note: non-update tag replacing existing ID3v2 data\n");
                reset_id3(fr);
            }
            if(ret > 0)
            {
                char id[5];
                unsigned long framesize;
                unsigned long fflags; /* need 16 bits, actually */
                id[4] = 0;
                fr->id3v2.version = major;
                /* Pos now advanced after ext head, now a frame has to follow. */
                /* Note: tagpos <= length, which is 28 bit integer, so both */
                /* far away from overflow for adding known small values. */
                /* I want to read at least one full header now. */
                while(length >= tagpos+framebegin)
                {
                    int i = 0;
                    unsigned long pos = tagpos;
                    /* level 1,2,3 - 0 is info from lame/info tag! */
                    /* rva tags with ascending significance, then general frames */
                    enum frame_types tt = unknown;
                    /* we may have entered the padding zone or any other strangeness: check if we have valid frame id characters */
                    for(i=0; i< head_part; ++i)
                    if( !( ((tagdata[tagpos+i] > 47) && (tagdata[tagpos+i] < 58))
                         || ((tagdata[tagpos+i] > 64) && (tagdata[tagpos+i] < 91)) ) )
                    {
                        debug5("ID3v2: real tag data apparently ended after %lu bytes with 0x%02x%02x%02x%02x", tagpos, tagdata[tagpos], tagdata[tagpos+1], tagdata[tagpos+2], tagdata[tagpos+3]);
                        /* This is no hard error... let's just hope that we got something meaningful already (ret==1 in that case). */
                        goto tagparse_cleanup; /* Need to escape two loops here. */
                    }
                    if(ret > 0)
                    {
                        /* 4 or 3 bytes id */
                        strncpy(id, (char*) tagdata+pos, head_part);
                        id[head_part] = 0; /* terminate for 3 or 4 bytes */
                        pos += head_part;
                        tagpos += head_part;
                        /* size as 32 bits or 28 bits */
                        if(fr->id3v2.version == 2) threebytes_to_long(tagdata+pos, framesize);
                        else
                        if(!bytes_to_long(tagdata+pos, framesize))
                        {
                            /* Just assume that up to now there was some good data. */
                            if(NOQUIET) error1("ID3v2: non-syncsafe size of %s frame, skipping the remainder of tag", id);
                            break;
                        }
                        if(VERBOSE3) fprintf(stderr, "Note: ID3v2 %s frame of size %lu\n", id, framesize);
                        tagpos += head_part;
                        pos += head_part;
                        if(fr->id3v2.version > 2)
                        {
                            fflags  = (((unsigned long) tagdata[pos]) << 8) | ((unsigned long) tagdata[pos+1]);
                            pos    += 2;
                            tagpos += 2;
                        }
                        else fflags = 0;
 
                        if(length - tagpos < framesize)
                        {
                            if(NOQUIET) error("Whoa! ID3v2 frame claims to be larger than the whole rest of the tag.");
                            break;
                        }
                        tagpos += framesize; /* the important advancement in whole tag */
                        /* for sanity, after full parsing tagpos should be == pos */
                        /* debug4("ID3v2: found %s frame, size %lu (as bytes: 0x%08lx), flags 0x%016lx", id, framesize, framesize, fflags); */
                        /* %0abc0000 %0h00kmnp */
                        #define BAD_FFLAGS (unsigned long) 36784
                        #define PRES_TAG_FFLAG 16384
                        #define PRES_FILE_FFLAG 8192
                        #define READ_ONLY_FFLAG 4096
                        #define GROUP_FFLAG 64
                        #define COMPR_FFLAG 8
                        #define ENCR_FFLAG 4
                        #define UNSYNC_FFLAG 2
                        #define DATLEN_FFLAG 1
                        if(head_part < 4 && promote_framename(fr, id) != 0) continue;
 
                        /* shall not or want not handle these */
                        if(fflags & (BAD_FFLAGS | COMPR_FFLAG | ENCR_FFLAG))
                        {
                            if(NOQUIET) warning("ID3v2: skipping invalid/unsupported frame");
                            continue;
                        }
 
                        for(i = 0; i < KNOWN_FRAMES; ++i)
                        if(!strncmp(frame_type[i], id, 4)){ tt = i; break; }
 
                        if(id[0] == 'T' && tt != extra) tt = text;
 
                        if(tt != unknown)
                        {
                            int rva_mode = -1; /* mix / album */
                            unsigned long realsize = framesize;
                            unsigned char* realdata = tagdata+pos;
                            unsigned char* unsyncbuffer = NULL;
                            if(((flags & UNSYNC_FLAG) || (fflags & UNSYNC_FFLAG)) && framesize > 0)
                            {
                                unsigned long ipos = 0;
                                unsigned long opos = 0;
                                debug("Id3v2: going to de-unsync the frame data");
                                /* de-unsync: FF00 -> FF; real FF00 is simply represented as FF0000 ... */
                                /* damn, that means I have to delete bytes from withing the data block... thus need temporal storage */
                                /* standard mandates that de-unsync should always be safe if flag is set */
                                realdata = unsyncbuffer = malloc(framesize+1); /* will need <= bytes, plus a safety zero */
                                if(realdata == NULL)
                                {
                                    if(NOQUIET) error("ID3v2: unable to allocate working buffer for de-unsync");
                                    continue;
                                }
                                /* now going byte per byte through the data... */
                                realdata[0] = tagdata[pos];
                                opos = 1;
                                for(ipos = pos+1; ipos < pos+framesize; ++ipos)
                                {
                                    if(!((tagdata[ipos] == 0) && (tagdata[ipos-1] == 0xff)))
                                    {
                                        realdata[opos++] = tagdata[ipos];
                                    }
                                }
                                realsize = opos;
                                /* Append a zero to keep strlen() safe. */
                                realdata[realsize] = 0;
                                debug2("ID3v2: de-unsync made %lu out of %lu bytes", realsize, framesize);
                            }
                            pos = 0; /* now at the beginning again... */
                            /* Avoid reading over boundary, even if there is a */
                            /* zero byte of padding for safety. */
                            if(realsize) switch(tt)
                            {
                                case comment:
                                case uslt:
                                    process_comment(fr, tt, realdata, realsize, comment+1, id);
                                break;
                                case extra: /* perhaps foobar2000's work */
                                    process_extra(fr, realdata, realsize, extra+1, id);
                                break;
                                case rva2: /* "the" RVA tag */
                                {
                                    /* starts with null-terminated identification */
                                    if(VERBOSE3) fprintf(stderr, "Note: RVA2 identification \"%s\"\n", realdata);
                                    /* default: some individual value, mix mode */
                                    rva_mode = 0;
                                    if( !strncasecmp((char*)realdata, "album", 5)
                                         || !strncasecmp((char*)realdata, "audiophile", 10)
                                         || !strncasecmp((char*)realdata, "user", 4))
                                    rva_mode = 1;
                                    if(fr->rva.level[rva_mode] <= rva2+1)
                                    {
                                        pos += strlen((char*) realdata) + 1;
                                        debug2("got my pos: %zu - %zu", realsize, pos);
                                        // channel and two bytes for RVA value
                                        // pos possibly just past the safety zero, so one more than realsize
                                        if(pos > realsize || realsize-pos < 3)
                                        {
                                            if(NOQUIET)
                                                error("bad RVA2 tag (truncated?)");
                                        }
                                        else if(realdata[pos] == 1)
                                        {
                                            ++pos;
                                            /* only handle master channel */
                                            debug("ID3v2: it is for the master channel");
                                            /* two bytes adjustment, one byte for bits representing peak - n bytes, eh bits, for peak */
                                            /* 16 bit signed integer = dB * 512. Do not shift signed integers! Multiply instead.
                                               Also no implementation-defined casting. Reinterpret the pointer to signed char, then do
                                               proper casting. */
                                            fr->rva.gain[rva_mode] = (float) (
                                                ((short)((signed char*)realdata)[pos]) * 256 + (short)realdata[pos+1] ) / 512;
                                            pos += 2;
                                            if(VERBOSE3) fprintf(stderr, "Note: RVA value %fdB\n", fr->rva.gain[rva_mode]);
                                            /* heh, the peak value is represented by a number of bits - but in what manner? Skipping that part */
                                            fr->rva.peak[rva_mode] = 0;
                                            fr->rva.level[rva_mode] = rva2+1;
                                        }
                                    }
                                }
                                break;
                                /* non-rva metainfo, simply store... */
                                case text:
                                    process_text(fr, realdata, realsize, id);
                                break;
                                case picture:
                                    if (fr->p.flags & MPG123_PICTURE)
                                    process_picture(fr, realdata, realsize);
 
                                    break;
                                default: if(NOQUIET) error1("ID3v2: unknown frame type %i", tt);
                            }
                            if(unsyncbuffer)
                                free(unsyncbuffer);
                        }
                        #undef BAD_FFLAGS
                        #undef PRES_TAG_FFLAG
                        #undef PRES_FILE_FFLAG
                        #undef READ_ONLY_FFLAG
                        #undef GROUP_FFLAG
                        #undef COMPR_FFLAG
                        #undef ENCR_FFLAG
                        #undef UNSYNC_FFLAG
                        #undef DATLEN_FFLAG
                    }
                    else break;
                    #undef KNOWN_FRAMES
                }
            } else
            {
                if(VERBOSE3)
                    fprintf(stderr, "Note: faulty ID3v2 tag still clearing old data\n");
                reset_id3(fr);
            }
        } else // No new data, but still there was a tag that invalidates old data.
        {
            if(VERBOSE3)
                fprintf(stderr, "Note: empty ID3v2 clearing old data\n");
            reset_id3(fr);
        }
tagparse_cleanup:
        /* Get rid of stored raw data that should not be kept. */
        if(!(fr->p.flags & MPG123_STORE_RAW_ID3))
        {
            free(fr->id3v2_raw);
            fr->id3v2_raw = NULL;
            fr->id3v2_size = 0;
        }
    }
#endif /* NO_ID3V2 */
    return ret;
    #undef UNSYNC_FLAG
    #undef EXTHEAD_FLAG
    #undef COMPRESS_FLAG
    #undef EXP_FLAG
    #undef FOOTER_FLAG
    #undef EXT_UPDATE_FLAG
    #undef UNKOWN_FLAGS
}

reset_id3()

void reset_id3

(

mpg123_handle *

fr

)

Definition at line 292 of file id3.c.

{
    exit_id3(fr);
    init_id3(fr);
}