path: root/Src/replicant/nsid3v2/nsid3v2_common.cpp

#include "nsid3v2/nsid3v2.h"
#include "nsid3v2/header.h"
#include "nsid3v2/tag.h"
#include <string.h> // for memcmp
#include <new>

int NSID3v2_Header_Valid(const void *header_data)
{
	ID3v2::Header header(header_data);
	if (header.Valid())
		return NErr_Success;
	else
		return NErr_False;
}

int NSID3v2_Header_FooterValid(const void *footer_data)
{
	ID3v2::Header footer(footer_data);
	if (footer.FooterValid())
		return NErr_Success;
	else
		return NErr_False;
}

int NSID3v2_Header_Create(nsid3v2_header_t *h, const void *header_data, size_t header_len)
{
	if (header_len < 10)
		return NErr_NeedMoreData;

	ID3v2::Header header(header_data);
	if (!header.Valid())
		return NErr_Error;

	nsid3v2_header_t new_header = (nsid3v2_header_t)new (std::nothrow) ID3v2::Header(header);
	if (!new_header)
		return NErr_OutOfMemory;
	*h = new_header;
	return NErr_Success;
}

int NSID3v2_Header_New(nsid3v2_header_t *h, uint8_t version, uint8_t revision)
{
	nsid3v2_header_t new_header = (nsid3v2_header_t)new (std::nothrow) ID3v2::Header(version, revision);
	if (!new_header)
		return NErr_OutOfMemory;
	*h = new_header;
	return NErr_Success;
}

int NSID3v2_Header_FooterCreate(nsid3v2_header_t *f, const void *footer_data, size_t footer_len)
{
	if (footer_len < 10)
		return NErr_NeedMoreData;

	ID3v2::Header footer(footer_data);
	if (!footer.FooterValid())
		return NErr_Error;

	nsid3v2_header_t new_header = (nsid3v2_header_t)new (std::nothrow) ID3v2::Header(footer);
	if (!new_header)
		return NErr_OutOfMemory;
	*f = new_header;
	return NErr_Success;
}

int NSID3v2_Header_TagSize(const nsid3v2_header_t h, uint32_t *tag_size)
{
	const ID3v2::Header *header = (const ID3v2::Header *)h;
	if (!header)
		return NErr_NullPointer;

	*tag_size = header->TagSize();
	return NErr_Success;
}

int NSID3v2_Header_HasFooter(const nsid3v2_header_t h)
{
	const ID3v2::Header *header = (const ID3v2::Header *)h;
	if (!header)
		return NErr_NullPointer;

	if (header->HasFooter())
		return NErr_Success;
	else
		return NErr_False;
}

int NSID3v2_Header_Destroy(nsid3v2_header_t h)
{
	const ID3v2::Header *header = (const ID3v2::Header *)h;
	if (!header)
		return NErr_NullPointer;

	delete header;
	return NErr_Success;
}

/*
================== Tag ================== 
=                                       =
========================================= 
*/

int NSID3v2_Tag_Create(nsid3v2_tag_t *t, const nsid3v2_header_t h, const void *bytes, size_t bytes_len)
{
	const ID3v2::Header *header = (const ID3v2::Header *)h;
	if (!header)
		return NErr_NullPointer;

	switch(header->GetVersion())
	{
	case 2:
		{
			ID3v2_2::Tag *tag = new (std::nothrow) ID3v2_2::Tag(*header);
			if (!tag)
				return NErr_OutOfMemory;
			tag->Parse(bytes, bytes_len);
			*t = (nsid3v2_tag_t)tag;
			return NErr_Success;
		}
	case 3:
		{
			ID3v2_3::Tag *tag = new (std::nothrow) ID3v2_3::Tag(*header);
			if (!tag)
				return NErr_OutOfMemory;
			tag->Parse(bytes, bytes_len);
			*t = (nsid3v2_tag_t)tag;
			return NErr_Success;
		}
	case 4:
		{
			ID3v2_4::Tag *tag = new (std::nothrow) ID3v2_4::Tag(*header);
			if (!tag)
				return NErr_OutOfMemory;
			tag->Parse(bytes, bytes_len);
			*t = (nsid3v2_tag_t)tag;
			return NErr_Success;
		}
	default:
		return NErr_NotImplemented;
	}
}

