haiku.git

/*
 * Copyright 2009-2010 Stephan Aßmus <superstippi@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT license.
 */

#include "FilePlaylistItem.h"

#include <stdio.h>

#include <new>

#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <MediaFile.h>
#include <MediaTrack.h>
#include <Path.h>
#include <TranslationUtils.h>

#include "MediaFileTrackSupplier.h"
#include "SubTitlesSRT.h"

static const char* kPathKey = "path";

FilePlaylistItem::FilePlaylistItem(const entry_ref& ref)
{
	fRefs.push_back(ref);
	fNamesInTrash.push_back("");
}


FilePlaylistItem::FilePlaylistItem(const FilePlaylistItem& other)
	:
	fRefs(other.fRefs),
	fNamesInTrash(other.fNamesInTrash),
	fImageRefs(other.fImageRefs),
	fImageNamesInTrash(other.fImageNamesInTrash)
{
}


FilePlaylistItem::FilePlaylistItem(const BMessage* archive)
{
	const char* path;
	entry_ref	ref;
	if (archive != NULL) {
		int32 i = 0;
		while (archive->FindString(kPathKey, i, &path) == B_OK) {
			if (get_ref_for_path(path, &ref) == B_OK) {
				fRefs.push_back(ref);
			}
			i++;
		}
	}
	if (fRefs.empty()) {
		fRefs.push_back(entry_ref());
	}
	for (vector<entry_ref>::size_type i = 0; i < fRefs.size(); i++) {
		fNamesInTrash.push_back("");
	}
}


FilePlaylistItem::~FilePlaylistItem()
{
}


PlaylistItem*
FilePlaylistItem::Clone() const
{
	return new (std::nothrow) FilePlaylistItem(*this);
}


BArchivable*
FilePlaylistItem::Instantiate(BMessage* archive)
{
	if (validate_instantiation(archive, "FilePlaylistItem"))
		return new (std::nothrow) FilePlaylistItem(archive);

	return NULL;
}


// #pragma mark -


status_t
FilePlaylistItem::Archive(BMessage* into, bool deep) const
{
	status_t ret = BArchivable::Archive(into, deep);
	if (ret != B_OK)
		return ret;
	for (vector<entry_ref>::size_type i = 0; i < fRefs.size(); i++) {
		BPath path(&fRefs[i]);
		ret = path.InitCheck();
		if (ret != B_OK)
			return ret;
		ret = into->AddString(kPathKey, path.Path());
		if (ret != B_OK)
			return ret;
	}
	return B_OK;
}


status_t
FilePlaylistItem::SetAttribute(const Attribute& attribute,
	const BString& string)
{
	switch (attribute) {
		case ATTR_STRING_NAME:
		{
			BEntry entry(&fRefs[0], false);
			return entry.Rename(string.String(), false);
		}
	
		case ATTR_STRING_KEYWORDS:
			return _SetAttribute("Meta:Keywords", B_STRING_TYPE,
				string.String(), string.Length());

		case ATTR_STRING_ARTIST:
			return _SetAttribute("Audio:Artist", B_STRING_TYPE,
				string.String(), string.Length());
		case ATTR_STRING_AUTHOR:
			return _SetAttribute("Media:Author", B_STRING_TYPE,
				string.String(), string.Length());
		case ATTR_STRING_ALBUM:
			return _SetAttribute("Audio:Album", B_STRING_TYPE,
				string.String(), string.Length());
		case ATTR_STRING_TITLE:
			return _SetAttribute("Media:Title", B_STRING_TYPE,
				string.String(), string.Length());
		case ATTR_STRING_AUDIO_BITRATE:
			return _SetAttribute("Audio:Bitrate", B_STRING_TYPE,
				string.String(), string.Length());
		case ATTR_STRING_VIDEO_BITRATE:
			return _SetAttribute("Video:Bitrate", B_STRING_TYPE,
				string.String(), string.Length());

		default:
			return B_NOT_SUPPORTED;
	}
}


status_t
FilePlaylistItem::GetAttribute(const Attribute& attribute,
	BString& string) const
{
	if (attribute == ATTR_STRING_NAME) {
		if (fRefs[0].name == NULL)
			return B_NAME_NOT_FOUND;
		string = fRefs[0].name;
		return B_OK;
	}

	return B_NOT_SUPPORTED;
}


