haiku.git

/*
 * Playlist.cpp - Media Player for the Haiku Operating System
 *
 * Copyright (C) 2006 Marcus Overhagen <marcus@overhagen.de>
 * Copyright (C) 2007-2009 Stephan Aßmus <superstippi@gmx.de> (MIT ok)
 * Copyright (C) 2008-2009 Fredrik Modéen <[FirstName]@[LastName].se> (MIT ok)
 *
 * Released under the terms of the MIT license.
 */


#include "Playlist.h"

#include <debugger.h>
#include <new>
#include <stdio.h>
#include <strings.h>

#include <AppFileInfo.h>
#include <Application.h>
#include <Autolock.h>
#include <Directory.h>
#include <Entry.h>
#include <File.h>
#include <Message.h>
#include <Mime.h>
#include <NodeInfo.h>
#include <Path.h>
#include <Roster.h>
#include <String.h>

#include <QueryFile.h>

#include "FilePlaylistItem.h"
#include "FileReadWrite.h"
#include "MainApp.h"

using std::nothrow;

// TODO: using BList for objects is bad, replace it with a template

Playlist::Listener::Listener() {}
Playlist::Listener::~Listener() {}
void Playlist::Listener::ItemAdded(PlaylistItem* item, int32 index) {}
void Playlist::Listener::ItemRemoved(int32 index) {}
void Playlist::Listener::ItemsSorted() {}
void Playlist::Listener::CurrentItemChanged(int32 newIndex, bool play) {}
void Playlist::Listener::ImportFailed() {}


// #pragma mark -


static void
make_item_compare_string(const PlaylistItem* item, char* buffer,
	size_t bufferSize)
{
	// TODO: Maybe "location" would be useful here as well.
//	snprintf(buffer, bufferSize, "%s - %s - %0*ld - %s",
//		item->Author().String(),
//		item->Album().String(),
//		3, item->TrackNumber(),
//		item->Title().String());
	snprintf(buffer, bufferSize, "%s", item->LocationURI().String());
}


static int
playlist_item_compare(const void* _item1, const void* _item2)
{
	// compare complete path
	const PlaylistItem* item1 = *(const PlaylistItem**)_item1;
	const PlaylistItem* item2 = *(const PlaylistItem**)_item2;

	static const size_t bufferSize = 1024;
	char string1[bufferSize];
	make_item_compare_string(item1, string1, bufferSize);
	char string2[bufferSize];
	make_item_compare_string(item2, string2, bufferSize);

	return strcmp(string1, string2);
}


// #pragma mark -


Playlist::Playlist()
	:
	BLocker("playlist lock"),
	fItems(),
 	fCurrentIndex(-1)
{
}


Playlist::~Playlist()
{
	MakeEmpty();

	if (fListeners.CountItems() > 0)
		debugger("Playlist::~Playlist() - there are still listeners attached!");
}


// #pragma mark - archiving


static const char* kItemArchiveKey = "item";


status_t
Playlist::Unarchive(const BMessage* archive)
{
	if (archive == NULL)
		return B_BAD_VALUE;

	MakeEmpty();

	BMessage itemArchive;
	for (int32 i = 0;
		archive->FindMessage(kItemArchiveKey, i, &itemArchive) == B_OK; i++) {

		BArchivable* archivable = instantiate_object(&itemArchive);
		PlaylistItem* item = dynamic_cast<PlaylistItem*>(archivable);
		if (!item) {
			delete archivable;
			continue;
		}

		if (!AddItem(item)) {
			delete item;
			return B_NO_MEMORY;
		}
	}

	return B_OK;
}


status_t
Playlist::Archive(BMessage* into) const
{
	if (into == NULL)
		return B_BAD_VALUE;

	int32 count = CountItems();
	for (int32 i = 0; i < count; i++) {
		const PlaylistItem* item = ItemAtFast(i);
		BMessage itemArchive;
		status_t ret = item->Archive(&itemArchive);
		if (ret != B_OK)
			return ret;
		ret = into->AddMessage(kItemArchiveKey, &itemArchive);
		if (ret != B_OK)
			return ret;
	}

	return B_OK;
}


