Commits

shuerhaaken committed 9993117

refactor

Comments (0)

Files changed (23)

bindings/c/taginfo_c.cc

 //! Get the content's type of the image.
 /*!
 \param img A TagInfo_Image object
-\return image type as TagInfo_ImageType
+\return image type as TagInfo_ImageContentType
 */
-TagInfo_ImageType taginfo_image_get_image_type(const TagInfo_Image * img) {
+TagInfo_ImageContentType taginfo_image_get_image_type(const TagInfo_Image * img) {
     if(!img)
-        return TAG_INFO_IMAGE_TYPE_OTHER;
+        return TAG_INFO_IMAGE_CONTENT_OTHER;
     const Image *i = reinterpret_cast<const Image *>(img);
-    return static_cast<TagInfo_ImageType>(i->get_image_type());
+    return static_cast<TagInfo_ImageContentType>(i->get_image_type());
 }
 
 //! Set the content's type of the image.
 /*!
 \param img A TagInfo_Image object
-\param itype image type as TagInfo_ImageType
+\param itype image type as TagInfo_ImageContentType
 */
-void taginfo_image_set_image_type(TagInfo_Image * img, TagInfo_ImageType itype) {
+void taginfo_image_set_image_type(TagInfo_Image * img, TagInfo_ImageContentType itype) {
     if(!img)
         return;
     Image *i = reinterpret_cast<Image *>(img);
-    i->set_image_type(static_cast<ImageType>(itype));
+    i->set_image_type(static_cast<Image::ContentType>(itype));
 }
 
 //! Get the file's type of the image.
     if(!img)
         return;
     Image *i = reinterpret_cast<Image *>(img);
-    i->set_image_file_type(static_cast<ImageFileType>(image_f_type));
+    i->set_image_file_type(static_cast<Image::FileType>(image_f_type));
 }
 
 //! Get the file's type of the image.

bindings/c/taginfo_c.h

 #endif
 
 
-//! \enum TagInfo_ImageFileType is an enumeration of image file types for embedded images
-typedef enum {
-        //! Unknown image file type
-    TAG_INFO_IMAGE_FILE_TYPE_UNKNOWN,
-        //! Jpg file type
-    TAG_INFO_IMAGE_FILE_TYPE_JPEG,
-        //! Png file type
-    TAG_INFO_IMAGE_FILE_TYPE_PNG,
-        //! Gif file type
-    TAG_INFO_IMAGE_FILE_TYPE_GIF,
-        //! Bitmap file type
-    TAG_INFO_IMAGE_FILE_TYPE_BMP
-} TagInfo_ImageFileType;
-
 //! \enum TagInfo_MediaFileType is an enumeration of media file types supported in libtaginfo
 typedef enum {
     //! Unknown media file type
     TAG_INFO_MEDIA_FILE_TYPE_OPUS
 } TagInfo_MediaFileType;
 
-//! \enum TagInfo_ImageType enumeration for image content description
+
+//! \enum TagInfo_ImageFileType is an enumeration of image file types for embedded images
+typedef enum {
+        //! Unknown image file type
+    TAG_INFO_IMAGE_FILE_TYPE_UNKNOWN,
+        //! Jpg file type
+    TAG_INFO_IMAGE_FILE_TYPE_JPEG,
+        //! Png file type
+    TAG_INFO_IMAGE_FILE_TYPE_PNG,
+        //! Gif file type
+    TAG_INFO_IMAGE_FILE_TYPE_GIF,
+        //! Bitmap file type
+    TAG_INFO_IMAGE_FILE_TYPE_BMP
+} TagInfo_ImageFileType;
+
+
+//! \enum TagInfo_ImageContentType enumeration for image content description
 typedef enum {
     //! An image type not listed here
-    TAG_INFO_IMAGE_TYPE_OTHER,
+    TAG_INFO_IMAGE_CONTENT_OTHER,
     //! 32x32 PNG image that should be used as the file icon
-    TAG_INFO_IMAGE_TYPE_FILE_ICON,
+    TAG_INFO_IMAGE_CONTENT_FILE_ICON,
     //! File icon of a different size or format
-    TAG_INFO_IMAGE_TYPE_OTHER_FILE_ICON,
+    TAG_INFO_IMAGE_CONTENT_OTHER_FILE_ICON,
     //! Front cover image of the album
-    TAG_INFO_IMAGE_TYPE_COVER_FRONT,
+    TAG_INFO_IMAGE_CONTENT_COVER_FRONT,
     //! Back cover image of the album
-    TAG_INFO_IMAGE_TYPE_COVER_BACK,
+    TAG_INFO_IMAGE_CONTENT_COVER_BACK,
     //! Inside leaflet page of the album
-    TAG_INFO_IMAGE_TYPE_LEAFLET_PAGE,
+    TAG_INFO_IMAGE_CONTENT_LEAFLET_PAGE,
     //! Image from the album itself
-    TAG_INFO_IMAGE_TYPE_MEDIA,
+    TAG_INFO_IMAGE_CONTENT_MEDIA,
     //! Picture of the lead artist or soloist
-    TAG_INFO_IMAGE_TYPE_LEAD_ARTIST,
+    TAG_INFO_IMAGE_CONTENT_LEAD_ARTIST,
     //! Picture of the artist or performer
-    TAG_INFO_IMAGE_TYPE_ARTIST,
+    TAG_INFO_IMAGE_CONTENT_ARTIST,
     //! Picture of the conductor
-    TAG_INFO_IMAGE_TYPE_CONDUCTOR,
+    TAG_INFO_IMAGE_CONTENT_CONDUCTOR,
     //! Picture of the band or orchestra
-    TAG_INFO_IMAGE_TYPE_BAND,
+    TAG_INFO_IMAGE_CONTENT_BAND,
     //! Picture of the composer
-    TAG_INFO_IMAGE_TYPE_COMPOSER,
+    TAG_INFO_IMAGE_CONTENT_COMPOSER,
     //! Picture of the lyricist or text writer
-    TAG_INFO_IMAGE_TYPE_LYRICIST,
+    TAG_INFO_IMAGE_CONTENT_LYRICIST,
     //! Picture of the recording location or studio
-    TAG_INFO_IMAGE_TYPE_RECORDING_LOCATION,
+    TAG_INFO_IMAGE_CONTENT_RECORDING_LOCATION,
     //! Picture of the artists during recording
-    TAG_INFO_IMAGE_TYPE_DURING_RECORDING,
+    TAG_INFO_IMAGE_CONTENT_DURING_RECORDING,
     //! Picture of the artists during performance
-    TAG_INFO_IMAGE_TYPE_DURING_PERFORMANCE,
+    TAG_INFO_IMAGE_CONTENT_DURING_PERFORMANCE,
     //! Picture from a movie or video related to the track
-    TAG_INFO_IMAGE_TYPE_MOVIESCREENCAPTURE,
+    TAG_INFO_IMAGE_CONTENT_MOVIESCREENCAPTURE,
     //! Picture of a large, coloured fish.
-    TAG_INFO_IMAGE_TYPE_COLOURED_FISH,
+    TAG_INFO_IMAGE_CONTENT_COLOURED_FISH,
     //! Illustration related to the track
-    TAG_INFO_IMAGE_TYPE_ILLUSTRATION,
+    TAG_INFO_IMAGE_CONTENT_ILLUSTRATION,
     //! Logo of the band or performer
-    TAG_INFO_IMAGE_TYPE_ARTIST_LOGO,
+    TAG_INFO_IMAGE_CONTENT_ARTIST_LOGO,
     //! Logo of the publisher (record company)
-    TAG_INFO_IMAGE_TYPE_PUBLISHER_LOGO
-} TagInfo_ImageType;
+    TAG_INFO_IMAGE_CONTENT_PUBLISHER_LOGO
+} TagInfo_ImageContentType;
 
 
 //! TagInfo_Info is an abstraction for accessing media file tags. 
 
 /*----------------------------------------------------------------------------------------*/
 // IMAGE API
