Attachment #1030 for bug #7555

View | Details | Raw Unified | Return to bug 7555
Collapse All | Expand All




/* charset.h - 2001/12/04 */
/*
 *  EasyTAG - Tag editor for MP3 and OGG files
 *  Copyright (C) 2000-2002  Jerome Couderc <j.couderc@ifrance.com>
 *
 *  This program 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif

/*
 * Standard gettext macros.
 */
#ifdef ENABLE_NLS
#  include <libintl.h>
#  define _(String) gettext (String)
#  ifdef gettext_noop
#    define N_(String) gettext_noop (String)
#  else
#    define N_(String) (String)
#  endif
#else
#  define textdomain(String) (String)
#  define gettext(String) (String)
#  define dgettext(Domain,Message) (Message)
#  define dcgettext(Domain,Message,Type) (Message)
#  define bindtextdomain(Domain,Directory) (Domain)
#  define _(String) (String)
#  define N_(String) (String)
#endif

#ifndef DLL_H
#define DLL_H
typedef struct DLL_s
{
	void *prev;
	void *data;
	void *next;
} DLL;
#endif

#ifndef __CHARSET_H__
#define __CHARSET_H__


/***************
 * Declaration *
 ***************/

typedef struct {
	char *charset_title;
	char *charset_name;
} CharsetInfo;


/**************
 * Prototypes *
 **************/

//static gchar* get_current_charset (void);

/* Used for ogg tags */
char* convert_to_utf8   (const char *string);
char* convert_from_utf8 (const char *string);

char* convert_from_file_to_user (const char *string);
char* convert_from_user_to_file (const char *string);

DLL *Charset_Create_List (void);
char *Charset_Get_Name_From_Title (char *charset_title);
char *Charset_Get_Title_From_Name (char *charset_name);

short int test_conversion_charset (char *from, char *to);


#endif /* __CHARSET_H__ */

/*
 * Main part of code, written by:
 *
 * Copyright (C) 1999-2001  Håvard Kvålen <havardk@xmms.org>
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#include <stdlib.h>
#include <string.h>
#include <errno.h>

#ifdef HAVE_ICONV_OPEN
#include <iconv.h>
#endif

#ifdef HAVE_LANGINFO_CODESET
#include <langinfo.h>
#endif

/****************
 * Declarations *
 ****************/

#define CHARSET_TRANS_ARRAY_LEN ( sizeof(charset_trans_array) / sizeof((charset_trans_array)[0]) )
const CharsetInfo charset_trans_array[] = { 
    {N_("Arabic (IBM-864)"),                  "IBM864"        },
    {N_("Arabic (ISO-8859-6)"),               "ISO-8859-6"    },
    {N_("Arabic (Windows-1256)"),             "windows-1256"  },
    {N_("Baltic (ISO-8859-13)"),              "ISO-8859-13"   },
    {N_("Baltic (ISO-8859-4)"),               "ISO-8859-4"    },
    {N_("Baltic (Windows-1257)"),             "windows-1257"  },
    {N_("Celtic (ISO-8859-14)"),              "ISO-8859-14"   },
    {N_("Central European (IBM-852)"),        "IBM852"        },
    {N_("Central European (ISO-8859-2)"),     "ISO-8859-2"    },
    {N_("Central European (Windows-1250)"),   "windows-1250"  },
    {N_("Chinese Simplified (GB18030)"),      "gb18030"       },
    {N_("Chinese Simplified (GB2312)"),       "GB2312"        },
    {N_("Chinese Traditional (Big5)"),        "Big5"          },
    {N_("Chinese Traditional (Big5-HKSCS)"),  "Big5-HKSCS"    },
    {N_("Cyrillic (IBM-855)"),                "IBM855"        },
    {N_("Cyrillic (ISO-8859-5)"),             "ISO-8859-5"    },
    {N_("Cyrillic (ISO-IR-111)"),             "ISO-IR-111"    },
    {N_("Cyrillic (KOI8-R)"),                 "KOI8-R"        },
    {N_("Cyrillic (Windows-1251)"),           "windows-1251"  },
    {N_("Cyrillic/Russian (CP-866)"),         "IBM866"        },
    {N_("Cyrillic/Ukrainian (KOI8-U)"),       "KOI8-U"        },
    {N_("English (US-ASCII)"),                "us-ascii"      },
    {N_("Greek (ISO-8859-7)"),                "ISO-8859-7"    },
    {N_("Greek (Windows-1253)"),              "windows-1253"  },
    {N_("Hebrew (IBM-862)"),                  "IBM862"        },
    {N_("Hebrew (Windows-1255)"),             "windows-1255"  },
    {N_("Japanese (EUC-JP)"),                 "EUC-JP"        },
    {N_("Japanese (ISO-2022-JP)"),            "ISO-2022-JP"   },
    {N_("Japanese (Shift_JIS)"),              "Shift_JIS"     },
    {N_("Korean (EUC-KR)"),                   "EUC-KR"        },
    {N_("Nordic (ISO-8859-10)"),              "ISO-8859-10"   },
    {N_("South European (ISO-8859-3)"),       "ISO-8859-3"    },
    {N_("Thai (TIS-620)"),                    "TIS-620"       },
    {N_("Turkish (IBM-857)"),                 "IBM857"        },
    {N_("Turkish (ISO-8859-9)"),              "ISO-8859-9"    },
    {N_("Turkish (Windows-1254)"),            "windows-1254"  },
    {N_("Unicode (UTF-7)"),                   "UTF-7"         },
    {N_("Unicode (UTF-8)"),                   "UTF-8"         },
    {N_("Unicode (UTF-16BE)"),                "UTF-16BE"      },
    {N_("Unicode (UTF-16LE)"),                "UTF-16LE"      },
    {N_("Unicode (UTF-32BE)"),                "UTF-32BE"      },
    {N_("Unicode (UTF-32LE)"),                "UTF-32LE"      },
    {N_("Vietnamese (VISCII)"),               "VISCII"        },
    {N_("Vietnamese (Windows-1258)"),         "windows-1258"  },
    {N_("Visual Hebrew (ISO-8859-8)"),        "ISO-8859-8"    },
    {N_("Western (IBM-850)"),                 "IBM850"        },
    {N_("Western (ISO-8859-1)"),              "ISO-8859-1"    },
    {N_("Western (ISO-8859-15)"),             "ISO-8859-15"   },
    {N_("Western (Windows-1252)"),            "windows-1252"  }

    /*
     * From this point, character sets aren't supported by iconv
     */
/*    {N_("Arabic (IBM-864-I)"),                "IBM864i"              },
    {N_("Arabic (ISO-8859-6-E)"),             "ISO-8859-6-E"         },
    {N_("Arabic (ISO-8859-6-I)"),             "ISO-8859-6-I"         },
    {N_("Arabic (MacArabic)"),                "x-mac-arabic"         },
    {N_("Armenian (ARMSCII-8)"),              "armscii-8"            },
    {N_("Central European (MacCE)"),          "x-mac-ce"             },
    {N_("Chinese Simplified (GBK)"),          "x-gbk"                },
    {N_("Chinese Simplified (HZ)"),           "HZ-GB-2312"           },
    {N_("Chinese Traditional (EUC-TW)"),      "x-euc-tw"             },
    {N_("Croatian (MacCroatian)"),            "x-mac-croatian"       },
    {N_("Cyrillic (MacCyrillic)"),            "x-mac-cyrillic"       },
    {N_("Cyrillic/Ukrainian (MacUkrainian)"), "x-mac-ukrainian"      },
    {N_("Farsi (MacFarsi)"),                  "x-mac-farsi"},
    {N_("Greek (MacGreek)"),                  "x-mac-greek"          },
    {N_("Gujarati (MacGujarati)"),            "x-mac-gujarati"       },
    {N_("Gurmukhi (MacGurmukhi)"),            "x-mac-gurmukhi"       },
    {N_("Hebrew (ISO-8859-8-E)"),             "ISO-8859-8-E"         },
    {N_("Hebrew (ISO-8859-8-I)"),             "ISO-8859-8-I"         },
    {N_("Hebrew (MacHebrew)"),                "x-mac-hebrew"         },
    {N_("Hindi (MacDevanagari)"),             "x-mac-devanagari"     },
    {N_("Icelandic (MacIcelandic)"),          "x-mac-icelandic"      },
    {N_("Korean (JOHAB)"),                    "x-johab"              },
    {N_("Korean (UHC)"),                      "x-windows-949"        },
    {N_("Romanian (MacRomanian)"),            "x-mac-romanian"       },
    {N_("Turkish (MacTurkish)"),              "x-mac-turkish"        },
    {N_("User Defined"),                      "x-user-defined"       },
    {N_("Vietnamese (TCVN)"),                 "x-viet-tcvn5712"      },
    {N_("Vietnamese (VPS)"),                  "x-viet-vps"           },
    {N_("Western (MacRoman)"),                "x-mac-roman"          },
    // charsets whithout posibly translatable names
    {"T61.8bit",                              "T61.8bit"             },
    {"x-imap4-modified-utf7",                 "x-imap4-modified-utf7"},
    {"x-u-escaped",                           "x-u-escaped"          },
    {"windows-936",                           "windows-936"          }
*/
};




/*************
 * Functions *
 *************/
// Return the last item of an doubly linked list
static DLL *
dll_last_c (DLL *list)
{
	DLL *item = list;
	
	while ( item->next )
		item = item->next;
	
	return item;
}

// Append an item to the doubly linked list
static DLL *
dll_append_c (DLL *list, void *data)
{
	DLL *item = malloc (sizeof(DLL));
	
	item->data = data;
	item->prev = dll_last_c(list);
	item->next = NULL;
	
	return item;
}

static char* get_current_charset (void)
{
    char *charset = getenv("CHARSET");

#ifdef HAVE_LANGINFO_CODESET
    if (!charset)
        charset = nl_langinfo(CODESET);
#endif
    if (!charset)
        charset = "ISO-8859-1";

    return charset;
}


#ifdef HAVE_ICONV_OPEN
static char* convert_string (const char *string, char *from, char *to)
{
    size_t outleft, outsize, length;
    iconv_t cd;
    char *out, *outptr;
    const char *input = string;

    if (!string)
        return NULL;

    length = strlen(string);

    /*  g_message("converting %s from %s to %s", string, from, to); */
    if ((cd = iconv_open(to, from)) == (iconv_t)-1)
    {
		fprintf (stderr, "convert_string(): Conversion not supported. Charsets: %s -> %s", from, to);
        return strdup(string);
    }

    /* Due to a GLIBC bug, round outbuf_size up to a multiple of 4 */
    /* + 1 for nul in case len == 1 */
    outsize = ((length + 3) & ~3) + 1;
    out = g_malloc(outsize);
    outleft = outsize - 1;
    outptr = out;

 retry:
    if (iconv(cd, (char **)&input, &length, &outptr, &outleft) == -1)
    {
        int used;
        switch (errno)
        {
            case E2BIG:
                used = outptr - out;
                outsize = (outsize - 1) * 2 + 1;
                out = g_realloc(out, outsize);
                outptr = out + used;
                outleft = outsize - 1 - used;
                goto retry;
            case EINVAL:
                break;
            case EILSEQ:
                /* Invalid sequence, try to get the
                                   rest of the string */
                input++;
                length = strlen(input);
                goto retry;
            default:
                fprintf (stderr, "convert_string(): Conversion failed. Inputstring: %s; Error: %s", string, strerror(errno));
                break;
        }
    }
    *outptr = '\0';

    iconv_close(cd);
    return out;
}
#else
static char* convert_string (const char *string, char *from, char *to)
{
    if (!string)
        return NULL;
    return strdup(string);
}
#endif


/*
 * Conversion with UTF-8 for ogg tags
 */
char* convert_to_utf8 (const char *string)
{
    char *charset = get_current_charset();

    return convert_string(string, charset, "UTF-8");
}

char* convert_from_utf8 (const char *string)
{
    char *charset = get_current_charset();

    return convert_string(string, "UTF-8", charset);
}


DLL *Charset_Create_List (void)
{
    DLL *list = NULL;
    int i;

    for (i=0; i<CHARSET_TRANS_ARRAY_LEN; i++)
        list = dll_append_c (list,_(charset_trans_array[i].charset_title));
    return list;
}


/*
 * Return charset_name from charset_title
 */
char *Charset_Get_Name_From_Title (char *charset_title)
{
    int i;

    if (charset_title)
        for (i=0; i<CHARSET_TRANS_ARRAY_LEN; i++)
            if ( strcasecmp(_(charset_title),_(charset_trans_array[i].charset_title)) == 0 )
                return charset_trans_array[i].charset_name;
    return "";
}


/*
 * Return charset_title from charset_name
 */
char *Charset_Get_Title_From_Name (char *charset_name)
{
    int i;

    if (charset_name)
        for (i=0; i<CHARSET_TRANS_ARRAY_LEN; i++)
            if ( strcasecmp(charset_name,charset_trans_array[i].charset_name) == 0 )
                return _(charset_trans_array[i].charset_title);
    return "";
}



/*
 * Test if the conversion is supported between two character sets ('from' and 'to)
 */
#ifdef HAVE_ICONV_OPEN
short int test_conversion_charset (char *from, char *to)
{
    iconv_t cd;

    if ((cd=iconv_open(to,from)) == (iconv_t)-1)
    {
        /* Conversion not supported */
        return FALSE;
    }
    iconv_close(cd);
    return TRUE;
}
#else
short int test_conversion_charset (char *from, char *to)
{
    return TRUE;
}
#endif

Lines 25-52 Link Here

(-)xmms-1.2.10.orig/Input/mpg123/fileinfo.c (-292 / +739 lines)
25	#include <errno.h>	25	#include <errno.h>
26	#include <libxmms/xentry.h>	26	#include <libxmms/xentry.h>
27	#include "mpg123.h"	27	#include "mpg123.h"
		28	#include "lib_id3v2.h"
		29
		30	#define MAX_STR_LEN 100
		31	#define MAX_ENTRY_LEN2 1023
28		32
29	static GtkWidget *window = NULL;	33	static GtkWidget *window = NULL;
30	static GtkWidget filename_entry, id3_frame;	34	static GtkWidget *notebook = NULL;
31	static GtkWidget title_entry, artist_entry, album_entry, year_entry;	35	static GtkWidget filename_entry, id3v1_frame, *id3v2_frame;
32	static GtkWidget tracknum_entry, comment_entry, *genre_combo;	36	static GtkWidget v1_checkbox, v2_checkbox;
		37	static GtkWidget v1_title_entry, v1_artist_entry, v1_album_entry, v1_year_entry, v1_tracknum_entry, v1_comment_entry;
		38	static GtkWidget v2_title_entry, v2_artist_entry, v2_album_entry, v2_year_entry, v2_tracknum_entry, v2_comment_entry,
		39	v2_composer_entry, v2_orig_artist_entry, v2_url_entry, v2_encoded_by_entry;
		40	static GtkWidget v1_genre_combo, v2_genre_combo;
33	static GtkWidget mpeg_level, mpeg_bitrate, mpeg_samplerate, mpeg_flags;	41	static GtkWidget mpeg_level, mpeg_bitrate, mpeg_samplerate, mpeg_flags;
34	static GtkWidget *mpeg_fileinfo;	42	static GtkWidget *mpeg_fileinfo;
35		43
		44	static GPtrArray v1_labels_list = NULL, v2_labels_list = NULL; // TODO: Where will these be freed?
36	static GList *genre_list;	45	static GList *genre_list;
37	struct genre_item {	46	struct genre_item {
38	const char *name;	47	const char *name;
39	int id;	48	int id;
40	};	49	};
41	static int current_genre;	50	static int v1_current_genre;
		51	static int v2_current_genre;
42	static char *current_filename;	52	static char *current_filename;
43		53
44	extern char *mpg123_filename;	54	extern char *mpg123_filename;
45	extern int mpg123_bitrate, mpg123_frequency, mpg123_layer, mpg123_lsf, mpg123_mode;	55	extern int mpg123_bitrate, mpg123_frequency, mpg123_layer, mpg123_lsf, mpg123_mode;
46	extern gboolean mpg123_stereo, mpg123_mpeg25;	56	extern gboolean mpg123_stereo, mpg123_mpeg25;
47		57
48	#define MAX_STR_LEN 100
49
50	static void label_set_text(GtkWidget * label, char *str, ...)	58	static void label_set_text(GtkWidget * label, char *str, ...)
51	G_GNUC_PRINTF(2, 3);	59	G_GNUC_PRINTF(2, 3);
52		60
Lines 66-71 Link Here
66	strncpy(tag, gtk_entry_get_text(entry), length);	74	strncpy(tag, gtk_entry_get_text(entry), length);
67	}	75	}
68		76
		77	void copy_entry_tag(GtkEntry * src, GtkEntry * dest, int length)
		78	{
		79	set_entry_tag(dest, gtk_entry_get_text(src), length);
		80	return;
		81	}
		82
69	static int genre_find_index(GList *genre_list, int id)	83	static int genre_find_index(GList *genre_list, int id)
70	{	84	{
71	int idx = 0;	85	int idx = 0;
Lines 80-94 Link Here
80	return idx;	94	return idx;
81	}	95	}
82		96
		97	static int genre_find_index_str(GList genre_list, const char str)
		98	{
		99	int idx = 0;
		100	while (genre_list)
		101	{
		102	struct genre_item *item = genre_list->data;
		103	if (strcmp(item->name, str) == 0)
		104	break;
		105	idx++;
		106	genre_list = genre_list->next;
		107	}
		108	return idx;
		109	}
		110
