From 4691dc7ff85ec616d1beb7dfa521e79e8f33abac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Duval?= Date: Wed, 12 Nov 2003 10:24:42 +0000 Subject: [PATCH] MediaFiles support added git-svn-id: file:///srv/svn/repos/haiku/trunk/current@5324 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/kits/media/MediaFiles.cpp | 182 +++++++++++- src/servers/media/Jamfile | 1 + src/servers/media/MMediaFilesManager.cpp | 336 +++++++++++++++++++++++ src/servers/media/MMediaFilesManager.h | 59 ++++ src/servers/media/media_server.cpp | 115 ++++++++ src/servers/media/media_server.h | 2 + 6 files changed, 680 insertions(+), 15 deletions(-) create mode 100644 src/servers/media/MMediaFilesManager.cpp create mode 100644 src/servers/media/MMediaFilesManager.h diff --git a/src/kits/media/MediaFiles.cpp b/src/kits/media/MediaFiles.cpp index 9260640c53..6c21ea613d 100644 --- a/src/kits/media/MediaFiles.cpp +++ b/src/kits/media/MediaFiles.cpp @@ -1,34 +1,73 @@ /*********************************************************************** - * AUTHOR: Marcus Overhagen + * AUTHOR: Marcus Overhagen, Jérôme Duval * FILE: MediaFiles.cpp * DESCR: ***********************************************************************/ #include +#include "DataExchange.h" #include "debug.h" /************************************************************* * public BMediaFiles *************************************************************/ -const char BMediaFiles::B_SOUNDS[] = "XXX fixme"; /* for "types" */ +const char BMediaFiles::B_SOUNDS[] = "Sounds"; /* for "types" */ BMediaFiles::BMediaFiles() + : m_type_index(-1), + m_cur_type(""), + m_item_index(-1) { - UNIMPLEMENTED(); + } /* virtual */ BMediaFiles::~BMediaFiles() { - UNIMPLEMENTED(); + } /* virtual */ status_t BMediaFiles::RewindTypes() { - UNIMPLEMENTED(); + CALLED(); + status_t rv; + server_rewindtypes_request request; + server_rewindtypes_reply reply; + + for(int32 i = 0; i < m_types.CountItems(); i++) + delete m_types.ItemAt(i); + + m_types.MakeEmpty(); + + TRACE("BMediaFiles::RewindTypes: sending SERVER_REWINDTYPES\n"); + + rv = QueryServer(SERVER_REWINDTYPES, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) { + ERROR("BMediaFiles::RewindTypes: failed to rewindtypes (error %#lx)\n", rv); + return rv; + } + + char *types; + area_id clone; + + clone = clone_area("rewind types clone", reinterpret_cast(&types), B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, reply.area); + if (clone < B_OK) { + ERROR("BMediaFiles::RewindTypes failed to clone area, %#lx\n", clone); + delete_area(reply.area); + return B_ERROR; + } + + for (int32 i = 0; i < reply.count; i++) { + m_types.AddItem(new BString(types + i * B_MEDIA_NAME_LENGTH)); + } + + delete_area(clone); + delete_area(reply.area); + + m_type_index = 0; return B_OK; } @@ -37,16 +76,62 @@ BMediaFiles::RewindTypes() /* virtual */ status_t BMediaFiles::GetNextType(BString *out_type) { - UNIMPLEMENTED(); + CALLED(); + if(m_type_index < 0 || m_type_index >= m_types.CountItems()) { + m_type_index = -1; + return B_BAD_INDEX; + } + + *out_type = *(BString*)m_types.ItemAt(m_type_index); + m_type_index++; - return B_ERROR; + return B_OK; } /* virtual */ status_t BMediaFiles::RewindRefs(const char *type) { - UNIMPLEMENTED(); + CALLED(); + status_t rv; + server_rewindrefs_request request; + server_rewindrefs_reply reply; + + for(int32 i = 0; i < m_items.CountItems(); i++) + delete m_items.ItemAt(i); + + m_items.MakeEmpty(); + + TRACE("BMediaFiles::RewindRefs: sending SERVER_REWINDREFS for type %s\n", type); + strncpy(request.type, type, B_MEDIA_NAME_LENGTH); + + rv = QueryServer(SERVER_REWINDREFS, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) { + ERROR("BMediaFiles::RewindRefs: failed to rewindrefs (error %#lx)\n", rv); + return rv; + } + + if(reply.count>0) { + char *items; + area_id clone; + + clone = clone_area("rewind refs clone", reinterpret_cast(&items), B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, reply.area); + if (clone < B_OK) { + ERROR("BMediaFiles::RewindRefs failed to clone area, %#lx\n", clone); + delete_area(reply.area); + return B_ERROR; + } + + for (int32 i = 0; i < reply.count; i++) { + m_items.AddItem(new BString(items + i * B_MEDIA_NAME_LENGTH)); + } + + delete_area(clone); + delete_area(reply.area); + } + + m_cur_type = BString(type); + m_item_index = 0; return B_OK; } @@ -56,9 +141,18 @@ BMediaFiles::RewindRefs(const char *type) BMediaFiles::GetNextRef(BString *out_type, entry_ref *out_ref) { - UNIMPLEMENTED(); + CALLED(); + if(m_item_index < 0 || m_item_index >= m_items.CountItems()) { + m_item_index = -1; + return B_BAD_INDEX; + } + + *out_type = *(BString*)m_items.ItemAt(m_item_index); + m_item_index++; + + GetRefFor(m_cur_type.String(), out_type->String(), out_ref); - return B_ERROR; + return B_OK; } @@ -67,9 +161,25 @@ BMediaFiles::GetRefFor(const char *type, const char *item, entry_ref *out_ref) { - UNIMPLEMENTED(); + CALLED(); + status_t rv; + server_getreffor_request request; + server_getreffor_reply reply; + + strncpy(request.type, type, B_MEDIA_NAME_LENGTH); + strncpy(request.item, item, B_MEDIA_NAME_LENGTH); + + TRACE("BMediaFiles::GetRefFor: sending SERVER_GETREFFOR\n"); + + rv = QueryServer(SERVER_GETREFFOR, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) { + ERROR("BMediaFiles::GetRefFor: failed to getreffor (error %#lx)\n", rv); + return rv; + } - return B_ERROR; + *out_ref = reply.ref; + + return B_OK; } @@ -78,7 +188,22 @@ BMediaFiles::SetRefFor(const char *type, const char *item, const entry_ref &ref) { - UNIMPLEMENTED(); + CALLED(); + status_t rv; + server_setreffor_request request; + server_setreffor_reply reply; + + strncpy(request.type, type, B_MEDIA_NAME_LENGTH); + strncpy(request.item, item, B_MEDIA_NAME_LENGTH); + request.ref = ref; + + TRACE("BMediaFiles::SetRefFor: sending SERVER_SETREFFOR\n"); + + rv = QueryServer(SERVER_SETREFFOR, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) { + ERROR("BMediaFiles::SetRefFor: failed to setreffor (error %#lx)\n", rv); + return rv; + } return B_OK; } @@ -89,7 +214,21 @@ BMediaFiles::RemoveRefFor(const char *type, const char *item, const entry_ref &ref) { - UNIMPLEMENTED(); + status_t rv; + server_removereffor_request request; + server_removereffor_reply reply; + + strncpy(request.type, type, B_MEDIA_NAME_LENGTH); + strncpy(request.item, item, B_MEDIA_NAME_LENGTH); + request.ref = ref; + + TRACE("BMediaFiles::RemoveRefFor: sending SERVER_REMOVEREFFOR\n"); + + rv = QueryServer(SERVER_REMOVEREFFOR, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) { + ERROR("BMediaFiles::RemoveRefFor: failed to removereffor (error %#lx)\n", rv); + return rv; + } return B_OK; } @@ -99,7 +238,20 @@ BMediaFiles::RemoveRefFor(const char *type, BMediaFiles::RemoveItem(const char *type, const char *item) { - UNIMPLEMENTED(); + status_t rv; + server_removeitem_request request; + server_removeitem_reply reply; + + strncpy(request.type, type, B_MEDIA_NAME_LENGTH); + strncpy(request.item, item, B_MEDIA_NAME_LENGTH); + + TRACE("BMediaFiles::RemoveItem: sending SERVER_REMOVEITEM\n"); + + rv = QueryServer(SERVER_REMOVEITEM, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) { + ERROR("BMediaFiles::RemoveItem: failed to removeitem (error %#lx)\n", rv); + return rv; + } return B_OK; } diff --git a/src/servers/media/Jamfile b/src/servers/media/Jamfile index 1960a2fb2f..358ba13bbd 100644 --- a/src/servers/media/Jamfile +++ b/src/servers/media/Jamfile @@ -9,6 +9,7 @@ Server media_server : AppManager.cpp BufferManager.cpp DefaultManager.cpp + MMediaFilesManager.cpp NodeManager.cpp NotificationManager.cpp Queue.cpp diff --git a/src/servers/media/MMediaFilesManager.cpp b/src/servers/media/MMediaFilesManager.cpp new file mode 100644 index 0000000000..1ca350df6b --- /dev/null +++ b/src/servers/media/MMediaFilesManager.cpp @@ -0,0 +1,336 @@ +/* + * Copyright 2003, Jérôme Duval. All rights reserved. + * Distributed under the terms of the MIT License. + */ +#include +#include +#include +#include +#include "MMediaFilesManager.h" +#include "debug.h" + + +MMediaFilesManager::MMediaFilesManager() + : fLocker(new BLocker("media files manager locker")), + fRegistryMap(new Map >) +{ + CALLED(); + LoadState(); +#if DEBUG >=3 + Dump(); +#endif +} + +MMediaFilesManager::~MMediaFilesManager() +{ + CALLED(); + SaveState(); + delete fRegistryMap; + delete fLocker; +} + + +int32 +MMediaFilesManager::ReadPascalString(BFile &file, char **str) +{ + uint32 len; + *str=NULL; + if (file.Read(&len, 4) < 4) + return -1; + if (len == 0) + return 0; + *str = (char *)malloc(len); + if (file.Read(*str, len) < (int32)len) { + free(*str); + *str = NULL; + return -1; + } + return (int32)len; +} + + +int32 +MMediaFilesManager::WritePascalString(BFile &file, const char *str) +{ + + if(str == NULL) + return -1; + uint32 len = strlen(str) + 1; + if (file.Write(&len, 4) < 4) + return -1; + if (len == 0) + return 0; + if (file.Write(str, len) < (int32)len) { + return -1; + } + return (int32)len; +} + + +// this is called by the media_server *before* any add-ons have been loaded +status_t +MMediaFilesManager::LoadState() +{ + CALLED(); + status_t err = B_OK; + BPath path; + if((err = find_directory(B_USER_SETTINGS_DIRECTORY, &path))!=B_OK) + return err; + + path.Append("Media/MMediaFilesManager"); + + BFile file(path.Path(), B_READ_ONLY); + + uint32 category_count; + if (file.Read(header, sizeof(uint32)*3) < (int32)sizeof(uint32)*3) + return B_ERROR; + TRACE("0x%08lx %ld\n", header[0], header[0]); + TRACE("0x%08lx %ld\n", header[1], header[1]); + TRACE("0x%08lx %ld\n", header[2], header[2]); + if (file.Read(&category_count, sizeof(uint32)) < (int32)sizeof(uint32)) + return B_ERROR; + while (category_count--) { + char *str; + char *key, *val; + int32 len; + len = ReadPascalString(file, &str); + if (len < 0) + return B_ERROR; + if (len == 0) + break; + TRACE("%s {\n", str); + do { + int32 vol = 0; + len = ReadPascalString(file, &key); + if (len < 0) + return B_ERROR; + if (len == 0) + break; + len = ReadPascalString(file, &val); + if (len == 1) { + free(val); + val = strdup("(null)"); + } + /*if (file.Read(&vol, sizeof(uint32)) < (int32)sizeof(uint32)) + return B_ERROR;*/ + TRACE(" %s: %s, volume: %f\n", key, val, *(float *)&vol); + + entry_ref ref; + if(len>1) { + BEntry entry(val); + entry.GetRef(&ref); + } + SetRefFor(str, key, ref); + + free(key); + free(val); + } while (true); + TRACE("}\n"); + free(str); + } + + return B_OK; +} + + +status_t +MMediaFilesManager::SaveState() +{ + status_t err = B_OK; + BPath path; + if((err = find_directory(B_USER_SETTINGS_DIRECTORY, &path))!=B_OK) + return err; + + path.Append("Media/MMediaFilesManager"); + + BFile file(path.Path(), B_WRITE_ONLY | B_CREATE_FILE); + uint32 zero = 0; + + if (file.Write(header, sizeof(uint32)*3) < (int32)sizeof(uint32)*3) + return B_ERROR; + uint32 category_count = fRegistryMap->CountItems(); + if (file.Write(&category_count, sizeof(uint32)) < (int32)sizeof(uint32)) + return B_ERROR; + + BString *type; + Map *map; + BString *item; + entry_ref *ref; + for (fRegistryMap->Rewind(); fRegistryMap->GetNext(&map); ) { + fRegistryMap->GetCurrentKey(&type); + + WritePascalString(file, type->String()); + + for (map->Rewind(); map->GetNext(&ref);) { + map->GetCurrentKey(&item); + BPath path(ref); + + WritePascalString(file, item->String()); + WritePascalString(file, path.Path() ? path.Path() : ""); + + } + + file.Write(&zero, sizeof(uint32)); + } + file.Write(&zero, sizeof(uint32)); + + return B_OK; +} + + +void +MMediaFilesManager::Dump() +{ + BAutolock lock(fLocker); + printf("\n"); + + /* for each type, the registry map contains a map of item/entry_ref + */ + printf("MMediaFilesManager: registry map follows\n"); + BString *type; + Map *map; + BString *item; + entry_ref *ref; + for (fRegistryMap->Rewind(); fRegistryMap->GetNext(&map); ) { + fRegistryMap->GetCurrentKey(&type); + + for (map->Rewind(); map->GetNext(&ref);) { + map->GetCurrentKey(&item); + BPath path(ref); + printf(" type \"%s\", item \"%s\", path \"%s\"\n", + type->String(), item->String(), (path.InitCheck() == B_OK) ? path.Path() : "INVALID"); + } + } + printf("MMediaFilesManager: list end\n"); + printf("\n"); + +} + + +status_t +MMediaFilesManager::RewindTypes(BString ***types, int32 *count) +{ + CALLED(); + if(types==NULL || count == NULL) + return B_BAD_VALUE; + + Map *map; + BString *type; + + *count = fRegistryMap->CountItems(); + *types = new (BString*)[*count]; + int32 i=0; + + for (fRegistryMap->Rewind(); i<*count && fRegistryMap->GetNext(&map); i++) { + fRegistryMap->GetCurrentKey(&type); + (*types)[i] = type; + } + + return B_OK; +} + + +status_t +MMediaFilesManager::RewindRefs(const char* type, BString ***items, int32 *count) +{ + CALLED(); + if(type == NULL || items==NULL || count == NULL) + return B_BAD_VALUE; + + Map *map; + entry_ref *ref; + BString *item; + + fRegistryMap->Get(BString(type), &map); + + *count = map->CountItems(); + *items = new (BString*)[*count]; + int32 i=0; + + for (map->Rewind(); i<*count && map->GetNext(&ref); i++) { + map->GetCurrentKey(&item); + (*items)[i] = item; + } + + return B_OK; +} + + +status_t +MMediaFilesManager::GetRefFor(const char *type, + const char *item, + entry_ref **out_ref) +{ + CALLED(); + Map *map; + if(!fRegistryMap->Get(BString(type), &map)) + return B_ENTRY_NOT_FOUND; + + if(!map->Get(BString(item), out_ref)) + return B_ENTRY_NOT_FOUND; + + return B_OK; +} + + +status_t +MMediaFilesManager::SetRefFor(const char *type, + const char *item, + const entry_ref &ref) +{ + CALLED(); + TRACE("MMediaFilesManager::SetRefFor %s %s\n", type, item); + + BString itemString(item); + itemString.Truncate(B_MEDIA_NAME_LENGTH); + BString typeString(type); + Map *map; + if(!fRegistryMap->Get(typeString, &map)) { + map = new Map; + fRegistryMap->Insert(typeString, *map); + fRegistryMap->Get(typeString, &map); + } + + if(map->Has(itemString)) + map->Remove(itemString); + map->Insert(itemString, ref); + + return B_OK; +} + + +status_t +MMediaFilesManager::RemoveRefFor(const char *type, + const char *item, + const entry_ref &ref) +{ + CALLED(); + BString itemString(item); + BString typeString(type); + Map *map; + if(!fRegistryMap->Get(typeString, &map)) + return B_OK; + + map->Remove(itemString); + map->Insert(itemString, *(new entry_ref)); + + return B_OK; +} + + +status_t +MMediaFilesManager::RemoveItem(const char *type, + const char *item) +{ + CALLED(); + BString itemString(item); + BString typeString(type); + Map *map; + if(!fRegistryMap->Get(typeString, &map)) + return B_OK; + + map->Remove(itemString); + + return B_OK; +} + diff --git a/src/servers/media/MMediaFilesManager.h b/src/servers/media/MMediaFilesManager.h new file mode 100644 index 0000000000..8e549233cb --- /dev/null +++ b/src/servers/media/MMediaFilesManager.h @@ -0,0 +1,59 @@ +/* + * Copyright 2003, Jérôme Duval. All rights reserved. + * Distributed under the terms of the MIT License. + */ + +#include +#include +#include +#include +#include "TMap.h" +#include "DataExchange.h" + +class MMediaFilesManager +{ +public: + MMediaFilesManager(); + ~MMediaFilesManager(); + + status_t LoadState(); + status_t SaveState(); + + void Dump(); + + status_t RewindTypes( + BString ***types, + int32 *count); + status_t RewindRefs( + const char * type, + BString ***items, + int32 *count); + status_t GetRefFor( + const char * type, + const char * item, + entry_ref ** out_ref); + status_t SetRefFor( + const char * type, + const char * item, + const entry_ref & ref); + status_t RemoveRefFor( // This might better be called "ClearRefFor" + const char * type, // but it's too late now... + const char * item, + const entry_ref & ref); + + status_t RemoveItem( // new in 4.1, removes the whole item. + const char * type, + const char * item); + + +private: + static int32 ReadPascalString(BFile &file, char **str); + static int32 WritePascalString(BFile &file, const char *str); + +private: + BLocker *fLocker; + + Map > * fRegistryMap; + + uint32 header[3]; +}; diff --git a/src/servers/media/media_server.cpp b/src/servers/media/media_server.cpp index ee37b87cf6..f374a3911f 100644 --- a/src/servers/media/media_server.cpp +++ b/src/servers/media/media_server.cpp @@ -37,6 +37,7 @@ char __dont_remove_copyright_from_binary[] = "Copyright (c) 2002, 2003 Marcus Ov #include #include #include +#include "MMediaFilesManager.h" #include "NotificationManager.h" #include "ServerInterface.h" #include "DataExchange.h" @@ -58,6 +59,7 @@ NotificationManager *gNotificationManager; BufferManager *gBufferManager; AppManager *gAppManager; NodeManager *gNodeManager; +MMediaFilesManager *gMMediaFilesManager; namespace BPrivate { namespace media { extern team_id team; @@ -118,6 +120,7 @@ ServerApp::ServerApp() gBufferManager = new BufferManager; gAppManager = new AppManager; gNodeManager = new NodeManager; + gMMediaFilesManager = new MMediaFilesManager; control_port = create_port(64, MEDIA_SERVER_PORT_NAME); control_thread = spawn_thread(controlthread, "media_server control", 105, this); @@ -135,6 +138,7 @@ ServerApp::~ServerApp() delete gBufferManager; delete gAppManager; delete gNodeManager; + delete gMMediaFilesManager; delete fLocker; delete_port(control_port); status_t err; @@ -149,6 +153,7 @@ void ServerApp::ArgvReceived(int32 argc, char **argv) gNodeManager->Dump(); gBufferManager->Dump(); gNotificationManager->Dump(); + gMMediaFilesManager->Dump(); } if (strstr(argv[arg], "buffer")) { gBufferManager->Dump(); @@ -554,7 +559,117 @@ ServerApp::HandleMessage(int32 code, void *data, size_t size) gBufferManager->UnregisterBuffer(cmd->team, cmd->bufferid); break; } + + case SERVER_REWINDTYPES: + { + const server_rewindtypes_request *request = reinterpret_cast(data); + server_rewindtypes_reply reply; + + BString **types = NULL; + + rv = gMMediaFilesManager->RewindTypes( + &types, &reply.count); + if(reply.count>0) { + // we create an area here, and pass it to the library, where it will be deleted. + char *start_addr; + size_t size = ((reply.count * B_MEDIA_NAME_LENGTH) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1); + reply.area = create_area("rewind types", reinterpret_cast(&start_addr), B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); + if (reply.area < B_OK) { + ERROR("SERVER_REWINDTYPES: failed to create area, error %s\n", strerror(reply.area)); + reply.count = 0; + rv = B_ERROR; + } else { + for (int32 index = 0; index < reply.count; index++) + strncpy(start_addr + B_MEDIA_NAME_LENGTH * index, types[index]->String(), B_MEDIA_NAME_LENGTH); + } + } + + delete types; + + rv = request->SendReply(rv, &reply, sizeof(reply)); + if (rv != B_OK) + delete_area(reply.area); // if we couldn't send the message, delete the area + break; + } + + case SERVER_REWINDREFS: + { + const server_rewindrefs_request *request = reinterpret_cast(data); + server_rewindrefs_reply reply; + + BString **items = NULL; + + rv = gMMediaFilesManager->RewindRefs(request->type, + &items, &reply.count); + // we create an area here, and pass it to the library, where it will be deleted. + if(reply.count>0) { + char *start_addr; + size_t size = ((reply.count * B_MEDIA_NAME_LENGTH) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1); + reply.area = create_area("rewind refs", reinterpret_cast(&start_addr), B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); + if (reply.area < B_OK) { + ERROR("SERVER_REWINDREFS: failed to create area, error %s\n", strerror(reply.area)); + reply.count = 0; + rv = B_ERROR; + } else { + for (int32 index = 0; index < reply.count; index++) + strncpy(start_addr + B_MEDIA_NAME_LENGTH * index, items[index]->String(), B_MEDIA_NAME_LENGTH); + } + } + + delete items; + rv = request->SendReply(rv, &reply, sizeof(reply)); + if (rv != B_OK) + delete_area(reply.area); // if we couldn't send the message, delete the area + break; + } + + case SERVER_GETREFFOR: + { + const server_getreffor_request *request = reinterpret_cast(data); + server_getreffor_reply reply; + entry_ref *ref; + + rv = gMMediaFilesManager->GetRefFor(request->type, request->item, &ref); + if(rv==B_OK) { + reply.ref = *ref; + } + request->SendReply(rv, &reply, sizeof(reply)); + break; + } + + case SERVER_SETREFFOR: + { + const server_setreffor_request *request = reinterpret_cast(data); + server_setreffor_reply reply; + entry_ref ref = request->ref; + + rv = gMMediaFilesManager->SetRefFor(request->type, request->item, ref); + request->SendReply(rv, &reply, sizeof(reply)); + break; + } + + case SERVER_REMOVEREFFOR: + { + const server_removereffor_request *request = reinterpret_cast(data); + server_removereffor_reply reply; + entry_ref ref = request->ref; + + rv = gMMediaFilesManager->RemoveRefFor(request->type, request->item, ref); + request->SendReply(rv, &reply, sizeof(reply)); + break; + } + + case SERVER_REMOVEITEM: + { + const server_removeitem_request *request = reinterpret_cast(data); + server_removeitem_reply reply; + + rv = gMMediaFilesManager->RemoveItem(request->type, request->item); + request->SendReply(rv, &reply, sizeof(reply)); + break; + } + default: printf("media_server: received unknown message code %#08lx\n",code); } diff --git a/src/servers/media/media_server.h b/src/servers/media/media_server.h index a1ff1f53e8..00732fd013 100644 --- a/src/servers/media/media_server.h +++ b/src/servers/media/media_server.h @@ -3,8 +3,10 @@ class AppManager; class NodeManager; class BufferManager; class NotificationManager; +class MMediaFilesManager; extern AppManager * gAppManager; extern NodeManager * gNodeManager; extern BufferManager * gBufferManager; extern NotificationManager * gNotificationManager; +extern MMediaFilesManager * gMMediaFilesManager; \ No newline at end of file