const uint32 kPlaylistMagicBytes = 'MPPL';
const char* kTextPlaylistMimeString = "text/x-playlist";
const char* kBinaryPlaylistMimeString = "application/x-vnd.haiku-playlist";

status_t
Playlist::Unflatten(BDataIO* stream)
{
	if (stream == NULL)
		return B_BAD_VALUE;

	uint32 magicBytes;
	ssize_t read = stream->Read(&magicBytes, 4);
	if (read != 4) {
		if (read < 0)
			return (status_t)read;
		return B_IO_ERROR;
	}

	if (B_LENDIAN_TO_HOST_INT32(magicBytes) != kPlaylistMagicBytes)
		return B_BAD_VALUE;

	BMessage archive;
	status_t ret = archive.Unflatten(stream);
	if (ret != B_OK)
		return ret;

	return Unarchive(&archive);
}


status_t
Playlist::Flatten(BDataIO* stream) const
{
	if (stream == NULL)
		return B_BAD_VALUE;

	BMessage archive;
	status_t ret = Archive(&archive);
	if (ret != B_OK)
		return ret;

	uint32 magicBytes = B_HOST_TO_LENDIAN_INT32(kPlaylistMagicBytes);
	ssize_t written = stream->Write(&magicBytes, 4);
	if (written != 4) {
		if (written < 0)
			return (status_t)written;
		return B_IO_ERROR;
	}

	return archive.Flatten(stream);
}


// #pragma mark - list access


void
Playlist::MakeEmpty(bool deleteItems)
{
	int32 count = CountItems();
	for (int32 i = count - 1; i >= 0; i--) {
		PlaylistItem* item = RemoveItem(i, false);
		_NotifyItemRemoved(i);
		if (deleteItems)
			item->ReleaseReference();
	}
	SetCurrentItemIndex(-1);
}


int32
Playlist::CountItems() const
{
	return fItems.CountItems();
}


bool
Playlist::IsEmpty() const
{
	return fItems.IsEmpty();
}


void
Playlist::Sort()
{
	fItems.SortItems(playlist_item_compare);
	_NotifyItemsSorted();
}


bool
Playlist::AddItem(PlaylistItem* item)
{
	return AddItem(item, CountItems());
}


bool
Playlist::AddItem(PlaylistItem* item, int32 index)
{
	if (!fItems.AddItem(item, index))
		return false;

	if (index <= fCurrentIndex)
		SetCurrentItemIndex(fCurrentIndex + 1, false);

	_NotifyItemAdded(item, index);

	return true;
}


bool
Playlist::AdoptPlaylist(Playlist& other)
{
	return AdoptPlaylist(other, CountItems());
}


bool
Playlist::AdoptPlaylist(Playlist& other, int32 index)
{
	if (&other == this)
		return false;
	// NOTE: this is not intended to merge two "equal" playlists
	// the given playlist is assumed to be a temporary "dummy"
	if (fItems.AddList(&other.fItems, index)) {
		// take care of the notifications
		int32 count = other.CountItems();
		for (int32 i = index; i < index + count; i++) {
			PlaylistItem* item = ItemAtFast(i);
			_NotifyItemAdded(item, i);
		}
		if (index <= fCurrentIndex)
			SetCurrentItemIndex(fCurrentIndex + count);
		// empty the other list, so that the PlaylistItems are now ours
		other.fItems.MakeEmpty();
		return true;
	}
	return false;
}


PlaylistItem*
Playlist::RemoveItem(int32 index, bool careAboutCurrentIndex)
{
	PlaylistItem* item = (PlaylistItem*)fItems.RemoveItem(index);
	if (!item)
		return NULL;
	_NotifyItemRemoved(index);

	if (careAboutCurrentIndex) {
		// fCurrentIndex isn't in sync yet, so might be one too large (if the
		// removed item was above the currently playing item).
		if (index < fCurrentIndex)
			SetCurrentItemIndex(fCurrentIndex - 1, false);
		else if (index == fCurrentIndex) {
			if (fCurrentIndex == CountItems())
				fCurrentIndex--;
			SetCurrentItemIndex(fCurrentIndex, true);
		}
	}

	return item;
}