83	static int genre_comp_func(gconstpointer a, gconstpointer b)	111	static int genre_comp_func(gconstpointer a, gconstpointer b)
84	{	112	{
85	const struct genre_item ga = a, gb = b;	113	const struct genre_item ga = a, gb = b;
86	return strcasecmp(ga->name, gb->name);	114	return strcasecmp(ga->name, gb->name);
87	}	115	}
88		116
89	static void save_cb(GtkWidget * w, gpointer data)	117	static void remove_id3v1(void)
90	{	118	{
91	int fd;	119	int fd, len;
92	struct id3v1tag_t tag;	120	struct id3v1tag_t tag;
93	char *msg = NULL;	121	char *msg = NULL;
94		122
Lines 97-167 Link Here
97		125
98	if ((fd = open(current_filename, O_RDWR)) != -1)	126	if ((fd = open(current_filename, O_RDWR)) != -1)
99	{	127	{
100	int tracknum;	128	len = lseek(fd, -128, SEEK_END);
101
102	lseek(fd, -128, SEEK_END);
103	read(fd, &tag, sizeof (struct id3v1tag_t));	129	read(fd, &tag, sizeof (struct id3v1tag_t));
104		130
105	if (!strncmp(tag.tag, "TAG", 3))	131	if (!strncmp(tag.tag, "TAG", 3))
106	lseek(fd, -128, SEEK_END);
107	else
108	lseek(fd, 0, SEEK_END);
109	tag.tag[0] = 'T';
110	tag.tag[1] = 'A';
111	tag.tag[2] = 'G';
112	get_entry_tag(GTK_ENTRY(title_entry), tag.title, 30);
113	get_entry_tag(GTK_ENTRY(artist_entry), tag.artist, 30);
114	get_entry_tag(GTK_ENTRY(album_entry), tag.album, 30);
115	get_entry_tag(GTK_ENTRY(year_entry), tag.year, 4);
116	tracknum = atoi(gtk_entry_get_text(GTK_ENTRY(tracknum_entry)));
117	if (tracknum > 0)
118	{	132	{
119	get_entry_tag(GTK_ENTRY(comment_entry),	133	if (ftruncate(fd, len))
120	tag.u.v1_1.comment, 28);	134	msg = g_strdup_printf(_("%s\n"
121	tag.u.v1_1.__zero = 0;	135	"Unable to truncate file: %s"),
122	tag.u.v1_1.track_number = MIN(tracknum, 255);	136	_("Couldn't remove tag!"),
		137	strerror(errno));
123	}	138	}
124	else
125	get_entry_tag(GTK_ENTRY(comment_entry),
126	tag.u.v1_0.comment, 30);
127	tag.genre = current_genre;
128	if (write(fd, &tag, sizeof (tag)) != sizeof (tag))
129	msg = g_strdup_printf(_("%s\nUnable to write to file: %s"),
130	_("Couldn't write tag!"),
131	strerror(errno));
132	close(fd);	139	close(fd);
133	}	140	}
134	else	141	else
135	msg = g_strdup_printf(_("%s\nUnable to open file: %s"),	142	msg = g_strdup_printf(_("%s\nUnable to open file: %s"),
136	_("Couldn't write tag!"),	143	_("Couldn't remove tag!"),
137	strerror(errno));	144	strerror(errno));
138	if (msg)	145	if (msg)
139	{	146	{
140	GtkWidget *mwin = xmms_show_message(_("File Info"), msg,	147	GtkWidget *mwin = xmms_show_message(_("File Info"), msg, _("Ok"),
141	_("Ok"), FALSE, NULL, NULL);	148	FALSE, NULL, NULL);
142	gtk_window_set_transient_for(GTK_WINDOW(mwin),	149	gtk_window_set_transient_for(GTK_WINDOW(mwin),
143	GTK_WINDOW(window));	150	GTK_WINDOW(window));
144	g_free(msg);	151	g_free(msg);
145	}	152	}
146	else
147	gtk_widget_destroy(window);
148	}
149
150	static void label_set_text(GtkWidget * label, char *str, ...)
151	{
152	va_list args;
153	char tempstr[MAX_STR_LEN];
154
155	va_start(args, str);
156	g_vsnprintf(tempstr, MAX_STR_LEN, str, args);
157	va_end(args);
158
159	gtk_label_set_text(GTK_LABEL(label), tempstr);
160	}	153	}
161		154
162	static void remove_id3_cb(GtkWidget * w, gpointer data)	155	static void save_cb(GtkWidget * w, gpointer data)
163	{	156	{
164	int fd, len;	157	int fd;
165	struct id3v1tag_t tag;	158	struct id3v1tag_t tag;
166	char *msg = NULL;	159	char *msg = NULL;
167		160
Lines 170-205 Link Here
170		163
171	if ((fd = open(current_filename, O_RDWR)) != -1)	164	if ((fd = open(current_filename, O_RDWR)) != -1)
172	{	165	{
173	len = lseek(fd, -128, SEEK_END);	166	if (!GTK_TOGGLE_BUTTON(v1_checkbox)->active) {
174	read(fd, &tag, sizeof (struct id3v1tag_t));	167	// Try to save id3v1 tag
		168	int tracknum;
175		169
176	if (!strncmp(tag.tag, "TAG", 3))	170	lseek(fd, -128, SEEK_END);
177	{	171	read(fd, &tag, sizeof (struct id3v1tag_t));
178	if (ftruncate(fd, len))	172
179	msg = g_strdup_printf(	173	if (!strncmp(tag.tag, "TAG", 3))
180	_("%s\n"	174	lseek(fd, -128, SEEK_END);
181	"Unable to truncate file: %s"),	175	else
182	_("Couldn't remove tag!"),	176	lseek(fd, 0, SEEK_END);
183	strerror(errno));	177	tag.tag[0] = 'T';
		178	tag.tag[1] = 'A';
		179	tag.tag[2] = 'G';
		180	get_entry_tag(GTK_ENTRY(v1_title_entry), tag.title, 30);
		181	get_entry_tag(GTK_ENTRY(v1_artist_entry), tag.artist, 30);
		182	get_entry_tag(GTK_ENTRY(v1_album_entry), tag.album, 30);
		183	get_entry_tag(GTK_ENTRY(v1_year_entry), tag.year, 4);
		184	tracknum = atoi(gtk_entry_get_text(GTK_ENTRY(v1_tracknum_entry)));
		185	if (tracknum > 0)
		186	{
		187	get_entry_tag(GTK_ENTRY(v1_comment_entry),
		188	tag.u.v1_1.comment, 28);
		189	tag.u.v1_1.__zero = 0;
		190	tag.u.v1_1.track_number = MIN(tracknum, 255);
		191	}
		192	else
		193	get_entry_tag(GTK_ENTRY(v1_comment_entry),
		194	tag.u.v1_0.comment, 30);
		195	tag.genre = v1_current_genre;
		196	if (write(fd, &tag, sizeof (tag)) != sizeof (tag))
		197	msg = g_strdup_printf(_("%s\nUnable to write to file: %s"),
		198	_("Couldn't write tag!"),
		199	strerror(errno));
		200	} else {
		201	// Remove the id3v1 tag from the file
		202	remove_id3v1();
184	}	203	}
185	else	204
186	msg = strdup(_("No tag to remove!"));	205	if (!GTK_TOGGLE_BUTTON(v2_checkbox)->active) {
187	close(fd);	206
		207	id3Tag v2_tag;
		208	memset(&v2_tag, 0, sizeof (v2_tag));
		209	strncpy(v2_tag.title, gtk_entry_get_text(GTK_ENTRY(v2_title_entry)), MAX_ENTRY_LEN2);
		210	strncpy(v2_tag.artist, gtk_entry_get_text(GTK_ENTRY(v2_artist_entry)), MAX_ENTRY_LEN2);
		211	strncpy(v2_tag.album, gtk_entry_get_text(GTK_ENTRY(v2_album_entry)), MAX_ENTRY_LEN2);
		212	strncpy(v2_tag.year, gtk_entry_get_text(GTK_ENTRY(v2_year_entry)), 4);
		213	strncpy(v2_tag.comment, gtk_entry_get_text(GTK_ENTRY(v2_comment_entry)), MAX_ENTRY_LEN2);
		214	strncpy(v2_tag.track, gtk_entry_get_text(GTK_ENTRY(v2_tracknum_entry)), 3);
		215	snprintf(v2_tag.genre, 6, "(%d)", v2_current_genre);
		216
		217	strncpy(v2_tag.composer, gtk_entry_get_text(GTK_ENTRY(v2_composer_entry)), MAX_ENTRY_LEN2);
		218	strncpy(v2_tag.url, gtk_entry_get_text(GTK_ENTRY(v2_url_entry)), MAX_ENTRY_LEN2);
		219	strncpy(v2_tag.orig_artist, gtk_entry_get_text(GTK_ENTRY(v2_orig_artist_entry)), MAX_ENTRY_LEN2);
		220	strncpy(v2_tag.enc_by, gtk_entry_get_text(GTK_ENTRY(v2_encoded_by_entry)), MAX_ENTRY_LEN2);
		221
		222	set_id3v2_tag(&v2_tag, current_filename);
		223
		224	} else {
		225	// remove the id3v2 tag from the file
		226	del_id3v2_tag(current_filename);
		227	}
		228
		229	if (fd)
		230	close(fd);
188	}	231	}
189	else	232	else
190	msg = g_strdup_printf(_("%s\nUnable to open file: %s"),	233	msg = g_strdup_printf(_("%s\nUnable to open file: %s"),
191	_("Couldn't remove tag!"),	234	_("Couldn't write tag!"),
192	strerror(errno));	235	strerror(errno));
193	if (msg)	236	if (msg)
194	{	237	{
195	GtkWidget *mwin = xmms_show_message(_("File Info"), msg,	238	GtkWidget *mwin = xmms_show_message(_("File Info"), msg, _("Ok"),
196	_("Ok"), FALSE, NULL, NULL);	239	FALSE, NULL, NULL);
197	gtk_window_set_transient_for(GTK_WINDOW(mwin),	240	gtk_window_set_transient_for(GTK_WINDOW(mwin),
198	GTK_WINDOW(window));	241	GTK_WINDOW(window));
199	g_free(msg);	242	g_free(msg);
200	}	243	}
201	else	244	}
202	gtk_widget_destroy(window);	245
		246	static void label_set_text(GtkWidget * label, char *str, ...)
		247	{
		248	va_list args;
		249	char tempstr[MAX_STR_LEN];
		250
		251	va_start(args, str);
		252	g_vsnprintf(tempstr, MAX_STR_LEN, str, args);
		253	va_end(args);
		254
		255	gtk_label_set_text(GTK_LABEL(label), tempstr);
203	}	256	}
204		257
205	static void set_mpeg_level_label(gboolean mpeg25, int lsf, int layer)	258	static void set_mpeg_level_label(gboolean mpeg25, int lsf, int layer)
Lines 222-249 Link Here
222		275
223	static void file_info_http(char *filename)	276	static void file_info_http(char *filename)
224	{	277	{
225	gtk_widget_set_sensitive(id3_frame, FALSE);	278	gtk_widget_set_sensitive(id3v1_frame, FALSE);
		279	gtk_widget_set_sensitive(id3v2_frame, FALSE);
226	if (mpg123_filename && !strcmp(filename, mpg123_filename) &&	280	if (mpg123_filename && !strcmp(filename, mpg123_filename) &&
227	mpg123_bitrate != 0)	281	mpg123_bitrate != 0)
228	{	282	{
229	set_mpeg_level_label(mpg123_mpeg25, mpg123_lsf, mpg123_layer);	283	set_mpeg_level_label(mpg123_mpeg25, mpg123_lsf,
		284	mpg123_layer);
230	label_set_text(mpeg_bitrate, _("Bitrate: %d kb/s"),	285	label_set_text(mpeg_bitrate, _("Bitrate: %d kb/s"),
231	mpg123_bitrate);	286	mpg123_bitrate);
232	label_set_text(mpeg_samplerate, _("Samplerate: %d Hz"),	287	label_set_text(mpeg_samplerate, _("Samplerate: %d Hz"),
233	mpg123_frequency);	288	mpg123_frequency);
234	label_set_text(mpeg_flags, "%s",	289	label_set_text(mpeg_flags, "%s",
235	channel_mode_name(mpg123_mode));	290	channel_mode_name(mpg123_mode));
236	}	291	}
237	}	292	}
238		293
239	static void genre_selected(GtkList list, GtkWidget w, gpointer data)	294	void copy_v2_to_v1_cb(GtkButton *button, gpointer user_data)
		295	{
		296	copy_entry_tag(GTK_ENTRY(v2_title_entry), GTK_ENTRY(v1_title_entry), 30);
		297	copy_entry_tag(GTK_ENTRY(v2_artist_entry), GTK_ENTRY(v1_artist_entry), 30);
		298	copy_entry_tag(GTK_ENTRY(v2_album_entry), GTK_ENTRY(v1_album_entry), 30);
		299	copy_entry_tag(GTK_ENTRY(v2_year_entry), GTK_ENTRY(v1_year_entry), 4);
		300	copy_entry_tag(GTK_ENTRY(v2_comment_entry), GTK_ENTRY(v1_comment_entry), 30);
		301	copy_entry_tag(GTK_ENTRY(v2_tracknum_entry), GTK_ENTRY(v1_tracknum_entry), 3);
		302
		303	gtk_list_select_item(GTK_LIST(GTK_COMBO(v1_genre_combo)->list), genre_find_index(genre_list, v2_current_genre));
		304	return;
		305	}
		306
		307	void copy_v1_to_v2_cb(GtkButton *button, gpointer user_data)
		308	{
		309	copy_entry_tag(GTK_ENTRY(v1_title_entry), GTK_ENTRY(v2_title_entry), MAX_ENTRY_LEN2);
		310	copy_entry_tag(GTK_ENTRY(v1_artist_entry), GTK_ENTRY(v2_artist_entry), MAX_ENTRY_LEN2);
		311	copy_entry_tag(GTK_ENTRY(v1_album_entry), GTK_ENTRY(v2_album_entry), MAX_ENTRY_LEN2);
		312	copy_entry_tag(GTK_ENTRY(v1_year_entry), GTK_ENTRY(v2_year_entry), 4);
		313	copy_entry_tag(GTK_ENTRY(v1_comment_entry), GTK_ENTRY(v2_comment_entry), MAX_ENTRY_LEN2);
		314	copy_entry_tag(GTK_ENTRY(v1_tracknum_entry), GTK_ENTRY(v2_tracknum_entry), 3);
		315
		316	gtk_list_select_item(GTK_LIST(GTK_COMBO(v2_genre_combo)->list), genre_find_index(genre_list, v1_current_genre));
		317	//int genreID = find_genre_id(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(v1_genre_combo)->entry)));
		318	//gtk_list_select_item(GTK_LIST(GTK_COMBO(v2_genre_combo)->list),
		319	// g_list_index(genre_list, (char *) mpg123_id3_genres[genreID]));
		320	return;
		321	}
		322
		323	void v1_toggle_cb (GtkWidget *widget, gpointer data)
		324	{
		325	int i = 0;
		326	if (GTK_TOGGLE_BUTTON (widget)->active)
		327	{
		328	// If control reaches here, the toggle button is down
		329	// Gray out labels
		330	for (i = 0; i < v1_labels_list->len; i++) {
		331	gtk_widget_set_sensitive(GTK_WIDGET( g_ptr_array_index(v1_labels_list, i) ), FALSE);
		332	}
		333	gtk_widget_set_sensitive(v1_title_entry, FALSE);
		334	gtk_widget_set_sensitive(v1_artist_entry, FALSE);
		335	gtk_widget_set_sensitive(v1_album_entry, FALSE);
		336	gtk_widget_set_sensitive(v1_year_entry, FALSE);
		337	gtk_widget_set_sensitive(v1_tracknum_entry, FALSE);
		338	gtk_widget_set_sensitive(v1_comment_entry, FALSE);
		339	gtk_widget_set_sensitive(v1_genre_combo, FALSE);
		340	} else {
		341
		342	// If control reaches here, the toggle button is up
		343	// Enable labels
		344	for (i = 0; i < v1_labels_list->len; i++) {
		345	gtk_widget_set_sensitive(GTK_WIDGET( g_ptr_array_index(v1_labels_list, i) ), TRUE);
		346	}
		347	gtk_widget_set_sensitive(v1_title_entry, TRUE);
		348	gtk_widget_set_sensitive(v1_artist_entry, TRUE);
		349	gtk_widget_set_sensitive(v1_album_entry, TRUE);
		350	gtk_widget_set_sensitive(v1_year_entry, TRUE);
		351	gtk_widget_set_sensitive(v1_tracknum_entry, TRUE);
		352	gtk_widget_set_sensitive(v1_comment_entry, TRUE);
		353	gtk_widget_set_sensitive(v1_genre_combo, TRUE);
		354	}
		355	}
		356
		357	void v2_toggle_cb (GtkWidget *widget, gpointer data)
		358	{
359	int i = 0;
360	if (GTK_TOGGLE_BUTTON (widget)->active)
361	{
362	// If control reaches here, the toggle button is down
363	// Gray out labels
364	for (i = 0; i < v2_labels_list->len; i++) {
365	gtk_widget_set_sensitive(GTK_WIDGET( g_ptr_array_index(v2_labels_list, i) ), FALSE);
366	}
367	gtk_widget_set_sensitive(v2_title_entry, FALSE);
368	gtk_widget_set_sensitive(v2_artist_entry, FALSE);
369	gtk_widget_set_sensitive(v2_album_entry, FALSE);
370	gtk_widget_set_sensitive(v2_year_entry, FALSE);
371	gtk_widget_set_sensitive(v2_tracknum_entry, FALSE);
372	gtk_widget_set_sensitive(v2_comment_entry, FALSE);
373	gtk_widget_set_sensitive(v2_composer_entry, FALSE);
374	gtk_widget_set_sensitive(v2_orig_artist_entry, FALSE);
375	gtk_widget_set_sensitive(v2_url_entry, FALSE);
376	gtk_widget_set_sensitive(v2_encoded_by_entry, FALSE);
377	gtk_widget_set_sensitive(v2_genre_combo, FALSE);
378	} else {
379
380	// If control reaches here, the toggle button is up
381	// Enable labels
382	for (i = 0; i < v2_labels_list->len; i++) {
383	gtk_widget_set_sensitive(GTK_WIDGET( g_ptr_array_index(v2_labels_list, i) ), TRUE);
384	}
385	gtk_widget_set_sensitive(v2_title_entry, TRUE);
386	gtk_widget_set_sensitive(v2_artist_entry, TRUE);
387	gtk_widget_set_sensitive(v2_album_entry, TRUE);
388	gtk_widget_set_sensitive(v2_year_entry, TRUE);
389	gtk_widget_set_sensitive(v2_tracknum_entry, TRUE);
390	gtk_widget_set_sensitive(v2_comment_entry, TRUE);
391	gtk_widget_set_sensitive(v2_composer_entry, TRUE);
392	gtk_widget_set_sensitive(v2_orig_artist_entry, TRUE);
393	gtk_widget_set_sensitive(v2_url_entry, TRUE);
394	gtk_widget_set_sensitive(v2_encoded_by_entry, TRUE);
395	gtk_widget_set_sensitive(v2_genre_combo, TRUE);
396	}
397	}
398	static void v1_genre_selected(GtkList list, GtkWidget w, gpointer data)
399	{
400	void * p;
401	p = gtk_object_get_data(GTK_OBJECT(w), "genre_id");
402	if (p != NULL)
403	v1_current_genre = GPOINTER_TO_INT(p);
404	else
405	v1_current_genre = 0;
406	}
407
408	static void v2_genre_selected(GtkList list, GtkWidget w, gpointer data)
240	{	409	{
241	void * p;	410	void * p;
242	p = gtk_object_get_data(GTK_OBJECT(w), "genre_id");	411	p = gtk_object_get_data(GTK_OBJECT(w), "genre_id");
243	if (p != NULL)	412	if (p != NULL)
244	current_genre = GPOINTER_TO_INT(p);	413	v2_current_genre = GPOINTER_TO_INT(p);
245	else	414	else
246	current_genre = 0;	415	v2_current_genre = 0;
247	}	416	}
248		417
249	static void genre_set_popdown(GtkWidget combo, GList genres)	418	static void genre_set_popdown(GtkWidget combo, GList genres)
Lines 266-276 Link Here
266	void mpg123_file_info_box(char *filename)	435	void mpg123_file_info_box(char *filename)
267	{	436	{
268	int i;	437	int i;
269	struct id3v1tag_t tag;	438	struct id3v1tag_t id3v1tag;
270	FILE *fh;	439	FILE *fh;
271	char tmp, title;	440	char tmp, title;
272	const char *emphasis[4];	441	const char *emphasis[4];
273	const char *bool_label[2];	442	const char *bool_label[2];
		443	struct id3tag_t id3v2tag;
274		444
275	emphasis[0] = _("None");	445	emphasis[0] = _("None");
276	emphasis[1] = _("50/15 ms");	446	emphasis[1] = _("50/15 ms");
Lines 281-396 Link Here
281		451
282	if (!window)	452	if (!window)
283	{	453	{
284	GtkWidget vbox, hbox, left_vbox, table;	454	GtkWidget *window_vbox,
285	GtkWidget mpeg_frame, mpeg_box;	455	id3v1_vbox, id3v2_vbox, id3v1_frame_vbox, id3v2_frame_vbox,
286	GtkWidget label, filename_hbox;	456	mpeg_lvbox, mpeg_rvbox, mpeg_hbox, mpeg_box, *mpeg_frame,
287	GtkWidget bbox, save, remove_id3, cancel;	457	bbox, save, close, copy_to, *copy_from,
288		458	table, label, *filename_hbox;
289	window = gtk_window_new(GTK_WINDOW_DIALOG);	459
290	gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);	460	v1_labels_list = g_ptr_array_new();
291	gtk_signal_connect(GTK_OBJECT(window), "destroy",	461	v2_labels_list = g_ptr_array_new();
292	gtk_widget_destroyed, &window);	462
293	gtk_container_set_border_width(GTK_CONTAINER(window), 10);	463	window = gtk_window_new(GTK_WINDOW_DIALOG);
294		464	//gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
295	vbox = gtk_vbox_new(FALSE, 10);	465	gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
296	gtk_container_add(GTK_CONTAINER(window), vbox);	466	gtk_container_set_border_width(GTK_CONTAINER(window), 10);
297		467
		468	window_vbox = gtk_vbox_new(FALSE,10);
298	filename_hbox = gtk_hbox_new(FALSE, 5);	469	filename_hbox = gtk_hbox_new(FALSE, 5);
299	gtk_box_pack_start(GTK_BOX(vbox), filename_hbox,	470	gtk_box_pack_start(GTK_BOX(window_vbox), filename_hbox, FALSE, TRUE, 0);
300	FALSE, TRUE, 0);
301		471
302	label = gtk_label_new(_("Filename:"));	472	label = gtk_label_new(_("Filename:"));
303	gtk_box_pack_start(GTK_BOX(filename_hbox), label,	473	gtk_box_pack_start(GTK_BOX(filename_hbox), label, FALSE, TRUE, 0);
304	FALSE, TRUE, 0);
305	filename_entry = xmms_entry_new();	474	filename_entry = xmms_entry_new();
306	gtk_editable_set_editable(GTK_EDITABLE(filename_entry), FALSE);	475	gtk_editable_set_editable(GTK_EDITABLE(filename_entry), FALSE);
307	gtk_box_pack_start(GTK_BOX(filename_hbox),	476	gtk_box_pack_start(GTK_BOX(filename_hbox), filename_entry, TRUE, TRUE, 0);
308	filename_entry, TRUE, TRUE, 0);	477
309		478	id3v1_vbox = gtk_vbox_new(FALSE, 10);
310	hbox = gtk_hbox_new(FALSE, 10);	479	id3v1_frame = gtk_frame_new("ID3v1 Information");
311	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);	480	gtk_box_pack_start(GTK_BOX(id3v1_vbox), id3v1_frame, TRUE, TRUE, 0);
312		481
313	left_vbox = gtk_vbox_new(FALSE, 10);	482	id3v1_frame_vbox = gtk_vbox_new(FALSE,10);
314	gtk_box_pack_start(GTK_BOX(hbox), left_vbox, FALSE, FALSE, 0);	483	gtk_container_add(GTK_CONTAINER(id3v1_frame), id3v1_frame_vbox);
315		484
316	id3_frame = gtk_frame_new(_("ID3 Tag:"));	485	table = gtk_table_new(6, 6, FALSE);
317	gtk_box_pack_start(GTK_BOX(left_vbox), id3_frame,	486	gtk_container_set_border_width(GTK_CONTAINER(table), 5);
318	FALSE, FALSE, 0);	487	//gtk_widget_set_usize(GTK_WIDGET(table), 325, -1);
319		488	//gtk_container_add(GTK_CONTAINER(id3v1_frame), table);
320	table = gtk_table_new(5, 5, FALSE);	489	gtk_box_pack_start(GTK_BOX(id3v1_frame_vbox), table, FALSE, FALSE, 0);
321	gtk_container_set_border_width(GTK_CONTAINER(table), 5);	490
322	gtk_container_add(GTK_CONTAINER(id3_frame), table);	491	v1_checkbox = gtk_check_button_new_with_label ("Disable ID3v1 Tag");
323		492	gtk_signal_connect(GTK_OBJECT(v1_checkbox), "toggled", GTK_SIGNAL_FUNC(v1_toggle_cb), NULL);
324	label = gtk_label_new(_("Title:"));	493	gtk_table_attach(GTK_TABLE(table), v1_checkbox, 1, 3, 0, 1,
325	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);	494	GTK_FILL, GTK_FILL, 0, 2);
326	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,	495
327	GTK_FILL, GTK_FILL, 5, 5);	496	label = gtk_label_new("Track number:");
328		497	g_ptr_array_add(v1_labels_list, (gpointer)label);
329	title_entry = gtk_entry_new_with_max_length(30);	498	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
330	gtk_table_attach(GTK_TABLE(table), title_entry, 1, 4, 0, 1,	499	gtk_table_attach(GTK_TABLE(table), label, 3, 4, 0, 1,
331	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,	500	GTK_FILL, GTK_FILL, 5,5);
332	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 5);	501
333		502	v1_tracknum_entry = gtk_entry_new_with_max_length(3);
334	label = gtk_label_new(_("Artist:"));	503	gtk_widget_set_usize(v1_tracknum_entry, 20, -1);
335	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);	504	gtk_table_attach(GTK_TABLE(table), v1_tracknum_entry, 4, 5, 0, 1,
336	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,	505	GTK_FILL, GTK_FILL, 0, 2);
337	GTK_FILL, GTK_FILL, 5, 5);	506
338		507	label = gtk_label_new("Title:");
339	artist_entry = gtk_entry_new_with_max_length(30);	508	g_ptr_array_add(v1_labels_list, (gpointer)label);
340	gtk_table_attach(GTK_TABLE(table), artist_entry, 1, 4, 1, 2,	509	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
341	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,	510	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
342	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 5);	511	GTK_FILL, GTK_FILL, 5, 5);
343		512
344	label = gtk_label_new(_("Album:"));	513	v1_title_entry = gtk_entry_new_with_max_length(30);
345	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);	514	gtk_table_attach(GTK_TABLE(table), v1_title_entry, 1, 5, 1, 2,
346	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,	515	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
347	GTK_FILL, GTK_FILL, 5, 5);	516	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
348		517
349	album_entry = gtk_entry_new_with_max_length(30);	518	label = gtk_label_new("Artist:");
350	gtk_table_attach(GTK_TABLE(table), album_entry, 1, 4, 2, 3,	519	g_ptr_array_add(v1_labels_list, (gpointer)label);
351	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,	520	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
352	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 5);	521	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
353		522	GTK_FILL, GTK_FILL, 5, 5);
354	label = gtk_label_new(_("Comment:"));	523
355	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);	524	v1_artist_entry = gtk_entry_new_with_max_length(30);
356	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,	525	gtk_table_attach(GTK_TABLE(table), v1_artist_entry, 1, 5, 2, 3,
357	GTK_FILL, GTK_FILL, 5, 5);	526	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
358		527	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
359	comment_entry = gtk_entry_new_with_max_length(30);	528
360	gtk_table_attach(GTK_TABLE(table), comment_entry, 1, 4, 3, 4,	529	label = gtk_label_new("Album:");
361	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,	530	g_ptr_array_add(v1_labels_list, (gpointer)label);
362	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 5);	531	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
363		532	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
364	label = gtk_label_new(_("Year:"));	533	GTK_FILL, GTK_FILL, 5, 5);
365	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);	534
366	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5,	535	v1_album_entry = gtk_entry_new_with_max_length(30);
367	GTK_FILL, GTK_FILL, 5, 5);	536	gtk_table_attach(GTK_TABLE(table), v1_album_entry, 1, 5, 3, 4,
368		537	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
369	year_entry = gtk_entry_new_with_max_length(4);	538	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
370	gtk_widget_set_usize(year_entry, 40, -1);	539
371	gtk_table_attach(GTK_TABLE(table), year_entry, 1, 2, 4, 5,	540	label = gtk_label_new("Comment:");
372	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,	541	g_ptr_array_add(v1_labels_list, (gpointer)label);
373	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 5);	542	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
374		543	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5,
375	label = gtk_label_new(_("Track number:"));	544	GTK_FILL, GTK_FILL, 5, 5);
376	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);	545
377	gtk_table_attach(GTK_TABLE(table), label, 2, 3, 4, 5,	546	v1_comment_entry = gtk_entry_new_with_max_length(30);
378	GTK_FILL, GTK_FILL, 5, 5);	547	gtk_table_attach(GTK_TABLE(table), v1_comment_entry, 1, 5, 4, 5,
379		548	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
380	tracknum_entry = gtk_entry_new_with_max_length(3);	549	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
381	gtk_widget_set_usize(tracknum_entry, 40, -1);	550
382	gtk_table_attach(GTK_TABLE(table), tracknum_entry, 3, 4, 4, 5,	551	label = gtk_label_new("Year:");
383	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,	552	g_ptr_array_add(v1_labels_list, (gpointer)label);
384	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 5);	553	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
385		554	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6,
386	label = gtk_label_new(_("Genre:"));	555	GTK_FILL, GTK_FILL, 5, 5);
387	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);	556
388	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6,	557	v1_year_entry = gtk_entry_new_with_max_length(4);
389	GTK_FILL, GTK_FILL, 5, 5);	558	gtk_widget_set_usize(v1_year_entry, 45, -1);
390		559	gtk_table_attach(GTK_TABLE(table), v1_year_entry, 1, 2, 5, 6,
391	genre_combo = gtk_combo_new();	560	GTK_FILL, GTK_FILL, 0, 2);
392	gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(genre_combo)->entry),	561
393	FALSE);	562	label = gtk_label_new("Genre:");
		563	g_ptr_array_add(v1_labels_list, (gpointer)label);
		564	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
		565	gtk_table_attach(GTK_TABLE(table), label, 2, 3, 5, 6,
		566	GTK_FILL, GTK_FILL, 5, 5);
		567
		568	v1_genre_combo = gtk_combo_new();
		569	gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(v1_genre_combo)->entry),
		570	FALSE);
