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 203 of file id3.c.

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

Referenced by reset_id3().

id3_link()

void id3_link

(

mpg123_handle *

fr

)

Definition at line 218 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 292 of file id3.c.

{
    unsigned int bwidth;
    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);
}

Referenced by process_picture(), and store_id3_text().

init_id3()

void init_id3

(

mpg123_handle *

fr

)

Definition at line 52 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;
}

Referenced by reset_id3().

parse_new_id3()

int parse_new_id3	(	mpg123_handle *	fr,
		unsigned long	first4bytes
	)

Definition at line 670 of file id3.c.

{
    #define UNSYNC_FLAG 128
    #define EXTHEAD_FLAG 64
    #define EXP_FLAG 32
    #define FOOTER_FLAG 16
    #define UNKNOWN_FLAGS 15 /* 00001111*/
    unsigned char buf[6];
    unsigned long length=0;
    unsigned char flags = 0;
    int ret = 1;
    int ret2;
#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. */

    /* 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;
    }
    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;
    }
    if(length < 10)
    {
        if(NOQUIET)
            warning1("ID3v2: unrealistic small tag lengh %lu, skipping", length);
        skiptag = 1;
    }
    if(skiptag)
    {
#endif
        if((ret2 = fr->rd->skip_bytes(fr,length)) < 0) /* will not store data in backbuff! */
        ret = ret2;
#ifndef NO_ID3V2
    }
    else
    {
        unsigned char* tagdata = NULL;
        fr->id3v2.version = major;
        /* try to interpret that beast */
        if((tagdata = (unsigned char*) malloc(length+1)) != NULL)
        {
            debug("ID3v2: analysing frames...");
            if((ret2 = fr->rd->read_frame_body(fr,tagdata,length)) > 0)
            {
                unsigned long tagpos = 0;
                /* bytes of frame title and of framesize value */
                unsigned int head_part = fr->id3v2.version > 2 ? 4 : 3;
                unsigned int flag_part = fr->id3v2.version > 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);
                /* going to apply strlen for strings inside frames, make sure that it doesn't overflow! */
                tagdata[length] = 0;
                if(flags & EXTHEAD_FLAG)
                {
                    debug("ID3v2: skipping extended header");
                    if(!bytes_to_long(tagdata, tagpos) || tagpos >= length)
                    {
                        ret = 0;
                        if(NOQUIET)
                            error4( "Bad (non-synchsafe/too large) tag offset:"
                                "0x%02x%02x%02x%02x"
                            ,   tagdata[0], tagdata[1], tagdata[2], tagdata[3] );
                    }
                }
                if(ret > 0)
                {
                    char id[5];
                    unsigned long framesize;
                    unsigned long fflags; /* need 16 bits, actually */
                    id[4] = 0;
                    /* 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;
                                if((flags & UNSYNC_FLAG) || (fflags & UNSYNC_FFLAG))
                                {
                                    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 = (unsigned char*) malloc(framesize); /* will need <= bytes */
                                    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;
                                    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;
                                            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  ... the double cast is needed to preserve the sign of negative values! */
                                                fr->rva.gain[rva_mode] = (float) ( (((short)((signed char)realdata[pos])) << 8) | 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((flags & UNSYNC_FLAG) || (fflags & UNSYNC_FFLAG)) free(realdata);
                            }
                            #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
            {
                /* There are tags with zero length. Strictly not an error, then. */
                if(length > 0 && NOQUIET && ret2 != MPG123_NEED_MORE) error("ID3v2: Duh, not able to read ID3v2 tag data.");
                ret = ret2;
            }
tagparse_cleanup:
            free(tagdata);
        }
        else
        {
            if(NOQUIET) error1("ID3v2: Arrg! Unable to allocate %lu bytes for interpreting ID3v2 data - trying to skip instead.", length);
            if((ret2 = fr->rd->skip_bytes(fr,length)) < 0) ret = ret2; /* will not store data in backbuff! */
            else ret = 0;
        }
    }
#endif /* NO_ID3V2 */
    /* skip footer if present */
    if((ret > 0) && (flags & FOOTER_FLAG) && ((ret2 = fr->rd->skip_bytes(fr,length)) < 0)) ret = ret2;

    return ret;
    #undef UNSYNC_FLAG
    #undef EXTHEAD_FLAG
    #undef EXP_FLAG
    #undef FOOTER_FLAG
    #undef UNKOWN_FLAGS
}

reset_id3()

void reset_id3

(

mpg123_handle *

fr

)

Definition at line 211 of file id3.c.

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