winamp/Src/Plugins/Input/in_flac/Metadata.cpp

/*
** Copyright (C) 2007-2011 Nullsoft, Inc.
**
** This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held 
** liable for any damages arising from the use of this software. 
**
** Permission is granted to anyone to use this software for any purpose, including commercial applications, and to 
** alter it and redistribute it freely, subject to the following restrictions:
**
**   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. 
**      If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
**
**   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
**
**   3. This notice may not be removed or altered from any source distribution.
**
** Author: Ben Allison [email protected]
** Created: March 1, 2007
**
*/
#include "Metadata.h"
#include <FLAC/all.h>
#include "StreamFileWin32.h" // for FileSize64
#include "api__in_flv.h"
#include <strsafe.h>

struct MetadataReader
{
	MetadataReader(HANDLE _handle)
	{
		handle = _handle;
		endOfFile=false;
	}
		HANDLE handle;
	bool endOfFile;	
};

static size_t win32_read(void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle)
{
	MetadataReader *reader = (MetadataReader *)handle;
	DWORD bytesRead=0;
	BOOL result = ReadFile(reader->handle, ptr, size*nmemb, &bytesRead, NULL);
	if (result == TRUE && bytesRead == 0)
		reader->endOfFile=true;
	return bytesRead/size;
}

static size_t win32_write(const void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle)
{
	MetadataReader *reader = (MetadataReader *)handle;
	DWORD bytesWritten=0;
	WriteFile(reader->handle, ptr, size*nmemb, &bytesWritten, NULL);
	return bytesWritten/size;
}

static __int64 Seek64(HANDLE hf, __int64 distance, DWORD MoveMethod)
{
	LARGE_INTEGER li;

	li.QuadPart = distance;

	li.LowPart = SetFilePointer (hf, li.LowPart, &li.HighPart, MoveMethod);

	if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
	{
		li.QuadPart = -1;
	}

	return li.QuadPart;
}

static int win32_seek(FLAC__IOHandle handle, FLAC__int64 offset, int whence)
{
		MetadataReader *reader = (MetadataReader *)handle;
	if (Seek64(reader->handle, offset, whence) == -1)
		return -1;
	else
		return 0;
	
}

static FLAC__int64 win32_tell(FLAC__IOHandle handle)
{
	MetadataReader *reader = (MetadataReader *)handle;
	return Seek64(reader->handle, 0, FILE_CURRENT);
}

static int win32_eof(FLAC__IOHandle handle)
{
	MetadataReader *reader = (MetadataReader *)handle;
	return !!reader->endOfFile;
}

static int win32_close(FLAC__IOHandle handle)
{
	MetadataReader *reader = (MetadataReader *)handle;

	CloseHandle(reader->handle);
	reader->handle = INVALID_HANDLE_VALUE;
	return 0;
}

static FLAC__IOCallbacks unicodeIO =
{
  win32_read,
  win32_write,
  win32_seek,
  win32_tell,
  win32_eof,
  win32_close,
};

FLACMetadata::FLACMetadata()
{
	chain=FLAC__metadata_chain_new();
	itr = FLAC__metadata_iterator_new();
	block=0;
	streamInfo=0;
	filesize=0;
}

FLACMetadata::~FLACMetadata()
{
	if (chain)
		FLAC__metadata_chain_delete(chain);
	if (itr)
		FLAC__metadata_iterator_delete(itr);
}

void FLACMetadata::Reset()
{
	if (chain)
		FLAC__metadata_chain_delete(chain);
	if (itr)
		FLAC__metadata_iterator_delete(itr);
	chain=FLAC__metadata_chain_new();
	itr = FLAC__metadata_iterator_new();
	block=0;
	streamInfo=0;
	filesize=0;
}

const FLAC__StreamMetadata_StreamInfo *FLACMetadata::GetStreamInfo()
{
	if (streamInfo)
		return &streamInfo->data.stream_info;
	else
		return 0;
}

