file_info.cpp

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

		strncpy(str, (char *)tag->genre().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		if (is_all_wspace(str)) {
			data = NULL;
		} else {
			data = import_data_new();
			trashlist_add(fileinfo_trash, data);
			data->model = save_basic->mode.model;
			data->track_iter = save_basic->mode.track_iter;
			data->dest_type = IMPORT_DEST_COMMENT;
			snprintf(data->str, MAXLEN-1, "%s %s", _("Genre:"), str);
		}
		save_basic->entry_genre = append_table(table, cnt, edit_mode, _("Genre:"),
						       str, _("Add to Comments"), data);

		strncpy(str, (char *)tag->comment().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		if (is_all_wspace(str)) {
			data = NULL;
		} else {
			data = import_data_new();
			trashlist_add(fileinfo_trash, data);
			data->model = save_basic->mode.model;
			data->track_iter = save_basic->mode.track_iter;
			data->dest_type = IMPORT_DEST_COMMENT;
			snprintf(data->str, MAXLEN-1, "%s %s", _("Comment:"), str);
		}
		save_basic->entry_comment = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
							 _("Comment:"), str, _("Add to Comments"), data);
	} else {
		strncpy(str, (char *)tag->title().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		save_basic->entry_title = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						       _("Title:"), str,  NULL, NULL);

		strncpy(str, (char *)tag->artist().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		save_basic->entry_artist = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
							_("Artist:"), str, NULL, NULL);

		strncpy(str, (char *)tag->album().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		save_basic->entry_album = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						       _("Album:"), str,  NULL, NULL);

		if (tag->track() != 0) {
			sprintf(str, "%d", tag->track());
		} else {
			str[0] = '\0';
		}
		save_basic->entry_track = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						       _("Track:"), str, NULL, NULL);

		if (tag->year() != 0) {
			sprintf(str, "%d", tag->year());
		} else {
			str[0] = '\0';
		}
		save_basic->entry_year = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
						      _("Year:"), str, NULL, NULL);

		strncpy(str, (char *)tag->genre().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		save_basic->entry_genre = append_table(table, cnt, edit_mode, _("Genre:"), str,   NULL, NULL);

		strncpy(str, (char *)tag->comment().toCString(true), MAXLEN-1);
		cut_trailing_whitespace(str);
		save_basic->entry_comment = append_table(table, cnt, edit_mode ? EDITABLE_YES : EDITABLE_NO,
							 _("Comment:"), str, NULL, NULL);
	}

	if (ptable) {
		*ptable = table;
	}

	if (edit_mode) {
                GtkWidget * hbuttonbox = gtk_hbutton_box_new();
                gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox), GTK_BUTTONBOX_END);
                GtkWidget * button = gui_stock_label_button(_("Save basic fields"), GTK_STOCK_SAVE);
  	        gtk_container_add(GTK_CONTAINER(hbuttonbox), button);   
		savepage_data_t * sdata = savepage_data_new();
		trashlist_add(fileinfo_trash, sdata);
		sdata->save_page_no = page_id;
		sdata->save_basic = save_basic;
		g_signal_connect(G_OBJECT(button), "clicked",
				 G_CALLBACK(save_basic_fields), (gpointer)sdata);
		gtk_table_resize(GTK_TABLE(table), *cnt + 1, 3);
		gtk_table_attach(GTK_TABLE(table), hbuttonbox, 1, 3, *cnt, *cnt + 1, GTK_FILL, GTK_FILL, 5, 3);
		(*cnt)++;
	}
	return page_id;
}


int
build_id3v1_page(save_basic_t * save_basic, int edit_mode, TagLib::ID3v1::Tag * id3v1_tag) {

	int cnt = 0;
	TagLib::Tag * tag = dynamic_cast<TagLib::Tag *>(id3v1_tag);
	save_basic->id3v1_tag = id3v1_tag;
	int page_no = build_simple_page(save_basic, tag, &cnt, NULL, edit_mode, _("ID3v1"));
	gtk_widget_show_all(GTK_WIDGET(save_basic->nb));
	return page_no;
}