int32
Playlist::IndexOf(PlaylistItem* item) const
{
	return fItems.IndexOf(item);
}


PlaylistItem*
Playlist::ItemAt(int32 index) const
{
	return (PlaylistItem*)fItems.ItemAt(index);
}


PlaylistItem*
Playlist::ItemAtFast(int32 index) const
{
	return (PlaylistItem*)fItems.ItemAtFast(index);
}


// #pragma mark - navigation


bool
Playlist::SetCurrentItemIndex(int32 index, bool notify)
{
	bool result = true;
	if (index >= CountItems()) {
		index = CountItems() - 1;
		result = false;
		notify = false;
	}
	if (index < 0) {
		index = -1;
		result = false;
	}
	if (index == fCurrentIndex && !notify)
		return result;

	fCurrentIndex = index;
	_NotifyCurrentItemChanged(fCurrentIndex, notify);
	return result;
}


int32
Playlist::CurrentItemIndex() const
{
	return fCurrentIndex;
}


void
Playlist::GetSkipInfo(bool* canSkipPrevious, bool* canSkipNext) const
{
	if (canSkipPrevious)
		*canSkipPrevious = fCurrentIndex > 0;
	if (canSkipNext)
		*canSkipNext = fCurrentIndex < CountItems() - 1;
}


// pragma mark -


bool
Playlist::AddListener(Listener* listener)
{
	BAutolock _(this);
	if (listener && !fListeners.HasItem(listener))
		return fListeners.AddItem(listener);
	return false;
}


void
Playlist::RemoveListener(Listener* listener)
{
	BAutolock _(this);
	fListeners.RemoveItem(listener);
}


// #pragma mark - support


void
Playlist::AppendItems(const BMessage* refsReceivedMessage, int32 appendIndex,
	bool sortItems)
{
	// the playlist is replaced by the refs in the message
	// or the refs are appended at the appendIndex
	// in the existing playlist
	if (appendIndex == APPEND_INDEX_APPEND_LAST)
		appendIndex = CountItems();

	bool add = appendIndex != APPEND_INDEX_REPLACE_PLAYLIST;

	if (!add)
		MakeEmpty();

	bool startPlaying = CountItems() == 0;

	Playlist temporaryPlaylist;
	Playlist* playlist = add ? &temporaryPlaylist : this;
	bool hasSavedPlaylist = false;

	// TODO: This is not very fair, we should abstract from
	// entry ref representation and support more URLs.
	BMessage archivedUrl;
	if (refsReceivedMessage->FindMessage("mediaplayer:url", &archivedUrl)
			== B_OK) {
		BUrl url(&archivedUrl);
		AddItem(new UrlPlaylistItem(url));
	}

	entry_ref ref;
	int32 subAppendIndex = CountItems();
	for (int i = 0; refsReceivedMessage->FindRef("refs", i, &ref) == B_OK;
			i++) {
		Playlist subPlaylist;
		BString type = _MIMEString(&ref);

		if (_IsPlaylist(type)) {
			AppendPlaylistToPlaylist(ref, &subPlaylist);
			// Do not sort the whole playlist anymore, as that
			// will screw up the ordering in the saved playlist.
			hasSavedPlaylist = true;
		} else {
			if (_IsQuery(type))
				AppendQueryToPlaylist(ref, &subPlaylist);
			else {
				PlaylistFileReader* reader = PlaylistFileReader::GenerateReader(ref);
				if (reader != NULL) {
					reader->AppendToPlaylist(ref, &subPlaylist);
					delete reader;
				} else {
					if (!_ExtraMediaExists(this, ref)) {
						AppendToPlaylistRecursive(ref, &subPlaylist);
					}
				}
			}

			// At least sort this subsection of the playlist
			// if the whole playlist is not sorted anymore.
			if (sortItems && hasSavedPlaylist)
				subPlaylist.Sort();
		}

		if (!subPlaylist.IsEmpty()) {
			// Add to recent documents
			be_roster->AddToRecentDocuments(&ref, kAppSig);
		}

		int32 subPlaylistCount = subPlaylist.CountItems();
		AdoptPlaylist(subPlaylist, subAppendIndex);
		subAppendIndex += subPlaylistCount;
	}

	if (sortItems)
		playlist->Sort();

	if (add)
		AdoptPlaylist(temporaryPlaylist, appendIndex);

	if (startPlaying) {
		// open first file
		SetCurrentItemIndex(0);
	}
}