bool FLACMetadata::Open(const wchar_t *filename, bool optimize)
{
	if (!chain || !itr)
		return false;

	HANDLE hfile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, 0, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, 0);
	MetadataReader reader(hfile);
	if (reader.handle == INVALID_HANDLE_VALUE)
		return false;
	filesize = FileSize64(reader.handle);

	FLAC__bool success = FLAC__metadata_chain_read_with_callbacks(chain, &reader, unicodeIO);
	CloseHandle(hfile);
	if (!success)
		return false;

	if (optimize)
	{
		FLAC__metadata_chain_sort_padding(chain);
		FLAC__metadata_chain_merge_padding(chain);
	}

	FLAC__metadata_iterator_init(itr, chain);
	while (1)
	{
		FLAC__MetadataType type=FLAC__metadata_iterator_get_block_type(itr);
		switch (type)
		{
		case FLAC__METADATA_TYPE_VORBIS_COMMENT:
			block = FLAC__metadata_iterator_get_block(itr);
			break;
		case FLAC__METADATA_TYPE_STREAMINFO:
			streamInfo = FLAC__metadata_iterator_get_block(itr);
			break;
		}
		if (FLAC__metadata_iterator_next(itr) == false)
			break;
	}
	return true;
}

const char *FLACMetadata::GetMetadata(const char *tag)
{
	if (!block)
		return 0;

	int pos = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, tag);
	if (pos < 0)
	{
		// fail
	}
	else
	{
		const char *entry = (const char *)block->data.vorbis_comment.comments[pos].entry;
		const char *metadata = strchr(entry, '='); // find the first equal
		if (metadata)
		{
			return metadata+1;
		}
	}

	return 0;
}

void FLACMetadata::SetMetadata(const char *tag, const char *value)
{
	if (!block)
	{
		FLAC__metadata_iterator_init(itr, chain);
		do
		{
			if (FLAC__METADATA_TYPE_VORBIS_COMMENT == FLAC__metadata_iterator_get_block_type(itr))
			{
				block = FLAC__metadata_iterator_get_block(itr);
				break;
			}
		}
		while (FLAC__metadata_iterator_next(itr) != 0);
		if (!block)
		{
			block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
			FLAC__metadata_iterator_insert_block_after(itr, block);
		}		
	}

	if (!block)
		return;

	FLAC__StreamMetadata_VorbisComment_Entry entry;
	size_t totalLen = strlen(tag) + 1 /* = */ + strlen(value);
	entry.entry = (FLAC__byte *)malloc(totalLen + 1);
	entry.length = totalLen;

	StringCchPrintfA((char *)entry.entry, totalLen+1, "%s=%s", tag, value);

	int pos = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, tag);
	if (pos < 0)
	{
		//new comment
		FLAC__metadata_object_vorbiscomment_append_comment(block, entry, true);
		// would love to not copy, but we can't guarantee that FLAC links to the same CRT as us
	}
	else
	{
		FLAC__metadata_object_vorbiscomment_set_comment(block, pos, entry, true);
		// would love to not copy, but we can't guarantee that FLAC links to the same CRT as us
	}
	free(entry.entry);
}

void FLACMetadata::RemoveMetadata(const char *tag)
{
	if (!block)
		return;

	FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, tag);
}

void FLACMetadata::RemoveMetadata(int n)
{
	if (!block)
		return;

	FLAC__metadata_object_vorbiscomment_delete_comment(block, (unsigned int)n);
}

static FLAC__StreamMetadata *GetOrMakePadding(FLAC__Metadata_Chain *chain, FLAC__Metadata_Iterator *itr)
{
	FLAC__metadata_iterator_init(itr, chain);
	while (1)
	{
		if (FLAC__METADATA_TYPE_PADDING == FLAC__metadata_iterator_get_block_type(itr))
		{
			FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(itr);
			return block;
		}

		if (FLAC__metadata_iterator_next(itr) == false)
			break;
	}
	FLAC__StreamMetadata *padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
	if (padding)
		FLAC__metadata_iterator_insert_block_after(itr, padding);

	return padding;
}

