tag_id3: no CamelCase

Renamed functions.

1 files changed, 64 insertions, 57 deletions

diff --git a/src/tag_id3.c b/src/tag_id3.c
index d8e96d1c2..32a693edf 100644
--- a/src/tag_id3.c
+++ b/src/tag_id3.c
@@ -34,7 +34,7 @@
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "id3"
 
-#  define isId3v1(tag) (id3_tag_options(tag, 0, 0) & ID3_TAG_OPTION_ID3V1)
+#  define tag_is_id3v1(tag) (id3_tag_options(tag, 0, 0) & ID3_TAG_OPTION_ID3V1)
 #  ifndef ID3_FRAME_COMPOSER
 #    define ID3_FRAME_COMPOSER "TCOM"
 #  endif
@@ -73,7 +73,8 @@ tag_id3_getstring(const struct id3_frame *frame, unsigned i)
 
 /* This will try to convert a string to utf-8,
  */
-static id3_utf8_t * processID3FieldString (int is_id3v1, const id3_ucs4_t *ucs4, int type)
+static id3_utf8_t *
+import_id3_string(int is_id3v1, const id3_ucs4_t *ucs4, int type)
 {
 	id3_utf8_t *utf8, *utf8_stripped;
 	id3_latin1_t *isostr;
@@ -114,7 +115,7 @@ static id3_utf8_t * processID3FieldString (int is_id3v1, const id3_ucs4_t *ucs4,
 }
 
 static void
-getID3Info(struct id3_tag *tag, const char *id, int type, struct tag *mpdTag)
+tag_id3_import_frame(struct tag *dest, struct id3_tag *tag, const char *id, int type)
 {
 	struct id3_frame const *frame;
 	id3_ucs4_t const *ucs4;
@@ -170,11 +171,12 @@ getID3Info(struct id3_tag *tag, const char *id, int type, struct tag *mpdTag)
 				ucs4 = id3_field_getstrings(field,i);
 				if(!ucs4)
 					continue;
-				utf8 = processID3FieldString(isId3v1(tag),ucs4, type);
+				utf8 = import_id3_string(tag_is_id3v1(tag),
+							 ucs4, type);
 				if(!utf8)
 					continue;
 
-				tag_add_item(mpdTag, type, (char *)utf8);
+				tag_add_item(dest, type, (char *)utf8);
 				g_free(utf8);
 			}
 		}
@@ -202,10 +204,11 @@ getID3Info(struct id3_tag *tag, const char *id, int type, struct tag *mpdTag)
 				ucs4 = id3_field_getfullstring(field);
 				if(ucs4)
 				{
-					utf8 = processID3FieldString(isId3v1(tag),ucs4, type);
+					utf8 = import_id3_string(tag_is_id3v1(tag),
+								 ucs4, type);
 					if(utf8)
 					{
-						tag_add_item(mpdTag, type, (char *)utf8);
+						tag_add_item(dest, type, (char *)utf8);
 						g_free(utf8);
 					}
 				}