/*static*/ void
Playlist::AppendToPlaylistRecursive(const entry_ref& ref, Playlist* playlist)
{
	// recursively append the ref (dive into folders)
	BEntry entry(&ref, true);
	if (entry.InitCheck() != B_OK || !entry.Exists())
		return;

	if (entry.IsDirectory()) {
		BDirectory dir(&entry);
		if (dir.InitCheck() != B_OK)
			return;

		entry.Unset();

		entry_ref subRef;
		while (dir.GetNextRef(&subRef) == B_OK) {
			AppendToPlaylistRecursive(subRef, playlist);
		}
	} else if (entry.IsFile()) {
		BString mimeString = _MIMEString(&ref);
		if (_IsMediaFile(mimeString, ref)) {
			PlaylistItem* item = new (std::nothrow) FilePlaylistItem(ref);
			if (!_ExtraMediaExists(playlist, ref)) {
				_BindExtraMedia(item);
				if (item != NULL && !playlist->AddItem(item))
					delete item;
			} else
				delete item;
		} else
			printf("MIME Type = %s\n", mimeString.String());
	}
}


/*static*/ void
Playlist::AppendPlaylistToPlaylist(const entry_ref& ref, Playlist* playlist)
{
	BEntry entry(&ref, true);
	if (entry.InitCheck() != B_OK || !entry.Exists())
		return;

	BString mimeString = _MIMEString(&ref);
	if (_IsTextPlaylist(mimeString)) {
		//printf("RunPlaylist thing\n");
		BFile file(&ref, B_READ_ONLY);
		FileReadWrite lineReader(&file);

		BString str;
		entry_ref refPath;
		status_t err;
		BPath path;
		while (lineReader.Next(str)) {
			str = str.RemoveFirst("file://");
			str = str.RemoveLast("..");
			path = BPath(str.String());
			printf("Line %s\n", path.Path());
			if (path.Path() != NULL) {
				if ((err = get_ref_for_path(path.Path(), &refPath)) == B_OK) {
					PlaylistItem* item
						= new (std::nothrow) FilePlaylistItem(refPath);
					if (item == NULL || !playlist->AddItem(item))
						delete item;
				} else {
					printf("Error - %s: [%" B_PRIx32 "]\n", strerror(err),
						err);
				}
			} else
				printf("Error - No File Found in playlist\n");
		}
	} else if (_IsBinaryPlaylist(mimeString)) {
		BFile file(&ref, B_READ_ONLY);
		Playlist temp;
		if (temp.Unflatten(&file) == B_OK)
			playlist->AdoptPlaylist(temp, playlist->CountItems());
	}
}


/*static*/ void
Playlist::AppendQueryToPlaylist(const entry_ref& ref, Playlist* playlist)
{
	BQueryFile query(&ref);
	if (query.InitCheck() != B_OK)
		return;

	entry_ref foundRef;
	while (query.GetNextRef(&foundRef) == B_OK) {
		PlaylistItem* item = new (std::nothrow) FilePlaylistItem(foundRef);
		if (item == NULL || !playlist->AddItem(item))
			delete item;
	}
}


void
Playlist::NotifyImportFailed()
{
	BAutolock _(this);
	_NotifyImportFailed();
}