bool FLACMetadata::Save(const wchar_t *filename)
{
	if (FLAC__metadata_chain_check_if_tempfile_needed(chain, true))
	{
		// since we needed to write a tempfile, let's add some more padding so it doesn't happen again
		FLAC__metadata_chain_sort_padding(chain);

		FLAC__StreamMetadata *padding = GetOrMakePadding(chain, itr);
		if (padding && padding->length < 16384)
			padding->length = 16384; // TODO: configurable padding size

		HANDLE hfile = CreateFileW(filename, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
		MetadataReader reader(hfile);
		if (reader.handle == INVALID_HANDLE_VALUE)
			return false;

		wchar_t tempPath[MAX_PATH-14] = {0}, tempFile[MAX_PATH] = {0};
		GetTempPathW(MAX_PATH-14, tempPath);
		GetTempFileNameW(tempPath, L"waf", 0, tempFile);

		HANDLE hTempFile = CreateFileW(tempFile, GENERIC_READ|GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
		MetadataReader tempReader(hTempFile);

		FLAC__bool res = FLAC__metadata_chain_write_with_callbacks_and_tempfile(chain, false, &reader, unicodeIO, &tempReader, unicodeIO);

		CloseHandle(hfile);
		CloseHandle(hTempFile);
		if (!MoveFileW(tempFile, filename))
		{
			if (CopyFileW(tempFile, filename, FALSE))
			{
				DeleteFileW(tempFile);
			}
			else
			{
				DeleteFileW(tempFile);
				return false;
			}
		}
		return !!res;
	}
	else
	{
		HANDLE hfile = CreateFileW(filename, GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
		MetadataReader reader(hfile);
		if (reader.handle == INVALID_HANDLE_VALUE)
			return false;

		FLAC__bool res = FLAC__metadata_chain_write_with_callbacks(chain, true, &reader, unicodeIO);

		CloseHandle(hfile);
		return !!res;
	}
}

bool FLACMetadata::GetLengthMilliseconds(unsigned __int64 *length)
{
	if (!streamInfo)
		return false;
	*length = (__int64)((double)(FLAC__int64)streamInfo->data.stream_info.total_samples / (double)streamInfo->data.stream_info.sample_rate * 1000.0 + 0.5);
	return true;
}

int FLACMetadata::GetNumMetadataItems()
{
	if (block) return block->data.vorbis_comment.num_comments;
	else return 0;
}

const char* FLACMetadata::EnumMetadata(int n, char *tag, int taglen)
{
	if (tag) tag[0]=0;
	if (!block) return 0;
	const char *entry = (const char *)block->data.vorbis_comment.comments[n].entry;
	const char *metadata = strchr(entry, '='); // find the first equal
	if (metadata)
	{
		if (tag) lstrcpynA(tag,entry,min(metadata-entry+1,taglen));
		return metadata+1;
	}
	else return 0;
}

void FLACMetadata::SetTag(int pos, const char *tag)
{
	char * value = (char*)EnumMetadata(pos,0,0);
	value = _strdup(value?value:"");
	FLAC__StreamMetadata_VorbisComment_Entry entry;
	size_t totalLen = strlen(tag) + 1 /* = */ + strlen(value);
	entry.entry = (FLAC__byte *)malloc(totalLen + 1);
	entry.length = totalLen;
	StringCchPrintfA((char *)entry.entry, totalLen+1, "%s=%s", tag, value);
	FLAC__metadata_object_vorbiscomment_set_comment(block, pos, entry, true);
	free(value);
}

bool FLACMetadata::GetPicture(FLAC__StreamMetadata_Picture_Type type, void **data, size_t *len, wchar_t **mimeType)
{
	if (!chain || !itr)
		return false;

	FLAC__metadata_iterator_init(itr, chain);
	while (1)
	{
		if (FLAC__METADATA_TYPE_PICTURE == FLAC__metadata_iterator_get_block_type(itr))
		{
			FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(itr);
			FLAC__StreamMetadata_Picture &picture = block->data.picture;
			if (picture.type == type)
			{
				*len = picture.data_length;
				*data = WASABI_API_MEMMGR->sysMalloc(picture.data_length);
				if (!*data)
					return false;
				memcpy(*data, picture.data, picture.data_length);

				char *type = 0;
				if (picture.mime_type)
					type = strchr(picture.mime_type, '/');

				if (type && *type)
				{
					type++;

					char *type2 = strchr(type, '/');
					if (type2 && *type2) type2++;
					else type2 = type;

					int typelen = MultiByteToWideChar(CP_ACP, 0, type2, -1, 0, 0);
					*mimeType = (wchar_t *)WASABI_API_MEMMGR->sysMalloc(typelen * sizeof(wchar_t));
					if (*mimeType)
						MultiByteToWideChar(CP_ACP, 0, type, -1, *mimeType, typelen);
				}
				else
					*mimeType = 0; // unknown!

				return true;
			}
		}

		if (FLAC__metadata_iterator_next(itr) == false)
			break;
	}

	return false;
}

bool FLACMetadata::RemovePicture(FLAC__StreamMetadata_Picture_Type type)
{
	if (!chain || !itr)
		return false;

	FLAC__metadata_iterator_init(itr, chain);
	while (1)
	{
		if (FLAC__METADATA_TYPE_PICTURE == FLAC__metadata_iterator_get_block_type(itr))
		{
			FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(itr);
			FLAC__StreamMetadata_Picture &picture = block->data.picture;
			if (picture.type == type)
			{
				FLAC__metadata_iterator_delete_block(itr, false);
				return true;
			}
		}

		if (FLAC__metadata_iterator_next(itr) == false)
			break;
	}

	return false;
}

bool FLACMetadata::SetPicture(FLAC__StreamMetadata_Picture_Type type, void *data, size_t len, const wchar_t *mimeType, int width, int height)
{
	if (!chain || !itr)
		return false;

	FLAC__metadata_iterator_init(itr, chain);
	while (1)
	{
		if (FLAC__METADATA_TYPE_PICTURE == FLAC__metadata_iterator_get_block_type(itr))
		{
			FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(itr);
			FLAC__StreamMetadata_Picture &picture = block->data.picture;
			if (picture.type == type)
			{
				FLAC__metadata_object_picture_set_data(block, (FLAC__byte *)data, len, true);
				picture.width = width;
				picture.height = height;
				picture.depth = 32;
				picture.colors = 0;

				FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)"", true);// TODO?

				char mime[256] = {0};
				if (wcsstr(mimeType, L"/") != 0)
				{
					StringCchPrintfA(mime, 256, "%S", mimeType);
				}
				else
				{
					StringCchPrintfA(mime, 256, "image/%S", mimeType);
				}
				FLAC__metadata_object_picture_set_mime_type(block, mime, true);
				return true;
			}
		}

		if (FLAC__metadata_iterator_next(itr) == false)
			break;
	}

	// not found. let's add it
	FLAC__StreamMetadata *newBlock = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE);

	FLAC__metadata_object_picture_set_data(newBlock, (FLAC__byte *)data, len, true);
	FLAC__StreamMetadata_Picture &picture = newBlock->data.picture;
	picture.type = type;
	picture.width = width;
	picture.height = height;
	picture.depth = 32;
	picture.colors = 0;

	FLAC__metadata_object_picture_set_description(newBlock, (FLAC__byte *)"", true);// TODO?

	char mime[256] = {0};
	StringCchPrintfA(mime, 256, "image/%S", mimeType);
	FLAC__metadata_object_picture_set_mime_type(newBlock, mime, true);

	FLAC__metadata_iterator_insert_block_after(itr, newBlock);
	return true;
}