void
insert_id3v2_text(GtkNotebook * nb, GtkWidget * table, int * cnt, fileinfo_mode_t mode,
		  TagLib::ID3v2::Frame * frame, char * frameID) {

	char descr[MAXLEN];
	char str[MAXLEN];

	TagLib::ID3v2::TextIdentificationFrame * tid_frame =
		dynamic_cast<TagLib::ID3v2::TextIdentificationFrame *>(frame);

	if (!lookup_id3v2_textframe(frameID, descr))
		return;

	int len = strlen(descr);
	if (len < MAXLEN-1) {
		descr[len++] = ':';
		descr[len] = '\0';
	}

	if (mode.is_called_from_browser) {
		import_data_t * data;

		data = import_data_new();
		trashlist_add(fileinfo_trash, data);
		data->model = mode.model;
		data->track_iter = mode.track_iter;
		data->dest_type = IMPORT_DEST_COMMENT;
		strncpy(str, (char *)tid_frame->toString().toCString(true), MAXLEN-1);
		snprintf(data->str, MAXLEN-1, "%s: %s", descr, str);
		append_table(table, cnt, false, descr, str, _("Add to Comments"), data);
	} else {
		strncpy(str, (char *)tid_frame->toString().toCString(true), MAXLEN-1);
		append_table(table, cnt, false, descr, str, NULL, NULL);
	}
}


void
insert_id3v2_rva2(GtkNotebook * nb, GtkWidget * table, int * cnt, fileinfo_mode_t mode,
		  char * id_str, float voladj) {
	
	char descr[MAXLEN];

	snprintf(descr, MAXLEN-1, _("%+.1f dB (Id: %s)"), voladj, id_str);

	if (mode.is_called_from_browser) {
		import_data_t * data;

		data = import_data_new();
		trashlist_add(fileinfo_trash, data);
		data->model = mode.model;
		data->track_iter = mode.track_iter;
		data->dest_type = IMPORT_DEST_RVA;
		data->fval = voladj;
		append_table(table, cnt, false, _("Relative Volume Adj.:"), descr, _("Import as RVA"), data);
	} else {
		append_table(table, cnt, false, _("Relative Volume Adj.:"), descr, NULL, NULL);
	}
}


char *
pic_type_to_string(int type) {

	using namespace TagLib::ID3v2;

	switch (type) {
	case AttachedPictureFrame::Other:
		return _("Other");
	case AttachedPictureFrame::FileIcon:
		return _("File icon (32x32 PNG)");
	case AttachedPictureFrame::OtherFileIcon:
		return _("File icon (other)");
	case AttachedPictureFrame::FrontCover:
		return _("Front cover");
	case AttachedPictureFrame::BackCover:
		return _("Back cover");
	case AttachedPictureFrame::LeafletPage:
		return _("Leaflet page");
	case AttachedPictureFrame::Media:
		return _("Album image");
	case AttachedPictureFrame::LeadArtist:
		return _("Lead artist/performer");
	case AttachedPictureFrame::Artist:
		return _("Artist/performer");
	case AttachedPictureFrame::Conductor:
		return _("Conductor");
	case AttachedPictureFrame::Band:
		return _("Band/orchestra");
	case AttachedPictureFrame::Composer:
		return _("Composer");
	case AttachedPictureFrame::Lyricist:
		return _("Lyricist/text writer");
	case AttachedPictureFrame::RecordingLocation:
		return _("Recording location/studio");
	case AttachedPictureFrame::DuringRecording:
		return _("During recording");
	case AttachedPictureFrame::DuringPerformance:
		return _("During performance");
	case AttachedPictureFrame::MovieScreenCapture:
		return _("Movie/video screen capture");
	case AttachedPictureFrame::ColouredFish:
		return _("A large, coloured fish");
	case AttachedPictureFrame::Illustration:
		return _("Illustration");
	case AttachedPictureFrame::BandLogo:
		return _("Band/artist logotype");
	case AttachedPictureFrame::PublisherLogo:
		return _("Publisher/studio logotype");
	default:
		return NULL;
	}
}


