livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MAINT-6578 Broken texture batching - fixed along with misc LibVLC plugin additions (status, titles, looping)

master
Callum Linden 2016-07-20 19:54:54 -07:00
parent cd47f86c4a
commit 8a25489591
6 changed files with 410 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
autobuild.xml
View File

@ -2164,16 +2164,16 @@
<key>archive</key>
<map>
<key>hash</key>
<string>3bdbb86adc2119a0b7bb17a54372dcd2</string>
<string>04cff37070a5f65f3652b4ddcec7183f</string>
<key>url</key>
<string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/3p-vlc-bin/rev/315283/arch/CYGWIN/installer/vlc_bin-2.2.3.315283-windows-315283.tar.bz2</string>
<string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/3p-vlc-bin/rev/317935/arch/CYGWIN/installer/vlc_bin-2.2.4.317935-windows-317935.tar.bz2</string>
</map>
<key>name</key>
<string>windows</string>
</map>
</map>
<key>version</key>
<string>2.2.3.315283</string>
<string>2.2.4.317935</string>
</map>
<key>xmlrpc-epi</key>
<map>

1
indra/media_plugins/base/media_plugin_base.cpp
View File

@ -73,6 +73,7 @@ std::string MediaPluginBase::statusString()
case STATUS_PLAYING: result = "playing"; break;
case STATUS_PAUSED: result = "paused"; break;
case STATUS_DONE: result = "done"; break;
case STATUS_BUFFERING: result = "buffering"; break;
default:
// keep the empty string
break;

3
indra/media_plugins/base/media_plugin_base.h
View File

@ -56,7 +56,8 @@ protected:
STATUS_ERROR,
STATUS_PLAYING,
STATUS_PAUSED,
STATUS_DONE
STATUS_DONE,
STATUS_BUFFERING
} EStatus;
/** Plugin shared memory. */

4
indra/media_plugins/cef/media_plugin_cef.cpp
View File

@ -189,7 +189,7 @@ void MediaPluginCEF::onPageChangedCallback(unsigned char* pixels, int x, int y,
mPopupH = height;
mPopupW = width;
mPopupX = x;
mPopupY = y;
mPopupY = mHeight - y - height;
}
}
else
@ -526,7 +526,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
message.setValueU32("internalformat", GL_RGB);
message.setValueU32("format", GL_BGRA);
message.setValueU32("type", GL_UNSIGNED_BYTE);
message.setValueBoolean("coords_opengl", false);
message.setValueBoolean("coords_opengl", true);
sendMessage(message);
}
else if (message_name == "set_user_data_path")

633
indra/media_plugins/libvlc/media_plugin_libvlc.cpp
View File