/*static*/ bool
Playlist::ExtraMediaExists(Playlist* playlist, PlaylistItem* item)
{
	FilePlaylistItem* fileItem = dynamic_cast<FilePlaylistItem*>(item);
	if (fileItem != NULL)
		return _ExtraMediaExists(playlist, fileItem->Ref());

	// If we are here let's see if it is an url
	UrlPlaylistItem* urlItem = dynamic_cast<UrlPlaylistItem*>(item);
	if (urlItem == NULL)
		return true;

	return _ExtraMediaExists(playlist, urlItem->Url());
}


// #pragma mark - private


/*static*/ bool
Playlist::_ExtraMediaExists(Playlist* playlist, const entry_ref& ref)
{
	BString exceptExtension = _GetExceptExtension(BPath(&ref).Path());

	for (int32 i = 0; i < playlist->CountItems(); i++) {
		FilePlaylistItem* compare = dynamic_cast<FilePlaylistItem*>(playlist->ItemAt(i));
		if (compare == NULL)
			continue;
		if (compare->Ref() != ref
				&& _GetExceptExtension(BPath(&compare->Ref()).Path()) == exceptExtension )
			return true;
	}
	return false;
}


/*static*/ bool
Playlist::_ExtraMediaExists(Playlist* playlist, BUrl url)
{
	for (int32 i = 0; i < playlist->CountItems(); i++) {
		UrlPlaylistItem* compare
			= dynamic_cast<UrlPlaylistItem*>(playlist->ItemAt(i));
		if (compare == NULL)
			continue;
		if (compare->Url() == url)
			return true;
	}
	return false;
}


/*static*/ bool
Playlist::_IsImageFile(const BString& mimeString)
{
	BMimeType superType;
	BMimeType fileType(mimeString.String());

	if (fileType.GetSupertype(&superType) != B_OK)
		return false;

	if (superType == "image")
		return true;

	return false;
}


/*static*/ bool
Playlist::_IsMediaFile(const BString& mimeString, const entry_ref& ref)
{
	BMimeType superType;
	BMimeType fileType(mimeString.String());

	if (fileType.GetSupertype(&superType) != B_OK) {
		// no superType, try to sniff the type
		if (BMimeType::GuessMimeType(&ref, &fileType) != B_OK)
			return false;
	}

	BEntry entry(&ref);
	if (entry.IsSymLink()) {
		// traverse link
		entry_ref* fileRef = const_cast<entry_ref*>(&ref);
		if (entry.SetTo(fileRef, true) != B_OK)
			return false;
		if (entry.GetRef(fileRef) != B_OK)
			return false;
		fileType.SetTo(_MIMEString(fileRef));
	}

	if (fileType.GetSupertype(&superType) != B_OK)
		return false;

	// try a shortcut first
	if (superType == "audio" || superType == "video")
		return true;

	// Look through our supported types
	app_info appInfo;
	if (be_app->GetAppInfo(&appInfo) != B_OK)
		return false;
	BFile appFile(&appInfo.ref, B_READ_ONLY);
	if (appFile.InitCheck() != B_OK)
		return false;
	BMessage types;
	BAppFileInfo appFileInfo(&appFile);
	if (appFileInfo.GetSupportedTypes(&types) != B_OK)
		return false;

	const char* type;
	for (int32 i = 0; types.FindString("types", i, &type) == B_OK; i++) {
		if (strcasecmp(fileType.Type(), type) == 0)
			return true;
	}

	return false;
}


/*static*/ bool
Playlist::_IsTextPlaylist(const BString& mimeString)
{
	return mimeString.Compare(kTextPlaylistMimeString) == 0;
}


/*static*/ bool
Playlist::_IsBinaryPlaylist(const BString& mimeString)
{
	return mimeString.Compare(kBinaryPlaylistMimeString) == 0;
}


/*static*/ bool
Playlist::_IsPlaylist(const BString& mimeString)
{
	return _IsTextPlaylist(mimeString) || _IsBinaryPlaylist(mimeString);
}


/*static*/ bool
Playlist::_IsQuery(const BString& mimeString)
{
	return mimeString.Compare(BQueryFile::MimeType()) == 0;
}