int NSID3v2_Tag_Destroy(nsid3v2_tag_t t)
{
	ID3v2::Tag *tag = (ID3v2::Tag *)t;
	delete tag;
	return NErr_Success;
}

int NSID3v2_Tag_RemoveFrame(nsid3v2_tag_t t, nsid3v2_frame_t f)
{
	ID3v2::Tag *tag = (ID3v2::Tag *)t;
	ID3v2::Frame *frame = (ID3v2::Frame *)f;
	tag->RemoveFrame(frame);
	return NErr_Success;
}

int NSID3v2_Tag_CreateFrame(nsid3v2_tag_t t, int frame_enum, int flags, nsid3v2_frame_t *f)
{
	ID3v2::Tag *tag = (ID3v2::Tag *)t;
	*f = (nsid3v2_frame_t)tag->NewFrame(frame_enum, flags);
	return NErr_Success;
}

int NSID3v2_Tag_AddFrame(nsid3v2_tag_t t, nsid3v2_frame_t f)
{
	ID3v2::Tag *tag = (ID3v2::Tag *)t;
	ID3v2::Frame *frame = (ID3v2::Frame *)f;
	tag->AddFrame(frame);
	return NErr_Success;
}

int NSID3v2_Tag_GetFrame(const nsid3v2_tag_t t, int frame_enum, nsid3v2_frame_t *frame)
{
	ID3v2::Tag *tag = (ID3v2::Tag *)t;
	ID3v2::Frame *found_frame = tag->FindFirstFrame(frame_enum);
	if (found_frame)
	{
		*frame = (nsid3v2_frame_t)found_frame;
		return NErr_Success;
	}
	else
		return NErr_Empty;
}

int NSID3v2_Tag_GetNextFrame(const nsid3v2_tag_t t, const nsid3v2_frame_t f, nsid3v2_frame_t *frame)
{
	ID3v2::Tag *tag = (ID3v2::Tag *)t;
	ID3v2::Frame *start_frame = (ID3v2::Frame *)f;

	ID3v2::Frame *found_frame = tag->FindNextFrame(start_frame);
	if (found_frame)
	{
		*frame = (nsid3v2_frame_t)found_frame;
		return NErr_Success;
	}
	else
		return NErr_EndOfEnumeration;
}

int NSID3v2_Frame_Binary_Get(nsid3v2_frame_t f, const void **binary, size_t *length)
{
	ID3v2::Frame *frame = (ID3v2::Frame *)f;
	if (!frame)
		return NErr_BadParameter;

	return frame->GetData(binary, length);
}

int NSID3v2_Tag_EnumerateFrame(const nsid3v2_tag_t t, nsid3v2_frame_t p, nsid3v2_frame_t *f)
{
	const ID3v2::Tag *tag = (const ID3v2::Tag *)t;
	const ID3v2::Frame *frame = tag->EnumerateFrame((const ID3v2::Frame *)p);
	*f = (nsid3v2_frame_t)frame;
	if (frame)
	{
		return NErr_Success;
	}
	else
	{
		return NErr_Error;
	}
}

int NSID3v2_Tag_GetInformation(nsid3v2_tag_t t, uint8_t *version, uint8_t *revision, int *flags)
{
	const ID3v2::Tag *tag = (const ID3v2::Tag *)t;
	if (!tag)
		return NErr_BadParameter;

	*version = tag->GetVersion();
	*revision = tag->GetRevision();

	int local_flags=0;
	if (tag->HasExtendedHeader())
		local_flags |= NSID3V2_TAGFLAG_EXTENDED_HEADER;

	if (tag->Unsynchronised())
		local_flags |= NSID3V2_TAGFLAG_UNSYNCHRONIZED;
	if (tag->HasFooter())
		local_flags |= NSID3V2_TAGFLAG_HASFOOTER;

	*flags = local_flags;

	return NErr_Success;
}

int NSID3v2_Tag_SerializedSize(nsid3v2_tag_t t, uint32_t *length, uint32_t padding_size, int flags)
{
	const ID3v2::Tag *tag = (const ID3v2::Tag *)t;
	if (!tag)
		return NErr_BadParameter;

	return tag->SerializedSize(length, padding_size, flags);
}