status_t
FilePlaylistItem::SetAttribute(const Attribute& attribute,
	const int32& value)
{
	switch (attribute) {
		case ATTR_INT32_TRACK:
			return _SetAttribute("Audio:Track", B_INT32_TYPE, &value,
				sizeof(int32));
		case ATTR_INT32_YEAR:
			return _SetAttribute("Media:Year", B_INT32_TYPE, &value,
				sizeof(int32));
		case ATTR_INT32_RATING:
			return _SetAttribute("Media:Rating", B_INT32_TYPE, &value,
				sizeof(int32));

		default:
			return B_NOT_SUPPORTED;
	}
}


status_t
FilePlaylistItem::GetAttribute(const Attribute& attribute,
	int32& value) const
{
	switch (attribute) {
		case ATTR_INT32_TRACK:
			return _GetAttribute("Audio:Track", B_INT32_TYPE, &value,
				sizeof(int32));
		case ATTR_INT32_YEAR:
			return _GetAttribute("Media:Year", B_INT32_TYPE, &value,
				sizeof(int32));
		case ATTR_INT32_RATING:
			return _GetAttribute("Media:Rating", B_INT32_TYPE, &value,
				sizeof(int32));

		default:
			return B_NOT_SUPPORTED;
	}
}


status_t
FilePlaylistItem::SetAttribute(const Attribute& attribute,
	const int64& value)
{
	switch (attribute) {
		case ATTR_INT64_FRAME:
			return _SetAttribute("Media:Frame", B_INT64_TYPE, &value,
				sizeof(int64));
		case ATTR_INT64_DURATION:
			return _SetAttribute("Media:Length", B_INT64_TYPE, &value,
				sizeof(int64));
		default:
			return B_NOT_SUPPORTED;
	}
}


status_t
FilePlaylistItem::GetAttribute(const Attribute& attribute,
	int64& value) const
{
	switch (attribute) {
		case ATTR_INT64_FRAME:
			return _GetAttribute("Media:Frame", B_INT64_TYPE, &value,
				sizeof(int64));
		case ATTR_INT64_DURATION:
			return _GetAttribute("Media:Length", B_INT64_TYPE, &value,
				sizeof(int64));
		default:
			return B_NOT_SUPPORTED;
	}
}


status_t
FilePlaylistItem::SetAttribute(const Attribute& attribute,
	const float& value)
{
	if (attribute == ATTR_FLOAT_VOLUME) {
		return _SetAttribute("Media:Volume", B_FLOAT_TYPE, &value,
			sizeof(float));
	}

	return B_NOT_SUPPORTED;
}


status_t
FilePlaylistItem::GetAttribute(const Attribute& attribute,
	float& value) const
{
	if (attribute == ATTR_FLOAT_VOLUME) {
		return _GetAttribute("Media:Volume", B_FLOAT_TYPE, &value,
			sizeof(float));
	}

	return B_NOT_SUPPORTED;
}


// #pragma mark -


BString
FilePlaylistItem::LocationURI() const
{
	BPath path(&fRefs[0]);
	BString locationURI("file://");
	locationURI << path.Path();
	return locationURI;
}


status_t
FilePlaylistItem::GetIcon(BBitmap* bitmap, icon_size iconSize) const
{
	BNode node(&fRefs[0]);
	BNodeInfo info(&node);
	return info.GetTrackerIcon(bitmap, iconSize);
}


status_t
FilePlaylistItem::MoveIntoTrash()
{
	if (fNamesInTrash[0].Length() != 0) {
		// Already in the trash!
		return B_ERROR;
	}

	status_t err;
	err = _MoveIntoTrash(&fRefs, &fNamesInTrash);
	if (err != B_OK)
		return err;
	
	if (fImageRefs.empty())
		return B_OK;

	err = _MoveIntoTrash(&fImageRefs, &fImageNamesInTrash);
	if (err != B_OK)
		return err;

	return B_OK;
}


status_t
FilePlaylistItem::RestoreFromTrash()
{
	if (fNamesInTrash[0].Length() <= 0) {
		// Not in the trash!
		return B_ERROR;
	}

	status_t err;
	err = _RestoreFromTrash(&fRefs, &fNamesInTrash);
	if (err != B_OK)
		return err;
	
	if (fImageRefs.empty())
		return B_OK;

	err = _RestoreFromTrash(&fImageRefs, &fImageNamesInTrash);
	if (err != B_OK)
		return err;

	return B_OK;
}


// #pragma mark -