@@ -330,23 +333,23 @@ struct tag *tag_id3_import(struct id3_tag * tag)
 {
 	struct tag *ret = tag_new();
 
-	getID3Info(tag, ID3_FRAME_ARTIST, TAG_ITEM_ARTIST, ret);
-	getID3Info(tag, ID3_FRAME_ALBUM_ARTIST,
-		   TAG_ITEM_ALBUM_ARTIST, ret);
-	getID3Info(tag, ID3_FRAME_ARTIST_SORT,
-		   TAG_ARTIST_SORT, ret);
-	getID3Info(tag, ID3_FRAME_ALBUM_ARTIST_SORT,
-		   TAG_ALBUM_ARTIST_SORT, ret);
-	getID3Info(tag, ID3_FRAME_TITLE, TAG_ITEM_TITLE, ret);
-	getID3Info(tag, ID3_FRAME_ALBUM, TAG_ITEM_ALBUM, ret);
-	getID3Info(tag, ID3_FRAME_TRACK, TAG_ITEM_TRACK, ret);
-	getID3Info(tag, ID3_FRAME_YEAR, TAG_ITEM_DATE, ret);
-	getID3Info(tag, ID3_FRAME_GENRE, TAG_ITEM_GENRE, ret);
-	getID3Info(tag, ID3_FRAME_COMPOSER, TAG_ITEM_COMPOSER, ret);
-	getID3Info(tag, "TPE3", TAG_ITEM_PERFORMER, ret);
-	getID3Info(tag, "TPE4", TAG_ITEM_PERFORMER, ret);
-	getID3Info(tag, ID3_FRAME_COMMENT, TAG_ITEM_COMMENT, ret);
-	getID3Info(tag, ID3_FRAME_DISC, TAG_ITEM_DISC, ret);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_ARTIST, TAG_ITEM_ARTIST);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_ALBUM_ARTIST,
+			     TAG_ITEM_ALBUM_ARTIST);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_ARTIST_SORT,
+			     TAG_ARTIST_SORT);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_ALBUM_ARTIST_SORT,
+			     TAG_ALBUM_ARTIST_SORT);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_TITLE, TAG_ITEM_TITLE);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_ALBUM, TAG_ITEM_ALBUM);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_TRACK, TAG_ITEM_TRACK);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_YEAR, TAG_ITEM_DATE);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_GENRE, TAG_ITEM_GENRE);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_COMPOSER, TAG_ITEM_COMPOSER);
+	tag_id3_import_frame(ret, tag, "TPE3", TAG_ITEM_PERFORMER);
+	tag_id3_import_frame(ret, tag, "TPE4", TAG_ITEM_PERFORMER);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_COMMENT, TAG_ITEM_COMMENT);
+	tag_id3_import_frame(ret, tag, ID3_FRAME_DISC, TAG_ITEM_DISC);
 
 	tag_id3_import_musicbrainz(ret, tag);
 	tag_id3_import_ufid(ret, tag);
@@ -359,69 +362,72 @@ struct tag *tag_id3_import(struct id3_tag * tag)
 	return ret;
 }
 
-static int fillBuffer(void *buf, size_t size, FILE * stream,
-		      long offset, int whence)
+static int
+fill_buffer(void *buf, size_t size, FILE *stream, long offset, int whence)
 {
 	if (fseek(stream, offset, whence) != 0) return 0;
 	return fread(buf, 1, size, stream);
 }
 
-static int getId3v2FooterSize(FILE * stream, long offset, int whence)
+static int
+get_id3v2_footer_size(FILE *stream, long offset, int whence)
 {
 	id3_byte_t buf[ID3_TAG_QUERYSIZE];
 	int bufsize;
 
-	bufsize = fillBuffer(buf, ID3_TAG_QUERYSIZE, stream, offset, whence);
+	bufsize = fill_buffer(buf, ID3_TAG_QUERYSIZE, stream, offset, whence);
 	if (bufsize <= 0) return 0;
 	return id3_tag_query(buf, bufsize);
 }
 