void
insert_id3v2_apic(GtkNotebook * nb, GtkWidget * table, int * cnt, fileinfo_mode_t mode,
		  TagLib::ID3v2::Frame * frame) {

	TagLib::ID3v2::AttachedPictureFrame * apic_frame =
		dynamic_cast<TagLib::ID3v2::AttachedPictureFrame *>(frame);
	
	char mime_type[20];
	char savefilename[256];
	char tmpname[256];
	void * image_data = NULL;

	mime_type[0] = '\0';
	strcpy(savefilename, "picture.");
	int r = sscanf(apic_frame->mimeType().toCString(true), "image/%s", mime_type);

	if (r == 0) {
		strncpy(mime_type, apic_frame->mimeType().toCString(true), 19);
	}
	for (int i = 0; mime_type[i] != '\0'; i++) {
		mime_type[i] = tolower(mime_type[i]);
	}
	if (mime_type[0] == '\0') {
		strcpy(mime_type, "dat");
	}
	strncat(savefilename, mime_type, 255);

	TagLib::ByteVector bv = apic_frame->picture();
	
	if (bv.size() <= 0)
		return;

	image_data = malloc(bv.size());
	if (!image_data)
		return;

	trashlist_add(fileinfo_trash, image_data);
	memcpy(image_data, bv.data(), bv.size());

	strcpy(tmpname, "/tmp/aqualung-picture-XXXXXX.dat");
	int fd = g_mkstemp(tmpname);
	if (fd < 0) {
		printf("error: g_mkstemp() failed\n");
		return;
	}
	if (write(fd, bv.data(), bv.size()) != (int)bv.size()) {
		printf("write() error\n");
		return;
	}
	close(fd);

	GtkWidget * image = gtk_image_new_from_file(tmpname);
	if (g_unlink(tmpname) < 0) {
		printf("error: g_unlink() failed on %s\n", tmpname);
		return;
	}

	append_table_pic(table, cnt, image,
			 pic_type_to_string(apic_frame->type()),
			 apic_frame->description().isEmpty() ?
			 NULL : (char *)apic_frame->description().toCString(true),
			 savefilename, image_data, bv.size());
}


int
build_id3v2_page(save_basic_t * save_basic, int edit_mode, TagLib::ID3v2::Tag * id3v2_tag) {

	int cnt = 0;
	GtkWidget * table;

	TagLib::ID3v2::FrameList l = id3v2_tag->frameList();
	std::list<TagLib::ID3v2::Frame*>::iterator i;
	
	TagLib::Tag * tag = dynamic_cast<TagLib::Tag *>(id3v2_tag);
	save_basic->id3v2_tag = id3v2_tag;
	int page_no = build_simple_page(save_basic, tag, &cnt, &table, edit_mode, _("ID3v2"));

	for (i = l.begin(); i != l.end(); ++i) {
		TagLib::ID3v2::Frame * frame = *i;
		char frameID[5];
		
		for(int j = 0; j < 4; j++) {
			frameID[j] = frame->frameID().data()[j];
		}
		frameID[4] = '\0';

		if (strcmp(frameID, "APIC") == 0) {
			insert_id3v2_apic(save_basic->nb, table, &cnt, save_basic->mode, frame);
		} else if (strcmp(frameID, "RVA2") == 0) {
			char id_str[MAXLEN];
			float voladj;
			read_rva2(frame->render().data() + 10, frame->size(), id_str, &voladj);
			insert_id3v2_rva2(save_basic->nb, table, &cnt, save_basic->mode, id_str, voladj);
		} else if (frameID[0] == 'T') {
			/* skip frames that are handled by the simple mode */
			if ((strcmp(frameID, "TIT2") != 0) && /* title */
			    (strcmp(frameID, "TPE1") != 0) && /* artist */
			    (strcmp(frameID, "TALB") != 0) && /* album */
			    (strcmp(frameID, "TRCK") != 0) && /* track no. */
			    (strcmp(frameID, "TCON") != 0) && /* genre */
			    (strcmp(frameID, "TDRC") != 0)) { /* year */
				insert_id3v2_text(save_basic->nb, table, &cnt, save_basic->mode, frame, frameID);
			}
		} else {
			/* XXX incomplete */
		}
	}
	gtk_widget_show_all(GTK_WIDGET(save_basic->nb));
	return page_no;
}