TrackSupplier*
FilePlaylistItem::_CreateTrackSupplier() const
{
	MediaFileTrackSupplier* supplier
		= new(std::nothrow) MediaFileTrackSupplier();
	if (supplier == NULL)
		return NULL;

	for (vector<entry_ref>::size_type i = 0; i < fRefs.size(); i++) {
		BMediaFile* mediaFile = new(std::nothrow) BMediaFile(&fRefs[i]);
		if (mediaFile == NULL) {
			delete supplier;
			return NULL;
		}
		if (supplier->AddMediaFile(mediaFile) != B_OK)
			delete mediaFile;
	}

	for (vector<entry_ref>::size_type i = 0; i < fImageRefs.size(); i++) {
		BBitmap* bitmap = BTranslationUtils::GetBitmap(&fImageRefs[i]);
		if (bitmap == NULL)
			continue;
		if (supplier->AddBitmap(bitmap) != B_OK)
			delete bitmap;
	}

	// Search for subtitle files in the same folder
	// TODO: Error checking
	BEntry entry(&fRefs[0], true);

	char originalName[B_FILE_NAME_LENGTH];
	entry.GetName(originalName);
	BString nameWithoutExtension(originalName);
	int32 extension = nameWithoutExtension.FindLast('.');
	if (extension > 0)
		nameWithoutExtension.Truncate(extension);

	BPath path;
	entry.GetPath(&path);
	path.GetParent(&path);
	BDirectory directory(path.Path());
	while (directory.GetNextEntry(&entry) == B_OK) {
		char name[B_FILE_NAME_LENGTH];
		if (entry.GetName(name) != B_OK)
			continue;
		BString nameString(name);
		if (nameString == originalName)
			continue;
		if (nameString.IFindFirst(nameWithoutExtension) < 0)
			continue;

		BFile file(&entry, B_READ_ONLY);
		if (file.InitCheck() != B_OK)
			continue;

		int32 pos = nameString.FindLast('.');
		if (pos < 0)
			continue;

		BString extensionString(nameString.String() + pos + 1);
		extensionString.ToLower();

		BString language = "default";
		if (pos > 1) {
			int32 end = pos;
			while (pos > 0 && *(nameString.String() + pos - 1) != '.')
				pos--;
			language.SetTo(nameString.String() + pos, end - pos);
		}

		if (extensionString == "srt") {
			SubTitles* subTitles
				= new(std::nothrow) SubTitlesSRT(&file, language.String());
			if (subTitles != NULL && !supplier->AddSubTitles(subTitles))
				delete subTitles;
		}
	}

	return supplier;
}


status_t
FilePlaylistItem::AddRef(const entry_ref& ref)
{
	fRefs.push_back(ref);
	fNamesInTrash.push_back("");
	return B_OK;
}


status_t
FilePlaylistItem::AddImageRef(const entry_ref& ref)
{
	fImageRefs.push_back(ref);
	fImageNamesInTrash.push_back("");
	return B_OK;
}


const entry_ref&
FilePlaylistItem::ImageRef() const
{
	static entry_ref ref;

	if (fImageRefs.empty())
		return ref;
	
	return fImageRefs[0];
}


bigtime_t
FilePlaylistItem::_CalculateDuration()
{
	BMediaFile mediaFile(&Ref());

	if (mediaFile.InitCheck() != B_OK || mediaFile.CountTracks() < 1)
		return 0;

	return mediaFile.TrackAt(0)->Duration();
}


status_t
FilePlaylistItem::_SetAttribute(const char* attrName, type_code type,
	const void* data, size_t size)
{
	BEntry entry(&fRefs[0], true);
	BNode node(&entry);
	if (node.InitCheck() != B_OK)
		return node.InitCheck();

	ssize_t written = node.WriteAttr(attrName, type, 0, data, size);
	if (written != (ssize_t)size) {
		if (written < 0)
			return (status_t)written;
		return B_IO_ERROR;
	}
	return B_OK;
}


status_t
FilePlaylistItem::_GetAttribute(const char* attrName, type_code type,
	void* data, size_t size) const
{
	BEntry entry(&fRefs[0], true);
	BNode node(&entry);
	if (node.InitCheck() != B_OK)
		return node.InitCheck();

	ssize_t read = node.ReadAttr(attrName, type, 0, data, size);
	if (read != (ssize_t)size) {
		if (read < 0)
			return (status_t)read;
		return B_IO_ERROR;
	}
	return B_OK;
}