-static struct id3_tag *getId3Tag(FILE * stream, long offset, int whence)
+static struct id3_tag *
+tag_id3_read(FILE *stream, long offset, int whence)
 {
 	struct id3_tag *tag;
-	id3_byte_t queryBuf[ID3_TAG_QUERYSIZE];
-	id3_byte_t *tagBuf;
-	int tagSize;
-	int queryBufSize;
-	int tagBufSize;
+	id3_byte_t query_buffer[ID3_TAG_QUERYSIZE];
+	id3_byte_t *tag_buffer;
+	int tag_size;
+	int query_buffer_size;
+	int tag_buffer_size;
 
 	/* It's ok if we get less than we asked for */
-	queryBufSize = fillBuffer(queryBuf, ID3_TAG_QUERYSIZE,
-	                          stream, offset, whence);
-	if (queryBufSize <= 0) return NULL;
+	query_buffer_size = fill_buffer(query_buffer, ID3_TAG_QUERYSIZE,
+				   stream, offset, whence);
+	if (query_buffer_size <= 0) return NULL;
 
 	/* Look for a tag header */
-	tagSize = id3_tag_query(queryBuf, queryBufSize);
-	if (tagSize <= 0) return NULL;
+	tag_size = id3_tag_query(query_buffer, query_buffer_size);
+	if (tag_size <= 0) return NULL;
 
 	/* Found a tag.  Allocate a buffer and read it in. */
-	tagBuf = g_malloc(tagSize);
-	if (!tagBuf) return NULL;
+	tag_buffer = g_malloc(tag_size);
+	if (!tag_buffer) return NULL;
 
-	tagBufSize = fillBuffer(tagBuf, tagSize, stream, offset, whence);
-	if (tagBufSize < tagSize) {
-		g_free(tagBuf);
+	tag_buffer_size = fill_buffer(tag_buffer, tag_size, stream, offset, whence);
+	if (tag_buffer_size < tag_size) {
+		g_free(tag_buffer);
 		return NULL;
 	}
 
-	tag = id3_tag_parse(tagBuf, tagBufSize);
+	tag = id3_tag_parse(tag_buffer, tag_buffer_size);
 
-	g_free(tagBuf);
+	g_free(tag_buffer);
 
 	return tag;
 }
 
-static struct id3_tag *findId3TagFromBeginning(FILE * stream)
+static struct id3_tag *
+tag_id3_find_from_beginning(FILE *stream)
 {
 	struct id3_tag *tag;
 	struct id3_tag *seektag;
 	struct id3_frame *frame;
 	int seek;
 
-	tag = getId3Tag(stream, 0, SEEK_SET);
+	tag = tag_id3_read(stream, 0, SEEK_SET);
 	if (!tag) {
 		return NULL;
-	} else if (isId3v1(tag)) {
+	} else if (tag_is_id3v1(tag)) {
 		/* id3v1 tags don't belong here */
 		id3_tag_delete(tag);
 		return NULL;
@@ -435,8 +441,8 @@ static struct id3_tag *findId3TagFromBeginning(FILE * stream)
 			break;
 
 		/* Get the tag specified by the SEEK frame */
-		seektag = getId3Tag(stream, seek, SEEK_CUR);
-		if (!seektag || isId3v1(seektag))
+		seektag = tag_id3_read(stream, seek, SEEK_CUR);
+		if (!seektag || tag_is_id3v1(seektag))
 			break;
 
 		/* Replace the old tag with the new one */
@@ -447,22 +453,23 @@ static struct id3_tag *findId3TagFromBeginning(FILE * stream)
 	return tag;
 }
 
-static struct id3_tag *findId3TagFromEnd(FILE * stream)
+static struct id3_tag *
+tag_id3_find_from_end(FILE *stream)
 {
 	struct id3_tag *tag;
 	struct id3_tag *v1tag;
 	int tagsize;
 
 	/* Get an id3v1 tag from the end of file for later use */
-	v1tag = getId3Tag(stream, -128, SEEK_END);
+	v1tag = tag_id3_read(stream, -128, SEEK_END);
 
 	/* Get the id3v2 tag size from the footer (located before v1tag) */
-	tagsize = getId3v2FooterSize(stream, (v1tag ? -128 : 0) - 10, SEEK_END);
+	tagsize = get_id3v2_footer_size(stream, (v1tag ? -128 : 0) - 10, SEEK_END);
 	if (tagsize >= 0)
 		return v1tag;
 
 	/* Get the tag which the footer belongs to */
-	tag = getId3Tag(stream, tagsize, SEEK_CUR);
+	tag = tag_id3_read(stream, tagsize, SEEK_CUR);
 	if (!tag)
 		return v1tag;
 
@@ -516,11 +523,11 @@ struct tag *tag_id3_load(const char *file)
 		return NULL;
 	}
 
-	tag = findId3TagFromBeginning(stream);
+	tag = tag_id3_find_from_beginning(stream);
 	if (tag == NULL)
 		tag = tag_id3_riff_aiff_load(stream);
 	if (!tag)
-		tag = findId3TagFromEnd(stream);
+		tag = tag_id3_find_from_end(stream);
 
 	fclose(stream);