bool FLACMetadata::GetIndexPicture(int index, FLAC__StreamMetadata_Picture_Type *type, void **data, size_t *len, wchar_t **mimeType)
{
	if (!chain || !itr)
		return false;
	int i=0;
	FLAC__metadata_iterator_init(itr, chain);
	while (1)
	{
		if (FLAC__METADATA_TYPE_PICTURE == FLAC__metadata_iterator_get_block_type(itr))
		{
			FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(itr);
			FLAC__StreamMetadata_Picture &picture = block->data.picture;
			if (i++ == index)
			{
				*type = picture.type;
				*len = picture.data_length;
				*data = WASABI_API_MEMMGR->sysMalloc(picture.data_length);
				if (!*data)
					return false;
				memcpy(*data, picture.data, picture.data_length);

				char *type = 0;
				if (picture.mime_type)
					type = strchr(picture.mime_type, '/');

				if (type && *type)
				{
					type++;
					int typelen = MultiByteToWideChar(CP_ACP, 0, type, -1, 0, 0);
					*mimeType = (wchar_t *)WASABI_API_MEMMGR->sysMalloc(typelen * sizeof(wchar_t));
					if (*mimeType)
						MultiByteToWideChar(CP_ACP, 0, type, -1, *mimeType, typelen);
				}
				else
					*mimeType = 0; // unknown!

				return true;
			}
		}

		if (FLAC__metadata_iterator_next(itr) == false)
			break;
	}

	return false;
}