394	if (!genre_list)	571	if (!genre_list)
395	{	572	{
396	struct genre_item *item;	573	struct genre_item *item;
Lines 408-484 Link Here
408	genre_list = g_list_prepend(genre_list, item);	585	genre_list = g_list_prepend(genre_list, item);
409	genre_list = g_list_sort(genre_list, genre_comp_func);	586	genre_list = g_list_sort(genre_list, genre_comp_func);
410	}	587	}
411	genre_set_popdown(genre_combo, genre_list);	588	genre_set_popdown(v1_genre_combo, genre_list);
412	gtk_signal_connect(GTK_OBJECT(GTK_COMBO(genre_combo)->list),	589	gtk_signal_connect(GTK_OBJECT(GTK_COMBO(v1_genre_combo)->list),
413	"select-child", genre_selected, NULL);	590	"select-child", v1_genre_selected, NULL);
414		591
415	gtk_table_attach(GTK_TABLE(table), genre_combo, 1, 4, 5, 6,	592	gtk_table_attach(GTK_TABLE(table), v1_genre_combo, 3, 5, 5, 6,
416	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,	593	GTK_FILL \| GTK_SHRINK, GTK_FILL \|
417	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 5);	594	GTK_SHRINK, 0, 2);
418		595
419	bbox = gtk_hbutton_box_new();	596	bbox = gtk_hbutton_box_new();
420	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox),	597	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
421	GTK_BUTTONBOX_END);	598	gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 0);
422	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);	599	gtk_container_set_border_width(GTK_CONTAINER(bbox), 5);
423	gtk_box_pack_start(GTK_BOX(left_vbox), bbox, FALSE, FALSE, 0);	600	gtk_box_pack_start(GTK_BOX(id3v1_frame_vbox), bbox, FALSE, FALSE, 0);
424		601
425	save = gtk_button_new_with_label(_("Save"));	602	copy_from = gtk_button_new_with_label("ID3v1 to ID3v2");
426	gtk_signal_connect(GTK_OBJECT(save), "clicked", save_cb, NULL);	603	gtk_signal_connect(GTK_OBJECT(copy_from), "clicked", GTK_SIGNAL_FUNC(copy_v1_to_v2_cb), NULL);
427	GTK_WIDGET_SET_FLAGS(save, GTK_CAN_DEFAULT);	604	// remove the next line to thicken the button width
428	gtk_box_pack_start(GTK_BOX(bbox), save, TRUE, TRUE, 0);	605	GTK_WIDGET_SET_FLAGS(copy_from, GTK_CAN_DEFAULT);
429	gtk_widget_grab_default(save);	606	gtk_box_pack_start(GTK_BOX(bbox), copy_from, FALSE, TRUE, 0);
430		607
431	remove_id3 = gtk_button_new_with_label(_("Remove ID3"));	608
432	gtk_signal_connect(GTK_OBJECT(remove_id3), "clicked",	609	notebook = gtk_notebook_new ();
433	remove_id3_cb, NULL);	610	gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
434	GTK_WIDGET_SET_FLAGS(remove_id3, GTK_CAN_DEFAULT);	611
435	gtk_box_pack_start(GTK_BOX(bbox), remove_id3, TRUE, TRUE, 0);	612	label = gtk_label_new ("ID3v1");
436		613	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), id3v1_vbox, label);
437	cancel = gtk_button_new_with_label(_("Cancel"));	614
438	gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked",	615
439	gtk_widget_destroy, GTK_OBJECT(window));	616	////////////////////////////////////////////////////////////////////////////////////////////////////
440	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);	617	////////////////////////////////////////////////////////////////////////////////////////////////////
441	gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);	618
442		619	id3v2_vbox = gtk_vbox_new(FALSE, 0);
443	mpeg_frame = gtk_frame_new(_("MPEG Info:"));	620
444	gtk_box_pack_start(GTK_BOX(hbox), mpeg_frame, FALSE, FALSE, 0);	621	id3v2_frame = gtk_frame_new("ID3v2 Information");
445		622	gtk_box_pack_start(GTK_BOX(id3v2_vbox), id3v2_frame, FALSE, FALSE, 0);
446	mpeg_box = gtk_vbox_new(FALSE, 5);	623
447	gtk_container_add(GTK_CONTAINER(mpeg_frame), mpeg_box);	624	id3v2_frame_vbox = gtk_vbox_new(FALSE, 0);
448	gtk_container_set_border_width(GTK_CONTAINER(mpeg_box), 10);	625	gtk_container_add(GTK_CONTAINER(id3v2_frame), id3v2_frame_vbox);
449	gtk_box_set_spacing(GTK_BOX(mpeg_box), 0);	626
450		627	table = gtk_table_new(6, 6, FALSE);
451	mpeg_level = gtk_label_new("");	628	gtk_container_set_border_width(GTK_CONTAINER(table), 5);
452	gtk_widget_set_usize(mpeg_level, 120, -2);	629	gtk_widget_set_usize(GTK_WIDGET(table), 400, -1);
453	gtk_misc_set_alignment(GTK_MISC(mpeg_level), 0, 0);	630	//gtk_container_add(GTK_CONTAINER(id3v2_frame), table);
454	gtk_box_pack_start(GTK_BOX(mpeg_box), mpeg_level, FALSE, FALSE, 0);	631	gtk_box_pack_start(GTK_BOX(id3v2_frame_vbox), table, FALSE, FALSE, 0);
455		632
456	mpeg_bitrate = gtk_label_new("");	633	v2_checkbox = gtk_check_button_new_with_label ("Disable ID3v2 Tag");
457	gtk_misc_set_alignment(GTK_MISC(mpeg_bitrate), 0, 0);	634	gtk_signal_connect(GTK_OBJECT(v2_checkbox), "toggled", GTK_SIGNAL_FUNC(v2_toggle_cb), NULL);
458	gtk_label_set_justify(GTK_LABEL(mpeg_bitrate),	635	gtk_table_attach(GTK_TABLE(table), v2_checkbox, 1, 3, 0, 1,
459	GTK_JUSTIFY_LEFT);	636	GTK_FILL, GTK_FILL, 0, 2);
460	gtk_box_pack_start(GTK_BOX(mpeg_box),	637
461	mpeg_bitrate, FALSE, FALSE, 0);	638	label = gtk_label_new("Track number:");
462		639	g_ptr_array_add(v2_labels_list, (gpointer)label);
463	mpeg_samplerate = gtk_label_new("");	640	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
464	gtk_misc_set_alignment(GTK_MISC(mpeg_samplerate), 0, 0);	641	gtk_table_attach(GTK_TABLE(table), label, 3, 4, 0, 1,
465	gtk_box_pack_start(GTK_BOX(mpeg_box), mpeg_samplerate,	642	GTK_FILL, GTK_FILL, 5,5);
466	FALSE, FALSE, 0);	643
467		644	v2_tracknum_entry = gtk_entry_new_with_max_length(3);
468	mpeg_flags = gtk_label_new("");	645	gtk_widget_set_usize(v2_tracknum_entry, 20, -1);
469	gtk_misc_set_alignment(GTK_MISC(mpeg_flags), 0, 0);	646	gtk_table_attach(GTK_TABLE(table), v2_tracknum_entry, 4, 5, 0, 1,
470	gtk_label_set_justify(GTK_LABEL(mpeg_flags), GTK_JUSTIFY_LEFT);	647	GTK_FILL, GTK_FILL, 0, 2);
471	gtk_box_pack_start(GTK_BOX(mpeg_box), mpeg_flags,	648
472	FALSE, FALSE, 0);	649	label = gtk_label_new("Title:");
473		650	g_ptr_array_add(v2_labels_list, (gpointer)label);
474	mpeg_fileinfo = gtk_label_new("");	651	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
475	gtk_misc_set_alignment(GTK_MISC(mpeg_fileinfo), 0, 0);	652	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
476	gtk_label_set_justify(GTK_LABEL(mpeg_fileinfo),	653	GTK_FILL, GTK_FILL, 5, 5);
477	GTK_JUSTIFY_LEFT);	654
478	gtk_box_pack_start(GTK_BOX(mpeg_box), mpeg_fileinfo,	655	v2_title_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
479	FALSE, FALSE, 0);	656	gtk_table_attach(GTK_TABLE(table), v2_title_entry, 1, 5, 1, 2,
		657	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
		658	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
		659
		660	label = gtk_label_new("Artist:");
		661	g_ptr_array_add(v2_labels_list, (gpointer)label);
		662	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
		663	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
		664	GTK_FILL, GTK_FILL, 5, 5);
		665
		666	v2_artist_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
		667	gtk_table_attach(GTK_TABLE(table), v2_artist_entry, 1, 5, 2, 3,
		668	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
		669	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
		670
		671	label = gtk_label_new("Album:");
		672	g_ptr_array_add(v2_labels_list, (gpointer)label);
		673	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
		674	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
		675	GTK_FILL, GTK_FILL, 5, 5);
		676
		677	v2_album_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
		678	gtk_table_attach(GTK_TABLE(table), v2_album_entry, 1, 5, 3, 4,
		679	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
		680	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
		681
		682	label = gtk_label_new("Comment:");
		683	g_ptr_array_add(v2_labels_list, (gpointer)label);
		684	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
		685	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5,
		686	GTK_FILL, GTK_FILL, 5, 5);
		687
		688	v2_comment_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
		689	gtk_table_attach(GTK_TABLE(table), v2_comment_entry, 1, 5, 4, 5,
		690	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
		691	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
		692
		693	label = gtk_label_new("Year:");
		694	g_ptr_array_add(v2_labels_list, (gpointer)label);
		695	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
		696	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6,
		697	GTK_FILL, GTK_FILL, 5, 5);
		698
		699	v2_year_entry = gtk_entry_new_with_max_length(4);
		700	gtk_widget_set_usize(v2_year_entry, 45, -1);
		701	gtk_table_attach(GTK_TABLE(table), v2_year_entry, 1, 2, 5, 6,
		702	GTK_FILL, GTK_FILL, 0, 2);
		703
		704	label = gtk_label_new("Genre:");
		705	g_ptr_array_add(v2_labels_list, (gpointer)label);
		706	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
		707	gtk_table_attach(GTK_TABLE(table), label, 2, 3, 5, 6,
		708	GTK_FILL, GTK_FILL, 5, 5);
		709
		710	v2_genre_combo = gtk_combo_new();
		711	gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(v2_genre_combo)->entry), FALSE);
		712	genre_set_popdown(v2_genre_combo, genre_list);
		713	gtk_signal_connect(GTK_OBJECT(GTK_COMBO(v2_genre_combo)->list),
		714	"select-child", v2_genre_selected, NULL);
		715
		716	gtk_table_attach(GTK_TABLE(table), v2_genre_combo, 3, 5, 5, 6,
		717	GTK_FILL \| GTK_SHRINK, GTK_FILL \|
		718	GTK_SHRINK, 0, 2);
		719
		720	label = gtk_label_new("Composer:");
