static FLAC__bool local__extract_mime_type_(FLAC__StreamMetadata *obj)
{
if(obj->data.picture.data_length >= 8 && 0 == memcmp(obj->data.picture.data, "\x89PNG\x0d\x0a\x1a\x0a", 8))
return FLAC__metadata_object_picture_set_mime_type(obj, "image/png", /*copy=*/true);
else if(obj->data.picture.data_length >= 6 && (0 == memcmp(obj->data.picture.data, "GIF87a", 6) || 0 == memcmp(obj->data.picture.data, "GIF89a", 6)))
return FLAC__metadata_object_picture_set_mime_type(obj, "image/gif", /*copy=*/true);
else if(obj->data.picture.data_length >= 2 && 0 == memcmp(obj->data.picture.data, "\xff\xd8", 2))
return FLAC__metadata_object_picture_set_mime_type(obj, "image/jpeg", /*copy=*/true);
return false;
}
int __stdcall
WWFlacRW_EncodeSetPicture(int id, const uint8_t * pictureData, int pictureBytes)
{
if (NULL == pictureData || pictureBytes <= 0) {
dprintf("%s parameter pictureData or pictureBytes error\n", __FUNCTION__);
return FRT_BadParams;
}
FlacEncodeInfo *fei = FlacTInfoFindById<FlacEncodeInfo>(g_flacEncodeInfoMap, id);
if (NULL == fei) {
return FRT_IdNotFound;
}
if (fei->pictureData != NULL) {
dprintf("%s already has picture data!\n", __FUNCTION__);
return FRT_BadParams;
}
assert(fei->flacMetaArray[FMT_Picture]);
if (0 < fei->pictureBytes && 0 != fei->pictureMimeTypeStr[0]) {
// copy==falseにすると開放時にクラッシュする
if (!FLAC__metadata_object_picture_set_mime_type(fei->flacMetaArray[FMT_Picture], fei->pictureMimeTypeStr, true)) {
dprintf("FLAC__metadata_object_picture_set_mime_type failed\n");
fei->errorCode = FRT_OtherError;
goto end;
}
}
if (0 < fei->pictureBytes && 0 != fei->pictureDescriptionStr[0]) {
if (!FLAC__metadata_object_picture_set_description(fei->flacMetaArray[FMT_Picture], (FLAC__byte*)fei->pictureDescriptionStr, true)) {
dprintf("FLAC__metadata_object_picture_set_description failed\n");
fei->errorCode = FRT_OtherError;
goto end;
}
}
fei->pictureBytes = pictureBytes;
fei->pictureData = new uint8_t[fei->pictureBytes];
if (NULL == fei->pictureData) {
dprintf("%s could not alloc picture data!\n", __FUNCTION__);
fei->errorCode = FRT_MemoryExhausted;
goto end;
}
memcpy(fei->pictureData, pictureData, fei->pictureBytes);
if (!FLAC__metadata_object_picture_set_data(fei->flacMetaArray[FMT_Picture], fei->pictureData, fei->pictureBytes, true)) {
fei->errorCode = FRT_OtherError;
goto end;
}
fei->flacMetaCount = 2;
end:
return fei->errorCode;
}
/*
* Write Flac tag, using the level 2 flac interface
*/
gboolean
flac_tag_write_file_tag (const ET_File *ETFile,
GError **error)
{
const File_Tag *FileTag;
GFile *file;
GFileIOStream *iostream;
EtFlacWriteState state;
FLAC__IOCallbacks callbacks = { et_flac_read_func, et_flac_write_func,
et_flac_seek_func, et_flac_tell_func,
et_flac_eof_func,
et_flac_write_close_func
};
const gchar *filename;
const gchar *filename_utf8;
const gchar *flac_error_msg;
FLAC__Metadata_Chain *chain;
FLAC__Metadata_Iterator *iter;
FLAC__StreamMetadata_VorbisComment_Entry vce_field_vendor_string; // To save vendor string
gboolean vce_field_vendor_string_found = FALSE;
g_return_val_if_fail (ETFile != NULL && ETFile->FileTag != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
FileTag = (File_Tag *)ETFile->FileTag->data;
filename = ((File_Name *)ETFile->FileNameCur->data)->value;
filename_utf8 = ((File_Name *)ETFile->FileNameCur->data)->value_utf8;
/* libFLAC is able to detect (and skip) ID3v2 tags by itself */
/* Create a new chain instance to get all blocks in one time. */
chain = FLAC__metadata_chain_new ();
if (chain == NULL)
{
flac_error_msg = FLAC__Metadata_ChainStatusString[FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR];
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error while opening file ‘%s’ as FLAC: %s"),
filename_utf8, flac_error_msg);
return FALSE;
}
file = g_file_new_for_path (filename);
state.file = file;
state.error = NULL;
/* TODO: Fallback to an in-memory copy of the file for non-local files,
* where creation of the GFileIOStream may fail. */
iostream = g_file_open_readwrite (file, NULL, &state.error);
if (iostream == NULL)
{
FLAC__metadata_chain_delete (chain);
g_propagate_error (error, state.error);
g_object_unref (file);
return FALSE;
}
state.istream = G_FILE_INPUT_STREAM (g_io_stream_get_input_stream (G_IO_STREAM (iostream)));
state.ostream = G_FILE_OUTPUT_STREAM (g_io_stream_get_output_stream (G_IO_STREAM (iostream)));
state.seekable = G_SEEKABLE (iostream);
state.iostream = iostream;
if (!FLAC__metadata_chain_read_with_callbacks (chain, &state, callbacks))
{
const FLAC__Metadata_ChainStatus status = FLAC__metadata_chain_status (chain);
flac_error_msg = FLAC__Metadata_ChainStatusString[status];
FLAC__metadata_chain_delete (chain);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error while opening file ‘%s’ as FLAC: %s"),
filename_utf8, flac_error_msg);
et_flac_write_close_func (&state);
return FALSE;
}
/* Create a new iterator instance for the chain. */
iter = FLAC__metadata_iterator_new ();
if (iter == NULL)
{
flac_error_msg = FLAC__Metadata_ChainStatusString[FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR];
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error while opening file ‘%s’ as FLAC: %s"),
filename_utf8, flac_error_msg);
FLAC__metadata_chain_delete (chain);
et_flac_write_close_func (&state);
return FALSE;
}
FLAC__metadata_iterator_init (iter, chain);
while (FLAC__metadata_iterator_next (iter))
{
const FLAC__MetadataType block_type = FLAC__metadata_iterator_get_block_type (iter);
/* TODO: Modify the blocks directly, rather than deleting and
* recreating. */
if (block_type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
{
// Delete the VORBIS_COMMENT block and convert to padding. But before, save the original vendor string.
/* Get block data. */
FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(iter);
FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
if (vc->vendor_string.entry != NULL)
{
// Get initial vendor string, to don't alterate it by FLAC__VENDOR_STRING when saving file
vce_field_vendor_string.entry = (FLAC__byte *)g_strdup ((gchar *)vc->vendor_string.entry);
vce_field_vendor_string.length = strlen ((gchar *)vce_field_vendor_string.entry);
vce_field_vendor_string_found = TRUE;
}
/* Free block data. */
FLAC__metadata_iterator_delete_block (iter, true);
}
else if (block_type == FLAC__METADATA_TYPE_PICTURE)
{
/* Delete all the PICTURE blocks, and convert to padding. */
FLAC__metadata_iterator_delete_block (iter, true);
}
}
//
// Create and insert a new VORBISCOMMENT block
//
{
FLAC__StreamMetadata *vc_block; // For vorbis comments
GList *l;
// Allocate a block for Vorbis comments
vc_block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
// Set the original vendor string, else will be use the version of library
if (vce_field_vendor_string_found)
{
// must set 'copy' param to false, because the API will reuse the pointer of an empty
// string (yet still return 'true', indicating it was copied); the string is free'd during
// metadata_chain_delete routine
FLAC__metadata_object_vorbiscomment_set_vendor_string(vc_block, vce_field_vendor_string, /*copy=*/false);
}
/*********
* Title *
*********/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_TITLE,
FileTag->title,
g_settings_get_boolean (MainSettings,
"ogg-split-title"));
/**********
* Artist *
**********/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_ARTIST,
FileTag->artist,
g_settings_get_boolean (MainSettings,
"ogg-split-artist"));
/****************
* Album Artist *
****************/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_ALBUM_ARTIST,
FileTag->album_artist,
g_settings_get_boolean (MainSettings,
"ogg-split-artist"));
/*********
* Album *
*********/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_ALBUM,
FileTag->album,
g_settings_get_boolean (MainSettings,
"ogg-split-album"));
/******************************
* Disc Number and Disc Total *
******************************/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_DISC_NUMBER,
FileTag->disc_number, FALSE);
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_DISC_TOTAL,
FileTag->disc_total, FALSE);
/********
* Year *
********/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_DATE,
FileTag->year, FALSE);
/*************************
* Track and Total Track *
*************************/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_TRACK_NUMBER,
FileTag->track, FALSE);
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_TRACK_TOTAL,
FileTag->track_total, FALSE);
/*********
* Genre *
*********/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_GENRE,
FileTag->genre,
g_settings_get_boolean (MainSettings,
"ogg-split-genre"));
/***********
* Comment *
***********/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_DESCRIPTION,
FileTag->comment,
g_settings_get_boolean (MainSettings,
"ogg-split-comment"));
/************
* Composer *
************/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_COMPOSER,
FileTag->composer,
g_settings_get_boolean (MainSettings,
"ogg-split-composer"));
/*******************
* Original artist *
*******************/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_PERFORMER,
FileTag->orig_artist,
g_settings_get_boolean (MainSettings,
"ogg-split-original-artist"));
/*************
* Copyright *
*************/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_COPYRIGHT,
FileTag->copyright, FALSE);
/*******
* URL *
*******/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_CONTACT,
FileTag->url, FALSE);
/**************
* Encoded by *
**************/
vc_block_append_tag (vc_block, ET_VORBIS_COMMENT_FIELD_ENCODED_BY,
FileTag->encoded_by, FALSE);
/**************************
* Set unsupported fields *
**************************/
for (l = FileTag->other; l != NULL; l = g_list_next (l))
{
vc_block_append_other_tag (vc_block, (gchar *)l->data);
}
// Add the block to the the chain (so we don't need to free the block)
FLAC__metadata_iterator_insert_block_after(iter, vc_block);
}
//
// Create and insert PICTURE blocks
//
/***********
* Picture *
***********/
{
EtPicture *pic = FileTag->picture;
while (pic)
{
/* TODO: Can this ever be NULL? */
if (pic->bytes)
{
const gchar *violation;
FLAC__StreamMetadata *picture_block; // For picture data
Picture_Format format;
gconstpointer data;
gsize data_size;
// Allocate block for picture data
picture_block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE);
// Type
picture_block->data.picture.type = pic->type;
// Mime type
format = Picture_Format_From_Data(pic);
/* Safe to pass a const string, according to the FLAC API
* reference. */
FLAC__metadata_object_picture_set_mime_type(picture_block, (gchar *)Picture_Mime_Type_String(format), TRUE);
// Description
if (pic->description)
{
FLAC__metadata_object_picture_set_description(picture_block, (FLAC__byte *)pic->description, TRUE);
}
// Resolution
picture_block->data.picture.width = pic->width;
picture_block->data.picture.height = pic->height;
picture_block->data.picture.depth = 0;
/* Picture data. */
data = g_bytes_get_data (pic->bytes, &data_size);
/* Safe to pass const data, if the last argument (copy) is
* TRUE, according the the FLAC API reference. */
FLAC__metadata_object_picture_set_data (picture_block,
(FLAC__byte *)data,
(FLAC__uint32)data_size,
true);
if (!FLAC__metadata_object_picture_is_legal (picture_block,
&violation))
{
g_critical ("Created an invalid picture block: ‘%s’",
violation);
FLAC__metadata_object_delete (picture_block);
}
else
{
// Add the block to the the chain (so we don't need to free the block)
FLAC__metadata_iterator_insert_block_after(iter, picture_block);
}
}
pic = pic->next;
}
}
FLAC__metadata_iterator_delete (iter);
//
// Prepare for writing tag
//
FLAC__metadata_chain_sort_padding (chain);
/* Write tag. */
if (FLAC__metadata_chain_check_if_tempfile_needed (chain, true))
{
EtFlacWriteState temp_state;
GFile *temp_file;
GFileIOStream *temp_iostream;
GError *temp_error = NULL;
temp_file = g_file_new_tmp ("easytag-XXXXXX", &temp_iostream,
&temp_error);
if (temp_file == NULL)
{
FLAC__metadata_chain_delete (chain);
g_propagate_error (error, temp_error);
et_flac_write_close_func (&state);
return FALSE;
}
temp_state.file = temp_file;
temp_state.error = NULL;
temp_state.istream = G_FILE_INPUT_STREAM (g_io_stream_get_input_stream (G_IO_STREAM (temp_iostream)));
temp_state.ostream = G_FILE_OUTPUT_STREAM (g_io_stream_get_output_stream (G_IO_STREAM (temp_iostream)));
temp_state.seekable = G_SEEKABLE (temp_iostream);
temp_state.iostream = temp_iostream;
if (!FLAC__metadata_chain_write_with_callbacks_and_tempfile (chain,
true,
&state,
callbacks,
&temp_state,
callbacks))
{
const FLAC__Metadata_ChainStatus status = FLAC__metadata_chain_status (chain);
flac_error_msg = FLAC__Metadata_ChainStatusString[status];
FLAC__metadata_chain_delete (chain);
et_flac_write_close_func (&temp_state);
et_flac_write_close_func (&state);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Failed to write comments to file ‘%s’: %s"),
filename_utf8, flac_error_msg);
return FALSE;
}
if (!g_file_move (temp_file, file, G_FILE_COPY_OVERWRITE, NULL, NULL,
NULL, &state.error))
{
FLAC__metadata_chain_delete (chain);
et_flac_write_close_func (&temp_state);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Failed to write comments to file ‘%s’: %s"),
filename_utf8, state.error->message);
et_flac_write_close_func (&state);
return FALSE;
}
et_flac_write_close_func (&temp_state);
}
else
{
if (!FLAC__metadata_chain_write_with_callbacks (chain, true, &state,
callbacks))
{
const FLAC__Metadata_ChainStatus status = FLAC__metadata_chain_status (chain);
flac_error_msg = FLAC__Metadata_ChainStatusString[status];
FLAC__metadata_chain_delete (chain);
et_flac_write_close_func (&state);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Failed to write comments to file ‘%s’: %s"),
filename_utf8, flac_error_msg);
return FALSE;
}
}
FLAC__metadata_chain_delete (chain);
et_flac_write_close_func (&state);
#ifdef ENABLE_MP3
{
// Delete the ID3 tags (create a dummy ETFile for the Id3tag_... function)
ET_File *ETFile_tmp = ET_File_Item_New();
File_Name *FileName_tmp = et_file_name_new ();
File_Tag *FileTag_tmp = et_file_tag_new ();
// Same file...
FileName_tmp->value = g_strdup(filename);
FileName_tmp->value_utf8 = g_strdup(filename_utf8); // Not necessary to fill 'value_ck'
ETFile_tmp->FileNameList = g_list_append(NULL,FileName_tmp);
ETFile_tmp->FileNameCur = ETFile_tmp->FileNameList;
// With empty tag...
ETFile_tmp->FileTagList = g_list_append(NULL,FileTag_tmp);
ETFile_tmp->FileTag = ETFile_tmp->FileTagList;
id3tag_write_file_tag (ETFile_tmp, NULL);
ET_Free_File_List_Item(ETFile_tmp);
}
#endif
return TRUE;
}
FLAC__StreamMetadata *grabbag__picture_parse_specification(const char *spec, const char **error_message)
{
FLAC__StreamMetadata *obj;
int state = 0;
static const char *error_messages[] = {
"memory allocation error",
"invalid picture specification",
"invalid picture specification: can't parse resolution/color part",
"unable to extract resolution and color info from URL, user must set explicitly",
"unable to extract resolution and color info from file, user must set explicitly",
"error opening picture file",
"error reading picture file",
"invalid picture type",
"unable to guess MIME type from file, user must set explicitly",
"type 1 icon must be a 32x32 pixel PNG"
};
FLAC__ASSERT(0 != spec);
FLAC__ASSERT(0 != error_message);
/* double protection */
if(0 == spec)
return 0;
if(0 == error_message)
return 0;
*error_message = 0;
if(0 == (obj = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE))) {
*error_message = error_messages[0];
return obj;
}
if(strchr(spec, '|')) { /* full format */
const char *p;
char *q;
for(p = spec; *error_message==0 && *p; ) {
if(*p == '|') {
switch(state) {
case 0: /* type */
if(!local__parse_type_(spec, p-spec, &obj->data.picture))
*error_message = error_messages[7];
break;
case 1: /* mime type */
if(p-spec) { /* if blank, we'll try to guess later from the picture data */
if(0 == (q = local__strndup_(spec, p-spec)))
*error_message = error_messages[0];
else if(!FLAC__metadata_object_picture_set_mime_type(obj, q, /*copy=*/false))
*error_message = error_messages[0];
}
break;
case 2: /* description */
if(0 == (q = local__strndup_(spec, p-spec)))
*error_message = error_messages[0];
else if(!FLAC__metadata_object_picture_set_description(obj, (FLAC__byte*)q, /*copy=*/false))
*error_message = error_messages[0];
break;
case 3: /* resolution/color (e.g. [300x300x16[/1234]] */
if(!local__parse_resolution_(spec, p-spec, &obj->data.picture))
*error_message = error_messages[2];
break;
default:
*error_message = error_messages[1];
break;
}
p++;
spec = p;
state++;
}
else
p++;
}
}
else { /* simple format, filename only, everything else guessed */
if(!local__parse_type_("", 0, &obj->data.picture)) /* use default picture type */
*error_message = error_messages[7];
/* leave MIME type to be filled in later */
/* leave description empty */
/* leave the rest to be filled in later: */
else if(!local__parse_resolution_("", 0, &obj->data.picture))
*error_message = error_messages[2];
else
state = 4;
}
/* parse filename, read file, try to extract resolution/color info if needed */
if(*error_message == 0) {
if(state != 4)
*error_message = error_messages[1];
else { /* 'spec' points to filename/URL */
if(0 == strcmp(obj->data.picture.mime_type, "-->")) { /* magic MIME type means URL */
if(!FLAC__metadata_object_picture_set_data(obj, (FLAC__byte*)spec, strlen(spec), /*copy=*/true))
*error_message = error_messages[0];
else if(obj->data.picture.width == 0 || obj->data.picture.height == 0 || obj->data.picture.depth == 0)
*error_message = error_messages[3];
}
else { /* regular picture file */
const FLAC__off_t size = grabbag__file_get_filesize(spec);
if(size < 0)
*error_message = error_messages[5];
else {
FLAC__byte *buffer = safe_malloc_(size);
if(0 == buffer)
*error_message = error_messages[0];
else {
FILE *f = flac_fopen(spec, "rb");
if(0 == f) {
*error_message = error_messages[5];
free(buffer);
}
else {
if(fread(buffer, 1, size, f) != (size_t)size)
*error_message = error_messages[6];
fclose(f);
if(0 == *error_message) {
if(!FLAC__metadata_object_picture_set_data(obj, buffer, size, /*copy=*/false))
*error_message = error_messages[6];
/* try to extract MIME type if user left it blank */
else if(*obj->data.picture.mime_type == '\0' && !local__extract_mime_type_(obj))
*error_message = error_messages[8];
/* try to extract resolution/color info if user left it blank */
else if((obj->data.picture.width == 0 || obj->data.picture.height == 0 || obj->data.picture.depth == 0) && !local__extract_resolution_color_info_(&obj->data.picture))
*error_message = error_messages[4];
}
else {
free(buffer);
}
}
}
}
}
}
}
if(*error_message == 0) {
if(
obj->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD &&
(
(strcmp(obj->data.picture.mime_type, "image/png") && strcmp(obj->data.picture.mime_type, "-->")) ||
obj->data.picture.width != 32 ||
obj->data.picture.height != 32
)
)
*error_message = error_messages[9];
}
if(*error_message && obj) {
FLAC__metadata_object_delete(obj);
obj = 0;
}
return obj;
}
/*
* Write Flac tag, using the level 2 flac interface
*/
gboolean Flac_Tag_Write_File_Tag (ET_File *ETFile)
{
File_Tag *FileTag;
gchar *filename_utf8, *filename;
gchar *basename_utf8;
FLAC__Metadata_Chain *chain;
FLAC__Metadata_Iterator *iter;
FLAC__StreamMetadata_VorbisComment_Entry vce_field_vendor_string; // To save vendor string
gboolean vce_field_vendor_string_found = FALSE;
if (!ETFile || !ETFile->FileTag)
return FALSE;
FileTag = (File_Tag *)ETFile->FileTag->data;
filename = ((File_Name *)ETFile->FileNameCur->data)->value;
filename_utf8 = ((File_Name *)ETFile->FileNameCur->data)->value_utf8;
flac_error_msg = NULL;
/* libFLAC is able to detect (and skip) ID3v2 tags by itself */
// Create a new chain instance to get all blocks in one time
chain = FLAC__metadata_chain_new();
if (chain == NULL || !FLAC__metadata_chain_read(chain,filename))
{
if (chain == NULL)
{
// Error with "FLAC__metadata_chain_new"
flac_error_msg = FLAC__Metadata_ChainStatusString[FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR];
} else
{
// Error with "FLAC__metadata_chain_read"
FLAC__Metadata_ChainStatus status = FLAC__metadata_chain_status(chain);
flac_error_msg = FLAC__Metadata_ChainStatusString[status];
FLAC__metadata_chain_delete(chain);
}
Log_Print(LOG_ERROR,_("ERROR while opening file: '%s' as FLAC (%s)."),filename_utf8,flac_error_msg);
return FALSE;
}
// Create a new iterator instance for the chain
iter = FLAC__metadata_iterator_new();
if (iter == NULL)
{
flac_error_msg = FLAC__Metadata_ChainStatusString[FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR];
Log_Print(LOG_ERROR,_("ERROR while opening file: '%s' as FLAC (%s)."),filename_utf8,flac_error_msg);
return FALSE;
}
// Initialize the iterator to point to the first metadata block in the given chain.
FLAC__metadata_iterator_init(iter,chain);
while (FLAC__metadata_iterator_next(iter))
{
//g_print("Write: %d %s -> block type: %d\n",j++,g_path_get_basename(filename),FLAC__metadata_iterator_get_block_type(iter));
// Action to do according the type
switch ( FLAC__metadata_iterator_get_block_type(iter) )
{
//
// Delete the VORBIS_COMMENT block and convert to padding. But before, save the original vendor string.
//
case FLAC__METADATA_TYPE_VORBIS_COMMENT:
{
// Get block data
FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(iter);
FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
if (vc->vendor_string.entry != NULL)
{
// Get initial vendor string, to don't alterate it by FLAC__VENDOR_STRING when saving file
vce_field_vendor_string.entry = (FLAC__byte *)g_strdup((gchar *)vc->vendor_string.entry);
vce_field_vendor_string.length = strlen((gchar *)vce_field_vendor_string.entry);
vce_field_vendor_string_found = TRUE;
}
// Free block data
FLAC__metadata_iterator_delete_block(iter,true);
break;
}
//
// Delete all the PICTURE blocks, and convert to padding
//
#ifndef LEGACY_FLAC // For FLAC >= 1.1.3
case FLAC__METADATA_TYPE_PICTURE:
{
FLAC__metadata_iterator_delete_block(iter,true);
break;
}
#endif
default:
break;
}
}
//
// Create and insert a new VORBISCOMMENT block
//
{
FLAC__StreamMetadata *vc_block; // For vorbis comments
FLAC__StreamMetadata_VorbisComment_Entry field;
gchar *string;
GList *list;
// Allocate a block for Vorbis comments
vc_block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
// Set the original vendor string, else will be use the version of library
if (vce_field_vendor_string_found)
{
// must set 'copy' param to false, because the API will reuse the pointer of an empty
// string (yet still return 'true', indicating it was copied); the string is free'd during
// metadata_chain_delete routine
FLAC__metadata_object_vorbiscomment_set_vendor_string(vc_block, vce_field_vendor_string, /*copy=*/false);
}
/*********
* Title *
*********/
if ( FileTag->title )
{
Flac_Write_Delimetered_Tag(vc_block,"TITLE=",FileTag->title);
}
/**********
* Artist *
**********/
if ( FileTag->artist )
{
Flac_Write_Delimetered_Tag(vc_block,"ARTIST=",FileTag->artist);
}
/*********
* Album *
*********/
if ( FileTag->album )
{
Flac_Write_Delimetered_Tag(vc_block,"ALBUM=",FileTag->album);
}
/***************
* Disc Number *
***************/
if ( FileTag->disc_number )
{
string = g_strconcat("DISCNUMBER=",FileTag->disc_number,NULL);
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
g_free(string);
}
/********
* Year *
********/
if ( FileTag->year )
{
string = g_strconcat("DATE=",FileTag->year,NULL);
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
g_free(string);
}
/*************************
* Track and Total Track *
*************************/
if ( FileTag->track )
{
string = g_strconcat("TRACKNUMBER=",FileTag->track,NULL);
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
g_free(string);
}
if ( FileTag->track_total /*&& strlen(FileTag->track_total)>0*/ )
{
string = g_strconcat("TRACKTOTAL=",FileTag->track_total,NULL);
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
g_free(string);
}
/*********
* Genre *
*********/
if ( FileTag->genre )
{
Flac_Write_Delimetered_Tag(vc_block,"GENRE=",FileTag->genre);
}
/***********
* Comment *
***********/
// We write the comment using the "both" format
if ( FileTag->comment )
{
Flac_Write_Delimetered_Tag(vc_block,"DESCRIPTION=",FileTag->comment);
Flac_Write_Delimetered_Tag(vc_block,"COMMENT=",FileTag->comment);
}
/************
* Composer *
************/
if ( FileTag->composer )
{
Flac_Write_Delimetered_Tag(vc_block,"COMPOSER=",FileTag->composer);
}
/*******************
* Original artist *
*******************/
if ( FileTag->orig_artist )
{
Flac_Write_Delimetered_Tag(vc_block,"PERFORMER=",FileTag->orig_artist);
}
/*************
* Copyright *
*************/
if ( FileTag->copyright )
{
string = g_strconcat("COPYRIGHT=",FileTag->copyright,NULL);
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
g_free(string);
}
/*******
* URL *
*******/
if ( FileTag->url )
{
string = g_strconcat("LICENSE=",FileTag->url,NULL);
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
g_free(string);
}
/**************
* Encoded by *
**************/
if ( FileTag->encoded_by )
{
string = g_strconcat("ENCODED-BY=",FileTag->encoded_by,NULL);
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
g_free(string);
}
/**************************
* Set unsupported fields *
**************************/
list = FileTag->other;
while (list)
{
if (list->data)
{
string = (gchar*)list->data;
field.entry = (FLAC__byte *)string;
field.length = strlen(string);
FLAC__metadata_object_vorbiscomment_insert_comment(vc_block,vc_block->data.vorbis_comment.num_comments,field,true);
}
list = list->next;
}
// Add the block to the the chain (so we don't need to free the block)
FLAC__metadata_iterator_insert_block_after(iter, vc_block);
}
//
// Create and insert PICTURE blocks
//
/***********
* Picture *
***********/
// For FLAC >= 1.1.3
#ifndef LEGACY_FLAC
{
Picture *pic = FileTag->picture;
while (pic)
{
if (pic->data)
{
const gchar *violation;
FLAC__StreamMetadata *picture_block; // For picture data
Picture_Format format;
// Allocate block for picture data
picture_block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE);
// Type
picture_block->data.picture.type = pic->type;
// Mime type
format = Picture_Format_From_Data(pic);
FLAC__metadata_object_picture_set_mime_type(picture_block, (gchar *)Picture_Mime_Type_String(format), TRUE);
// Description
if (pic->description)
{
FLAC__metadata_object_picture_set_description(picture_block, (FLAC__byte *)pic->description, TRUE);
}
// Resolution
picture_block->data.picture.width = pic->width;
picture_block->data.picture.height = pic->height;
picture_block->data.picture.depth = 0;
// Picture data
FLAC__metadata_object_picture_set_data(picture_block, (FLAC__byte *)pic->data, (FLAC__uint32) pic->size, TRUE);
if (!FLAC__metadata_object_picture_is_legal(picture_block, &violation))
{
Log_Print(LOG_ERROR,_("Picture block isn't valid: '%s'"),violation);
FLAC__metadata_object_delete(picture_block);
} else
{
// Add the block to the the chain (so we don't need to free the block)
FLAC__metadata_iterator_insert_block_after(iter, picture_block);
}
}
pic = pic->next;
}
}
#endif
// Free iter
FLAC__metadata_iterator_delete(iter);
//
// Prepare for writing tag
//
// Move all PADDING blocks to the end on the metadata, and merge them into a single block.
FLAC__metadata_chain_sort_padding(chain);
// Write tag
if ( !FLAC__metadata_chain_write(chain, /*padding*/TRUE, PRESERVE_MODIFICATION_TIME) )
{
// Error with "FLAC__metadata_chain_write"
FLAC__Metadata_ChainStatus status = FLAC__metadata_chain_status(chain);
flac_error_msg = FLAC__Metadata_ChainStatusString[status];
FLAC__metadata_chain_delete(chain);
Log_Print(LOG_ERROR,_("ERROR: Failed to write comments to file '%s' (%s)."),filename_utf8,flac_error_msg);
return FALSE;
} else
{
basename_utf8 = g_path_get_basename(filename_utf8);
Log_Print(LOG_OK,_("Written tag of '%s'"),basename_utf8);
g_free(basename_utf8);
}
FLAC__metadata_chain_delete(chain);
#ifdef ENABLE_MP3
/*
* Write also the ID3 tags (ID3v1 and/or ID3v2) if wanted (as needed by some players)
*/
if (WRITE_ID3_TAGS_IN_FLAC_FILE)
{
Id3tag_Write_File_Tag(ETFile);
} else
{
// Delete the ID3 tags (create a dummy ETFile for the Id3tag_... function)
ET_File *ETFile_tmp = ET_File_Item_New();
File_Name *FileName_tmp = ET_File_Name_Item_New();
File_Tag *FileTag_tmp = ET_File_Tag_Item_New();
// Same file...
FileName_tmp->value = g_strdup(filename);
FileName_tmp->value_utf8 = g_strdup(filename_utf8); // Not necessary to fill 'value_ck'
ETFile_tmp->FileNameList = g_list_append(NULL,FileName_tmp);
ETFile_tmp->FileNameCur = ETFile_tmp->FileNameList;
// With empty tag...
ETFile_tmp->FileTagList = g_list_append(NULL,FileTag_tmp);
ETFile_tmp->FileTag = ETFile_tmp->FileTagList;
Id3tag_Write_File_Tag(ETFile_tmp);
ET_Free_File_List_Item(ETFile_tmp);
}
#endif
return TRUE;
}