status_t
FilePlaylistItem::_MoveIntoTrash(vector<entry_ref>* refs,
	vector<BString>* namesInTrash)
{
	char trashPath[B_PATH_NAME_LENGTH];
	status_t err = find_directory(B_TRASH_DIRECTORY, (*refs)[0].device,
		true /*create it*/, trashPath, B_PATH_NAME_LENGTH);
	if (err != B_OK) {
		fprintf(stderr, "failed to find Trash: %s\n", strerror(err));
		return err;
	}

	BDirectory trashDir(trashPath);
	err = trashDir.InitCheck();
	if (err != B_OK) {
		fprintf(stderr, "failed to init BDirectory for %s: %s\n",
			trashPath, strerror(err));
		return err;
	}

	for (vector<entry_ref>::size_type i = 0; i < refs->size(); i++) {
		BEntry entry(&(*refs)[i]);
		err = entry.InitCheck();
		if (err != B_OK) {
			fprintf(stderr, "failed to init BEntry for %s: %s\n",
				(*refs)[i].name, strerror(err));
			return err;
		}
	
		// Find a unique name for the entry in the trash
		(*namesInTrash)[i] = (*refs)[i].name;
		int32 uniqueNameIndex = 1;
		while (true) {
			BEntry test(&trashDir, (*namesInTrash)[i].String());
			if (!test.Exists())
				break;
			(*namesInTrash)[i] = (*refs)[i].name;
			(*namesInTrash)[i] << ' ' << uniqueNameIndex;
			uniqueNameIndex++;
		}
	
		// Remember the original path
		BPath originalPath;
		entry.GetPath(&originalPath);
	
		// Finally, move the entry into the trash
		err = entry.MoveTo(&trashDir, (*namesInTrash)[i].String());
		if (err != B_OK) {
			fprintf(stderr, "failed to move entry into trash %s: %s\n",
				trashPath, strerror(err));
			return err;
		}
	
		// Allow Tracker to restore this entry
		BNode node(&entry);
		BString originalPathString(originalPath.Path());
		node.WriteAttrString("_trk/original_path", &originalPathString);
	}

	return B_OK;
}


status_t
FilePlaylistItem::_RestoreFromTrash(vector<entry_ref>* refs,
	vector<BString>* namesInTrash)
{
	char trashPath[B_PATH_NAME_LENGTH];
	status_t err = find_directory(B_TRASH_DIRECTORY, (*refs)[0].device,
		false /*create it*/, trashPath, B_PATH_NAME_LENGTH);
	if (err != B_OK) {
		fprintf(stderr, "failed to find Trash: %s\n", strerror(err));
		return err;
	}
	
	for (vector<entry_ref>::size_type i = 0; i < refs->size(); i++) {
		// construct the entry to the file in the trash
		// TODO: BEntry(const BDirectory* directory, const char* path) is broken!
		//	BEntry entry(trashPath, (*namesInTrash)[i].String());
		BPath path(trashPath, (*namesInTrash)[i].String());
		BEntry entry(path.Path());
		err = entry.InitCheck();
		if (err != B_OK) {
			fprintf(stderr, "failed to init BEntry for %s: %s\n",
				(*namesInTrash)[i].String(), strerror(err));
			return err;
		}
		//entry.GetPath(&path);
		//printf("moving '%s'\n", path.Path());
	
		// construct the folder of the original entry_ref
		node_ref nodeRef;
		nodeRef.device = (*refs)[i].device;
		nodeRef.node = (*refs)[i].directory;
		BDirectory originalDir(&nodeRef);
		err = originalDir.InitCheck();
		if (err != B_OK) {
			fprintf(stderr, "failed to init original BDirectory for "
				"%s: %s\n", (*refs)[i].name, strerror(err));
			return err;
		}
	
		//path.SetTo(&originalDir, fItems[i].name);
		//printf("as '%s'\n", path.Path());
	
		// Reset the name here, the user may have already moved the entry
		// out of the trash via Tracker for example.
		(*namesInTrash)[i] = "";
	
		// Finally, move the entry back into the original folder
		err = entry.MoveTo(&originalDir, (*refs)[i].name);
		if (err != B_OK) {
			fprintf(stderr, "failed to restore entry from trash "
				"%s: %s\n", (*refs)[i].name, strerror(err));
			return err;
		}
	
		// Remove the attribute that helps Tracker restore the entry.
		BNode node(&entry);
		node.RemoveAttr("_trk/original_path");
	}

	return B_OK;
}