721	g_ptr_array_add(v2_labels_list, (gpointer)label);
722	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
723	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 6, 7,
724	GTK_FILL, GTK_FILL, 5, 5);
725
726	v2_composer_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
727	gtk_table_attach(GTK_TABLE(table), v2_composer_entry, 1, 5, 6, 7,
728	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
729	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
730
731	label = gtk_label_new("Orig. Artist:");
732	g_ptr_array_add(v2_labels_list, (gpointer)label);
733	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
734	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 7, 8,
735	GTK_FILL, GTK_FILL, 5, 5);
736
737	v2_orig_artist_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
738	gtk_table_attach(GTK_TABLE(table), v2_orig_artist_entry, 1, 5, 7, 8,
739	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
740	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
741
742	label = gtk_label_new("URL:");
743	g_ptr_array_add(v2_labels_list, (gpointer)label);
744	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
745	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 8, 9,
746	GTK_FILL, GTK_FILL, 5, 5);
747
748	v2_url_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
749	gtk_table_attach(GTK_TABLE(table), v2_url_entry, 1, 5, 8, 9,
750	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
751	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
752	label = gtk_label_new("Encoded By:");
753	g_ptr_array_add(v2_labels_list, (gpointer)label);
754	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
755	gtk_table_attach(GTK_TABLE(table), label, 0, 1, 9, 10,
756	GTK_FILL, GTK_FILL, 5, 5);
757
758	v2_encoded_by_entry = gtk_entry_new_with_max_length(MAX_ENTRY_LEN2);
759	gtk_table_attach(GTK_TABLE(table), v2_encoded_by_entry, 1, 5, 9, 10,
760	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
761	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK, 0, 2);
762
763	bbox = gtk_hbutton_box_new();
764	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
765	gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 0);
766	gtk_container_set_border_width(GTK_CONTAINER(bbox), 5);
767	gtk_box_pack_start(GTK_BOX(id3v2_frame_vbox), bbox, FALSE, FALSE, 0);
768
769	copy_to = gtk_button_new_with_label("ID3v2 to ID3v1");
770	gtk_signal_connect(GTK_OBJECT(copy_to), "clicked", GTK_SIGNAL_FUNC(copy_v2_to_v1_cb), NULL);
771	// remove the next line to thicken the button width
772	GTK_WIDGET_SET_FLAGS(copy_to, GTK_CAN_DEFAULT);
773	gtk_box_pack_start(GTK_BOX(bbox), copy_to, FALSE, TRUE, 0);
774
775	label = gtk_label_new ("ID3v2");
776	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), id3v2_vbox, label);
777
778
779	////////////////////////////////////////////////////////////////////////////////////////////////////
780	////////////////////////////////////////////////////////////////////////////////////////////////////
781
782	mpeg_frame = gtk_frame_new("MPEG Information");
783	mpeg_hbox = gtk_hbox_new(FALSE,50);
784	gtk_container_add(GTK_CONTAINER(mpeg_frame), mpeg_hbox);
785
786	mpeg_lvbox = gtk_vbox_new(FALSE, 5);
787	gtk_container_set_border_width(GTK_CONTAINER(mpeg_lvbox), 10);
788	gtk_box_pack_start(GTK_BOX(mpeg_hbox), mpeg_lvbox, FALSE, FALSE, 0);
789
790	//gtk_container_set_border_width(GTK_CONTAINER(table), 5);
791	//gtk_widget_set_usize(GTK_WIDGET(table), 325, -1);
792	//gtk_container_add(GTK_CONTAINER(mpeg_frame), table);
793
794	mpeg_box = gtk_vbox_new(FALSE, 5);
795	gtk_box_pack_start(GTK_BOX(mpeg_hbox), mpeg_box, FALSE, FALSE, 0);
796	gtk_container_set_border_width(GTK_CONTAINER(mpeg_box), 10);
797	gtk_box_set_spacing(GTK_BOX(mpeg_box), 0);
798
799	mpeg_level = gtk_label_new("");
800	//gtk_widget_set_usize(mpeg_level, 120, -2);
801	gtk_label_set_justify (GTK_LABEL(mpeg_level), GTK_JUSTIFY_LEFT);
802	gtk_misc_set_alignment(GTK_MISC(mpeg_level), 0, 0.5);
803	gtk_box_pack_start(GTK_BOX(mpeg_lvbox), mpeg_level, FALSE, FALSE, 0);
804
805	mpeg_samplerate = gtk_label_new("");
806	gtk_label_set_justify (GTK_LABEL(mpeg_samplerate), GTK_JUSTIFY_LEFT);
807	gtk_misc_set_alignment(GTK_MISC(mpeg_samplerate), 0, 0.5);
808	gtk_box_pack_start(GTK_BOX(mpeg_lvbox), mpeg_samplerate, FALSE, FALSE, 0);
809
810	mpeg_fileinfo = gtk_label_new("");
811	gtk_label_set_justify (GTK_LABEL(mpeg_fileinfo), GTK_JUSTIFY_LEFT);
812	gtk_misc_set_alignment(GTK_MISC(mpeg_fileinfo), 0, 0.5);
813	gtk_box_pack_start(GTK_BOX(mpeg_lvbox), mpeg_fileinfo, FALSE, FALSE, 0);
814
815	mpeg_rvbox = gtk_vbox_new(FALSE, 5);
816	gtk_box_pack_start(GTK_BOX(mpeg_hbox), mpeg_rvbox, FALSE, FALSE, 0);
817	gtk_container_set_border_width(GTK_CONTAINER(mpeg_rvbox), 10);
818
819	mpeg_bitrate = gtk_label_new("");
820	gtk_label_set_justify (GTK_LABEL(mpeg_bitrate), GTK_JUSTIFY_LEFT);
821	gtk_misc_set_alignment(GTK_MISC(mpeg_bitrate), 0, 0.5);
822	gtk_box_pack_start(GTK_BOX(mpeg_rvbox), mpeg_bitrate, FALSE, FALSE, 0);
823
824	mpeg_flags = gtk_label_new("");
825	gtk_label_set_justify (GTK_LABEL(mpeg_flags), GTK_JUSTIFY_LEFT);
826	gtk_misc_set_alignment(GTK_MISC(mpeg_flags), 0, 0.5);
827	gtk_box_pack_start(GTK_BOX(mpeg_rvbox), mpeg_flags, FALSE, FALSE, 0);
828
829	label = gtk_label_new ("MPEG");
830	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), mpeg_frame, label);
831
832	//////////////////////////////////////////////////////////////////
833	//////////////////////////////////////////////////////////////////
834
835	// add notebook to window vbox
836	gtk_box_pack_start(GTK_BOX(window_vbox), notebook, FALSE, FALSE, 0);
837
838	// add button box to window vbox
839	bbox = gtk_hbutton_box_new();
840	gtk_box_pack_start(GTK_BOX(window_vbox), bbox, FALSE, FALSE, 0);
841
842	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
843	gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 5);
844	//gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
845
846	save = gtk_button_new_with_label("Save");
847	gtk_signal_connect(GTK_OBJECT(save), "clicked", GTK_SIGNAL_FUNC(save_cb), NULL);
848	//GTK_WIDGET_SET_FLAGS(save, GTK_CAN_DEFAULT);
849	gtk_box_pack_start(GTK_BOX(bbox), save, TRUE, TRUE, 5);
850	//gtk_widget_grab_default(save);
851
852	close = gtk_button_new_with_label("Close");
853	gtk_signal_connect_object(GTK_OBJECT(close), "clicked",
854	GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window));
855	//GTK_WIDGET_SET_FLAGS(close, GTK_CAN_DEFAULT);
856	gtk_box_pack_start(GTK_BOX(bbox), close, TRUE, TRUE, 5);
480		857
481	gtk_widget_show_all(window);	858	gtk_container_add(GTK_CONTAINER(window), window_vbox);
		859	gtk_widget_show_all(window);
482	}	860	}
483		861
484	if (current_filename)	862	if (current_filename)
Lines 495-523 Link Here
495	title = g_strdup(g_basename(filename));	873	title = g_strdup(g_basename(filename));
496	if ((tmp = strrchr(title, '.')) != NULL)	874	if ((tmp = strrchr(title, '.')) != NULL)
497	*tmp = '\0';	875	*tmp = '\0';
498	gtk_entry_set_text(GTK_ENTRY(title_entry), title);	876	gtk_entry_set_text(GTK_ENTRY(v1_title_entry), title);
		877	gtk_entry_set_text(GTK_ENTRY(v2_title_entry), title);
499	g_free(title);	878	g_free(title);
500		879
501	gtk_entry_set_text(GTK_ENTRY(artist_entry), "");	880	gtk_entry_set_text(GTK_ENTRY(v1_artist_entry), "");
502	gtk_entry_set_text(GTK_ENTRY(album_entry), "");	881	gtk_entry_set_text(GTK_ENTRY(v1_album_entry), "");
503	gtk_entry_set_text(GTK_ENTRY(year_entry), "");	882	gtk_entry_set_text(GTK_ENTRY(v1_year_entry), "");
504	gtk_entry_set_text(GTK_ENTRY(tracknum_entry), "");	883	gtk_entry_set_text(GTK_ENTRY(v1_tracknum_entry), "");
505	gtk_entry_set_text(GTK_ENTRY(comment_entry), "");	884	gtk_entry_set_text(GTK_ENTRY(v1_comment_entry), "");
506	gtk_list_select_item(GTK_LIST(GTK_COMBO(genre_combo)->list),	885	gtk_list_select_item(GTK_LIST(GTK_COMBO(v1_genre_combo)->list),
		886	genre_find_index(genre_list, 0xff));
		887
		888	gtk_entry_set_text(GTK_ENTRY(v2_artist_entry), "");
		889	gtk_entry_set_text(GTK_ENTRY(v2_album_entry), "");
		890	gtk_entry_set_text(GTK_ENTRY(v2_year_entry), "");
		891	gtk_entry_set_text(GTK_ENTRY(v2_tracknum_entry), "");
		892	gtk_entry_set_text(GTK_ENTRY(v2_comment_entry), "");
		893	gtk_entry_set_text(GTK_ENTRY(v2_composer_entry), "");
		894	gtk_entry_set_text(GTK_ENTRY(v2_orig_artist_entry), "");
		895	gtk_entry_set_text(GTK_ENTRY(v2_url_entry), "");
		896	gtk_entry_set_text(GTK_ENTRY(v2_encoded_by_entry), "");
		897	gtk_list_select_item(GTK_LIST(GTK_COMBO(v2_genre_combo)->list),
507	genre_find_index(genre_list, 0xff));	898	genre_find_index(genre_list, 0xff));
		899
508	gtk_label_set_text(GTK_LABEL(mpeg_level), "MPEG ?, layer ?");	900	gtk_label_set_text(GTK_LABEL(mpeg_level), "MPEG ?, layer ?");
509	gtk_label_set_text(GTK_LABEL(mpeg_bitrate), "");	901	gtk_label_set_text(GTK_LABEL(mpeg_bitrate), "");
510	gtk_label_set_text(GTK_LABEL(mpeg_samplerate), "");	902	gtk_label_set_text(GTK_LABEL(mpeg_samplerate), "");
511	gtk_label_set_text(GTK_LABEL(mpeg_flags), "");	903	gtk_label_set_text(GTK_LABEL(mpeg_flags), "");
512	gtk_label_set_text(GTK_LABEL(mpeg_fileinfo), "");	904	gtk_label_set_text(GTK_LABEL(mpeg_fileinfo), "");
513
514	if (!strncasecmp(filename, "http://", 7))	905	if (!strncasecmp(filename, "http://", 7))
515	{	906	{
516	file_info_http(filename);	907	file_info_http(filename);
517	return;	908	return;
518	}	909	}
519		910
520	gtk_widget_set_sensitive(id3_frame, TRUE);	911	gtk_widget_set_sensitive(id3v1_frame, TRUE);
		912	gtk_widget_set_sensitive(id3v2_frame, TRUE);
521		913
522	if ((fh = fopen(current_filename, "rb")) != NULL)	914	if ((fh = fopen(current_filename, "rb")) != NULL)
523	{	915	{
Lines 525-564 Link Here
525	unsigned char tmp[4];	917	unsigned char tmp[4];
526	struct frame frm;	918	struct frame frm;
527	gboolean id3_found = FALSE;	919	gboolean id3_found = FALSE;
		920	char *temp = NULL;
		921	struct id3_tag *id3 = NULL;
528		922
529	fseek(fh, -sizeof (tag), SEEK_END);	923	/*
530	if (fread(&tag, 1, sizeof (tag), fh) == sizeof (tag))	924	* Try reading ID3v2 tag.
		925	*/
		926	if (!mpg123_cfg.disable_id3v2)
531	{	927	{
532	if (!strncmp(tag.tag, "TAG", 3))	928	fseek(fh, 0, SEEK_SET);
		929	id3 = id3_open_fp(fh, 0);
		930	if (id3)
533	{	931	{
534	id3_found = TRUE;	932	mpg123_get_id3v2(id3, &id3v2tag);
535	set_entry_tag(GTK_ENTRY(title_entry),	933	set_entry_tag(GTK_ENTRY(v2_title_entry),
536	tag.title, 30);	934	id3v2tag.title, 128);
537	set_entry_tag(GTK_ENTRY(artist_entry),	935	set_entry_tag(GTK_ENTRY(v2_artist_entry),
538	tag.artist, 30);	936	id3v2tag.artist, 128);
539	set_entry_tag(GTK_ENTRY(album_entry),	937	set_entry_tag(GTK_ENTRY(v2_album_entry),
540	tag.album, 30);	938	id3v2tag.album, 128);
541	set_entry_tag(GTK_ENTRY(year_entry),	939	set_entry_tag(GTK_ENTRY(v2_comment_entry),
542	tag.year, 4);	940	id3v2tag.comment, 256);
543	/* Check for v1.1 tags */	941	set_entry_tag(GTK_ENTRY(v2_composer_entry),
544	if (tag.u.v1_1.__zero == 0)	942	id3v2tag.composer, MAX_ENTRY_LEN2);
545	{	943	set_entry_tag(GTK_ENTRY(v2_orig_artist_entry),
546	char *temp = g_strdup_printf("%d", tag.u.v1_1.track_number);	944	id3v2tag.orig_artist, MAX_ENTRY_LEN2);
547	set_entry_tag(GTK_ENTRY(comment_entry),	945	set_entry_tag(GTK_ENTRY(v2_url_entry),
548	tag.u.v1_1.comment, 28);	946	id3v2tag.url, MAX_ENTRY_LEN2);
549	gtk_entry_set_text(GTK_ENTRY(tracknum_entry), temp);	947	set_entry_tag(GTK_ENTRY(v2_encoded_by_entry),
550	g_free(temp);	948	id3v2tag.encoded_by, MAX_ENTRY_LEN2);
551	}
552	else
553	{
554	set_entry_tag(GTK_ENTRY(comment_entry),
555	tag.u.v1_0.comment, 30);
556	gtk_entry_set_text(GTK_ENTRY(tracknum_entry), "");
557	}
558		949
559	gtk_list_select_item(GTK_LIST(GTK_COMBO(genre_combo)->list), genre_find_index(genre_list, tag.genre));	950	temp = g_strdup_printf("%d", id3v2tag.track_number);
		951	gtk_entry_set_text(GTK_ENTRY(v2_tracknum_entry), temp);
		952	g_free(temp);
		953
		954	temp = g_strdup_printf("%d", id3v2tag.year);
		955	gtk_entry_set_text(GTK_ENTRY(v2_year_entry), temp);
		956	g_free(temp);
		957
		958	printf("Loading genre: %s", id3v2tag.genre);
		959	gtk_list_select_item(GTK_LIST(GTK_COMBO(v2_genre_combo)->list), genre_find_index_str(genre_list, id3v2tag.genre));
		960	id3_close(id3);
560	}	961	}
		962	else
		963	{
		964	// Grey out the id3v2 tab
		965	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(v2_checkbox), TRUE);
		966	}
		967	}
		968
		969	/*
		970	* Try reading ID3v1 tag.
		971	*/
		972	fseek(fh, -sizeof (id3v1tag), SEEK_END);
		973	if ( (fread(&id3v1tag, 1, sizeof (id3v1tag), fh) == sizeof (id3v1tag)) &&
		974	!strncmp(id3v1tag.tag, "TAG", 3))
		975	{
		976	id3_found = TRUE;
		977	set_entry_tag(GTK_ENTRY(v1_title_entry),
		978	id3v1tag.title, 30);
		979	set_entry_tag(GTK_ENTRY(v1_artist_entry),
		980	id3v1tag.artist, 30);
		981	set_entry_tag(GTK_ENTRY(v1_album_entry),
		982	id3v1tag.album, 30);
		983	set_entry_tag(GTK_ENTRY(v1_year_entry),
		984	id3v1tag.year, 4);
		985	/* Check for v1.1 tags */
		986	if (id3v1tag.u.v1_1.__zero == 0)
		987	{
		988	char *temp = g_strdup_printf("%d", id3v1tag.u.v1_1.track_number);
		989	set_entry_tag(GTK_ENTRY(v1_comment_entry),
		990	id3v1tag.u.v1_1.comment, 28);
		991	gtk_entry_set_text(GTK_ENTRY(v1_tracknum_entry), temp);
		992	g_free(temp);
		993	}
		994	else
		995	{
		996	set_entry_tag(GTK_ENTRY(v1_comment_entry),
		997	id3v1tag.u.v1_0.comment, 30);
		998	gtk_entry_set_text(GTK_ENTRY(v1_tracknum_entry), "");
		999	}
		1000
		1001	gtk_list_select_item(GTK_LIST(GTK_COMBO(v1_genre_combo)->list), genre_find_index(genre_list, id3v1tag.genre));
561	}	1002	}
		1003	else
		1004	{
		1005	// Grey out id3v1 tab
		1006	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(v1_checkbox), TRUE);
		1007	}
		1008