-TagInfo_Image *         taginfo_image_new();
+TagInfo_Image *          taginfo_image_new();
 
-void                    taginfo_image_free(TagInfo_Image * img);
-void                    taginfo_image_array_free(TagInfo_Image ** img_arr);
+void                     taginfo_image_free(TagInfo_Image * img);
+void                     taginfo_image_array_free(TagInfo_Image ** img_arr);
 
-char *                  taginfo_image_get_data(const TagInfo_Image * img, unsigned int * bin_data_length);
-void                    taginfo_image_set_data(TagInfo_Image * img,
-                                               char * bin_data, 
-                                               unsigned int bin_data_length);
+char *                   taginfo_image_get_data(const TagInfo_Image * img, unsigned int * bin_data_length);
+void                     taginfo_image_set_data(TagInfo_Image * img,
+                                                char * bin_data, 
+                                                unsigned int bin_data_length);
 
-TagInfo_ImageType       taginfo_image_get_image_type(const TagInfo_Image * img);
-void                    taginfo_image_set_image_type(TagInfo_Image * img,
-                                                     TagInfo_ImageType itype);
+TagInfo_ImageContentType taginfo_image_get_image_type(const TagInfo_Image * img);
+void                     taginfo_image_set_image_type(TagInfo_Image * img,
+                                                      TagInfo_ImageContentType itype);
 
-TagInfo_ImageFileType   taginfo_image_get_image_file_type(const TagInfo_Image * img);
-void                    taginfo_image_set_image_file_type(TagInfo_Image * img,
-                                                          TagInfo_ImageFileType image_f_type);
+TagInfo_ImageFileType    taginfo_image_get_image_file_type(const TagInfo_Image * img);
+void                     taginfo_image_set_image_file_type(TagInfo_Image * img,
+                                                           TagInfo_ImageFileType image_f_type);
 
-char *                  taginfo_image_get_description(const TagInfo_Image * img);
-void                    taginfo_image_set_description(TagInfo_Image * img,
-                                                      const char * new_description);
+char *                   taginfo_image_get_description(const TagInfo_Image * img);
+void                     taginfo_image_set_description(TagInfo_Image * img,
+                                                       const char * new_description);
 /*----------------------------------------------------------------------------------------*/
 
 

