328 lines
11 KiB
C++
328 lines
11 KiB
C++
/*
|
|
* ZoneMinder Libvlc Camera Class Implementation, $Date$, $Revision$
|
|
* Copyright (C) 2001-2008 Philip Coombes
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include "zm_libvlc_camera.h"
|
|
|
|
#include "zm_packet.h"
|
|
#include "zm_signal.h"
|
|
#include "zm_utils.h"
|
|
#include <dlfcn.h>
|
|
|
|
#if HAVE_LIBVLC
|
|
static void *libvlc_lib = nullptr;
|
|
static void (*libvlc_media_player_release_f)(libvlc_media_player_t* ) = nullptr;
|
|
static void (*libvlc_media_release_f)(libvlc_media_t* ) = nullptr;
|
|
static void (*libvlc_release_f)(libvlc_instance_t* ) = nullptr;
|
|
static void (*libvlc_media_player_stop_f)(libvlc_media_player_t* ) = nullptr;
|
|
static libvlc_instance_t* (*libvlc_new_f)(int, const char* const *) = nullptr;
|
|
static void (*libvlc_log_set_f)(libvlc_instance_t*, libvlc_log_cb, void *) = nullptr;
|
|
static libvlc_media_t* (*libvlc_media_new_location_f)(libvlc_instance_t*, const char*) = nullptr;
|
|
static libvlc_media_player_t* (*libvlc_media_player_new_from_media_f)(libvlc_media_t*) = nullptr;
|
|
static void (*libvlc_video_set_format_f)(libvlc_media_player_t*, const char*, unsigned, unsigned, unsigned) = nullptr;
|
|
static void (*libvlc_video_set_callbacks_f)(libvlc_media_player_t*, libvlc_video_lock_cb, libvlc_video_unlock_cb, libvlc_video_display_cb, void*) = nullptr;
|
|
static int (*libvlc_media_player_play_f)(libvlc_media_player_t *) = nullptr;
|
|
static const char* (*libvlc_errmsg_f)(void) = nullptr;
|
|
static const char* (*libvlc_get_version_f)(void) = nullptr;
|
|
|
|
void bind_libvlc_symbols() {
|
|
if(libvlc_lib != nullptr) // Safe-check
|
|
return;
|
|
|
|
libvlc_lib = dlopen("libvlc.so", RTLD_LAZY | RTLD_GLOBAL);
|
|
if(!libvlc_lib){
|
|
Error("Error loading libvlc: %s", dlerror());
|
|
return;
|
|
}
|
|
|
|
*(void**) (&libvlc_media_player_release_f) = dlsym(libvlc_lib, "libvlc_media_player_release");
|
|
*(void**) (&libvlc_media_release_f) = dlsym(libvlc_lib, "libvlc_media_release");
|
|
*(void**) (&libvlc_release_f) = dlsym(libvlc_lib, "libvlc_release");
|
|
*(void**) (&libvlc_media_player_stop_f) = dlsym(libvlc_lib, "libvlc_media_player_stop");
|
|
*(void**) (&libvlc_new_f) = dlsym(libvlc_lib, "libvlc_new");
|
|
*(void**) (&libvlc_log_set_f) = dlsym(libvlc_lib, "libvlc_log_set");
|
|
*(void**) (&libvlc_media_new_location_f) = dlsym(libvlc_lib, "libvlc_media_new_location");
|
|
*(void**) (&libvlc_media_player_new_from_media_f) = dlsym(libvlc_lib, "libvlc_media_player_new_from_media");
|
|
*(void**) (&libvlc_video_set_format_f) = dlsym(libvlc_lib, "libvlc_video_set_format");
|
|
*(void**) (&libvlc_video_set_callbacks_f) = dlsym(libvlc_lib, "libvlc_video_set_callbacks");
|
|
*(void**) (&libvlc_media_player_play_f) = dlsym(libvlc_lib, "libvlc_media_player_play");
|
|
*(void**) (&libvlc_errmsg_f) = dlsym(libvlc_lib, "libvlc_errmsg");
|
|
*(void**) (&libvlc_get_version_f) = dlsym(libvlc_lib, "libvlc_get_version");
|
|
}
|
|
// Do all the buffer checking work here to avoid unnecessary locking
|
|
void* LibvlcLockBuffer(void* opaque, void** planes) {
|
|
LibvlcPrivateData* data = reinterpret_cast<LibvlcPrivateData*>(opaque);
|
|
data->mutex.lock();
|
|
|
|
uint8_t* buffer = data->buffer;
|
|
data->buffer = data->prevBuffer;
|
|
data->prevBuffer = buffer;
|
|
|
|
*planes = data->buffer;
|
|
return nullptr;
|
|
}
|
|
|
|
void LibvlcUnlockBuffer(void* opaque, void* picture, void *const *planes) {
|
|
LibvlcPrivateData* data = reinterpret_cast<LibvlcPrivateData*>(opaque);
|
|
|
|
bool newFrame = false;
|
|
for( unsigned int i=0; i < data->bufferSize; i++ ) {
|
|
if ( data->buffer[i] != data->prevBuffer[i] ) {
|
|
newFrame = true;
|
|
break;
|
|
}
|
|
}
|
|
data->mutex.unlock();
|
|
|
|
time_t now;
|
|
time(&now);
|
|
// Return frames slightly faster than 1fps (if time() supports greater than one second resolution)
|
|
if ( newFrame || difftime(now, data->prevTime) >= 0.8 ) {
|
|
data->prevTime = now;
|
|
{
|
|
std::lock_guard<std::mutex> lck(data->newImageMutex);
|
|
data->newImage = true;
|
|
}
|
|
data->newImageCv.notify_all();
|
|
}
|
|
}
|
|
|
|
LibvlcCamera::LibvlcCamera(
|
|
const Monitor *monitor,
|
|
const std::string &p_path,
|
|
const std::string &p_method,
|
|
const std::string &p_options,
|
|
int p_width,
|
|
int p_height,
|
|
int p_colours,
|
|
int p_brightness,
|
|
int p_contrast,
|
|
int p_hue,
|
|
int p_colour,
|
|
bool p_capture,
|
|
bool p_record_audio
|
|
) :
|
|
Camera(
|
|
monitor,
|
|
LIBVLC_SRC,
|
|
p_width,
|
|
p_height,
|
|
p_colours,
|
|
ZM_SUBPIX_ORDER_DEFAULT_FOR_COLOUR(p_colours),
|
|
p_brightness,
|
|
p_contrast,
|
|
p_hue,
|
|
p_colour,
|
|
p_capture,
|
|
p_record_audio
|
|
),
|
|
mPath(p_path),
|
|
mMethod(p_method),
|
|
mOptions(p_options)
|
|
{
|
|
mLibvlcInstance = nullptr;
|
|
mLibvlcMedia = nullptr;
|
|
mLibvlcMediaPlayer = nullptr;
|
|
mLibvlcData.buffer = nullptr;
|
|
mLibvlcData.prevBuffer = nullptr;
|
|
mOptArgV = nullptr;
|
|
|
|
/* Has to be located inside the constructor so other components such as zma will receive correct colours and subpixel order */
|
|
if ( colours == ZM_COLOUR_RGB32 ) {
|
|
subpixelorder = ZM_SUBPIX_ORDER_BGRA;
|
|
mTargetChroma = "RV32";
|
|
mBpp = 4;
|
|
} else if ( colours == ZM_COLOUR_RGB24 ) {
|
|
subpixelorder = ZM_SUBPIX_ORDER_BGR;
|
|
mTargetChroma = "RV24";
|
|
mBpp = 3;
|
|
} else if ( colours == ZM_COLOUR_GRAY8 ) {
|
|
subpixelorder = ZM_SUBPIX_ORDER_NONE;
|
|
mTargetChroma = "GREY";
|
|
mBpp = 1;
|
|
} else {
|
|
mBpp = 0;
|
|
Panic("Unexpected colours: %d",colours);
|
|
}
|
|
|
|
if ( capture ) {
|
|
Initialise();
|
|
}
|
|
}
|
|
|
|
LibvlcCamera::~LibvlcCamera() {
|
|
if ( capture ) {
|
|
Terminate();
|
|
}
|
|
|
|
mLibvlcData.newImageCv.notify_all(); // to unblock on termination (zm_terminate)
|
|
|
|
if ( mLibvlcMediaPlayer != nullptr ) {
|
|
(*libvlc_media_player_release_f)(mLibvlcMediaPlayer);
|
|
mLibvlcMediaPlayer = nullptr;
|
|
}
|
|
if ( mLibvlcMedia != nullptr ) {
|
|
(*libvlc_media_release_f)(mLibvlcMedia);
|
|
mLibvlcMedia = nullptr;
|
|
}
|
|
if ( mLibvlcInstance != nullptr ) {
|
|
(*libvlc_release_f)(mLibvlcInstance);
|
|
mLibvlcInstance = nullptr;
|
|
}
|
|
if (libvlc_lib) {
|
|
dlclose(libvlc_lib);
|
|
libvlc_lib = nullptr;
|
|
}
|
|
if ( mOptArgV != nullptr ) {
|
|
delete[] mOptArgV;
|
|
}
|
|
}
|
|
|
|
void LibvlcCamera::Initialise() {
|
|
bind_libvlc_symbols();
|
|
}
|
|
|
|
void LibvlcCamera::Terminate() {
|
|
(*libvlc_media_player_stop_f)(mLibvlcMediaPlayer);
|
|
if ( mLibvlcData.buffer ) {
|
|
zm_freealigned(mLibvlcData.buffer);
|
|
mLibvlcData.buffer = nullptr;
|
|
}
|
|
|
|
if ( mLibvlcData.prevBuffer ) {
|
|
zm_freealigned(mLibvlcData.prevBuffer);
|
|
mLibvlcData.prevBuffer = nullptr;
|
|
}
|
|
}
|
|
|
|
int LibvlcCamera::PrimeCapture() {
|
|
Debug(1, "Priming capture from %s, libvlc version %s", mPath.c_str(), (*libvlc_get_version_f)());
|
|
|
|
StringVector opVect = Split(Options(), ",");
|
|
|
|
// Set transport method as specified by method field, rtpUni is default
|
|
if ( Method() == "rtpMulti" )
|
|
opVect.push_back("--rtsp-mcast");
|
|
else if ( Method() == "rtpRtsp" )
|
|
opVect.push_back("--rtsp-tcp");
|
|
else if ( Method() == "rtpRtspHttp" )
|
|
opVect.push_back("--rtsp-http");
|
|
|
|
opVect.push_back("--no-audio");
|
|
|
|
if ( opVect.size() > 0 ) {
|
|
mOptArgV = new char*[opVect.size()];
|
|
Debug(2, "Number of Options: %zu", opVect.size());
|
|
for (size_t i=0; i< opVect.size(); i++) {
|
|
opVect[i] = TrimSpaces(opVect[i]);
|
|
mOptArgV[i] = (char *)opVect[i].c_str();
|
|
Debug(2, "set option %zu to '%s'", i, opVect[i].c_str());
|
|
}
|
|
}
|
|
|
|
mLibvlcInstance = (*libvlc_new_f)(opVect.size(), (const char* const*)mOptArgV);
|
|
if ( mLibvlcInstance == nullptr ) {
|
|
Error("Unable to create libvlc instance due to: %s", (*libvlc_errmsg_f)());
|
|
return -1;
|
|
}
|
|
(*libvlc_log_set_f)(mLibvlcInstance, LibvlcCamera::log_callback, nullptr);
|
|
|
|
|
|
mLibvlcMedia = (*libvlc_media_new_location_f)(mLibvlcInstance, mPath.c_str());
|
|
if ( mLibvlcMedia == nullptr ) {
|
|
Error("Unable to open input %s due to: %s", mPath.c_str(), (*libvlc_errmsg_f)());
|
|
return -1;
|
|
}
|
|
|
|
mLibvlcMediaPlayer = (*libvlc_media_player_new_from_media_f)(mLibvlcMedia);
|
|
if ( mLibvlcMediaPlayer == nullptr ) {
|
|
Error("Unable to create player for %s due to: %s", mPath.c_str(), (*libvlc_errmsg_f)());
|
|
return -1;
|
|
}
|
|
|
|
(*libvlc_video_set_format_f)(mLibvlcMediaPlayer, mTargetChroma.c_str(), width, height, width * mBpp);
|
|
(*libvlc_video_set_callbacks_f)(mLibvlcMediaPlayer, &LibvlcLockBuffer, &LibvlcUnlockBuffer, nullptr, &mLibvlcData);
|
|
|
|
mLibvlcData.bufferSize = width * height * mBpp;
|
|
// Libvlc wants 32 byte alignment for images (should in theory do this for all image lines)
|
|
mLibvlcData.buffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize);
|
|
mLibvlcData.prevBuffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize);
|
|
|
|
mLibvlcData.newImage = false;
|
|
|
|
(*libvlc_media_player_play_f)(mLibvlcMediaPlayer);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int LibvlcCamera::PreCapture() {
|
|
return 0;
|
|
}
|
|
|
|
// Should not return -1 as cancels capture. Always wait for image if available.
|
|
int LibvlcCamera::Capture(std::shared_ptr<ZMPacket> &zm_packet) {
|
|
// newImage is a mutex/condition based flag to tell us when there is an image available
|
|
{
|
|
std::unique_lock<std::mutex> lck(mLibvlcData.newImageMutex);
|
|
mLibvlcData.newImageCv.wait(lck, [&]{ return mLibvlcData.newImage || zm_terminate; });
|
|
mLibvlcData.newImage = false;
|
|
}
|
|
|
|
if (zm_terminate)
|
|
return 0;
|
|
|
|
mLibvlcData.mutex.lock();
|
|
zm_packet->image->Assign(width, height, colours, subpixelorder, mLibvlcData.buffer, width * height * mBpp);
|
|
zm_packet->packet.stream_index = mVideoStreamId;
|
|
zm_packet->stream = mVideoStream;
|
|
mLibvlcData.mutex.unlock();
|
|
|
|
return 1;
|
|
}
|
|
|
|
int LibvlcCamera::PostCapture() {
|
|
return 0;
|
|
}
|
|
|
|
void LibvlcCamera::log_callback(void *ptr, int level, const libvlc_log_t *ctx, const char *fmt, va_list vargs) {
|
|
Logger *log = Logger::fetch();
|
|
int log_level = Logger::NOLOG;
|
|
if ( level == LIBVLC_ERROR ) {
|
|
log_level = Logger::WARNING; // ffmpeg outputs a lot of errors that don't really affect anything.
|
|
//log_level = Logger::ERROR;
|
|
} else if ( level == LIBVLC_WARNING ) {
|
|
log_level = Logger::INFO;
|
|
//log_level = Logger::WARNING;
|
|
} else if ( level == LIBVLC_NOTICE ) {
|
|
log_level = Logger::DEBUG1;
|
|
//log_level = Logger::INFO;
|
|
} else if ( level == LIBVLC_DEBUG ) {
|
|
log_level = Logger::DEBUG3;
|
|
} else {
|
|
Error("Unknown log level %d", level);
|
|
}
|
|
|
|
if ( log ) {
|
|
char logString[8192];
|
|
vsnprintf(logString, sizeof(logString) - 1, fmt, vargs);
|
|
log->logPrint(false, __FILE__, __LINE__, log_level, "%s", logString);
|
|
}
|
|
}
|
|
#endif // HAVE_LIBVLC
|