562	rewind(fh);	1009	rewind(fh);
563	if (fread(tmp, 1, 4, fh) != 4)	1010	if (fread(tmp, 1, 4, fh) != 4)
564	{	1011	{





char *id3_utf16_to_ascii(void *utf16)
{
    char ascii[256];
    char *uc = (char *) utf16 + 2;
    int i;

    for (i = 0; *uc != 0 && i < sizeof(ascii); i++, uc += 2)
        ascii[i] = *uc;

    ascii[i] = 0;
    return g_strdup(ascii);
}



 */
gint8 id3_get_encoding(struct id3_frame *frame)
{
    /* Type check */
    if (!id3_frame_is_text(frame) &&
            frame->fr_desc->fd_id != ID3_WXXX &&
            frame->fr_desc->fd_id != ID3_IPLS &&
            frame->fr_desc->fd_id != ID3_USLT &&
            frame->fr_desc->fd_id != ID3_SYLT &&
            frame->fr_desc->fd_id != ID3_COMM &&
            frame->fr_desc->fd_id != ID3_APIC &&
            frame->fr_desc->fd_id != ID3_GEOB &&
            frame->fr_desc->fd_id != ID3_USER &&
            frame->fr_desc->fd_id != ID3_OWNE &&
            frame->fr_desc->fd_id != ID3_COMR)
        return -1;

    /* Check if frame is compressed */
    if (id3_decompress_frame(frame) == -1)
        return -1;

    return *(gint8 *) frame->fr_data;
}



{
    /* Type check */
    if ( frame->fr_desc->fd_idstr[0] != 'T' &&
            frame->fr_desc->fd_id != ID3_WXXX &&
            frame->fr_desc->fd_id != ID3_IPLS &&
            frame->fr_desc->fd_id != ID3_USLT &&
            frame->fr_desc->fd_id != ID3_SYLT &&
            frame->fr_desc->fd_id != ID3_COMM &&
            frame->fr_desc->fd_id != ID3_APIC &&
            frame->fr_desc->fd_id != ID3_GEOB &&
            frame->fr_desc->fd_id != ID3_USER &&
            frame->fr_desc->fd_id != ID3_OWNE &&
            frame->fr_desc->fd_id != ID3_COMR )
        return -1;

    /* Check if frame is compressed */
    if (id3_decompress_frame(frame) == -1)
        return -1;

    /* Changing the encoding of frames is not supported yet */
    if ( *(gint8 *) frame->fr_data != encoding )
        return -1;

    /* Set encoding */
    *(gint8 *) frame->fr_data = encoding;

{
    /* Type check */
    if ( frame->fr_desc->fd_idstr[0] != 'T' )
        return NULL;

    /* Check if frame is compressed */
    if (id3_decompress_frame(frame) == -1)
        return NULL;

    if ( frame->fr_desc->fd_id == ID3_TXXX ) {
        /*
         * This is a user defined text frame.  Skip the description.
         */
        switch ( *(guint8 *) frame->fr_data ) {
            case ID3_ENCODING_ISO_8859_1:
                {
                    char *text = (char *) frame->fr_data + 1;

                    while ( *text != 0 )
                        text++;

                    return g_strdup(++text);
                }
            case ID3_ENCODING_UTF16:
                {
                    char *text16 = (char *) frame->fr_data + 1;

                    while (*text16 != 0 || *(text16 + 1) != 0)
                        text16 += 2;

                    return id3_utf16_to_ascii(text16 + 2);
                }
            default:
                return NULL;
        }
    }

    if (*(guint8 *) frame->fr_data == ID3_ENCODING_ISO_8859_1)
        return g_strdup((char *) frame->fr_data + 1);
    else
        return id3_utf16_to_ascii(((char *) frame->fr_data + 1));
}



{
    /* Type check */
    if ( frame->fr_desc->fd_idstr[0] != 'T' )
        return NULL;

    /* If predefined text frame, return description. */
    if ( frame->fr_desc->fd_id != ID3_TXXX )
        return frame->fr_desc->fd_description;

    /* Check if frame is compressed */
    if (id3_decompress_frame(frame) == -1)
        return NULL;

    if (*(guint8 *) frame->fr_data == ID3_ENCODING_ISO_8859_1)
        return g_strdup((char *) frame->fr_data + 1);
    else
        return id3_utf16_to_ascii((char *) frame->fr_data + 1);
}




    /* Check if frame is compressed */
    if (id3_decompress_frame(frame) == -1)
        return -1;

    /*
     * Generate integer according to encoding.
     */
    switch ( *(guint8 *) frame->fr_data ) {
        case ID3_ENCODING_ISO_8859_1:
            {
                char *text = ((char *) frame->fr_data) + 1;

                while ( *text >= '0' && *text <= '9' ) {
                    number *= 10;
                    number += *text - '0';
                    text++;
                }

                return number;
            }
        case ID3_ENCODING_UTF16:
            {
                char *text = ((char *) frame->fr_data) + 3;

/*      if (*(gint16 *) frame->fr_data == 0xfeff) */
/*          text++; */

                while ( *text >= '0' && *text <= '9' ) {
                    number *= 10;
                    number += *text - '0';
                    text++;
                }

                return number;
            }
    case ID3_ENCODING_UTF16:
    {
	char *text = ((char *) frame->fr_data) + 3;

/*  	if (*(gint16 *) frame->fr_data == 0xfeff) */
/*  	    text++; */

	while ( *text >= '0' && *text <= '9' ) {
	    number *= 10;
	    number += *text - '0';
	    text++;
	}

        default:
            return -1;

    default:
	return -1;
    }
}


{
    /* Type check */
    if ( frame->fr_desc->fd_idstr[0] != 'T' )
        return -1;

    /*
     * Release memory occupied by previous data.

}




char* id3_get_comm(struct id3_frame *frame)
{

    /* Type check */
    if ( frame->fr_desc->fd_id != ID3_COMM )
        return NULL;

    /* Check if frame is compressed */
    if (id3_decompress_frame(frame) == -1)
        return NULL;

    /*
     * <Header for 'Comment', ID: "COMM">
     * Text encoding          $xx
     * Language               $xx xx xx
     * Short content descrip. <text string according to encoding> $00 (00)
     * The actual text        <full text string according to encoding>
     *
     * Skip language and short description.
     */
    switch ( *(guint8 *) frame->fr_data ) {
        case ID3_ENCODING_ISO_8859_1:
            {
                char *text = (char *) frame->fr_data + 4;

                while ( *text != 0 )
                    text++;
                
                return g_strdup(++text);
            }
        case ID3_ENCODING_UTF16:
            {
                char *text16 = (char *) frame->fr_data + 4;

                while (*text16 != 0 || *(text16 + 1) != 0)
                    text16 += 2;

                return id3_utf16_to_ascii(text16 + 2);
            }
        default:
            return NULL;
    }

    if (*(guint8 *) frame->fr_data == ID3_ENCODING_ISO_8859_1)
        return g_strdup((char *) frame->fr_data + 1);
    else
        return id3_utf16_to_ascii(((char *) frame->fr_data + 1));
}


/*
 * Function id3_set_text_number (frame, number)
 *


    /* Type check */
    if ( frame->fr_desc->fd_idstr[0] != 'T' )
        return -1;

    /*
     * Release memory occupied by previous data.
     */
    id3_frame_clear_data(frame);

    /*
     * Create a string with a reversed number.
     */
    pos = 0;
    while ( number > 0 && pos < 64 ) {
        buf[pos++] = (number % 10) + '0';
        number /= 10;
    }
    if ( pos == 64 )
        return -1;
    if ( pos == 0 )
        buf[pos++] = '0';

    /*
     * Allocate memory for new data.

    *(gint8 *) frame->fr_raw_data = ID3_ENCODING_ISO_8859_1;
    text = (char *) frame->fr_raw_data + 1;
    while ( --pos >= 0 ) 
        *text++ = buf[pos];
    *text = '\0';

    frame->fr_altered = 1;


gboolean id3_frame_is_text(struct id3_frame *frame)
{
    if (frame && frame->fr_desc &&
            (frame->fr_desc->fd_idstr[0] == 'T' ||
             frame->fr_desc->fd_idstr[0] == 'W' ))
        return TRUE;
    return FALSE;
}

Lines 351-356 Link Here

(-)xmms-1.2.10.orig/Input/mpg123/id3.h (+1 lines)
351	int id3_set_text(struct id3_frame , char );	351	int id3_set_text(struct id3_frame , char );
352	int id3_set_text_number(struct id3_frame *, int);	352	int id3_set_text_number(struct id3_frame *, int);
353	gboolean id3_frame_is_text(struct id3_frame *frame);	353	gboolean id3_frame_is_text(struct id3_frame *frame);
		354	char* id3_get_comm(struct id3_frame *frame);
354		355
355	/* From id3_frame_content.c */	356	/* From id3_frame_content.c */
356	char id3_get_content(struct id3_frame );	357	char id3_get_content(struct id3_frame );




/* the id3v2.3 library.
 * (c)2002 by Samuel Abels (sam@manicsadness.com)
 * This project's homepage is: http://software.manicsadness.com/cantus
 *
 * This library is designed for easyest possible access to id3 V2 tags.
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef DLL_H
#define DLL_H
typedef struct DLL_s
{
	void *prev;
	void *data;
	void *next;
} DLL;
#endif

#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif

#ifndef id3Tag_def
#define id3Tag_def

typedef struct id3Tag_s
{
	char title[1024];
	char artist[1024];
	char album[1024];
	char year[5];
	char comment[1024];
	char track[3];
	char genre[512];
    char composer[1024];
    char url[1024];
    char orig_artist[1024];
    char enc_by[1024];
	unsigned int size;
	short int has_footer;
} id3Tag;

typedef struct id3v2Tag_s
{
// header
	int tag_size;
	short int unsync;
	short int has_extheader;
	short int is_experimental;
//extheader
	int extheader_size;
	int padding_size;
	short int crc_data_present;
	char crc_data[4];
// frames
	DLL *frames;
} id3v2Tag;

typedef struct id3v2Frame_s
{
	unsigned char id[4];
	int datasize;
	short int tagalter;
	short int filealter;
	short int readonly;
	short int compression;
	short int encryption;
	short int grouping;
	char *data;
} id3v2Frame;

#endif

/* the id3v2.3 library.
 * (c)2002 by Samuel Abels (sam@manicsadness.com)
 * This project's homepage is: http://software.manicsadness.com/cantus
 *
 * This library is designed for easyest possible access to id3 V2 tags.
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "charset.h"



/***************************************************************************************
 * BELOW FOLLOW THE STATICS
 ***************************************************************************************/
// Return the last item of an doubly linked list
static DLL *
dll_last (DLL *list)
{
	if( list == NULL )
		return (NULL);
	
	while ( list->next != NULL )
		list = list->next;
	
	return (list);
}

// Append an item to the doubly linked list
static DLL *
dll_append (DLL *list, void *data)
{
	DLL *item = malloc (sizeof(DLL));
	DLL *lastitem = dll_last(list);
	
	item->data = data;
	item->next = NULL;
	
	if ( lastitem == NULL )
	{
		item->prev = NULL;
		return (item);
	}
	else
	{
		item->prev = lastitem;
		lastitem->next = item;
	}

	return list;
}
  
static DLL *
dll_remove (DLL *list, void *data)
{
	DLL *item = list;
	
	while ( item )
	{
		if ( item->data == data )
		{
			if ( item->prev == NULL 
				&& item->next == NULL )
			{
// No other items there? Then return a zero pointer.
				free (item);
				return (NULL);
			}
			if ( item->prev == NULL )
			{
// remove the first item of the list here...
				list = item->next;
				list->prev = NULL;
				free (item);
				
				break;
			}
			if ( item->next == NULL )
			{
// ...remove the last item of the list here...
				((DLL*)(item->prev))->next = NULL;
				free (item);
				
				break;
			}
// ...or other items here
			((DLL*)(item->prev))->next = item->next;
			((DLL*)(item->next))->prev = item->prev;
			free (item);
			
			break;
		}
		item = item->next;
	}
	
	return list;
}

// Free a doubly linked list
static DLL *
dll_free (DLL *list)
{
	DLL *item = list;
	DLL *current = NULL;
	
	while (item)
	{
		current = item;
		item = item->next;
		
		free (current);
	}
	
	return NULL;
}

/*
 * Converts all occurences of a CR/LF to LF
 */
static void
crlf2cr (char *source)
{
	char *psource = source;
	char destination[2048];

	if(source != NULL)
	{
		memset (destination, 0, 2048);
		for (psource = source; *psource != '\0'; psource++)
		{
			if(*psource == 13
				&& *(psource+1) == 10 )
			{
				psource++;
			}
			destination[strlen(destination)] = *psource;
		}
	}
	
	strncpy (source, destination, strlen(destination)+1);
}


/*
 * Converts all occurences of a LF to CR/LF
 */
static void
cr2crlf (char *source)
{
	char *psource = source;
	char destination[2048];
	
	if( source != NULL )
	{
		memset (destination, 0, 2048);
		for (psource = source; *psource != '\0'; psource++)
		{
			if (*psource == 10)
				destination[strlen(destination)] = 13;
			destination[strlen(destination)] = *psource;
		}
	}
	
	strncpy (source, destination, strlen(destination)+1);
}




/*
 * Reads the first ten bytes of an file and checks, if it's a valid ID3 V2.3 file
 * If it is, the header flags are stored in the tag struct.
 * Returns TRUE on a valid header, otherwise FALSE.
 */
static short int
check_header (FILE *mp3file, id3v2Tag *v2)
{
	unsigned char buf[10];
	
// get header (=first ten bytes of the file)
	fseek (mp3file, 0, SEEK_SET);
	if ( fread (buf, 1, 10, mp3file) < 10 )
		return (FALSE);

// a valid tag must begin with "ID3" followed by the version (checked below)
// followed by a flag byte, where the last five bytes are unused and must be FALSE
	if ( memcmp(buf, "ID3", 3) != 0
		|| (buf[5] & 31) != 0 )
		return (FALSE);

// check if version is supported
	if ( buf[3] != 3
		|| buf[4] != 0 )
		return (FALSE);

// The next thing to come is the tag size. These are 4 bytes, the MSB should always be set to zero. check!
	if ( (buf[6] & 128) != 0
		|| (buf[7] & 128) != 0
		|| (buf[8] & 128) != 0
		|| (buf[9] & 128) != 0 )
		return (FALSE);
	
// The tag size is encoded to be syncsave, so I got to decode it.
// The tag size is the size of the complete tag EXCLUDING the 10-byte header.
 	v2->tag_size = buf[9] + (buf[8] << 7) + (buf[7] << 14) + (buf[6] << 21);

// ok, so were save. put the flags in the nicer struct.
	v2->unsync = (buf[5] & 128) >> 7;
	v2->has_extheader = (buf[5] & 64) >> 6;
	v2->is_experimental = (buf[5] & 32) >> 5;
	
	return (TRUE);
}





/*
 * Reads the extheader of a valid ID3V2.3 file and checks, if it's a valid.
 * If it is, the extheader flags are stored in the tag struct.
 * Returns TRUE on a valid extheader, otherwise FALSE.
 */
static short int
check_extheader (FILE *mp3file, id3v2Tag *v2)
{
	unsigned char buf[10];

// Read id3 extheader intro (5 bytes)
	fseek (mp3file, 10, SEEK_SET);
	if ( fread(buf, 1, 5, mp3file) < 5 )
		return (FALSE);
	
// First comes the extheader size. These are 4 bytes, the MSB should always be set to zero. check!
	if( (buf[0] & 128) != 0
		|| (buf[1] & 128) != 0
		|| (buf[2] & 128) != 0
		|| (buf[3] & 128) != 0 )
		return (FALSE);
	
// OK. In ID3V2.3 only six byte or ten byte extheaders are allowed.
	if( v2->extheader_size != 6 
		&& v2->extheader_size != 10 )
		return (FALSE);
	
// The first four bytes specify the extheader size.
	v2->extheader_size = buf[3] + (buf[2] << 7) + (buf[1] << 14) + (buf[0] << 21);
	
// The fifth byte specifies extendened flags. (in fact, only one flag is used for ID3V2.3
// The MSB of the byte 5 specifies, if there is CRC data to come, appended to the extheader.
	if( (buf[4] & 127) != 0
		|| buf[5] != 0 )
		return (FALSE);
	
	v2->crc_data_present = (buf[4] & 128) >> 7;
	
// if crc data is present, the extheader size must be ten bytes, otherwise 6.
	if ( (v2->extheader_size == 6 && v2->crc_data_present == TRUE)
		|| (v2->extheader_size == 10 && v2->crc_data_present == FALSE) )
		return (FALSE);
	
// now come four bytes specifying the padding size
	if ( (buf[6] & 128) != 0
		|| (buf[7] & 128) != 0
		|| (buf[8] & 128) != 0
		|| (buf[9] & 128) != 0 )
		return (FALSE);
	
	v2->padding_size = buf[9] + (buf[8] << 7) + (buf[7] << 14) + (buf[6] << 21);
	
// Now to the optional crc data.
	if( v2->crc_data_present )
	{
		if( fread (buf, 1, 4, mp3file) < 4 )
			return (FALSE);
		
		memcpy (v2->crc_data, buf, 4);
	}
	
	return (TRUE);
}





/*
 * Reads the complete frames of a valid ID3V2.3 file and checks, if they are valid.
 * If they are, the flags are stored in a DLL and appended to the tag struct.
 * Returns TRUE on success, otherwise FALSE.
 */
static short int
read_frames (FILE *mp3file, id3v2Tag *v2)
{
	unsigned char buf[10];
	int numframes = 0;
	unsigned int totalframesize = 0;
	id3v2Frame *frame = NULL;
	
// set the position to the first frame header (header = 10 bytes + extheadersize + 4 bytes "extheaderheader")
	if (v2->has_extheader)
		fseek (mp3file, 10 + v2->extheader_size + 4, SEEK_SET);
	else
		fseek (mp3file, 10, SEEK_SET);

// If the tag size is too small for frames, return with an error.
	if ( ((v2->tag_size + 10) - v2->padding_size) <= ftell(mp3file) )
		return FALSE;
	
// now read all the frames
	numframes = 0;
	v2->frames = NULL;
	while ( ftell (mp3file) < ((v2->tag_size + 10) - v2->padding_size) )
	{
		frame = calloc (1, sizeof(id3v2Frame));

// the frame header is ten bytes long
		if ( fread (buf, 1, 10, mp3file) < 10 )
			goto error;

// if we are already in the padding, we must no longer look for frames...
		if ( buf[0] == 0 && buf[1] == 0 && buf[2] ==  0 && buf[3] == 0 )
		{
			if (numframes == 0)
				goto error;
			
			free (frame);
			break;
		}
		
// first come four characters identifying the frame. It must be alphanumeric.
		if ( !isalnum(buf[0]) || !isalnum(buf[1]) || !isalnum(buf[2]) || !isalnum(buf[3]) )
			goto error;
		
		*(frame->id) = buf[0];
		*(frame->id + 1) = buf[1];
		*(frame->id + 2) = buf[2];
		*(frame->id + 3) = buf[3];
		
// then, the frame size is to come. Again, the four MSBs must be zero.
		if ( (buf[4] & 128) != 0
			|| (buf[5] & 128) != 0
			|| (buf[6] & 128) != 0
			|| (buf[7] & 128) != 0 )
			goto error;
		
		frame->datasize = buf[7] + (buf[6] << 7) + (buf[5] << 14) + (buf[4] << 21);
		
// A minimum size must be present!
		if ( frame->datasize <= 0 )
			goto error;
		
// The two following frame header flags have the 5 LSBs not set.
		if ( (buf[8] & 31) != 0
			|| (buf[9] & 31) != 0 )
			goto error;

// now, put the flags in the struct.
		frame->tagalter = (buf[8] & 128) >> 7;
		frame->filealter = (buf[8] & 64) >> 6;
		frame->readonly = (buf[8] & 32) >> 5;
		
		frame->compression = (buf[9] & 128) >> 7;
		frame->encryption = (buf[8] & 64) >> 6;
		frame->grouping = (buf[8] & 32) >> 5;
		
// ok, we are done with the frame header, so now we read the frame data.
		frame->data = calloc (1, frame->datasize + 1);
		if( fread (frame->data, 1, frame->datasize, mp3file) < frame->datasize )
			goto error;
		
		numframes++;
		totalframesize += 10 + frame->datasize;
		
// we append it to a glist, which is appended to the v2 struct.
		v2->frames = dll_append (v2->frames, frame);
	}

// if we have no extheader, that means, we don't know how much padding we have!
// thus, i calculate it here.
	if ( !v2->has_extheader )
		v2->padding_size = v2->tag_size - totalframesize;
	
// A minimum of one frame is mandatory.
	if( numframes > 0 )
		return (TRUE);
	
error:
// cleanups in case of an error.
	if( frame && frame->data )
		free (frame->data);
	if( frame )
		free (frame);
	return (FALSE);
}















/*
 * Reads all tag information of a valid ID3V2.3 file.
 * When successful, the info is stored in the tag struct.
 * Returns:
 * 0 = success
 * 1 = Cannot open file.
 * 2 = No header or wrong version.
 * 3 = broken extheader.
 * 4 = broken frames.
 */
static int
get_id3v2tag_raw (id3v2Tag *v2, char *filename)
{
	FILE *mp3file = NULL;
	int error = 0;

// open file
	error = 1;
	mp3file = fopen (filename, "rb");
	if (!mp3file)
		goto done;
	
// check/get header
	error = 2;
	if( !check_header (mp3file, v2) )
		goto done;
	
// check/get extheader
	error = 3;
	if( v2->has_extheader
		&& !check_extheader (mp3file, v2) )
		goto done;

// get the content frames
	error = 4;
	if( !read_frames (mp3file, v2) )
		goto done;

	error = 0;
done:
	fclose (mp3file);
	return (error);
}
	
	
	
	
	
/*
 * Find one frames data and give back its data in the correct format.
 * Returns TRUE on success, otherwise FALSE;
 */
static short int
frame_find (id3v2Tag *v2, char *name, char *value)
{
	DLL *curframe = NULL;
    id3v2Frame *frame = NULL;

    // we parse through the whole list of frames, giving back the correct frame value.
    curframe = v2->frames;
    while ( curframe )
    {
        frame = (id3v2Frame *)curframe->data;

        // Just to be sure...
        if( frame->datasize <= 0 )
            goto nextframe;

        // Matches the users request? Otherwise try the next frame.
        if( memcmp (frame->id, name, 4) != 0 )
            goto nextframe;

        // These types don't need much change, just give the whole data back to the user according to the encoding.
        // The first byte is the encoding.
        // TPE1: Artist
        // TIT2: Song Title
        // TALB: Album Title
        // TYER: Year
        // TRCK: Track
        // TCON: Genre
        // COMM: Comment
        // TCOM: Composer
        // TOPE: TOPE Original artist(s)/performer(s)
        // TENC: Encoded by
        if ( memcmp (frame->id, "TPE1", 4) == 0
                || memcmp (frame->id, "TIT2", 4) == 0
                || memcmp (frame->id, "TALB", 4) == 0
                || memcmp (frame->id, "TYER", 4) == 0
                || memcmp (frame->id, "TRCK", 4) == 0
                || memcmp (frame->id, "TCON", 4) == 0
                || memcmp (frame->id, "TCOM", 4) == 0
                || memcmp (frame->id, "TOPE", 4) == 0
                || memcmp (frame->id, "TENC", 4) == 0)
            //|| memcmp (frame->id, "WXXX", 4) == 0)
        {
            if ( *frame->data == 0 )
                memcpy(value, frame->data + 1, frame->datasize - 1);
            if ( *frame->data == 1 )
            {
                char nulltermvalue[frame->datasize];
                char *isovalue = NULL;

                // the tag is not null terminated, so i have to create a null terminated string first.
                memset (nulltermvalue, 0, frame->datasize);
                memcpy (nulltermvalue, frame->data + 1, frame->datasize - 1);

                // Convert from UTF to ISO and copy to the users variable.
                isovalue = convert_from_utf8 (nulltermvalue);
                strncpy (value, isovalue, sizeof(value) - 1);
                free (isovalue);
            }

            // change linefeeds to a single "return" key.
            crlf2cr (value);
            return (TRUE);
        }
        if ( memcmp (frame->id, "WCOM", 4) == 0
                || memcmp (frame->id, "WCOP", 4) == 0
                || memcmp (frame->id, "WOAF", 4) == 0
                || memcmp (frame->id, "WOAR", 4) == 0
                || memcmp (frame->id, "WOAS", 4) == 0
                || memcmp (frame->id, "WPAY", 4) == 0
                || memcmp (frame->id, "WPUB", 4) == 0)
        {
            memcpy(value, frame->data, frame->datasize - 1);
            
            // change linefeeds to a single "return" key.
            crlf2cr (value);
            return (TRUE);
        }

        // The comment requires special handling.
        // Its data has: One byte "encoding" (0 = ISO-8859-1, 1 = UNICODE)
        // followed by the language (three bytes, e.g. "eng"),
        // followed by a short description,
        // then a NULL,
        // and the full description
        // For now, i simply drop the short description
        if( memcmp(frame->id, "COMM", 4) == 0 )
        {
            // check for the right format. (minsize 5, must contain a "\0" after the language)
            if ( frame->datasize < 5 )
                goto nextframe;
            if ( !memchr (frame->data + 4, '\0', frame->datasize - 4) )
                goto nextframe;

            // now, give the data back to the user, according to the encoding.
            if ( *frame->data == 0 )
                memcpy (value, frame->data + 5, frame->datasize - 5);
            if ( *frame->data == 1 )
            {
                char nulltermvalue[frame->datasize];
                char *isovalue = NULL;

                // the tag is not null terminated, so i have to create a null terminated string first.
                memset (nulltermvalue, 0, frame->datasize);
                memcpy (nulltermvalue, frame->data + 5, frame->datasize - 5);

                // Convert from UTF to ISO and copy to the users variable.
                isovalue = convert_from_utf8 (nulltermvalue);
                strncpy (value, isovalue, sizeof(value) - 1);
                free (isovalue);
            }

            // change linefeeds to a single "return" key.
            crlf2cr (value);
            return TRUE;
        }

nextframe:
        curframe = curframe->next;
    }

    return FALSE;
}
	



/*
 * Remove one frame out of the id3v2Tag struct
 * Returns TRUE on success, otherwise FALSE;
 */
static short int
frame_remove (id3v2Tag *v2, char *name)
{
	id3v2Frame *frame = NULL;
	DLL *curframe = NULL;
	DLL *tempframe = NULL;
	
// Parse through the list of frames.
	curframe = v2->frames;
	while ( curframe )
	{
		frame = (id3v2Frame *)curframe->data;
		tempframe = curframe;
		curframe = curframe->next;
		
		if ( memcmp (frame->id, name, 4) == 0 )
		{
// we have found the item! removing will NOT shrink the tag, but increase the padding.
			v2->padding_size += (frame->datasize + 10);
// and free memory.
			v2->frames = dll_remove (v2->frames, tempframe->data);
			free (frame->data);
			free (frame);
			
			return TRUE;
		}
	}
	
	return FALSE;
}



/*
 * Add a frame to the framelist. If the frame name is already in the list, it will be replaced.
 * Returns:
 * TRUE: The tag size HAS BEEN increased.
 * FALSE: The tag size has NOT been increased.
 */
static short int
frame_set (id3v2Tag *v2, char *name, char *value)
{
	id3v2Frame *frame = NULL;
	short int sizechange = FALSE;
	
// prevent the user to send CR/LF, which is forbidden.
	cr2crlf (value);
// eventually remove an existing item!
	frame_remove (v2, name);

// alloc space for the new frame.
	frame = malloc (sizeof(id3v2Frame));
	
	memcpy (frame->id, name, 4);
	frame->datasize = strlen (value);
	frame->tagalter = 0;
	frame->filealter = 0;
	frame->readonly = 0;
	frame->compression = 0;
	frame->encryption = 0;
	frame->grouping = 0;

// The comment requires special handling. If you need to know why, look at the documentation
// of the "frame_find" function above.
    if( memcmp (frame->id, "COMM", 4) == 0 )
    {
        char fullvalue[frame->datasize + 6];

        sprintf(fullvalue, "%ceng%c%s", 0, 0, value);

        frame->datasize += 5;
        frame->data = malloc (frame->datasize);
        memcpy (frame->data, fullvalue, frame->datasize);
    } 
    else if ((memcmp(frame->id, "WCOM", 4) == 0)
            || memcmp (frame->id, "WCOP", 4) == 0
            || memcmp (frame->id, "WOAF", 4) == 0
            || memcmp (frame->id, "WOAR", 4) == 0
            || memcmp (frame->id, "WOAS", 4) == 0
            || memcmp (frame->id, "WPAY", 4) == 0
            || memcmp (frame->id, "WPUB", 4) == 0)
    {
        frame->data = malloc (frame->datasize);
        memcpy (frame->data, value, frame->datasize);
    }
    else 
    {
        char fullvalue[frame->datasize + 2];

        // Put encoding type just before the value
        sprintf (fullvalue, "%c%s", 0, value);

        frame->datasize += 1;
        frame->data = malloc (frame->datasize);
        memcpy (frame->data, fullvalue, frame->datasize);
    }
	
// Ok. This decreases the available padding. If we have no padding left, we must increase the padding (and thus, the tag).
	if( v2->padding_size - (frame->datasize + 10) <= 0 )
	{
// add: framesize + frameheadersize + padding.
		v2->padding_size += frame->datasize + 10 + 1024;
		v2->tag_size += frame->datasize + 10 + 1024;
		
		sizechange = TRUE;
	}
	
// In every case, we must subtract the new allocated space from the padding.
	v2->padding_size -= frame->datasize + 10;
	
	v2->frames = dll_append (v2->frames, frame);
	
	return sizechange;
}



/*
 * Create raw header.
 * Returns:
 * TRUE: successful.
 * FALSE: unsuccessful.
 */
static int
create_header_raw (char *raw, id3v2Tag *v2)
{
// now we are going to write the tags raw data into the raw string
	memset (raw, 0, v2->tag_size + 10);
// ID3 identifier bytes
	memcpy (raw, "ID3", 3);
	raw += 3;
// major version byte
	*raw++ = 3;
// minor version byte
	*raw++ = 0;
// Flags byte
	*raw++ = ((v2->unsync & 1) << 7)
		| ((v2->has_extheader & 1) << 6)
		| ((v2->is_experimental & 1) << 5);
// Tag size. It must be syncsafe!
	*raw++ = ((v2->tag_size & 0x800000) >> 23) | (((v2->tag_size & 0x7f000000) >> 24) << 1);
	*raw++ = ((v2->tag_size & 0x8000) >> 15) | (((v2->tag_size & 0x7f0000) >> 16) << 1);
	*raw++ = ((v2->tag_size & 0x80) >> 7) | (((v2->tag_size & 0x7f00) >> 8) << 1);
	*raw++ = (v2->tag_size & 0x7f);
	
	return TRUE;
}




/*
 * Generates the frames. btw.: ID3 sucks!
 * Returns: TRUE if succesful, otherwise FALSE.
 */
static short int
create_frames_raw (char *raw, id3v2Tag *v2)
{
	id3v2Frame *frame = NULL;
	DLL *curframe = NULL;
	
// if we have no frames, just quit.
	if ( v2->frames == NULL )
		return FALSE;
	
// the header and extheader have already been written.
	raw += 10;
	if ( v2->has_extheader )
		raw += 4 + v2->extheader_size;
	
	curframe = v2->frames;
	while ( curframe )
	{
		frame = (id3v2Frame *)curframe->data;

// secure is secure
		if ( frame->datasize <= 0 )
			goto nextframe;
		
// add the frame id
		memcpy(raw, frame->id, 4);
		raw += 4;
// add the frame size (syncsafe)
		*raw++ = ((frame->datasize & 0x800000) >> 23) | (((frame->datasize & 0x7f000000) >> 24) << 1);
		*raw++ = ((frame->datasize & 0x8000) >> 15) | (((frame->datasize & 0x7f0000) >> 16) << 1);
		*raw++ = ((frame->datasize & 0x80) >> 7) | (((frame->datasize & 0x7f00) >> 8) << 1);
		*raw++ = (frame->datasize & 0x7f);

// The two flagbytes
		*raw++ = ((frame->tagalter & 1) << 7)
			| ((frame->filealter & 1) << 6)
			| ((frame->readonly & 1) << 5);
		
		*raw++ = ((frame->compression & 1) << 7)
			| ((frame->encryption & 1) << 6)
			| ((frame->grouping & 1) << 5);

// now the frame data.
		memcpy(raw, frame->data, frame->datasize);
		raw += frame->datasize;

nextframe:
		curframe = curframe->next;
	}
	
	return TRUE;
}

/***************************************************************************************
 * END OF STATICS
 ***************************************************************************************/







/*
 * Purpose: Reads the ID3 tag from a file.
 * Parameters: tag - The structure to store the tag in, filename - The name of the file to operate on.
 * Returns:
 * 0 if successful,
 * 1 if an error occured when opening the file
 * 2 if error while reading tag.
 * 3 if no TAG found.
 */
int
get_id3v2_tag (id3Tag *tag, char *filename)
{
	id3v2Tag *v2 = calloc (1, sizeof(id3v2Tag));
	DLL *curframe = NULL;
	int error = 0;
	
// Read the tag.
	error = get_id3v2tag_raw (v2, filename);
	
// Init the users tag
	memset (tag, 0, sizeof (id3Tag));
	
	if( error == 0 )
	{
// if we have a valid tag we copy the raw data to the users struct
		tag->size = v2->tag_size;
		
		frame_find (v2, "TPE1", tag->artist);
		frame_find (v2, "TIT2", tag->title);
		frame_find (v2, "TALB", tag->album);
		frame_find (v2, "TYER", tag->year);
		frame_find (v2, "COMM", tag->comment);
		frame_find (v2, "TRCK", tag->track);
		frame_find (v2, "TCON", tag->genre);
		frame_find (v2, "TCOM", tag->composer);     // Composer
		frame_find (v2, "TOPE", tag->orig_artist);  // Original artist(s)/performer(s)
		frame_find (v2, "WCOM", tag->url);          // URL
		frame_find (v2, "TENC", tag->enc_by);       // Encoded by
	}
	
// Free all the stuff
	if (v2->frames)
	{
		id3v2Frame *frame = NULL;
		
		curframe = v2->frames;
		while ( curframe )
		{
			frame = (id3v2Frame *)curframe->data;
			
			free (frame->data);
			free (frame);
			
			curframe = curframe->next;
		}
		v2->frames = dll_free (v2->frames);
	}
	
	free (v2);
	return (error);
}









/*
 * Purpose: Clear the ID3 tag of a file.
 * Parameters: a filename.
 * Returns:
 * 0 if successful,
 * 1 if an error occured when opening the file
 * 2 if an error while reading/writing the tag.
 */
int
del_id3v2_tag (char *filename)
{
	id3v2Tag *v2 = calloc (1, sizeof(id3v2Tag));
	long file_len;
	FILE *file;
	void *ptr;

// check if an valid old id3v2 tag is present
// In these two error-cases we don't know how big the tag is.
	if( get_id3v2tag_raw (v2, filename) == 1
		|| get_id3v2tag_raw (v2, filename) == 2 )
		return(0);
	
	ptr =  malloc (4096);

// open file read/write
	file = fopen (filename, "r+b");
	if (!file)
		return (1);

	fseek (file, 0, SEEK_END);
	file_len = ftell (file);
	if ( file_len < 11
		|| v2->tag_size < 11 )
		return (2);

// set anything but the header in tag to zero. I'll not really remove the tag,
// because this would be much slower and if we write a new tag, this would mean we´d have to
// rewrite the complete tag.
/*
	fseek (file, 10, SEEK_SET);
	for (read = 0; read < v2->tag_size - 10; read++)
		fputc (0, file);

*/
    {
        FILE *file = NULL;
        FILE *tempfile = NULL;
        char *tempfilename = NULL;
        int read = 0;
        char buf[4096];
	    int error = 0;

        // Open a tempfile
        error = 2;
        tempfilename = malloc (strlen (filename) + 11);
        sprintf (tempfilename, "%s%s", filename, ".tempXXXXX");
        if( !(tempfile = fopen(tempfilename, "wb")) )
        {
            remove (tempfilename);
            free (tempfilename);
            goto done;
        }

        // Write the tag to the tempfile.

        // Open the mp3file.
        error = 4;
        if( !(file = fopen(filename, "r+b")) )
        {
            fclose (file);
            remove (tempfilename);
            free (tempfilename);
            goto done;
        }
        // skip the old tag (if one existed)
        fseek (file, v2->tag_size + 10, SEEK_SET);

        // copy the rest of the file to the tempfile.
        while ( !feof(file) )
        {
            error = 5;
            read = fread (buf, 1, 4096, file);
            if( fwrite (buf, 1, read, tempfile) != read
                    && !feof (file) )
            {
                remove (tempfilename);
                free (tempfilename);
                fflush (tempfile);
                fclose (tempfile);
                fflush (file);
                fclose (file);
                goto done;
            }
        }

        fflush (file);
        fclose (file);
        fflush (tempfile);
        fclose (tempfile);

        // rename the tempfile, so it is the mp3file.
        rename (tempfilename, filename);
        free (tempfilename);
	}

done:
	if (v2) free (v2);
	if (ptr) free (ptr);
	
	return(0);
}











int
set_id3v2_tag (id3Tag *tag, char *filename)
{
	id3v2Tag *v2 = malloc (sizeof(id3v2Tag));
	id3v2Frame *frame = NULL;
	unsigned char *rawdata = NULL;
	DLL *curframe = NULL;
	int oldsize = 0;
	char track[3];
	int error = 0;

// Try to get the content of an old tag
	error = 1;
	memset (v2, 0, sizeof(id3v2Tag));
	get_id3v2tag_raw (v2, filename);
	
	oldsize = v2->tag_size;

// If the old tag had an extheader, I'll add its size to my tag, because i don't plan to add it again.
	if ( v2->has_extheader )
	{
		v2->padding_size += v2->extheader_size;
		v2->has_extheader = FALSE;
		v2->extheader_size = 0;
	}
	
// first of all I'll generate a valid id3v2 tag struct out of the tag struct we got by the user.
// Set the flags...
	v2->unsync = FALSE;
	v2->is_experimental = FALSE;
	v2->crc_data_present = FALSE;
	
// Set the contentframes
	frame_set (v2, "TIT2", tag->title);
	frame_set (v2, "TPE1", tag->artist);
	frame_set (v2, "TALB", tag->album);
	frame_set (v2, "TYER", tag->year);
	frame_set (v2, "COMM", tag->comment);
	frame_set (v2, "TCON", tag->genre);
    frame_set (v2, "TCOM", tag->composer);     // Composer
    frame_set (v2, "TOPE", tag->orig_artist);  // TOPE Original artist(s)/performer(s)
    frame_set (v2, "WCOM", tag->url);          // URL
    frame_set (v2, "TENC", tag->enc_by);       // Encoded by
	if ( atoi (tag->track) < 10 )
		snprintf (track, 3, "0%i", atoi(tag->track));
	else
		snprintf (track, 3, "%i", atoi(tag->track));
	frame_set (v2, "TRCK", track);
	
// Create a header in the raw data string
	rawdata = calloc (1, v2->tag_size + 10);
	create_header_raw (rawdata, v2);

// Create frames raw data.
	create_frames_raw (rawdata, v2);
	
// is the new tag bigger than the old one? Then we'll have to completely rewrite the file...
	if ( v2->tag_size > oldsize )
	{
		FILE *file = NULL;
		FILE *tempfile = NULL;
		char *tempfilename = NULL;
		int read = 0;
		char buf[4096];

// Open a tempfile
		error = 2;
		tempfilename = malloc (strlen (filename) + 11);
		sprintf (tempfilename, "%s%s", filename, ".tempXXXXX");
		if( !(tempfile = fopen(tempfilename, "wb")) )
		{
			remove (tempfilename);
			free (tempfilename);
			goto done;
		}
		
// Write the tag to the tempfile.
		error = 3;
		fseek (tempfile, 0, SEEK_SET);
		if( fwrite (rawdata, 1, v2->tag_size + 10, tempfile) < v2->tag_size )
		{
			fclose (tempfile);
			remove (tempfilename);
			free (tempfilename);
			goto done;
		}
		
// Open the mp3file.
		error = 4;
		if( !(file = fopen(filename, "r+b")) )
		{
			fclose (file);
			remove (tempfilename);
			free (tempfilename);
			goto done;
		}
// skip the old tag (if one existed)
		fseek (file, oldsize? oldsize + 10 : oldsize, SEEK_SET);
		
// copy the rest of the file to the tempfile.
		while ( !feof(file) )
		{
			error = 5;
			read = fread (buf, 1, 4096, file);
			if( fwrite (buf, 1, read, tempfile) != read
				&& !feof (file) )
			{
				remove (tempfilename);
				free (tempfilename);
				fflush (tempfile);
				fclose (tempfile);
				fflush (file);
				fclose (file);
				goto done;
			}
		}

		fflush (file);
		fclose (file);
		fflush (tempfile);
		fclose (tempfile);
		
// rename the tempfile, so it is the mp3file.
		rename (tempfilename, filename);
		free (tempfilename);
	}
	else
	{
		FILE *file = NULL;
		
// If the old tag was bigger than the new one, we can simply overwrite it!
// open.
		error = 10;
		if( !(file = fopen(filename, "r+b")) )
			goto done;

// write.
		error = 11;
		fseek (file, 0, SEEK_SET);
		if( fwrite (rawdata, 1, v2->tag_size + 10, file) < v2->tag_size )
		{
			fflush (file);
			fclose (file);
			goto done;
		}
		
		fflush (file);
		fclose (file);
	}
	
	error = 0;
	
done:
// Free all the stuff
	curframe = v2->frames;
	while ( curframe )
	{
		frame = (id3v2Frame *)curframe->data;
		
		free (frame->data);
		free (frame);
		
		curframe = curframe->next;
	}
	dll_free (v2->frames);

	if ( rawdata != NULL )
		free (rawdata);
	free (v2);
	return (error);
}

Lines 607-614 Link Here

(-)xmms-1.2.10.orig/Input/mpg123/mpg123.c (-2 / +11 lines)
607	{ \	607	{ \
608	id3frm = id3_get_frame( id3d, _tid, 1 ); \	608	id3frm = id3_get_frame( id3d, _tid, 1 ); \
609	if (id3frm) { \	609	if (id3frm) { \
610	txt = _tid == ID3_TCON ? id3_get_content(id3frm) \	610	if (_tid == ID3_COMM) \
611	: id3_get_text(id3frm); \	611	txt = id3_get_comm(id3frm); \
		612	else if (id3frm->fr_desc->fd_idstr[0] == 'W') \
		613	txt = id3_get_url(id3frm); \
		614	else \
		615	txt = _tid == ID3_TCON ? id3_get_content(id3frm) \
		616	: id3_get_text(id3frm); \
612	if(txt) \	617	if(txt) \
613	{ \	618	{ \
614	tlen = strlen(txt); \	619	tlen = strlen(txt); \
Lines 644-649 Link Here
644	ID3_SET_NUM (ID3_TRCK, track_number);	649	ID3_SET_NUM (ID3_TRCK, track_number);
645	ID3_SET (ID3_COMM, comment);	650	ID3_SET (ID3_COMM, comment);
646	ID3_SET (ID3_TCON, genre);	651	ID3_SET (ID3_TCON, genre);
		652	ID3_SET (ID3_TCOM, composer);
		653	ID3_SET (ID3_TOPE, orig_artist);
		654	ID3_SET (ID3_WCOM, url);
		655	ID3_SET (ID3_TENC, encoded_by);
647	}	656	}
648		657
649	/*	658	/*

Lines 78-83 Link Here

(-)xmms-1.2.10.orig/Input/mpg123/mpg123.h (+4 lines)
78	char genre[256];	78	char genre[256];
79	int year;	79	int year;
80	int track_number;	80	int track_number;
		81	char composer[1024];
		82	char orig_artist[1024];
		83	char url[1024];
		84	char encoded_by[1024];
81	};	85	};
82		86
83	typedef struct	87	typedef struct

Return to bug 7555

Line 0 Link Here

(-)xmms-1.2.10.orig/Input/mpg123/charset.h (+420 lines)
		1	/* charset.h - 2001/12/04 */
		2	/*
		3	* EasyTAG - Tag editor for MP3 and OGG files
		4	* Copyright (C) 2000-2002 Jerome Couderc <j.couderc@ifrance.com>
		5	*
		6	* This program is free software; you can redistribute it and/or modify
		7	* it under the terms of the GNU General Public License as published by
		8	* the Free Software Foundation; either version 2 of the License, or
		9	* (at your option) any later version.
		10	*
		11	* This program is distributed in the hope that it will be useful,
		12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		14	* GNU General Public License for more details.
		15	*
		16	* You should have received a copy of the GNU General Public License
		17	* along with this program; if not, write to the Free Software
		18	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		19	*/
		20
		21	#ifndef FALSE
		22	#define FALSE 0
		23	#endif
		24	#ifndef TRUE
		25	#define TRUE 1
		26	#endif
		27
		28	/*
		29	* Standard gettext macros.
		30	*/
		31	#ifdef ENABLE_NLS
		32	# include <libintl.h>
		33	# define _(String) gettext (String)
		34	# ifdef gettext_noop
		35	# define N_(String) gettext_noop (String)
		36	# else
		37	# define N_(String) (String)
		38	# endif
		39	#else
		40	# define textdomain(String) (String)
		41	# define gettext(String) (String)
		42	# define dgettext(Domain,Message) (Message)
		43	# define dcgettext(Domain,Message,Type) (Message)
		44	# define bindtextdomain(Domain,Directory) (Domain)
		45	# define _(String) (String)
		46	# define N_(String) (String)
		47	#endif
		48
		49	#ifndef DLL_H
		50	#define DLL_H
		51	typedef struct DLL_s
		52	{
		53	void *prev;
		54	void *data;
		55	void *next;
		56	} DLL;
		57	#endif
		58
		59	#ifndef __CHARSET_H__
		60	#define __CHARSET_H__
		61
		62
		63	/***************
		64	* Declaration *
65	***************/
66
67	typedef struct {
68	char *charset_title;
69	char *charset_name;
70	} CharsetInfo;
71
72
73	/**************
74	* Prototypes *
75	**************/
76
77	//static gchar* get_current_charset (void);
78
79	/* Used for ogg tags */
80	char* convert_to_utf8 (const char *string);
81	char* convert_from_utf8 (const char *string);
82
83	char* convert_from_file_to_user (const char *string);
84	char* convert_from_user_to_file (const char *string);
85
86	DLL *Charset_Create_List (void);
87	char Charset_Get_Name_From_Title (char charset_title);
88	char Charset_Get_Title_From_Name (char charset_name);
89
90	short int test_conversion_charset (char from, char to);
91
92
93	#endif /* __CHARSET_H__ */
94
95	/*
96	* Main part of code, written by:
97	*
98	* Copyright (C) 1999-2001 Håvard Kvålen <havardk@xmms.org>
99	*
100	* This program is free software; you can redistribute it and/or
101	* modify it under the terms of the GNU General Public License
102	* as published by the Free Software Foundation; either version 2
103	* of the License, or (at your option) any later version.
104	*
105	* This program is distributed in the hope that it will be useful,
106	* but WITHOUT ANY WARRANTY; without even the implied warranty of
107	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
108	* GNU General Public License for more details.
109	*
110	* You should have received a copy of the GNU General Public License
111	* along with this program; if not, write to the Free Software
112	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
113	* 02111-1307, USA.
114	*
115	*/
116
117	#include <stdlib.h>
118	#include <string.h>
119	#include <errno.h>
120
121	#ifdef HAVE_ICONV_OPEN
122	#include <iconv.h>
123	#endif
124
125	#ifdef HAVE_LANGINFO_CODESET
126	#include <langinfo.h>
127	#endif
128
129	/****************
130	* Declarations *
131	****************/
132
133	#define CHARSET_TRANS_ARRAY_LEN ( sizeof(charset_trans_array) / sizeof((charset_trans_array)[0]) )
134	const CharsetInfo charset_trans_array[] = {
135	{N_("Arabic (IBM-864)"), "IBM864" },
136	{N_("Arabic (ISO-8859-6)"), "ISO-8859-6" },
137	{N_("Arabic (Windows-1256)"), "windows-1256" },
138	{N_("Baltic (ISO-8859-13)"), "ISO-8859-13" },
139	{N_("Baltic (ISO-8859-4)"), "ISO-8859-4" },
140	{N_("Baltic (Windows-1257)"), "windows-1257" },
141	{N_("Celtic (ISO-8859-14)"), "ISO-8859-14" },
142	{N_("Central European (IBM-852)"), "IBM852" },
143	{N_("Central European (ISO-8859-2)"), "ISO-8859-2" },
144	{N_("Central European (Windows-1250)"), "windows-1250" },
145	{N_("Chinese Simplified (GB18030)"), "gb18030" },
146	{N_("Chinese Simplified (GB2312)"), "GB2312" },
147	{N_("Chinese Traditional (Big5)"), "Big5" },
148	{N_("Chinese Traditional (Big5-HKSCS)"), "Big5-HKSCS" },
149	{N_("Cyrillic (IBM-855)"), "IBM855" },
150	{N_("Cyrillic (ISO-8859-5)"), "ISO-8859-5" },
151	{N_("Cyrillic (ISO-IR-111)"), "ISO-IR-111" },
152	{N_("Cyrillic (KOI8-R)"), "KOI8-R" },
153	{N_("Cyrillic (Windows-1251)"), "windows-1251" },
154	{N_("Cyrillic/Russian (CP-866)"), "IBM866" },
155	{N_("Cyrillic/Ukrainian (KOI8-U)"), "KOI8-U" },
156	{N_("English (US-ASCII)"), "us-ascii" },
157	{N_("Greek (ISO-8859-7)"), "ISO-8859-7" },
158	{N_("Greek (Windows-1253)"), "windows-1253" },
159	{N_("Hebrew (IBM-862)"), "IBM862" },
160	{N_("Hebrew (Windows-1255)"), "windows-1255" },
161	{N_("Japanese (EUC-JP)"), "EUC-JP" },
162	{N_("Japanese (ISO-2022-JP)"), "ISO-2022-JP" },
163	{N_("Japanese (Shift_JIS)"), "Shift_JIS" },
164	{N_("Korean (EUC-KR)"), "EUC-KR" },
165	{N_("Nordic (ISO-8859-10)"), "ISO-8859-10" },
166	{N_("South European (ISO-8859-3)"), "ISO-8859-3" },
167	{N_("Thai (TIS-620)"), "TIS-620" },
168	{N_("Turkish (IBM-857)"), "IBM857" },
169	{N_("Turkish (ISO-8859-9)"), "ISO-8859-9" },
170	{N_("Turkish (Windows-1254)"), "windows-1254" },
171	{N_("Unicode (UTF-7)"), "UTF-7" },
172	{N_("Unicode (UTF-8)"), "UTF-8" },
173	{N_("Unicode (UTF-16BE)"), "UTF-16BE" },
174	{N_("Unicode (UTF-16LE)"), "UTF-16LE" },
175	{N_("Unicode (UTF-32BE)"), "UTF-32BE" },
176	{N_("Unicode (UTF-32LE)"), "UTF-32LE" },
177	{N_("Vietnamese (VISCII)"), "VISCII" },
178	{N_("Vietnamese (Windows-1258)"), "windows-1258" },
179	{N_("Visual Hebrew (ISO-8859-8)"), "ISO-8859-8" },
180	{N_("Western (IBM-850)"), "IBM850" },
181	{N_("Western (ISO-8859-1)"), "ISO-8859-1" },
182	{N_("Western (ISO-8859-15)"), "ISO-8859-15" },
183	{N_("Western (Windows-1252)"), "windows-1252" }
184
185	/*
186	* From this point, character sets aren't supported by iconv
187	*/
188	/* {N_("Arabic (IBM-864-I)"), "IBM864i" },
189	{N_("Arabic (ISO-8859-6-E)"), "ISO-8859-6-E" },
190	{N_("Arabic (ISO-8859-6-I)"), "ISO-8859-6-I" },
191	{N_("Arabic (MacArabic)"), "x-mac-arabic" },
192	{N_("Armenian (ARMSCII-8)"), "armscii-8" },
193	{N_("Central European (MacCE)"), "x-mac-ce" },
194	{N_("Chinese Simplified (GBK)"), "x-gbk" },
195	{N_("Chinese Simplified (HZ)"), "HZ-GB-2312" },
196	{N_("Chinese Traditional (EUC-TW)"), "x-euc-tw" },
197	{N_("Croatian (MacCroatian)"), "x-mac-croatian" },
198	{N_("Cyrillic (MacCyrillic)"), "x-mac-cyrillic" },
199	{N_("Cyrillic/Ukrainian (MacUkrainian)"), "x-mac-ukrainian" },
200	{N_("Farsi (MacFarsi)"), "x-mac-farsi"},
201	{N_("Greek (MacGreek)"), "x-mac-greek" },
202	{N_("Gujarati (MacGujarati)"), "x-mac-gujarati" },
203	{N_("Gurmukhi (MacGurmukhi)"), "x-mac-gurmukhi" },
204	{N_("Hebrew (ISO-8859-8-E)"), "ISO-8859-8-E" },
205	{N_("Hebrew (ISO-8859-8-I)"), "ISO-8859-8-I" },
206	{N_("Hebrew (MacHebrew)"), "x-mac-hebrew" },
207	{N_("Hindi (MacDevanagari)"), "x-mac-devanagari" },
208	{N_("Icelandic (MacIcelandic)"), "x-mac-icelandic" },
209	{N_("Korean (JOHAB)"), "x-johab" },
210	{N_("Korean (UHC)"), "x-windows-949" },
211	{N_("Romanian (MacRomanian)"), "x-mac-romanian" },
212	{N_("Turkish (MacTurkish)"), "x-mac-turkish" },
213	{N_("User Defined"), "x-user-defined" },
214	{N_("Vietnamese (TCVN)"), "x-viet-tcvn5712" },
215	{N_("Vietnamese (VPS)"), "x-viet-vps" },
216	{N_("Western (MacRoman)"), "x-mac-roman" },
217	// charsets whithout posibly translatable names
218	{"T61.8bit", "T61.8bit" },
219	{"x-imap4-modified-utf7", "x-imap4-modified-utf7"},
220	{"x-u-escaped", "x-u-escaped" },
221	{"windows-936", "windows-936" }
222	*/
223	};
224
225
226
227
228	/*************
229	* Functions *
230	*************/
231	// Return the last item of an doubly linked list
232	static DLL *
233	dll_last_c (DLL *list)
234	{
235	DLL *item = list;
236
237	while ( item->next )
238	item = item->next;
239
240	return item;
241	}
242
243	// Append an item to the doubly linked list
244	static DLL *
245	dll_append_c (DLL list, void data)
246	{
247	DLL *item = malloc (sizeof(DLL));
248
249	item->data = data;
250	item->prev = dll_last_c(list);
251	item->next = NULL;
252
253	return item;
254	}
255
256	static char* get_current_charset (void)
257	{
258	char *charset = getenv("CHARSET");
259
260	#ifdef HAVE_LANGINFO_CODESET
261	if (!charset)
262	charset = nl_langinfo(CODESET);
263	#endif
264	if (!charset)
265	charset = "ISO-8859-1";
266
267	return charset;
268	}
269
270
271	#ifdef HAVE_ICONV_OPEN
272	static char* convert_string (const char string, char from, char *to)
273	{
274	size_t outleft, outsize, length;
275	iconv_t cd;
276	char out, outptr;
277	const char *input = string;
278
279	if (!string)
280	return NULL;
281
282	length = strlen(string);
283
284	/* g_message("converting %s from %s to %s", string, from, to); */
285	if ((cd = iconv_open(to, from)) == (iconv_t)-1)
286	{
287	fprintf (stderr, "convert_string(): Conversion not supported. Charsets: %s -> %s", from, to);
288	return strdup(string);
289	}
290
291	/* Due to a GLIBC bug, round outbuf_size up to a multiple of 4 */
292	/* + 1 for nul in case len == 1 */
293	outsize = ((length + 3) & ~3) + 1;
294	out = g_malloc(outsize);
295	outleft = outsize - 1;
296	outptr = out;
297
298	retry:
299	if (iconv(cd, (char **)&input, &length, &outptr, &outleft) == -1)
300	{
301	int used;
302	switch (errno)
303	{
304	case E2BIG:
305	used = outptr - out;
306	outsize = (outsize - 1) * 2 + 1;
307	out = g_realloc(out, outsize);
308	outptr = out + used;
309	outleft = outsize - 1 - used;
310	goto retry;
311	case EINVAL:
312	break;
313	case EILSEQ:
314	/* Invalid sequence, try to get the
315	rest of the string */
316	input++;
317	length = strlen(input);
318	goto retry;
319	default:
320	fprintf (stderr, "convert_string(): Conversion failed. Inputstring: %s; Error: %s", string, strerror(errno));
321	break;
322	}
323	}
324	*outptr = '\0';
325
326	iconv_close(cd);
327	return out;
328	}
329	#else
330	static char* convert_string (const char string, char from, char *to)
331	{
332	if (!string)
333	return NULL;
334	return strdup(string);
335	}
336	#endif
337
338
339	/*
340	* Conversion with UTF-8 for ogg tags
341	*/
342	char* convert_to_utf8 (const char *string)
343	{
344	char *charset = get_current_charset();
345
346	return convert_string(string, charset, "UTF-8");
347	}
348
349	char* convert_from_utf8 (const char *string)
350	{
351	char *charset = get_current_charset();
352
353	return convert_string(string, "UTF-8", charset);
354	}
355
356
357	DLL *Charset_Create_List (void)
358	{
359	DLL *list = NULL;
360	int i;
361
362	for (i=0; i<CHARSET_TRANS_ARRAY_LEN; i++)
363	list = dll_append_c (list,_(charset_trans_array[i].charset_title));
364	return list;
365	}
366
367
368	/*
369	* Return charset_name from charset_title
370	*/
371	char Charset_Get_Name_From_Title (char charset_title)
372	{
373	int i;
374
375	if (charset_title)
376	for (i=0; i<CHARSET_TRANS_ARRAY_LEN; i++)
377	if ( strcasecmp(_(charset_title),_(charset_trans_array[i].charset_title)) == 0 )
378	return charset_trans_array[i].charset_name;
379	return "";
380	}
381
382
383	/*
384	* Return charset_title from charset_name
385	*/
386	char Charset_Get_Title_From_Name (char charset_name)
387	{
388	int i;
389
390	if (charset_name)
391	for (i=0; i<CHARSET_TRANS_ARRAY_LEN; i++)
392	if ( strcasecmp(charset_name,charset_trans_array[i].charset_name) == 0 )
393	return _(charset_trans_array[i].charset_title);
394	return "";
395	}
396
397
398
399	/*
400	* Test if the conversion is supported between two character sets ('from' and 'to)
401	*/
402	#ifdef HAVE_ICONV_OPEN
403	short int test_conversion_charset (char from, char to)
404	{
405	iconv_t cd;
406
407	if ((cd=iconv_open(to,from)) == (iconv_t)-1)
408	{
409	/* Conversion not supported */
410	return FALSE;
411	}
412	iconv_close(cd);
413	return TRUE;
414	}
415	#else
416	short int test_conversion_charset (char from, char to)
417	{
418	return TRUE;
419	}
420	#endif

Lines 38-52 Link Here

(-)xmms-1.2.10.orig/Input/mpg123/id3_frame_text.c (-116 / +168 lines)
38		38
39	char id3_utf16_to_ascii(void utf16)	39	char id3_utf16_to_ascii(void utf16)
40	{	40	{
41	char ascii[256];	41	char ascii[256];
42	char uc = (char ) utf16 + 2;	42	char uc = (char ) utf16 + 2;
43	int i;	43	int i;
44		44
45	for (i = 0; *uc != 0 && i < sizeof(ascii); i++, uc += 2)	45	for (i = 0; *uc != 0 && i < sizeof(ascii); i++, uc += 2)
46	ascii[i] = *uc;	46	ascii[i] = *uc;
47		47
48	ascii[i] = 0;	48	ascii[i] = 0;
49	return g_strdup(ascii);	49	return g_strdup(ascii);
50	}	50	}
51		51
52		52
Lines 59-83 Link Here
59	*/	59	*/
60	gint8 id3_get_encoding(struct id3_frame *frame)	60	gint8 id3_get_encoding(struct id3_frame *frame)
61	{	61	{
62	/* Type check */	62	/* Type check */
63	if (!id3_frame_is_text(frame) &&	63	if (!id3_frame_is_text(frame) &&
64	frame->fr_desc->fd_id != ID3_WXXX &&	64	frame->fr_desc->fd_id != ID3_WXXX &&
65	frame->fr_desc->fd_id != ID3_IPLS &&	65	frame->fr_desc->fd_id != ID3_IPLS &&
66	frame->fr_desc->fd_id != ID3_USLT &&	66	frame->fr_desc->fd_id != ID3_USLT &&
67	frame->fr_desc->fd_id != ID3_SYLT &&	67	frame->fr_desc->fd_id != ID3_SYLT &&
68	frame->fr_desc->fd_id != ID3_COMM &&	68	frame->fr_desc->fd_id != ID3_COMM &&
69	frame->fr_desc->fd_id != ID3_APIC &&	69	frame->fr_desc->fd_id != ID3_APIC &&
70	frame->fr_desc->fd_id != ID3_GEOB &&	70	frame->fr_desc->fd_id != ID3_GEOB &&
71	frame->fr_desc->fd_id != ID3_USER &&	71	frame->fr_desc->fd_id != ID3_USER &&
72	frame->fr_desc->fd_id != ID3_OWNE &&	72	frame->fr_desc->fd_id != ID3_OWNE &&
73	frame->fr_desc->fd_id != ID3_COMR)	73	frame->fr_desc->fd_id != ID3_COMR)
74	return -1;	74	return -1;
75		75
76	/* Check if frame is compressed */	76	/* Check if frame is compressed */
77	if (id3_decompress_frame(frame) == -1)	77	if (id3_decompress_frame(frame) == -1)
78	return -1;	78	return -1;
79		79
80	return (gint8 ) frame->fr_data;	80	return (gint8 ) frame->fr_data;
81	}	81	}
82		82
83		83
Lines 92-116 Link Here
92	{	92	{
93	/* Type check */	93	/* Type check */
94	if ( frame->fr_desc->fd_idstr[0] != 'T' &&	94	if ( frame->fr_desc->fd_idstr[0] != 'T' &&
95	frame->fr_desc->fd_id != ID3_WXXX &&	95	frame->fr_desc->fd_id != ID3_WXXX &&
96	frame->fr_desc->fd_id != ID3_IPLS &&	96	frame->fr_desc->fd_id != ID3_IPLS &&
97	frame->fr_desc->fd_id != ID3_USLT &&	97	frame->fr_desc->fd_id != ID3_USLT &&
98	frame->fr_desc->fd_id != ID3_SYLT &&	98	frame->fr_desc->fd_id != ID3_SYLT &&
99	frame->fr_desc->fd_id != ID3_COMM &&	99	frame->fr_desc->fd_id != ID3_COMM &&
100	frame->fr_desc->fd_id != ID3_APIC &&	100	frame->fr_desc->fd_id != ID3_APIC &&
101	frame->fr_desc->fd_id != ID3_GEOB &&	101	frame->fr_desc->fd_id != ID3_GEOB &&
102	frame->fr_desc->fd_id != ID3_USER &&	102	frame->fr_desc->fd_id != ID3_USER &&
103	frame->fr_desc->fd_id != ID3_OWNE &&	103	frame->fr_desc->fd_id != ID3_OWNE &&
104	frame->fr_desc->fd_id != ID3_COMR )	104	frame->fr_desc->fd_id != ID3_COMR )
105	return -1;	105	return -1;
106		106
107	/* Check if frame is compressed */	107	/* Check if frame is compressed */
108	if (id3_decompress_frame(frame) == -1)	108	if (id3_decompress_frame(frame) == -1)
109	return -1;	109	return -1;
110		110
111	/* Changing the encoding of frames is not supported yet */	111	/* Changing the encoding of frames is not supported yet */
112	if ( (gint8 ) frame->fr_data != encoding )	112	if ( (gint8 ) frame->fr_data != encoding )
113	return -1;	113	return -1;
114		114
115	/* Set encoding */	115	/* Set encoding */
116	(gint8 ) frame->fr_data = encoding;	116	(gint8 ) frame->fr_data = encoding;
Lines 128-171 Link Here
128	{	128	{
129	/* Type check */	129	/* Type check */
130	if ( frame->fr_desc->fd_idstr[0] != 'T' )	130	if ( frame->fr_desc->fd_idstr[0] != 'T' )
131	return NULL;	131	return NULL;
132		132
133	/* Check if frame is compressed */	133	/* Check if frame is compressed */
134	if (id3_decompress_frame(frame) == -1)	134	if (id3_decompress_frame(frame) == -1)
135	return NULL;	135	return NULL;
136		136
137	if ( frame->fr_desc->fd_id == ID3_TXXX ) {	137	if ( frame->fr_desc->fd_id == ID3_TXXX ) {
138	/*	138	/*
139	* This is a user defined text frame. Skip the description.	139	* This is a user defined text frame. Skip the description.
140	*/	140	*/
141	switch ( (guint8 ) frame->fr_data ) {	141	switch ( (guint8 ) frame->fr_data ) {
142	case ID3_ENCODING_ISO_8859_1:	142	case ID3_ENCODING_ISO_8859_1:
143	{	143	{
144	char text = (char ) frame->fr_data + 1;	144	char text = (char ) frame->fr_data + 1;
145		145
146	while ( *text != 0 )	146	while ( *text != 0 )
147	text++;	147	text++;
148		148
149	return g_strdup(++text);	149	return g_strdup(++text);
150	}	150	}
151	case ID3_ENCODING_UTF16:	151	case ID3_ENCODING_UTF16:
152	{	152	{
153	char text16 = (char ) frame->fr_data + 1;	153	char text16 = (char ) frame->fr_data + 1;
154		154
155	while (text16 != 0 \|\| (text16 + 1) != 0)	155	while (text16 != 0 \|\| (text16 + 1) != 0)
156	text16 += 2;	156	text16 += 2;
157		157
158	return id3_utf16_to_ascii(text16 + 2);	158	return id3_utf16_to_ascii(text16 + 2);
159	}	159	}
160	default:	160	default:
161	return NULL;	161	return NULL;
162	}	162	}
163	}	163	}
164		164
165	if ((guint8 ) frame->fr_data == ID3_ENCODING_ISO_8859_1)	165	if ((guint8 ) frame->fr_data == ID3_ENCODING_ISO_8859_1)
166	return g_strdup((char *) frame->fr_data + 1);	166	return g_strdup((char *) frame->fr_data + 1);
167	else	167	else
168	return id3_utf16_to_ascii(((char *) frame->fr_data + 1));	168	return id3_utf16_to_ascii(((char *) frame->fr_data + 1));
169	}	169	}
170		170
171		171
Lines 179-198 Link Here
179	{	179	{
180	/* Type check */	180	/* Type check */
181	if ( frame->fr_desc->fd_idstr[0] != 'T' )	181	if ( frame->fr_desc->fd_idstr[0] != 'T' )
182	return NULL;	182	return NULL;
183		183
184	/* If predefined text frame, return description. */	184	/* If predefined text frame, return description. */
185	if ( frame->fr_desc->fd_id != ID3_TXXX )	185	if ( frame->fr_desc->fd_id != ID3_TXXX )
186	return frame->fr_desc->fd_description;	186	return frame->fr_desc->fd_description;
187		187
188	/* Check if frame is compressed */	188	/* Check if frame is compressed */
189	if (id3_decompress_frame(frame) == -1)	189	if (id3_decompress_frame(frame) == -1)
190	return NULL;	190	return NULL;
191		191
192	if ((guint8 ) frame->fr_data == ID3_ENCODING_ISO_8859_1)	192	if ((guint8 ) frame->fr_data == ID3_ENCODING_ISO_8859_1)
193	return g_strdup((char *) frame->fr_data + 1);	193	return g_strdup((char *) frame->fr_data + 1);
194	else	194	else
195	return id3_utf16_to_ascii((char *) frame->fr_data + 1);	195	return id3_utf16_to_ascii((char *) frame->fr_data + 1);
196	}	196	}
197		197
198		198
Lines 209-250 Link Here
209		209
210	/* Check if frame is compressed */	210	/* Check if frame is compressed */
211	if (id3_decompress_frame(frame) == -1)	211	if (id3_decompress_frame(frame) == -1)
212	return -1;	212	return -1;
213		213
214	/*	214	/*
215	* Generate integer according to encoding.	215	* Generate integer according to encoding.
216	*/	216	*/
217	switch ( (guint8 ) frame->fr_data ) {	217	switch ( (guint8 ) frame->fr_data ) {
218	case ID3_ENCODING_ISO_8859_1:	218	case ID3_ENCODING_ISO_8859_1:
219	{	219	{
220	char text = ((char ) frame->fr_data) + 1;	220	char text = ((char ) frame->fr_data) + 1;
221		221
222	while ( text >= '0' && text <= '9' ) {	222	while ( text >= '0' && text <= '9' ) {
223	number *= 10;	223	number *= 10;
224	number += *text - '0';	224	number += *text - '0';
225	text++;	225	text++;
226	}	226	}
		227
		228	return number;
		229	}
		230	case ID3_ENCODING_UTF16:
		231	{
		232	char text = ((char ) frame->fr_data) + 3;
		233
		234	/* if ((gint16 ) frame->fr_data == 0xfeff) */
		235	/* text++; */
		236
		237	while ( text >= '0' && text <= '9' ) {
		238	number *= 10;
		239	number += *text - '0';
		240	text++;
		241	}
227		242
228	return number;	243	return number;
229	}	244	}
230	case ID3_ENCODING_UTF16:
231	{
232	char text = ((char ) frame->fr_data) + 3;
233
234	/* if ((gint16 ) frame->fr_data == 0xfeff) */
235	/* text++; */
236
237	while ( text >= '0' && text <= '9' ) {
238	number *= 10;
239	number += *text - '0';
240	text++;
241	}
242		245
243	return number;	246	default:
244	}	247	return -1;
245
246	default:
247	return -1;
248	}	248	}
249	}	249	}
250		250
Lines 260-266 Link Here
260	{	260	{
261	/* Type check */	261	/* Type check */
262	if ( frame->fr_desc->fd_idstr[0] != 'T' )	262	if ( frame->fr_desc->fd_idstr[0] != 'T' )
263	return -1;	263	return -1;
264		264
265	/*	265	/*
266	* Release memory occupied by previous data.	266	* Release memory occupied by previous data.
Lines 289-294 Link Here
289	}	289	}
290		290
291		291
		292
		293
		294	char* id3_get_comm(struct id3_frame *frame)
		295	{
		296
		297	/* Type check */
		298	if ( frame->fr_desc->fd_id != ID3_COMM )
		299	return NULL;
		300
		301	/* Check if frame is compressed */
		302	if (id3_decompress_frame(frame) == -1)
		303	return NULL;
		304
		305	/*
		306	* <Header for 'Comment', ID: "COMM">
		307	* Text encoding $xx
		308	* Language $xx xx xx
		309	* Short content descrip. <text string according to encoding> $00 (00)
		310	* The actual text <full text string according to encoding>
		311	*
		312	* Skip language and short description.
		313	*/
		314	switch ( (guint8 ) frame->fr_data ) {
		315	case ID3_ENCODING_ISO_8859_1:
		316	{
		317	char text = (char ) frame->fr_data + 4;
		318
		319	while ( *text != 0 )
		320	text++;
		321
		322	return g_strdup(++text);
		323	}
		324	case ID3_ENCODING_UTF16:
		325	{
		326	char text16 = (char ) frame->fr_data + 4;
		327
		328	while (text16 != 0 \|\| (text16 + 1) != 0)
		329	text16 += 2;
		330
		331	return id3_utf16_to_ascii(text16 + 2);
		332	}
		333	default:
		334	return NULL;
		335	}
		336
		337	if ((guint8 ) frame->fr_data == ID3_ENCODING_ISO_8859_1)
		338	return g_strdup((char *) frame->fr_data + 1);
		339	else
		340	return id3_utf16_to_ascii(((char *) frame->fr_data + 1));
		341	}
		342
		343
292	/*	344	/*
293	* Function id3_set_text_number (frame, number)	345	* Function id3_set_text_number (frame, number)
294	*	346	*
Lines 304-328 Link Here
304		356
305	/* Type check */	357	/* Type check */
306	if ( frame->fr_desc->fd_idstr[0] != 'T' )	358	if ( frame->fr_desc->fd_idstr[0] != 'T' )
307	return -1;	359	return -1;
308		360
309	/*	361	/*
310	* Release memory occupied by previous data.	362	* Release memory occupied by previous data.
311	*/	363	*/
312	id3_frame_clear_data(frame);	364	id3_frame_clear_data(frame);
313		365
314	/*	366	/*
315	* Create a string with a reversed number.	367	* Create a string with a reversed number.
316	*/	368	*/
317	pos = 0;	369	pos = 0;
318	while ( number > 0 && pos < 64 ) {	370	while ( number > 0 && pos < 64 ) {
319	buf[pos++] = (number % 10) + '0';	371	buf[pos++] = (number % 10) + '0';
320	number /= 10;	372	number /= 10;
321	}	373	}
322	if ( pos == 64 )	374	if ( pos == 64 )
323	return -1;	375	return -1;
324	if ( pos == 0 )	376	if ( pos == 0 )
325	buf[pos++] = '0';	377	buf[pos++] = '0';
326		378
327	/*	379	/*
328	* Allocate memory for new data.	380	* Allocate memory for new data.
Lines 336-342 Link Here
336	(gint8 ) frame->fr_raw_data = ID3_ENCODING_ISO_8859_1;	388	(gint8 ) frame->fr_raw_data = ID3_ENCODING_ISO_8859_1;
337	text = (char *) frame->fr_raw_data + 1;	389	text = (char *) frame->fr_raw_data + 1;
338	while ( --pos >= 0 )	390	while ( --pos >= 0 )
339	*text++ = buf[pos];	391	*text++ = buf[pos];
340	*text = '\0';	392	*text = '\0';
341		393
342	frame->fr_altered = 1;	394	frame->fr_altered = 1;
Lines 350-358 Link Here
350		402
351	gboolean id3_frame_is_text(struct id3_frame *frame)	403	gboolean id3_frame_is_text(struct id3_frame *frame)
352	{	404	{
353	if (frame && frame->fr_desc &&	405	if (frame && frame->fr_desc &&
354	(frame->fr_desc->fd_idstr[0] == 'T' \|\|	406	(frame->fr_desc->fd_idstr[0] == 'T' \|\|
355	frame->fr_desc->fd_idstr[0] == 'W' ))	407	frame->fr_desc->fd_idstr[0] == 'W' ))
356	return TRUE;	408	return TRUE;
357	return FALSE;	409	return FALSE;
358	}	410	}