/*static*/ BString
Playlist::_MIMEString(const entry_ref* ref)
{
	BFile file(ref, B_READ_ONLY);
	BNodeInfo nodeInfo(&file);
	char mimeString[B_MIME_TYPE_LENGTH];
	if (nodeInfo.GetType(mimeString) != B_OK) {
		BMimeType type;
		if (BMimeType::GuessMimeType(ref, &type) != B_OK)
			return BString();

		strlcpy(mimeString, type.Type(), B_MIME_TYPE_LENGTH);
		nodeInfo.SetType(type.Type());
	}
	return BString(mimeString);
}


// _BindExtraMedia() searches additional videos and audios
// and addes them as extra medias.
/*static*/ void
Playlist::_BindExtraMedia(PlaylistItem* item)
{
	FilePlaylistItem* fileItem = dynamic_cast<FilePlaylistItem*>(item);
	if (!fileItem)
		return;

	// If the media file is foo.mp3, _BindExtraMedia() searches foo.avi.
	BPath mediaFilePath(&fileItem->Ref());
	BString mediaFilePathString = mediaFilePath.Path();
	BPath dirPath;
	mediaFilePath.GetParent(&dirPath);
	BDirectory dir(dirPath.Path());
	if (dir.InitCheck() != B_OK)
		return;

	BEntry entry;
	BString entryPathString;
	while (dir.GetNextEntry(&entry, true) == B_OK) {
		if (!entry.IsFile())
			continue;
		entryPathString = BPath(&entry).Path();
		if (entryPathString != mediaFilePathString
				&& _GetExceptExtension(entryPathString) == _GetExceptExtension(mediaFilePathString)) {
			_BindExtraMedia(fileItem, entry);
		}
	}
}


/*static*/ void
Playlist::_BindExtraMedia(FilePlaylistItem* fileItem, const BEntry& entry)
{
	entry_ref ref;
	entry.GetRef(&ref);
	BString mimeString = _MIMEString(&ref);
	if (_IsMediaFile(mimeString, ref)) {
		fileItem->AddRef(ref);
	} else if (_IsImageFile(mimeString)) {
		fileItem->AddImageRef(ref);
	}
}


/*static*/ BString
Playlist::_GetExceptExtension(const BString& path)
{
	int32 periodPos = path.FindLast('.');
	if (periodPos <= path.FindLast('/'))
		return path;
	return BString(path.String(), periodPos);
}


// #pragma mark - notifications


void
Playlist::_NotifyItemAdded(PlaylistItem* item, int32 index) const
{
	BList listeners(fListeners);
	int32 count = listeners.CountItems();
	for (int32 i = 0; i < count; i++) {
		Listener* listener = (Listener*)listeners.ItemAtFast(i);
		listener->ItemAdded(item, index);
	}
}


void
Playlist::_NotifyItemRemoved(int32 index) const
{
	BList listeners(fListeners);
	int32 count = listeners.CountItems();
	for (int32 i = 0; i < count; i++) {
		Listener* listener = (Listener*)listeners.ItemAtFast(i);
		listener->ItemRemoved(index);
	}
}


void
Playlist::_NotifyItemsSorted() const
{
	BList listeners(fListeners);
	int32 count = listeners.CountItems();
	for (int32 i = 0; i < count; i++) {
		Listener* listener = (Listener*)listeners.ItemAtFast(i);
		listener->ItemsSorted();
	}
}


void
Playlist::_NotifyCurrentItemChanged(int32 newIndex, bool play) const
{
	BList listeners(fListeners);
	int32 count = listeners.CountItems();
	for (int32 i = 0; i < count; i++) {
		Listener* listener = (Listener*)listeners.ItemAtFast(i);
		listener->CurrentItemChanged(newIndex, play);
	}
}


void
Playlist::_NotifyImportFailed() const
{
	BList listeners(fListeners);
	int32 count = listeners.CountItems();
	for (int32 i = 0; i < count; i++) {
		Listener* listener = (Listener*)listeners.ItemAtFast(i);
		listener->ImportFailed();
	}
}