int NSID3v2_Tag_Serialize(nsid3v2_tag_t t, void *data, uint32_t len, int flags)
{
	const ID3v2::Tag *tag = (const ID3v2::Tag *)t;
	if (!tag)
		return NErr_BadParameter;

	return tag->Serialize(data, len, flags);
}
/*
================= Frame ================= 
=                                       =
========================================= 
*/

int NSID3v2_Frame_GetIdentifier(nsid3v2_frame_t f, const char **identifier)
{
	ID3v2::Frame *frame = (ID3v2::Frame *)f;
	if (!frame)
		return NErr_BadParameter;

	*identifier = (const char *)frame->GetIdentifier();
	return NErr_Success;
}


int NSID3v2_Frame_GetInformation(nsid3v2_frame_t f, int *type, int *flags)
{
	ID3v2::Frame *frame = (ID3v2::Frame *)f;
	if (!frame)
		return NErr_BadParameter;

	const char *identifier=0;
	int ret = NSID3v2_Frame_GetIdentifier(f, &identifier);
	if (ret != NErr_Success)
		return ret;

	/* TODO: make a method to get the version from the frame */

	/* ok this is a bit of hack job */
	if (!memcmp(identifier, "TXX", 4) || !memcmp(identifier, "TXXX", 4))
	{
		*type = NSID3V2_FRAMETYPE_USERTEXT;
	}
	else if (!memcmp(identifier, "COM", 4) || !memcmp(identifier, "COMM", 4))
	{
		*type = NSID3V2_FRAMETYPE_COMMENTS;
	}
	else if (identifier[0] == 'T') /* check for text */
	{
		*type = NSID3V2_FRAMETYPE_TEXT;
	}		
	else if (!memcmp(identifier, "WXX", 4) || !memcmp(identifier, "WXXX", 4))
	{
		*type = NSID3V2_FRAMETYPE_USERURL;
	}
	else if (identifier[0] == 'W') /* check for URL */
	{
		*type = NSID3V2_FRAMETYPE_URL;
	}		
	else if (!memcmp(identifier, "PRIV", 4))
	{
		*type = NSID3V2_FRAMETYPE_PRIVATE;
	}
	else if (!memcmp(identifier, "GEO", 4) || !memcmp(identifier, "GEOB", 4))
	{
		*type = NSID3V2_FRAMETYPE_OBJECT;
	}
	else if (!memcmp(identifier, "POP", 4) || !memcmp(identifier, "POPM", 4))
	{
		*type = NSID3V2_FRAMETYPE_POPULARITY;
	}
	else if (!memcmp(identifier, "PIC", 4) || !memcmp(identifier, "APIC", 4))
	{
		*type = NSID3V2_FRAMETYPE_PICTURE;
	}	
	else if (!memcmp(identifier, "UFI", 4) || !memcmp(identifier, "UFID", 4))
	{
		*type = NSID3V2_FRAMETYPE_ID;
	}		
	else
	{
		*type = NSID3V2_FRAMETYPE_UNKNOWN;
	}

	if (flags)
	{
		int local_flags=0;
		if (frame->TagAlterPreservation())
			local_flags |= NSID3V2_FRAMEFLAG_TAG_ALTER_PRESERVATION;
		if (frame->FileAlterPreservation())
			local_flags |= NSID3V2_FRAMEFLAG_FILE_ALTER_PRESERVATION;
		if (frame->Encrypted())
			local_flags |= NSID3V2_FRAMEFLAG_ENCRYPTED;
		if (frame->Compressed())
			local_flags |= NSID3V2_FRAMEFLAG_COMPRESSED;
		if (frame->Grouped())
			local_flags |= NSID3V2_FRAMEFLAG_GROUPED;
		if (frame->ReadOnly())
			local_flags |= NSID3V2_FRAMEFLAG_READONLY;
		if (frame->FrameUnsynchronised())
			local_flags |= NSID3V2_FRAMEFLAG_UNSYNCHRONIZED;
		if (frame->DataLengthIndicated())
			local_flags |= NSID3V2_FRAMEFLAG_DATALENGTHINDICATED;
		*flags = local_flags;
	}

	return NErr_Success;
}