@ -1,30 +1,30 @@
/**
* @file media_plugin_libvlc.cpp
* @brief LibVLC plugin for LLMedia API plugin system
*
* @cond
* $LicenseInfo:firstyear=2008&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
* @endcond
*/
* @file media_plugin_libvlc.cpp
* @brief LibVLC plugin for LLMedia API plugin system
*
* @cond
* $LicenseInfo:firstyear=2008&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
* @endcond
*/
#include "linden_common.h"
@ -40,61 +40,78 @@
////////////////////////////////////////////////////////////////////////////////
//
class MediaPluginLibVLC :
public MediaPluginBase
public MediaPluginBase
{
public:
MediaPluginLibVLC( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data );
~MediaPluginLibVLC();
public:
MediaPluginLibVLC(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
~MediaPluginLibVLC();
/*virtual*/ void receiveMessage( const char* message_string );
/*virtual*/ void receiveMessage(const char* message_string);
private:
bool init();
private:
bool init();
void initVLC();
void playMedia();
void resetVLC();
void setVolume(const F64 volume);
void initVLC();
void playMedia();
void resetVLC();
void setVolume(const F64 volume);
void updateTitle(const char* title);
static void* lock(void* data, void** p_pixels);
static void unlock(void* data, void* id, void* const* raw_pixels);
static void display(void* data, void* id);
static void* lock(void* data, void** p_pixels);
static void unlock(void* data, void* id, void* const* raw_pixels);
static void display(void* data, void* id);
libvlc_instance_t* gLibVLC;
libvlc_media_t* gLibVLCMedia;
libvlc_media_player_t* gLibVLCMediaPlayer;
/*virtual*/ void setDirty(int left, int top, int right, int bottom) override;
struct gVLCContext
{
unsigned char* texture_pixels;
libvlc_media_player_t* mp;
MediaPluginLibVLC* parent;
};
struct gVLCContext gVLCCallbackContext;
static void eventCallbacks(const libvlc_event_t* event, void* ptr);
std::string mURL;
F64 mCurVolume;
libvlc_instance_t* mLibVLC;
libvlc_media_t* mLibVLCMedia;
libvlc_media_player_t* mLibVLCMediaPlayer;
struct mLibVLCContext
{
unsigned char* texture_pixels;
libvlc_media_player_t* mp;
MediaPluginLibVLC* parent;
};
struct mLibVLCContext mLibVLCCallbackContext;
std::string mURL;
F64 mCurVolume;
bool mIsLooping;
float mCurTime;
float mDuration;
};
////////////////////////////////////////////////////////////////////////////////
//
MediaPluginLibVLC::MediaPluginLibVLC( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data ) :
MediaPluginBase( host_send_func, host_user_data )
MediaPluginLibVLC::MediaPluginLibVLC(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data) :
MediaPluginBase(host_send_func, host_user_data)
{
mTextureWidth = 0;
mTextureHeight = 0;
mWidth = 0;
mHeight = 0;
mDepth = 4;
mPixels = 0;
mWidth = 0;
mHeight = 0;
mDepth = 4;
mPixels = 0;
gLibVLC = 0;
gLibVLCMedia = 0;
gLibVLCMediaPlayer = 0;
mLibVLC = 0;
mLibVLCMedia = 0;
mLibVLCMediaPlayer = 0;
mCurVolume = 0.0;
mIsLooping = false;
mCurTime = 0.0;
mDuration = 0.0;
mURL = std::string();
setStatus(STATUS_NONE);
}
////////////////////////////////////////////////////////////////////////////////
@ -107,7 +124,7 @@ MediaPluginLibVLC::~MediaPluginLibVLC()
//
void* MediaPluginLibVLC::lock(void* data, void** p_pixels)
{
struct gVLCContext* context = (gVLCContext*)data;
struct mLibVLCContext* context = (mLibVLCContext*)data;
*p_pixels = context->texture_pixels;
@ -118,15 +135,16 @@ void* MediaPluginLibVLC::lock(void* data, void** p_pixels)
//
void MediaPluginLibVLC::unlock(void* data, void* id, void* const* raw_pixels)
{
// nothing to do here for the moment.
// we can modify the raw_pixels here if we want to.
// nothing to do here for the moment
// we *could* modify pixels here to, for example, Y flip, but this is done with
// a VLC video filter transform.
}
////////////////////////////////////////////////////////////////////////////////
//
void MediaPluginLibVLC::display(void* data, void* id)
{
struct gVLCContext* context = (gVLCContext*)data;
struct mLibVLCContext* context = (mLibVLCContext*)data;
context->parent->setDirty(0, 0, context->parent->mWidth, context->parent->mHeight);
}
@ -138,12 +156,13 @@ void MediaPluginLibVLC::initVLC()
char const* vlc_argv[] =
{
"--no-xlib",
"--video-filter=transform{type=vflip}", // MAINT-6578 Y flip textures in plugin vs client
};
int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
gLibVLC = libvlc_new(vlc_argc, vlc_argv);
mLibVLC = libvlc_new(vlc_argc, vlc_argv);
if (!gLibVLC)
if (!mLibVLC)
{
// for the moment, if this fails, the plugin will fail and
// the media sub-system will tell the viewer something went wrong.
@ -154,9 +173,91 @@ void MediaPluginLibVLC::initVLC()
//
void MediaPluginLibVLC::resetVLC()
{
libvlc_media_player_stop(gLibVLCMediaPlayer);
libvlc_media_player_release(gLibVLCMediaPlayer);
libvlc_release(gLibVLC);
libvlc_media_player_stop(mLibVLCMediaPlayer);
libvlc_media_player_release(mLibVLCMediaPlayer);
libvlc_release(mLibVLC);
}
////////////////////////////////////////////////////////////////////////////////
// *virtual*
void MediaPluginLibVLC::setDirty(int left, int top, int right, int bottom)
{
LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "updated");
message.setValueS32("left", left);
message.setValueS32("top", top);
message.setValueS32("right", right);
message.setValueS32("bottom", bottom);
message.setValueReal("current_time", mCurTime);
message.setValueReal("duration", mDuration);
message.setValueReal("current_rate", 1.0f);
sendMessage(message);
}
////////////////////////////////////////////////////////////////////////////////
//
void MediaPluginLibVLC::eventCallbacks(const libvlc_event_t* event, void* ptr)
{
MediaPluginLibVLC* parent = (MediaPluginLibVLC*)ptr;
if (parent == 0)
{
return;
}
switch (event->type)
{
case libvlc_MediaPlayerOpening:
parent->setStatus(STATUS_LOADING);
break;
case libvlc_MediaPlayerBuffering:
parent->setStatus(STATUS_BUFFERING);
break;
case libvlc_MediaPlayerPlaying:
parent->mDuration = (float)(libvlc_media_get_duration(parent->mLibVLCMedia)) / 1000.0f;
parent->setStatus(STATUS_PLAYING);
break;
case libvlc_MediaPlayerPaused:
parent->setStatus(STATUS_PAUSED);
break;
case libvlc_MediaPlayerStopped:
parent->setStatus(STATUS_DONE);
break;
case libvlc_MediaPlayerEndReached:
parent->setStatus(STATUS_DONE);
break;
case libvlc_MediaPlayerEncounteredError:
parent->setStatus(STATUS_ERROR);
break;
case libvlc_MediaPlayerTimeChanged:
parent->mCurTime = (float)libvlc_media_player_get_time(parent->mLibVLCMediaPlayer) / 1000.0f;
break;
case libvlc_MediaPlayerPositionChanged:
break;
case libvlc_MediaPlayerLengthChanged:
parent->mDuration = (float)libvlc_media_get_duration(parent->mLibVLCMedia) / 1000.0f;
break;
case libvlc_MediaPlayerTitleChanged:
{
char* title = libvlc_media_get_meta(parent->mLibVLCMedia, libvlc_meta_Title);
if (title)
{
parent->updateTitle(title);
}
}
break;
}
}
////////////////////////////////////////////////////////////////////////////////
@ -168,30 +269,73 @@ void MediaPluginLibVLC::playMedia()
return;
}
if (gLibVLCMediaPlayer)
if (mLibVLCMediaPlayer)
{
libvlc_media_player_stop(gLibVLCMediaPlayer);
libvlc_media_player_release(gLibVLCMediaPlayer);
// stop listening to events while we reset things
libvlc_event_manager_t* em = libvlc_media_player_event_manager(mLibVLCMediaPlayer);
if (em)
{
libvlc_event_detach(em, libvlc_MediaPlayerOpening, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerBuffering, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerPlaying, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerPaused, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerStopped, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerEndReached, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerEncounteredError, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerTimeChanged, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerPositionChanged, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerLengthChanged, eventCallbacks, NULL);
libvlc_event_detach(em, libvlc_MediaPlayerTitleChanged, eventCallbacks, NULL);
};
libvlc_media_player_stop(mLibVLCMediaPlayer);
libvlc_media_player_release(mLibVLCMediaPlayer);
mLibVLCMediaPlayer = 0;
}
gLibVLCMedia = libvlc_media_new_location(gLibVLC, mURL.c_str());
if (!gLibVLCMedia)
if (mLibVLCMedia)
{
gLibVLCMediaPlayer = 0;
libvlc_media_release(mLibVLCMedia);
mLibVLCMedia = 0;
}
mLibVLCMedia = libvlc_media_new_location(mLibVLC, mURL.c_str());
if (!mLibVLCMedia)
{
mLibVLCMediaPlayer = 0;
setStatus(STATUS_ERROR);
return;
}
gLibVLCMediaPlayer = libvlc_media_player_new_from_media(gLibVLCMedia);
if (!gLibVLCMediaPlayer)
mLibVLCMediaPlayer = libvlc_media_player_new_from_media(mLibVLCMedia);
if (!mLibVLCMediaPlayer)
{
setStatus(STATUS_ERROR);
return;
}
libvlc_media_release(gLibVLCMedia);
// listen to events
libvlc_event_manager_t* em = libvlc_media_player_event_manager(mLibVLCMediaPlayer);
if (em)
{
libvlc_event_attach(em, libvlc_MediaPlayerOpening, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerBuffering, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerPlaying, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerPaused, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerStopped, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerEndReached, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerEncounteredError, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerTimeChanged, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerPositionChanged, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerLengthChanged, eventCallbacks, this);
libvlc_event_attach(em, libvlc_MediaPlayerTitleChanged, eventCallbacks, this);
}
gVLCCallbackContext.parent = this;
gVLCCallbackContext.texture_pixels = mPixels;
gVLCCallbackContext.mp = gLibVLCMediaPlayer;
mLibVLCCallbackContext.parent = this;
mLibVLCCallbackContext.texture_pixels = mPixels;
mLibVLCCallbackContext.mp = mLibVLCMediaPlayer;
// Send a "navigate begin" event.
// This is really a browser message but the QuickTime plugin did it and
@ -208,9 +352,24 @@ void MediaPluginLibVLC::playMedia()
// it in mCurVolume and set it again here so that volume levels are correctly initialized
setVolume(mCurVolume);
libvlc_video_set_callbacks(gLibVLCMediaPlayer, lock, unlock, display, &gVLCCallbackContext);
libvlc_video_set_format(gLibVLCMediaPlayer, "RV32", mWidth, mHeight, mWidth * mDepth);
libvlc_media_player_play(gLibVLCMediaPlayer);
setStatus(STATUS_LOADED);
libvlc_video_set_callbacks(mLibVLCMediaPlayer, lock, unlock, display, &mLibVLCCallbackContext);
libvlc_video_set_format(mLibVLCMediaPlayer, "RV32", mWidth, mHeight, mWidth * mDepth);
if (mIsLooping)
{
libvlc_media_add_option(mLibVLCMedia, "input-repeat=-1");
}
libvlc_media_player_play(mLibVLCMediaPlayer);
// send a "location_changed" message - this informs the media system
// that a new URL is the 'current' one and is used extensively.
// Again, this is really a browser message but we will use it here.
LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "location_changed");
message.setValue("uri", mURL);
sendMessage(message);
// Send a "navigate complete" event.
// This is really a browser message but the QuickTime plugin did it and
@ -224,15 +383,24 @@ void MediaPluginLibVLC::playMedia()
sendMessage(message_complete);
}
////////////////////////////////////////////////////////////////////////////////
//
void MediaPluginLibVLC::updateTitle(const char* title)
{
LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
message.setValue("name", title);
sendMessage(message);
}
////////////////////////////////////////////////////////////////////////////////
//
void MediaPluginLibVLC::setVolume(const F64 volume)
{
mCurVolume = volume;
if (gLibVLCMediaPlayer)
if (mLibVLCMediaPlayer)
{
int result = libvlc_audio_set_volume(gLibVLCMediaPlayer, (int)(volume * 100));
int result = libvlc_audio_set_volume(mLibVLCMediaPlayer, (int)(volume * 100));
if (result != 0)
{
// volume wasn't set but not much to be done here
@ -248,26 +416,26 @@ void MediaPluginLibVLC::setVolume(const F64 volume)
////////////////////////////////////////////////////////////////////////////////
//
void MediaPluginLibVLC::receiveMessage( const char* message_string )
void MediaPluginLibVLC::receiveMessage(const char* message_string)
{
LLPluginMessage message_in;
LLPluginMessage message_in;
if(message_in.parse(message_string) >= 0)
{
std::string message_class = message_in.getClass();
std::string message_name = message_in.getName();
if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
{
if(message_name == "init")
{
if (message_in.parse(message_string) >= 0)
{
std::string message_class = message_in.getClass();
std::string message_name = message_in.getName();
if (message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
{
if (message_name == "init")
{
initVLC();
LLPluginMessage message("base", "init_response");
LLSD versions = LLSD::emptyMap();
versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
LLPluginMessage message("base", "init_response");
LLSD versions = LLSD::emptyMap();
versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
message.setValueLLSD("versions", versions);
message.setValueLLSD("versions", versions);
std::ostringstream s;
s << "LibVLC plugin ";
@ -277,96 +445,96 @@ void MediaPluginLibVLC::receiveMessage( const char* message_string )
s << ".";
s << LIBVLC_VERSION_REVISION;
message.setValue("plugin_version", s.str());
sendMessage(message);
}
else if(message_name == "idle")
{
}
else if(message_name == "cleanup")
{
message.setValue("plugin_version", s.str());
sendMessage(message);
}
else if (message_name == "idle")
{
}
else if (message_name == "cleanup")
{
resetVLC();
}
else if(message_name == "shm_added")
{
SharedSegmentInfo info;
info.mAddress = message_in.getValuePointer("address");
info.mSize = (size_t)message_in.getValueS32("size");
std::string name = message_in.getValue("name");
}
else if (message_name == "shm_added")
{
SharedSegmentInfo info;
info.mAddress = message_in.getValuePointer("address");
info.mSize = (size_t)message_in.getValueS32("size");
std::string name = message_in.getValue("name");
mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
}
else if(message_name == "shm_remove")
{
std::string name = message_in.getValue("name");
}
else if (message_name == "shm_remove")
{
std::string name = message_in.getValue("name");
SharedSegmentMap::iterator iter = mSharedSegments.find(name);
if(iter != mSharedSegments.end())
{
if(mPixels == iter->second.mAddress)
{
libvlc_media_player_stop(gLibVLCMediaPlayer);
libvlc_media_player_release(gLibVLCMediaPlayer);
gLibVLCMediaPlayer = 0;
SharedSegmentMap::iterator iter = mSharedSegments.find(name);
if (iter != mSharedSegments.end())
{
if (mPixels == iter->second.mAddress)
{
libvlc_media_player_stop(mLibVLCMediaPlayer);
libvlc_media_player_release(mLibVLCMediaPlayer);
mLibVLCMediaPlayer = 0;
mPixels = NULL;
mTextureSegmentName.clear();
}
mSharedSegments.erase(iter);
}
else
{
mPixels = NULL;
mTextureSegmentName.clear();
}
mSharedSegments.erase(iter);
}
else
{
//std::cerr << "MediaPluginWebKit::receiveMessage: unknown shared memory region!" << std::endl;
}
}
// Send the response so it can be cleaned up.
LLPluginMessage message("base", "shm_remove_response");
message.setValue("name", name);
sendMessage(message);
}
else
{
// Send the response so it can be cleaned up.
LLPluginMessage message("base", "shm_remove_response");
message.setValue("name", name);
sendMessage(message);
}
else
{
//std::cerr << "MediaPluginWebKit::receiveMessage: unknown base message: " << message_name << std::endl;
}
}
else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
{
if(message_name == "init")
{
LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
message.setValueS32("default_width", 1024);
message.setValueS32("default_height", 1024);
message.setValueS32("depth", mDepth);
}
}
else if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
{
if (message_name == "init")
{
LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
message.setValueS32("default_width", 1024);
message.setValueS32("default_height", 1024);
message.setValueS32("depth", mDepth);
message.setValueU32("internalformat", GL_RGB);
message.setValueU32("format", GL_BGRA_EXT);
message.setValueU32("type", GL_UNSIGNED_BYTE);
message.setValueBoolean("coords_opengl", false);
sendMessage(message);
}
else if(message_name == "size_change")
{
std::string name = message_in.getValue("name");
S32 width = message_in.getValueS32("width");
S32 height = message_in.getValueS32("height");
S32 texture_width = message_in.getValueS32("texture_width");
S32 texture_height = message_in.getValueS32("texture_height");
message.setValueU32("format", GL_BGRA_EXT);
message.setValueU32("type", GL_UNSIGNED_BYTE);
message.setValueBoolean("coords_opengl", true);
sendMessage(message);
}
else if (message_name == "size_change")
{
std::string name = message_in.getValue("name");
S32 width = message_in.getValueS32("width");
S32 height = message_in.getValueS32("height");
S32 texture_width = message_in.getValueS32("texture_width");
S32 texture_height = message_in.getValueS32("texture_height");
if(!name.empty())
{
// Find the shared memory region with this name
SharedSegmentMap::iterator iter = mSharedSegments.find(name);
if(iter != mSharedSegments.end())
{
mPixels = (unsigned char*)iter->second.mAddress;
mWidth = width;
mHeight = height;
mTextureWidth = texture_width;
mTextureHeight = texture_height;
if (!name.empty())
{
// Find the shared memory region with this name
SharedSegmentMap::iterator iter = mSharedSegments.find(name);
if (iter != mSharedSegments.end())
{
mPixels = (unsigned char*)iter->second.mAddress;
mWidth = width;
mHeight = height;
mTextureWidth = texture_width;
mTextureHeight = texture_height;
playMedia();
};
};
};
LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response");
message.setValue("name", name);
@ -375,74 +543,75 @@ void MediaPluginLibVLC::receiveMessage( const char* message_string )
message.setValueS32("texture_width", texture_width);
message.setValueS32("texture_height", texture_height);
sendMessage(message);
}
else if(message_name == "load_uri")
{
}
else if (message_name == "load_uri")
{
mURL = message_in.getValue("uri");
playMedia();
}
}
else
if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
{
if (message_name == "stop")
{
if (gLibVLCMediaPlayer)
{
libvlc_media_player_stop(gLibVLCMediaPlayer);
}
}
else if (message_name == "start")
{
if (gLibVLCMediaPlayer)
{
libvlc_media_player_play(gLibVLCMediaPlayer);
}
}
else if (message_name == "pause")
{
if (gLibVLCMediaPlayer)
{
libvlc_media_player_pause(gLibVLCMediaPlayer);
}
}
else if (message_name == "seek")
{
}
else if (message_name == "set_loop")
{
}
else if (message_name == "set_volume")
{
// volume comes in 0 -> 1.0
F64 volume = message_in.getValueReal("volume");
setVolume(volume);
}
}
}
else
if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
{
if (message_name == "stop")
{
if (mLibVLCMediaPlayer)
{
libvlc_media_player_stop(mLibVLCMediaPlayer);
}
}
else if (message_name == "start")
{
if (mLibVLCMediaPlayer)
{
libvlc_media_player_play(mLibVLCMediaPlayer);
}
}
else if (message_name == "pause")
{
if (mLibVLCMediaPlayer)
{
libvlc_media_player_pause(mLibVLCMediaPlayer);
}
}
else if (message_name == "seek")
{
}
else if (message_name == "set_loop")
{
mIsLooping = true;
}
else if (message_name == "set_volume")
{
// volume comes in 0 -> 1.0
F64 volume = message_in.getValueReal("volume");
setVolume(volume);
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
//
bool MediaPluginLibVLC::init()
{
LLPluginMessage message( LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text" );
message.setValue( "name", "LibVLC Plugin" );
sendMessage( message );
LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
message.setValue("name", "LibVLC Plugin");
sendMessage(message);
return true;
return true;
};
////////////////////////////////////////////////////////////////////////////////
//
int init_media_plugin( LLPluginInstance::sendMessageFunction host_send_func,
void* host_user_data,
LLPluginInstance::sendMessageFunction *plugin_send_func,
void **plugin_user_data )
int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func,
void* host_user_data,
LLPluginInstance::sendMessageFunction *plugin_send_func,
void **plugin_user_data)
{
MediaPluginLibVLC* self = new MediaPluginLibVLC( host_send_func, host_user_data );
*plugin_send_func = MediaPluginLibVLC::staticReceiveMessage;
*plugin_user_data = ( void* )self;
MediaPluginLibVLC* self = new MediaPluginLibVLC(host_send_func, host_user_data);
*plugin_send_func = MediaPluginLibVLC::staticReceiveMessage;
*plugin_user_data = (void*)self;
return 0;
return 0;
}

2
indra/newview/llmediactrl.cpp
View File

@ -911,7 +911,7 @@ void LLMediaCtrl::convertInputCoords(S32& x, S32& y)
}
x = ll_round((F32)x * LLUI::getScaleFactor().mV[VX]);
if ( coords_opengl )
if ( ! coords_opengl )
{
y = ll_round((F32)(y) * LLUI::getScaleFactor().mV[VY]);
}