bindings/vala/libtaginfo_c.vapi

 [CCode (cprefix = "TagInfo_", lower_case_cprefix = "taginfo_", cheader_filename = "taginfo_c.h")]
 namespace TagInfo
 {
-	[CCode (cname = "TagInfo_ImageFileType", cprefix = "TAG_INFO_IMAGE_FILE_TYPE_")]
-	public enum ImageFileType
-	{
-		UNKNOWN,
-		JPEG,
-		PNG,
-		GIF,
-		BMP
-	}
-	
 	[CCode (cname = "TagInfo_MediaFileType", cprefix = "TAG_INFO_MEDIA_FILE_TYPE_")]
 	public enum MediaFileType
 	{
 		OPUS
 	}
 	
-	[CCode (cname = "TagInfo_ImageType", cprefix = "TAG_INFO_IMAGE_TYPE_")]
-	public enum ImageType
-	{
-		//! An image type not listed here
-		OTHER,
-		//! 32x32 PNG image that should be used as the file icon
-		FILE_ICON,
-		//! File icon of a different size or format
-		OTHER_FILE_ICON,
-		//! Front cover image of the album
-		COVER_FRONT,
-		//! Back cover image of the album
-		COVER_BACK,
-		//! Inside leaflet page of the album
-		LEAFLET_PAGE,
-		//! Image from the album itself
-		MEDIA,
-		//! Picture of the lead artist or soloist
-		LEAD_ARTIST,
-		//! Picture of the artist or performer
-		ARTIST,
-		//! Picture of the conductor
-		CONDUCTOR,
-		//! Picture of the band or orchestra
-		BAND,
-		//! Picture of the composer
-		COMPOSER,
-		//! Picture of the lyricist or text writer
-		LYRICIST,
-		//! Picture of the recording location or studio
-		RECORDING_LOCATION,
-		//! Picture of the artists during recording
-		DURING_RECORDING,
-		//! Picture of the artists during performance
-		DURING_PERFORMANCE,
-		//! Picture from a movie or video related to the track
-		MOVIESCREENCAPTURE,
-		//! Picture of a large, coloured fish.
-		COLOURED_FISH,
-		//! Illustration related to the track
-		ILLUSTRATION,
-		//! Logo of the band or performer
-		ARTIST_LOGO,
-		//! Logo of the publisher (record company)
-		PUBLISHER_LOGO
-	}
-	
 	[Compact]
 	[CCode (free_function = "taginfo_image_free", cprefix = "taginfo_image_")]
 	public class Image
 	{
 		public Image();
+			
+		[CCode (cname = "TagInfo_ImageType", cprefix = "TAG_INFO_CONTENT_")]
+		public enum Type
+		{
+			//! An image type not listed here
+			OTHER,
+			//! 32x32 PNG image that should be used as the file icon
+			FILE_ICON,
+			//! File icon of a different size or format
+			OTHER_FILE_ICON,
+			//! Front cover image of the album
+			COVER_FRONT,
+			//! Back cover image of the album
+			COVER_BACK,
+			//! Inside leaflet page of the album
+			LEAFLET_PAGE,
+			//! Image from the album itself
+			MEDIA,
+			//! Picture of the lead artist or soloist
+			LEAD_ARTIST,
+			//! Picture of the artist or performer
+			ARTIST,
+			//! Picture of the conductor
+			CONDUCTOR,
+			//! Picture of the band or orchestra
+			BAND,
+			//! Picture of the composer
+			COMPOSER,
+			//! Picture of the lyricist or text writer
+			LYRICIST,
+			//! Picture of the recording location or studio
+			RECORDING_LOCATION,
+			//! Picture of the artists during recording
+			DURING_RECORDING,
+			//! Picture of the artists during performance
+			DURING_PERFORMANCE,
+			//! Picture from a movie or video related to the track
+			MOVIESCREENCAPTURE,
+			//! Picture of a large, coloured fish.
+			COLOURED_FISH,
+			//! Illustration related to the track
+			ILLUSTRATION,
+			//! Logo of the band or performer
+			ARTIST_LOGO,
+			//! Logo of the publisher (record company)
+			PUBLISHER_LOGO
+		}
 		
+		[CCode (cname = "TagInfo_ImageFileType", cprefix = "TAG_INFO_IMAGE_FILE_TYPE_")]
+		public enum FileType
+		{
+			UNKNOWN,
+			JPEG,
+			PNG,
+			GIF,
+			BMP
+		}
+	
 		[CCode (array_length_cname = "bin_data_length", array_length_type = "unsigned int")]
 		public uint8[] get_data();
 		public void set_data([CCode (array_length_cname = "bin_data_length", array_length_type = "unsigned int")] uint8[] data);
 			set;
 		}
 		public bool has_image {
-		    // A quick lookup without extracting anything
+			// A quick lookup without extracting anything
 			[CCode (cname = "taginfo_info_get_has_image")]
 			get;
 		}
 		
 		// USER LABELS
 		public string[] get_artist_labels ();
-		public void     set_artist_labels (string[] labels);
+		public void	 set_artist_labels (string[] labels);
 		
 		public string[] get_album_labels ();
-		public void     set_album_labels (string[] labels);
+		public void	 set_album_labels (string[] labels);
 		
 		public string[] get_track_labels ();
-		public void     set_track_labels (string[] labels);
+		public void	 set_track_labels (string[] labels);
 		
 		// IMAGE ACCESS
 		public Image[]  get_images ();
-		public void     set_images (Image[] images);
+		public void	 set_images (Image[] images);
 		
 		// LYRICS ACCESS
 		public string lyrics {

libtaginfo/apetaginfo.cc

 }
 
 void extract_image(const APE::Item &image_item, Image *& image) {
-    image->set_image_file_type(IMAGE_FILE_TYPE_UNKNOWN);
+    image->set_image_file_type(Image::TYPE_UNKNOWN);
     if(image_item.type() == APE::Item::Binary) {
         ByteVector CoverData = image_item.binaryData();
         if(CoverData.size() > 0) {
     }
 }
 
-String image_type_to_ape_image_name(const ImageType& image_type) {
+String image_type_to_ape_image_name(const Image::ContentType& image_type) {
     switch(image_type) {
-        case IMAGE_TYPE_COVER_FRONT :
+        case Image::CONTENT_COVER_FRONT :
             return APE_TAG_COVER_ART_FRONT;
-        case IMAGE_TYPE_COVER_BACK :
+        case Image::CONTENT_COVER_BACK :
             return APE_TAG_COVER_ART_BACK;
-        case IMAGE_TYPE_OTHER :
+        case Image::CONTENT_OTHER :
             return APE_TAG_COVER_ART_OTHER;
-        case IMAGE_TYPE_FILE_ICON :
+        case Image::CONTENT_FILE_ICON :
             return APE_TAG_COVER_ART_ICON;
-        case IMAGE_TYPE_OTHER_FILE_ICON :
+        case Image::CONTENT_OTHER_FILE_ICON :
             return APE_TAG_COVER_ART_OTHER_ICON;
-        case IMAGE_TYPE_LEAFLET_PAGE :
+        case Image::CONTENT_LEAFLET_PAGE :
             return APE_TAG_COVER_ART_LEAFLET;
-        case IMAGE_TYPE_MEDIA  :
+        case Image::CONTENT_MEDIA  :
             return APE_TAG_COVER_ART_MEDIA;
-        case IMAGE_TYPE_LEAD_ARTIST :
+        case Image::CONTENT_LEAD_ARTIST :
             return APE_TAG_COVER_ART_LEAD;
-        case IMAGE_TYPE_ARTIST :
+        case Image::CONTENT_ARTIST :
             return APE_TAG_COVER_ART_ARTIST;
-        case IMAGE_TYPE_CONDUCTOR :
+        case Image::CONTENT_CONDUCTOR :
             return APE_TAG_COVER_ART_CONDUCTOR;
-        case IMAGE_TYPE_BAND :
+        case Image::CONTENT_BAND :
             return APE_TAG_COVER_ART_BAND;
-        case IMAGE_TYPE_COMPOSER :
+        case Image::CONTENT_COMPOSER :
             return APE_TAG_COVER_ART_COMPOSER;
-        case IMAGE_TYPE_LYRICIST :
+        case Image::CONTENT_LYRICIST :
             return APE_TAG_COVER_ART_LYRICIST;
-        case IMAGE_TYPE_RECORDING_LOCATION :
+        case Image::CONTENT_RECORDING_LOCATION :
             return APE_TAG_COVER_ART_STUDIO;
-        case IMAGE_TYPE_DURING_RECORDING :
+        case Image::CONTENT_DURING_RECORDING :
             return APE_TAG_COVER_ART_RECORDING;
-        case IMAGE_TYPE_DURING_PERFORMANCE :
+        case Image::CONTENT_DURING_PERFORMANCE :
             return APE_TAG_COVER_ART_PERFORMANCE;;
-        case IMAGE_TYPE_MOVIESCREENCAPTURE :
+        case Image::CONTENT_MOVIESCREENCAPTURE :
             return APE_TAG_COVER_ART_MOVIE_SCENE;;
-        case IMAGE_TYPE_COLOURED_FISH :
+        case Image::CONTENT_COLOURED_FISH :
             return APE_TAG_COVER_ART_COLORED_FISH;
-        case IMAGE_TYPE_ILLUSTRATION :
+        case Image::CONTENT_ILLUSTRATION :
             return APE_TAG_COVER_ART_ILLUSTRATION;
-        case IMAGE_TYPE_ARTIST_LOGO :
+        case Image::CONTENT_ARTIST_LOGO :
             return APE_TAG_COVER_ART_BAND_LOGO;
-        case IMAGE_TYPE_PUBLISHER_LOGO :
+        case Image::CONTENT_PUBLISHER_LOGO :
             return APE_TAG_COVER_ART_PUBLISHER_LOGO;
         default:
             return APE_TAG_COVER_ART_OTHER;
     }
 }
 
-ImageType ape_image_type_to_image_type(const String &nme) {
+Image::ContentType ape_image_type_to_image_type(const String &nme) {
     if(nme == APE_TAG_COVER_ART_FRONT)
-        return IMAGE_TYPE_COVER_FRONT;
+        return Image::CONTENT_COVER_FRONT;
     else if(nme == APE_TAG_COVER_ART_OTHER)
-        return IMAGE_TYPE_OTHER;
+        return Image::CONTENT_OTHER;
     else if(nme == APE_TAG_COVER_ART_BACK)
-        return IMAGE_TYPE_COVER_BACK;
+        return Image::CONTENT_COVER_BACK;
     else if(nme == APE_TAG_COVER_ART_ICON)
-        return IMAGE_TYPE_FILE_ICON;
+        return Image::CONTENT_FILE_ICON;
     else if(nme == APE_TAG_COVER_ART_OTHER_ICON)
-        return IMAGE_TYPE_OTHER_FILE_ICON;
+        return Image::CONTENT_OTHER_FILE_ICON;
     else if(nme == APE_TAG_COVER_ART_LEAFLET)
-        return IMAGE_TYPE_LEAFLET_PAGE;
+        return Image::CONTENT_LEAFLET_PAGE;
     else if(nme == APE_TAG_COVER_ART_MEDIA)
-        return IMAGE_TYPE_MEDIA;
+        return Image::CONTENT_MEDIA;
     else if(nme == APE_TAG_COVER_ART_LEAD)
-        return IMAGE_TYPE_LEAD_ARTIST;
+        return Image::CONTENT_LEAD_ARTIST;
     else if(nme == APE_TAG_COVER_ART_ARTIST)
-        return IMAGE_TYPE_ARTIST;
+        return Image::CONTENT_ARTIST;
     else if(nme == APE_TAG_COVER_ART_CONDUCTOR)
-        return IMAGE_TYPE_CONDUCTOR;
+        return Image::CONTENT_CONDUCTOR;
     else if(nme == APE_TAG_COVER_ART_BAND)
-        return IMAGE_TYPE_BAND;
+        return Image::CONTENT_BAND;
     else if(nme == APE_TAG_COVER_ART_COMPOSER)
-        return IMAGE_TYPE_COMPOSER;
+        return Image::CONTENT_COMPOSER;
     else if(nme == APE_TAG_COVER_ART_LYRICIST)
-        return IMAGE_TYPE_LYRICIST;
+        return Image::CONTENT_LYRICIST;
     else if(nme == APE_TAG_COVER_ART_STUDIO)
-        return IMAGE_TYPE_RECORDING_LOCATION;
+        return Image::CONTENT_RECORDING_LOCATION;
     else if(nme == APE_TAG_COVER_ART_RECORDING)
-        return IMAGE_TYPE_DURING_RECORDING;
+        return Image::CONTENT_DURING_RECORDING;
     else if(nme == APE_TAG_COVER_ART_PERFORMANCE)
-        return IMAGE_TYPE_DURING_PERFORMANCE;
+        return Image::CONTENT_DURING_PERFORMANCE;
     else if(nme == APE_TAG_COVER_ART_MOVIE_SCENE)
-        return IMAGE_TYPE_MOVIESCREENCAPTURE;
+        return Image::CONTENT_MOVIESCREENCAPTURE;
     else if(nme == APE_TAG_COVER_ART_COLORED_FISH)
-        return IMAGE_TYPE_COLOURED_FISH;
+        return Image::CONTENT_COLOURED_FISH;
     else if(nme == APE_TAG_COVER_ART_ILLUSTRATION)
-        return IMAGE_TYPE_ILLUSTRATION;
+        return Image::CONTENT_ILLUSTRATION;
     else if(nme == APE_TAG_COVER_ART_BAND_LOGO)
-        return IMAGE_TYPE_ARTIST_LOGO;
+        return Image::CONTENT_ARTIST_LOGO;
     else if(nme == APE_TAG_COVER_ART_PUBLISHER_LOGO)
-        return IMAGE_TYPE_PUBLISHER_LOGO;
+        return Image::CONTENT_PUBLISHER_LOGO;
     else
-        return IMAGE_TYPE_OTHER;
+        return Image::CONTENT_OTHER;
 }
 
 

libtaginfo/asfinfo.cc

     return 5;
 }
 
-ImageType get_image_type_from_pic_type(const ASF::Picture::Type& tpe) {
+Image::ContentType get_image_type_from_pic_type(const ASF::Picture::Type& tpe) {
     switch(tpe) {
         case ASF::Picture::FrontCover :
-            return IMAGE_TYPE_COVER_FRONT;
+            return Image::CONTENT_COVER_FRONT;
         case ASF::Picture::BackCover :
-            return IMAGE_TYPE_COVER_BACK;
+            return Image::CONTENT_COVER_BACK;
         case ASF::Picture::Other :
-            return IMAGE_TYPE_OTHER;
+            return Image::CONTENT_OTHER;
         case ASF::Picture::FileIcon :
-            return IMAGE_TYPE_FILE_ICON;
+            return Image::CONTENT_FILE_ICON;
         case ASF::Picture::OtherFileIcon :
-            return IMAGE_TYPE_OTHER_FILE_ICON;
+            return Image::CONTENT_OTHER_FILE_ICON;
         case ASF::Picture::LeafletPage :
-            return IMAGE_TYPE_LEAFLET_PAGE;
+            return Image::CONTENT_LEAFLET_PAGE;
         case ASF::Picture::Media :
-            return IMAGE_TYPE_MEDIA;
+            return Image::CONTENT_MEDIA;
         case ASF::Picture::LeadArtist :
-            return IMAGE_TYPE_LEAD_ARTIST;
+            return Image::CONTENT_LEAD_ARTIST;
         case ASF::Picture::Artist :
-            return IMAGE_TYPE_ARTIST;
+            return Image::CONTENT_ARTIST;
         case ASF::Picture::Conductor :
-            return IMAGE_TYPE_CONDUCTOR;
+            return Image::CONTENT_CONDUCTOR;
         case ASF::Picture::Band :
-            return IMAGE_TYPE_BAND;
+            return Image::CONTENT_BAND;
         case ASF::Picture::Composer :
-            return IMAGE_TYPE_COMPOSER;
+            return Image::CONTENT_COMPOSER;
         case ASF::Picture::Lyricist :
-            return IMAGE_TYPE_LYRICIST;
+            return Image::CONTENT_LYRICIST;
         case ASF::Picture::RecordingLocation :
-            return IMAGE_TYPE_RECORDING_LOCATION;
+            return Image::CONTENT_RECORDING_LOCATION;
         case ASF::Picture::DuringRecording :
-            return IMAGE_TYPE_DURING_RECORDING;
+            return Image::CONTENT_DURING_RECORDING;
         case ASF::Picture::DuringPerformance :
-            return IMAGE_TYPE_DURING_PERFORMANCE;
+            return Image::CONTENT_DURING_PERFORMANCE;
         case ASF::Picture::MovieScreenCapture :
-            return IMAGE_TYPE_MOVIESCREENCAPTURE;
+            return Image::CONTENT_MOVIESCREENCAPTURE;
         case ASF::Picture::ColouredFish :
-            return IMAGE_TYPE_COLOURED_FISH;
+            return Image::CONTENT_COLOURED_FISH;
         case ASF::Picture::Illustration :
-            return IMAGE_TYPE_ILLUSTRATION;
+            return Image::CONTENT_ILLUSTRATION;
         case ASF::Picture::BandLogo :
-            return IMAGE_TYPE_ARTIST_LOGO;
+            return Image::CONTENT_ARTIST_LOGO;
         case ASF::Picture::PublisherLogo :
-            return IMAGE_TYPE_PUBLISHER_LOGO;
+            return Image::CONTENT_PUBLISHER_LOGO;
         default:
-            return IMAGE_TYPE_OTHER;
+            return Image::CONTENT_OTHER;
     }
 }
 
-ASF::Picture::Type image_type_to_picture_type(const ImageType& image_type) {
+ASF::Picture::Type image_type_to_picture_type(const Image::ContentType &image_type) {
     switch(image_type) {
-        case IMAGE_TYPE_COVER_FRONT :
+        case Image::CONTENT_COVER_FRONT :
             return ASF::Picture::FrontCover;
-        case IMAGE_TYPE_COVER_BACK :
+        case Image::CONTENT_COVER_BACK :
             return ASF::Picture::BackCover;
-        case IMAGE_TYPE_OTHER :
+        case Image::CONTENT_OTHER :
             return ASF::Picture::Other;
-        case IMAGE_TYPE_FILE_ICON :
+        case Image::CONTENT_FILE_ICON :
             return ASF::Picture::FileIcon;
-        case IMAGE_TYPE_OTHER_FILE_ICON :
+        case Image::CONTENT_OTHER_FILE_ICON :
             return ASF::Picture::OtherFileIcon;
-        case IMAGE_TYPE_LEAFLET_PAGE :
+        case Image::CONTENT_LEAFLET_PAGE :
             return ASF::Picture::LeafletPage;
-        case IMAGE_TYPE_MEDIA  :
+        case Image::CONTENT_MEDIA  :
             return ASF::Picture::Media;
-        case IMAGE_TYPE_LEAD_ARTIST :
+        case Image::CONTENT_LEAD_ARTIST :
             return ASF::Picture::LeadArtist;
-        case IMAGE_TYPE_ARTIST :
+        case Image::CONTENT_ARTIST :
             return ASF::Picture::Artist;
-        case IMAGE_TYPE_CONDUCTOR :
+        case Image::CONTENT_CONDUCTOR :
             return ASF::Picture::Conductor;
-        case IMAGE_TYPE_BAND :
+        case Image::CONTENT_BAND :
             return ASF::Picture::Band;
-        case IMAGE_TYPE_COMPOSER :
+        case Image::CONTENT_COMPOSER :
             return ASF::Picture::Composer;
-        case IMAGE_TYPE_LYRICIST :
+        case Image::CONTENT_LYRICIST :
             return ASF::Picture::Lyricist;
-        case IMAGE_TYPE_RECORDING_LOCATION :
+        case Image::CONTENT_RECORDING_LOCATION :
             return ASF::Picture::RecordingLocation;
-        case IMAGE_TYPE_DURING_RECORDING :
+        case Image::CONTENT_DURING_RECORDING :
             return ASF::Picture::DuringRecording;
-        case IMAGE_TYPE_DURING_PERFORMANCE :
+        case Image::CONTENT_DURING_PERFORMANCE :
             return ASF::Picture::DuringPerformance;
-        case IMAGE_TYPE_MOVIESCREENCAPTURE :
+        case Image::CONTENT_MOVIESCREENCAPTURE :
             return ASF::Picture::MovieScreenCapture;
-        case IMAGE_TYPE_COLOURED_FISH :
+        case Image::CONTENT_COLOURED_FISH :
             return ASF::Picture::ColouredFish;
-        case IMAGE_TYPE_ILLUSTRATION :
+        case Image::CONTENT_ILLUSTRATION :
             return ASF::Picture::Illustration;
-        case IMAGE_TYPE_ARTIST_LOGO :
+        case Image::CONTENT_ARTIST_LOGO :
             return ASF::Picture::BandLogo;
-        case IMAGE_TYPE_PUBLISHER_LOGO :
+        case Image::CONTENT_PUBLISHER_LOGO :
             return ASF::Picture::PublisherLogo;
         default:
             return ASF::Picture::Other;
                         
                         String mimetype = pict.mimeType();
                         if(mimetype.find("/jpeg") != -1 || mimetype.find("/jpg") != -1)
-                            image->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
+                            image->set_image_file_type(Image::TYPE_JPEG);
                         else if(mimetype.find("/png") != -1)
-                            image->set_image_file_type(IMAGE_FILE_TYPE_PNG);
+                            image->set_image_file_type(Image::TYPE_PNG);
                         else if(mimetype.find("/bmp") != -1)
-                            image->set_image_file_type(IMAGE_FILE_TYPE_BMP);
+                            image->set_image_file_type(Image::TYPE_BMP);
                         else if(mimetype.find("/gif") != -1)
-                            image->set_image_file_type(IMAGE_FILE_TYPE_GIF);
+                            image->set_image_file_type(Image::TYPE_GIF);
                         
                         image->set_image_type(get_image_type_from_pic_type(pict.type())); 
                         image->set_description(pict.description());
             if( image->get_data().isEmpty())
                 continue;
             ASF::Picture picture = ASF::Picture();
-            if(image->get_image_file_type() == IMAGE_FILE_TYPE_JPEG) //default to jpeg
+            if(image->get_image_file_type() == Image::TYPE_JPEG) //default to jpeg
                 picture.setMimeType("image/jpeg");
-            else if(image->get_image_file_type() == IMAGE_FILE_TYPE_PNG)
+            else if(image->get_image_file_type() == Image::TYPE_PNG)
                 picture.setMimeType("image/png");
-            else if(image->get_image_file_type() == IMAGE_FILE_TYPE_GIF)
+            else if(image->get_image_file_type() == Image::TYPE_GIF)
                 picture.setMimeType("image/gif");
-            else if(image->get_image_file_type() == IMAGE_FILE_TYPE_BMP)
+            else if(image->get_image_file_type() == Image::TYPE_BMP)
                 picture.setMimeType("image/bmp");
             
             ByteVector img_vect(image->get_data());

libtaginfo/flacinfo.cc

     return false;
 }
 
-ImageType flac_image_type_to_image_type(const FLAC::Picture::Type &tpe) {
+Image::ContentType flac_image_type_to_image_type(const FLAC::Picture::Type &tpe) {
     switch(tpe) {
         case FLAC::Picture::FrontCover:
-            return IMAGE_TYPE_COVER_FRONT;
+            return Image::CONTENT_COVER_FRONT;
         case FLAC::Picture::BackCover:
-            return IMAGE_TYPE_COVER_BACK;
+            return Image::CONTENT_COVER_BACK;
         case FLAC::Picture::Other:
-            return IMAGE_TYPE_OTHER;
+            return Image::CONTENT_OTHER;
         case FLAC::Picture::FileIcon:
-            return IMAGE_TYPE_FILE_ICON;
+            return Image::CONTENT_FILE_ICON;
         case FLAC::Picture::OtherFileIcon:
-            return IMAGE_TYPE_OTHER_FILE_ICON;
+            return Image::CONTENT_OTHER_FILE_ICON;
         case FLAC::Picture::LeafletPage:
-            return IMAGE_TYPE_LEAFLET_PAGE;
+            return Image::CONTENT_LEAFLET_PAGE;
         case FLAC::Picture::Media:
-            return IMAGE_TYPE_MEDIA;
+            return Image::CONTENT_MEDIA;
         case FLAC::Picture::LeadArtist:
-            return IMAGE_TYPE_LEAD_ARTIST;
+            return Image::CONTENT_LEAD_ARTIST;
         case FLAC::Picture::Artist:
-            return IMAGE_TYPE_ARTIST;
+            return Image::CONTENT_ARTIST;
         case FLAC::Picture::Conductor:
-            return IMAGE_TYPE_CONDUCTOR;
+            return Image::CONTENT_CONDUCTOR;
         case FLAC::Picture::Band:
-            return IMAGE_TYPE_BAND;
+            return Image::CONTENT_BAND;
         case FLAC::Picture::Composer:
-            return IMAGE_TYPE_COMPOSER;
+            return Image::CONTENT_COMPOSER;
         case FLAC::Picture::Lyricist:
-            return IMAGE_TYPE_LYRICIST;
+            return Image::CONTENT_LYRICIST;
         case FLAC::Picture::RecordingLocation:
-            return IMAGE_TYPE_RECORDING_LOCATION;
+            return Image::CONTENT_RECORDING_LOCATION;
         case FLAC::Picture::DuringRecording:
-            return IMAGE_TYPE_DURING_RECORDING;
+            return Image::CONTENT_DURING_RECORDING;
         case FLAC::Picture::DuringPerformance:
-            return IMAGE_TYPE_DURING_PERFORMANCE;
+            return Image::CONTENT_DURING_PERFORMANCE;
         case FLAC::Picture::MovieScreenCapture:
-            return IMAGE_TYPE_MOVIESCREENCAPTURE;
+            return Image::CONTENT_MOVIESCREENCAPTURE;
         case FLAC::Picture::ColouredFish:
-            return IMAGE_TYPE_COLOURED_FISH;
+            return Image::CONTENT_COLOURED_FISH;
         case FLAC::Picture::Illustration:
-            return IMAGE_TYPE_ILLUSTRATION;
+            return Image::CONTENT_ILLUSTRATION;
         case FLAC::Picture::BandLogo:
-            return IMAGE_TYPE_ARTIST_LOGO;
+            return Image::CONTENT_ARTIST_LOGO;
         case FLAC::Picture::PublisherLogo:
-            return IMAGE_TYPE_PUBLISHER_LOGO;
+            return Image::CONTENT_PUBLISHER_LOGO;
         default:
-            return IMAGE_TYPE_OTHER;
+            return Image::CONTENT_OTHER;
     }
 }
 

libtaginfo/id3info.cc

 
 
 
-ID3v2::AttachedPictureFrame::Type image_type_to_picframetype(const ImageType& image_type) {
+ID3v2::AttachedPictureFrame::Type image_type_to_picframetype(const Image::ContentType &image_type) {
     switch(image_type) {
-        case IMAGE_TYPE_COVER_FRONT :
+        case Image::CONTENT_COVER_FRONT :
             return ID3v2::AttachedPictureFrame::FrontCover;
-        case IMAGE_TYPE_COVER_BACK :
+        case Image::CONTENT_COVER_BACK :
             return ID3v2::AttachedPictureFrame::BackCover;
-        case IMAGE_TYPE_OTHER :
+        case Image::CONTENT_OTHER :
             return ID3v2::AttachedPictureFrame::Other;
-        case IMAGE_TYPE_FILE_ICON :
+        case Image::CONTENT_FILE_ICON :
             return ID3v2::AttachedPictureFrame::FileIcon;
-        case IMAGE_TYPE_OTHER_FILE_ICON :
+        case Image::CONTENT_OTHER_FILE_ICON :
             return ID3v2::AttachedPictureFrame::OtherFileIcon;
-        case IMAGE_TYPE_LEAFLET_PAGE :
+        case Image::CONTENT_LEAFLET_PAGE :
             return ID3v2::AttachedPictureFrame::LeafletPage;
-        case IMAGE_TYPE_MEDIA  :
+        case Image::CONTENT_MEDIA  :
             return ID3v2::AttachedPictureFrame::Media;
-        case IMAGE_TYPE_LEAD_ARTIST :
+        case Image::CONTENT_LEAD_ARTIST :
             return ID3v2::AttachedPictureFrame::LeadArtist;
-        case IMAGE_TYPE_ARTIST :
+        case Image::CONTENT_ARTIST :
             return ID3v2::AttachedPictureFrame::Artist;
-        case IMAGE_TYPE_CONDUCTOR :
+        case Image::CONTENT_CONDUCTOR :
             return ID3v2::AttachedPictureFrame::Conductor;
-        case IMAGE_TYPE_BAND :
+        case Image::CONTENT_BAND :
             return ID3v2::AttachedPictureFrame::Band;
-        case IMAGE_TYPE_COMPOSER :
+        case Image::CONTENT_COMPOSER :
             return ID3v2::AttachedPictureFrame::Composer;
-        case IMAGE_TYPE_LYRICIST :
+        case Image::CONTENT_LYRICIST :
             return ID3v2::AttachedPictureFrame::Lyricist;
-        case IMAGE_TYPE_RECORDING_LOCATION :
+        case Image::CONTENT_RECORDING_LOCATION :
             return ID3v2::AttachedPictureFrame::RecordingLocation;
-        case IMAGE_TYPE_DURING_RECORDING :
+        case Image::CONTENT_DURING_RECORDING :
             return ID3v2::AttachedPictureFrame::DuringRecording;
-        case IMAGE_TYPE_DURING_PERFORMANCE :
+        case Image::CONTENT_DURING_PERFORMANCE :
             return ID3v2::AttachedPictureFrame::DuringPerformance;
-        case IMAGE_TYPE_MOVIESCREENCAPTURE :
+        case Image::CONTENT_MOVIESCREENCAPTURE :
             return ID3v2::AttachedPictureFrame::MovieScreenCapture;
-        case IMAGE_TYPE_COLOURED_FISH :
+        case Image::CONTENT_COLOURED_FISH :
             return ID3v2::AttachedPictureFrame::ColouredFish;
-        case IMAGE_TYPE_ILLUSTRATION :
+        case Image::CONTENT_ILLUSTRATION :
             return ID3v2::AttachedPictureFrame::Illustration;
-        case IMAGE_TYPE_ARTIST_LOGO :
+        case Image::CONTENT_ARTIST_LOGO :
             return ID3v2::AttachedPictureFrame::BandLogo;
-        case IMAGE_TYPE_PUBLISHER_LOGO :
+        case Image::CONTENT_PUBLISHER_LOGO :
             return ID3v2::AttachedPictureFrame::PublisherLogo;
         default:
             return ID3v2::AttachedPictureFrame::Other;
     return Info::save();
 }
 
-ImageType get_image_type_from_pic_frame_type(const ID3v2::AttachedPictureFrame::Type &tpe) {
+Image::ContentType get_image_type_from_pic_frame_type(const ID3v2::AttachedPictureFrame::Type &tpe) {
     switch(tpe) {
         case ID3v2::AttachedPictureFrame::FrontCover:
-            return IMAGE_TYPE_COVER_FRONT;
+            return Image::CONTENT_COVER_FRONT;
         case ID3v2::AttachedPictureFrame::BackCover:
-            return IMAGE_TYPE_COVER_BACK;
+            return Image::CONTENT_COVER_BACK;
         case ID3v2::AttachedPictureFrame::Other:
-            return IMAGE_TYPE_OTHER;
+            return Image::CONTENT_OTHER;
         case ID3v2::AttachedPictureFrame::FileIcon:
-            return IMAGE_TYPE_FILE_ICON;
+            return Image::CONTENT_FILE_ICON;
         case ID3v2::AttachedPictureFrame::OtherFileIcon:
-            return IMAGE_TYPE_OTHER_FILE_ICON;
+            return Image::CONTENT_OTHER_FILE_ICON;
         case ID3v2::AttachedPictureFrame::LeafletPage:
-            return IMAGE_TYPE_LEAFLET_PAGE;
+            return Image::CONTENT_LEAFLET_PAGE;
         case ID3v2::AttachedPictureFrame::Media:
-            return IMAGE_TYPE_MEDIA;
+            return Image::CONTENT_MEDIA;
         case ID3v2::AttachedPictureFrame::LeadArtist:
-            return IMAGE_TYPE_LEAD_ARTIST;
+            return Image::CONTENT_LEAD_ARTIST;
         case ID3v2::AttachedPictureFrame::Artist:
-            return IMAGE_TYPE_ARTIST;
+            return Image::CONTENT_ARTIST;
         case ID3v2::AttachedPictureFrame::Conductor:
-            return IMAGE_TYPE_CONDUCTOR;
+            return Image::CONTENT_CONDUCTOR;
         case ID3v2::AttachedPictureFrame::Band:
-            return IMAGE_TYPE_BAND;
+            return Image::CONTENT_BAND;
         case ID3v2::AttachedPictureFrame::Composer:
-            return IMAGE_TYPE_COMPOSER;
+            return Image::CONTENT_COMPOSER;
         case ID3v2::AttachedPictureFrame::Lyricist:
-            return IMAGE_TYPE_LYRICIST;
+            return Image::CONTENT_LYRICIST;
         case ID3v2::AttachedPictureFrame::RecordingLocation:
-            return IMAGE_TYPE_RECORDING_LOCATION;
+            return Image::CONTENT_RECORDING_LOCATION;
         case ID3v2::AttachedPictureFrame::DuringRecording:
-            return IMAGE_TYPE_DURING_RECORDING;
+            return Image::CONTENT_DURING_RECORDING;
         case ID3v2::AttachedPictureFrame::DuringPerformance:
-            return IMAGE_TYPE_DURING_PERFORMANCE;
+            return Image::CONTENT_DURING_PERFORMANCE;
         case ID3v2::AttachedPictureFrame::MovieScreenCapture:
-            return IMAGE_TYPE_MOVIESCREENCAPTURE;
+            return Image::CONTENT_MOVIESCREENCAPTURE;
         case ID3v2::AttachedPictureFrame::ColouredFish:
-            return IMAGE_TYPE_COLOURED_FISH;
+            return Image::CONTENT_COLOURED_FISH;
         case ID3v2::AttachedPictureFrame::Illustration:
-            return IMAGE_TYPE_ILLUSTRATION;
+            return Image::CONTENT_ILLUSTRATION;
         case ID3v2::AttachedPictureFrame::BandLogo:
-            return IMAGE_TYPE_ARTIST_LOGO;
+            return Image::CONTENT_ARTIST_LOGO;
         case ID3v2::AttachedPictureFrame::PublisherLogo:
-            return IMAGE_TYPE_PUBLISHER_LOGO;
+            return Image::CONTENT_PUBLISHER_LOGO;
         default:
-            return IMAGE_TYPE_OTHER;
+            return Image::CONTENT_OTHER;
     }
 }
 
                 image->set_data(pic_frame->picture());
                 String mimetype = pic_frame->mimeType();
                 if(mimetype.find("/jpeg") != -1 || mimetype.find("/jpg") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
+                    image->set_image_file_type(Image::TYPE_JPEG);
                 else if(mimetype.find("/png") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_PNG);
+                    image->set_image_file_type(Image::TYPE_PNG);
                 else if(mimetype.find("/gif") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_GIF);
+                    image->set_image_file_type(Image::TYPE_GIF);
                 else if(mimetype.find("/bmp") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_BMP);
+                    image->set_image_file_type(Image::TYPE_BMP);
                 image->set_description(pic_frame->description());
             }
             images.append(image);
                     taglib_tagId3v2->removeFrame(PicFrame, true);
             }
             PicFrame = new ID3v2::AttachedPictureFrame;
-            if((*it)->get_image_file_type() == IMAGE_FILE_TYPE_JPEG || 
-               (*it)->get_image_file_type() == IMAGE_FILE_TYPE_UNKNOWN) //default to jpeg
+            if((*it)->get_image_file_type() == Image::TYPE_JPEG || 
+               (*it)->get_image_file_type() == Image::TYPE_UNKNOWN) //default to jpeg
                 PicFrame->setMimeType("image/jpeg");
-            else if((*it)->get_image_file_type() == IMAGE_FILE_TYPE_PNG)
+            else if((*it)->get_image_file_type() == Image::TYPE_PNG)
                 PicFrame->setMimeType("image/png");
-            else if((*it)->get_image_file_type() == IMAGE_FILE_TYPE_GIF)
+            else if((*it)->get_image_file_type() == Image::TYPE_GIF)
                 PicFrame->setMimeType("image/gif");
-            else if((*it)->get_image_file_type() == IMAGE_FILE_TYPE_BMP)
+            else if((*it)->get_image_file_type() == Image::TYPE_BMP)
                 PicFrame->setMimeType("image/bmp");
             PicFrame->setType(image_type_to_picframetype((*it)->get_image_type()));
             if(!(*it)->get_description().isEmpty())

libtaginfo/image.cc

 
 //! Constructor
 Image::Image() {
-    image_type      = IMAGE_TYPE_OTHER;
-    image_file_type = IMAGE_FILE_TYPE_UNKNOWN;
+    image_type      = Image::CONTENT_OTHER;
+    image_file_type = Image::TYPE_UNKNOWN;
     description     = String::null;
 }
 
 
 //! Get the image content's type from the Image object.
 //! \return type as ImageType
-ImageType Image::get_image_type(void) const {
+Image::ContentType Image::get_image_type(void) const {
     return image_type;
 }
 //! Set the image content's type in the Image object.
 //! \param it as ImageType
-void Image::set_image_type(const ImageType it) {
+void Image::set_image_type(const Image::ContentType it) {
     image_type = it;
 }
 
 //! Get the image file's type from the Image object.
 //! \return type as ImageFileType
-ImageFileType Image::get_image_file_type(void) const {
+Image::FileType Image::get_image_file_type(void) const {
     return image_file_type;
 }
 //! Set the image file's type in the Image object.
 //! \param ft as ImageFileType
-void Image::set_image_file_type(const ImageFileType ft) {
+void Image::set_image_file_type(const Image::FileType ft) {
     image_file_type = ft;
 }
 

libtaginfo/mp4info.cc

 }
 
 
-ImageFileType get_image_file_type_from_format(MP4::CoverArt::Format format) {
+Image::FileType get_image_file_type_from_format(MP4::CoverArt::Format format) {
     switch(format) {
         case MP4::CoverArt::JPEG:
-            return IMAGE_FILE_TYPE_JPEG;
+            return Image::TYPE_JPEG;
         case MP4::CoverArt::PNG:
-            return IMAGE_FILE_TYPE_PNG;
+            return Image::TYPE_PNG;
         case MP4::CoverArt::BMP:
-            return IMAGE_FILE_TYPE_BMP;
+            return Image::TYPE_BMP;
         case MP4::CoverArt::GIF:
-            return IMAGE_FILE_TYPE_GIF;
+            return Image::TYPE_GIF;
         default:
-            return IMAGE_FILE_TYPE_UNKNOWN;
+            return Image::TYPE_UNKNOWN;
     }
 }
 
-MP4::CoverArt::Format get_format_from_image_file_type(ImageFileType image_file_type) {
+MP4::CoverArt::Format get_format_from_image_file_type(Image::FileType image_file_type) {
     switch(image_file_type) {
-        case IMAGE_FILE_TYPE_JPEG:
+        case Image::TYPE_JPEG:
             return MP4::CoverArt::JPEG;
             break;
-        case IMAGE_FILE_TYPE_PNG:
+        case Image::TYPE_PNG:
             return MP4::CoverArt::PNG;
             break;
-        case IMAGE_FILE_TYPE_BMP:
+        case Image::TYPE_BMP:
             return MP4::CoverArt::BMP;
             break;
-        case IMAGE_FILE_TYPE_GIF:
+        case Image::TYPE_GIF:
             return MP4::CoverArt::GIF;
             break;
         default:
             Image * image = NULL;
             for(MP4::CoverArtList::Iterator it = covers.begin(); it != covers.end(); it++) {
                 image = new Image();
-                image->set_image_type(IMAGE_TYPE_OTHER);
+                image->set_image_type(Image::CONTENT_OTHER);
                 image->set_data(it->data());
                 image->set_image_file_type(get_image_file_type_from_format(it->format()));
                 if(!it->data().isEmpty())

libtaginfo/taginfo_image.h

 
 namespace TagInfo {
     
-    //! \enum ImageFileType The enumeration type for the image encoding
-    /*!
-    * Binary formats of embedded images (jpeg, png, ...)
-    */
-    enum ImageFileType {
-        //! Unknown image file type
-        IMAGE_FILE_TYPE_UNKNOWN,
-        //! Jpg file type
-        IMAGE_FILE_TYPE_JPEG,
-        //! Png file type
-        IMAGE_FILE_TYPE_PNG,
-        //! Gif file type
-        IMAGE_FILE_TYPE_GIF,
-        //! Bitmap file type
-        IMAGE_FILE_TYPE_BMP
-    };
-    
-    
-    //! \enum ImageType The enumeration type for the image content
-    /*!
-    * Enumerated classification of image content
-    */
-    enum ImageType { 
-        //! An image type not listed here
-        IMAGE_TYPE_OTHER, 
-        //! 32x32 PNG image that should be used as the file icon
-        IMAGE_TYPE_FILE_ICON,
-        //! File icon of a different size or format
-        IMAGE_TYPE_OTHER_FILE_ICON,
-        //! Front cover image of the album
-        IMAGE_TYPE_COVER_FRONT,
-        //! Back cover image of the album
-        IMAGE_TYPE_COVER_BACK,
-        //! Inside leaflet page of the album
-        IMAGE_TYPE_LEAFLET_PAGE,
-        //! Image from the album itself
-        IMAGE_TYPE_MEDIA,
-        //! Picture of the lead artist or soloist
-        IMAGE_TYPE_LEAD_ARTIST,
-        //! Picture of the artist or performer
-        IMAGE_TYPE_ARTIST,
-        //! Picture of the conductor
-        IMAGE_TYPE_CONDUCTOR,
-        //! Picture of the band or orchestra
-        IMAGE_TYPE_BAND,
-        //! Picture of the composer
-        IMAGE_TYPE_COMPOSER,
-        //! Picture of the lyricist or text writer
-        IMAGE_TYPE_LYRICIST,
-        //! Picture of the recording location or studio
-        IMAGE_TYPE_RECORDING_LOCATION,
-        //! Picture of the artists during recording
-        IMAGE_TYPE_DURING_RECORDING,
-        //! Picture of the artists during performance
-        IMAGE_TYPE_DURING_PERFORMANCE,
-        //! Picture from a movie or video related to the track
-        IMAGE_TYPE_MOVIESCREENCAPTURE,
-        //! Picture of a large, coloured fish.
-        IMAGE_TYPE_COLOURED_FISH,
-        //! Illustration related to the track
-        IMAGE_TYPE_ILLUSTRATION,
-        //! Logo of the band or performer
-        IMAGE_TYPE_ARTIST_LOGO,
-        //! Logo of the publisher (record company)
-        IMAGE_TYPE_PUBLISHER_LOGO
-    };
-    
-    
     //! Image is an wrapper for image data
     /*!
     * This class holds image data and information on loads and writes
     */
     class Image {
         public:
+            //! \enum ImageFileType The enumeration type for the image encoding
+            /*!
+            * Binary formats of embedded images (jpeg, png, ...)
+            */
+            enum FileType {
+                //! Unknown image file type
+                TYPE_UNKNOWN,
+                //! Jpg file type
+                TYPE_JPEG,
+                //! Png file type
+                TYPE_PNG,
+                //! Gif file type
+                TYPE_GIF,
+                //! Bitmap file type
+                TYPE_BMP
+            };
+            
+            
+            //! \enum ContentType The enumeration type for the image content
+            /*!
+            * Enumerated classification of image content
+            */
+            enum ContentType { 
+                //! An image type not listed here
+                CONTENT_OTHER, 
+                //! 32x32 PNG image that should be used as the file icon
+                CONTENT_FILE_ICON,
+                //! File icon of a different size or format
+                CONTENT_OTHER_FILE_ICON,
+                //! Front cover image of the album
+                CONTENT_COVER_FRONT,
+                //! Back cover image of the album
+                CONTENT_COVER_BACK,
+                //! Inside leaflet page of the album
+                CONTENT_LEAFLET_PAGE,
+                //! Image from the album itself
+                CONTENT_MEDIA,
+                //! Picture of the lead artist or soloist
+                CONTENT_LEAD_ARTIST,
+                //! Picture of the artist or performer
+                CONTENT_ARTIST,
+                //! Picture of the conductor
+                CONTENT_CONDUCTOR,
+                //! Picture of the band or orchestra
+                CONTENT_BAND,
+                //! Picture of the composer
+                CONTENT_COMPOSER,
+                //! Picture of the lyricist or text writer
+                CONTENT_LYRICIST,
+                //! Picture of the recording location or studio
+                CONTENT_RECORDING_LOCATION,
+                //! Picture of the artists during recording
+                CONTENT_DURING_RECORDING,
+                //! Picture of the artists during performance
+                CONTENT_DURING_PERFORMANCE,
+                //! Picture from a movie or video related to the track
+                CONTENT_MOVIESCREENCAPTURE,
+                //! Picture of a large, coloured fish.
+                CONTENT_COLOURED_FISH,
+                //! Illustration related to the track
+                CONTENT_ILLUSTRATION,
+                //! Logo of the band or performer
+                CONTENT_ARTIST_LOGO,
+                //! Logo of the publisher (record company)
+                CONTENT_PUBLISHER_LOGO
+            };
             
             //! Image constructor.
             /*!
             //! \param image_data ByteVector with binary image data
             void set_data(const ByteVector &image_data);
             
-            ImageType get_image_type(void) const;
-            void set_image_type(const ImageType it);
+            Image::ContentType get_image_type(void) const;
+            void set_image_type(const Image::ContentType it);
             
-            ImageFileType get_image_file_type(void) const;
-            void set_image_file_type(const ImageFileType ft);
+            Image::FileType get_image_file_type(void) const;
+            void set_image_file_type(const Image::FileType ft);
             
             const String get_description(void) const;
             void set_description(const String &description);
             
         private:
-//            //! \a bytes the image binary data
+            //! \a bytes The image binary data
             ByteVector      bytes;
             //! \a image_type is the ImageType enum, giving information 
             //! on the content of the picture 
-            ImageType       image_type;
+            ContentType     image_type;
             
             //! \a image_file_type is the ImageFileType enum, giving 
             //! information on the file type of the embedded picture
-            ImageFileType   image_file_type;
+            FileType        image_file_type;
             
             //! The \a description gives extra information on the image
             //! (Not supported by all media tags). NULL if not set

libtaginfo/xiphinfo.cc

             if(i < mimes_cnt) {
                 mimetype = pic_mimes[i];//.to8Bit(false); 
                 if(mimetype.find("/jpeg") != -1 || mimetype.find("/jpg") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
+                    image->set_image_file_type(Image::TYPE_JPEG);
                 else if(mimetype.find("/png") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_PNG);
+                    image->set_image_file_type(Image::TYPE_PNG);
                 else if(mimetype.find("/gif") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_GIF);
+                    image->set_image_file_type(Image::TYPE_GIF);
                 else if(mimetype.find("/bmp") != -1)
-                    image->set_image_file_type(IMAGE_FILE_TYPE_BMP);
+                    image->set_image_file_type(Image::TYPE_BMP);
             }
             if(i < types_cnt) {
                 itype = pic_types[i];
-                image->set_image_type((ImageType) itype.toInt());
+                image->set_image_type((Image::ContentType) itype.toInt());
             }
             if(i < descr_cnt) {
                 description = pic_descr[i];
         for(ImageList::ConstIterator it = images.begin(); it != images.end(); ++it) {
             const Image * image = *it;
             if(!image->get_data().isEmpty()) {
-                if(image->get_image_file_type() == IMAGE_FILE_TYPE_UNKNOWN || 
-                   image->get_image_file_type() == IMAGE_FILE_TYPE_JPEG)
+                if(image->get_image_file_type() == Image::TYPE_UNKNOWN || 
+                   image->get_image_file_type() == Image::TYPE_JPEG)
                     xiphcomment->addField(COVERARTMIME, "image/jpeg", false);
-                else if(image->get_image_file_type() == IMAGE_FILE_TYPE_PNG)
+                else if(image->get_image_file_type() == Image::TYPE_PNG)
                     xiphcomment->addField(COVERARTMIME, "image/png", false);
-                else if(image->get_image_file_type() == IMAGE_FILE_TYPE_GIF)
+                else if(image->get_image_file_type() == Image::TYPE_GIF)
                     xiphcomment->addField(COVERARTMIME, "image/gif", false);
-                else if(image->get_image_file_type() == IMAGE_FILE_TYPE_BMP)
+                else if(image->get_image_file_type() == Image::TYPE_BMP)
                     xiphcomment->addField(COVERARTMIME, "image/bmp", false);
                 String b64Encoded = base64encode(image->get_data().data(), image->get_data().size());
                 xiphcomment->addField(COVERART, 

tests/ctest_write/main.c

     }
     TagInfo_Image * img = taginfo_image_new();
     taginfo_image_set_data(img, (char*)mmap(0, filestatus.st_size, PROT_READ, MAP_SHARED, fd, 0), (unsigned int)filestatus.st_size);
-    taginfo_image_set_image_type(img, TAG_INFO_IMAGE_TYPE_OTHER);
+    taginfo_image_set_image_type(img, TAG_INFO_IMAGE_CONTENT_OTHER);
     taginfo_image_set_description(img, strdup(DESCRIPTION));
     TagInfo_Image ** ima = malloc(1 * sizeof(img));
     *ima = img;

tests/write_image_ape/main.cc

     std::ofstream  dst(target.c_str());
     dst << src.rdbuf();
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     // Image description not supported by APE
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     // Image description not supported by APE
     
     struct stat filestatus;

tests/write_image_flac/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_mp3/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_mp4/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-//    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+//    img->set_image_type(Image::CONTENT_COVER_FRONT);
 //    img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-//    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+//    img2->set_image_type(Image::CONTENT_COVER_BACK);
 //    img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_mpc/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
 
     struct stat filestatus;
     stat( image.c_str(), &filestatus );

tests/write_image_ogg/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_speex/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_tta/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_wav/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_wma/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     img->set_description("Bescräibunk");
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
     img2->set_description("Beßcräibunk");
 
     struct stat filestatus;

tests/write_image_wv/main.cc

     dst << src.rdbuf();
     
     Image * img = new Image();
-    img->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img->set_image_type(IMAGE_TYPE_COVER_FRONT);
+    img->set_image_file_type(Image::TYPE_JPEG);
+    img->set_image_type(Image::CONTENT_COVER_FRONT);
     
     Image * img2 = new Image();
-    img2->set_image_file_type(IMAGE_FILE_TYPE_JPEG);
-    img2->set_image_type(IMAGE_TYPE_COVER_BACK);
+    img2->set_image_file_type(Image::TYPE_JPEG);
+    img2->set_image_type(Image::CONTENT_COVER_BACK);
 
     struct stat filestatus;
     stat( image.c_str(), &filestatus );