/* ape tags also use this */
void
insert_oxc(GtkNotebook * nb, GtkWidget * table, int * cnt, fileinfo_mode_t mode,
	   char * key, char * val) {

	if (mode.is_called_from_browser) {
		import_data_t * data;
		
		data = import_data_new();
		trashlist_add(fileinfo_trash, data);
		
		data->model = mode.model;
		data->track_iter = mode.track_iter;
		snprintf(data->str, MAXLEN-1, "%s %s", key, val);
		
		if ((strcmp(key, "Replaygain_track_gain:") == 0) ||
		    (strcmp(key, "Replaygain_album_gain:") == 0)) {
			
			data->fval = convf(val);
			data->dest_type = IMPORT_DEST_RVA;
			append_table(table, cnt, false, key, val, _("Import as RVA"), data);
		} else {
			data->fval = 0.0f;
			data->dest_type = IMPORT_DEST_COMMENT;
			append_table(table, cnt, false, key, val, _("Add to Comments"), data);
		}
	} else {
		append_table(table, cnt, false, key, val, NULL, NULL);
	}
}


int
build_ape_page(save_basic_t * save_basic, int edit_mode, TagLib::APE::Tag * ape_tag) {

	int cnt = 0;
	GtkWidget * table;
	
	TagLib::Tag * tag = dynamic_cast<TagLib::Tag *>(ape_tag);
	save_basic->ape_tag = ape_tag;
	int page_no = build_simple_page(save_basic, tag, &cnt, &table, edit_mode, _("APE"));

	TagLib::APE::ItemListMap m = ape_tag->itemListMap();
	for (TagLib::APE::ItemListMap::Iterator i = m.begin(); i != m.end(); ++i) {

		TagLib::StringList::Iterator j;
		TagLib::StringList l = (*i).second.toStringList();
		for (j = l.begin(); j != l.end(); j++) {
			
			char key[MAXLEN];
			char val[MAXLEN];
			char c;
			int k;
			
			/* skip comments that are handled by the simple mode */
			if ((strcmp("TITLE", (*i).first.toCString(true)) == 0) ||
			    (strcmp("ARTIST", (*i).first.toCString(true)) == 0) ||
			    (strcmp("ALBUM", (*i).first.toCString(true)) == 0) ||
			    (strcmp("YEAR", (*i).first.toCString(true)) == 0) ||
			    (strcmp("COMMENT", (*i).first.toCString(true)) == 0) ||
			    (strcmp("TRACK", (*i).first.toCString(true)) == 0) ||
			    (strcmp("GENRE", (*i).first.toCString(true)) == 0)) {
				
				continue;
			}
			
			for (k = 0; ((c = (*i).first.toCString(true)[k]) != '\0') && (k < MAXLEN-1); k++) {
				key[k] = (k == 0) ? toupper(c) : tolower(c);
			}
			key[k++] = ':';
			key[k] = '\0';
			
			for (k = 0; ((c = (*j).toCString(true)[k]) != '\0') && (k < MAXLEN-1); k++) {
				val[k] = c;
			}
			val[k] = '\0';
			
			printf("'%s' =  '%s'\n", key, val);
			insert_oxc(save_basic->nb, table, &cnt, save_basic->mode, key, val);
		}
	}
	gtk_widget_show_all(GTK_WIDGET(save_basic->nb));
	return page_no;
}