eessppeelllloo/vimix
1
0
Fork 0
mirror of https://github.com/brunoherbelin/vimix.git synced 2025-12-05 15:30:00 +01:00
Code Issues Packages Projects Releases Wiki Activity

Unified class methods naming (lower case function names as other

Browse Source 
classes)
This commit is contained in:
brunoherbelin
2020-04-03 23:06:24 +02:00
parent fc256693dc
commit 0e25810a74
4 changed files with 295 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
FrameBuffer.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "FrameBuffer.h"
FrameBuffer::FrameBuffer()
{
}

11
FrameBuffer.h Normal file
View File

@@ -0,0 +1,11 @@
#ifndef FRAMEBUFFER_H
#define FRAMEBUFFER_H
class FrameBuffer
{
public:
FrameBuffer();
};
#endif // FRAMEBUFFER_H

448
MediaPlayer.cpp
View File

@@ -40,41 +40,41 @@ GLuint blackTexture()
return tex_index_black;
}
MediaPlayer::MediaPlayer(string name) : id(name)
MediaPlayer::MediaPlayer(string name) : id_(name)
{
if (std::empty(id))
id = GstToolkit::date_time_string();
if (std::empty(id_))
id_ = GstToolkit::date_time_string();
uri = "undefined";
pipeline = nullptr;
discoverer = nullptr;
uri_ = "undefined";
pipeline_ = nullptr;
discoverer_ = nullptr;
ready = false;
seekable = false;
isimage = false;
interlaced = false;
need_loop = false;
v_frame_is_full = false;
rate = 1.0;
framerate = 0.0;
ready_ = false;
seekable_ = false;
isimage_ = false;
interlaced_ = false;
need_loop_ = false;
v_frame_is_full_ = false;
rate_ = 1.0;
framerate_ = 0.0;
width = par_width = 640;
height = 480;
position = GST_CLOCK_TIME_NONE;
duration = GST_CLOCK_TIME_NONE;
start_position = GST_CLOCK_TIME_NONE;
frame_duration = GST_CLOCK_TIME_NONE;
desired_state = GST_STATE_PAUSED;
loop = LoopMode::LOOP_REWIND;
current_segment = segments.begin();
v_frame.buffer = nullptr;
width_ = par_width_ = 640;
height_ = 480;
position_ = GST_CLOCK_TIME_NONE;
duration_ = GST_CLOCK_TIME_NONE;
start_position_ = GST_CLOCK_TIME_NONE;
frame_duration_ = GST_CLOCK_TIME_NONE;
desired_state_ = GST_STATE_PAUSED;
loop_ = LoopMode::LOOP_REWIND;
current_segment_ = segments_.begin();
v_frame_.buffer = nullptr;
textureindex = 0;
textureindex_ = 0;
}
MediaPlayer::~MediaPlayer()
{
Close();
close();
// g_free(v_frame);
}
@@ -82,48 +82,48 @@ void MediaPlayer::accept(Visitor& v) {
v.visit(*this);
}
void MediaPlayer::Bind()
void MediaPlayer::bind()
{
glBindTexture(GL_TEXTURE_2D, Texture());
glBindTexture(GL_TEXTURE_2D, texture());
}
guint MediaPlayer::Texture() const
guint MediaPlayer::texture() const
{
if (textureindex == 0)
if (textureindex_ == 0)
return blackTexture();
return textureindex;
return textureindex_;
}
void MediaPlayer::Open(string uri)
void MediaPlayer::open(string uri)
{
// set uri to open
this->uri = uri;
this->uri_ = uri;
// reset
ready = false;
ready_ = false;
/* Instantiate the Discoverer */
GError *err = NULL;
discoverer = gst_discoverer_new (5 * GST_SECOND, &err);
if (!discoverer) {
discoverer_ = gst_discoverer_new (5 * GST_SECOND, &err);
if (!discoverer_) {
Log::Warning("MediaPlayer Error creating discoverer instance: %s\n", err->message);
g_clear_error (&err);
return;
}
// set callback for filling in information into this MediaPlayer
g_signal_connect (discoverer, "discovered", G_CALLBACK (callback_discoverer_process), this);
g_signal_connect (discoverer_, "discovered", G_CALLBACK (callback_discoverer_process), this);
// set callback when finished discovering
g_signal_connect (discoverer, "finished", G_CALLBACK (callback_discoverer_finished), this);
g_signal_connect (discoverer_, "finished", G_CALLBACK (callback_discoverer_finished), this);
// start discoverer
gst_discoverer_start(discoverer);
gst_discoverer_start(discoverer_);
// Add the request to process asynchronously the URI
if (!gst_discoverer_discover_uri_async (discoverer, uri.c_str())) {
Log::Warning("MediaPlayer %s Failed to start discovering URI '%s'\n", id.c_str(), uri.c_str());
g_object_unref (discoverer);
discoverer = nullptr;
if (!gst_discoverer_discover_uri_async (discoverer_, uri.c_str())) {
Log::Warning("MediaPlayer %s Failed to start discovering URI '%s'\n", id_.c_str(), uri.c_str());
g_object_unref (discoverer_);
discoverer_ = nullptr;
}
// and wait for discoverer to finish...
@@ -133,31 +133,31 @@ void MediaPlayer::Open(string uri)
void MediaPlayer::execute_open()
{
// build string describing pipeline
string description = "uridecodebin uri=" + uri + " name=decoder !";
if (interlaced)
string description = "uridecodebin uri=" + uri_ + " name=decoder !";
if (interlaced_)
description += " deinterlace !";
description += " videoconvert ! appsink name=sink";
// parse pipeline descriptor
GError *error = NULL;
pipeline = gst_parse_launch (description.c_str(), &error);
pipeline_ = gst_parse_launch (description.c_str(), &error);
if (error != NULL) {
Log::Warning("MediaPlayer %s Could not construct pipeline %s:\n%s", id.c_str(), description.c_str(), error->message);
Log::Warning("MediaPlayer %s Could not construct pipeline %s:\n%s", id_.c_str(), description.c_str(), error->message);
g_clear_error (&error);
return;
}
g_object_set(G_OBJECT(pipeline), "name", id.c_str(), NULL);
g_object_set(G_OBJECT(pipeline_), "name", id_.c_str(), NULL);
// GstCaps *caps = gst_static_caps_get (&frame_render_caps);
string capstring = "video/x-raw,format=RGBA,width="+ std::to_string(width) + ",height=" + std::to_string(height);
string capstring = "video/x-raw,format=RGBA,width="+ std::to_string(width_) + ",height=" + std::to_string(height_);
GstCaps *caps = gst_caps_from_string(capstring.c_str());
if (!gst_video_info_from_caps (&v_frame_video_info, caps)) {
Log::Warning("MediaPlayer %s Could not configure video frame info", id.c_str());
if (!gst_video_info_from_caps (&v_frame_video_info_, caps)) {
Log::Warning("MediaPlayer %s Could not configure video frame info", id_.c_str());
return;
}
// setup appsink
GstElement *sink = gst_bin_get_by_name (GST_BIN (pipeline), "sink");
GstElement *sink = gst_bin_get_by_name (GST_BIN (pipeline_), "sink");
if (sink) {
// set all properties
@@ -177,7 +177,7 @@ void MediaPlayer::execute_open()
gst_object_unref (sink);
}
else {
Log::Warning("MediaPlayer %s Could not configure sink", id.c_str());
Log::Warning("MediaPlayer %s Could not configure sink", id_.c_str());
return;
}
gst_caps_unref (caps);
@@ -186,226 +186,226 @@ void MediaPlayer::execute_open()
//Rendering::LinkPipeline(GST_PIPELINE (pipeline));
// set to desired state (PLAY or PAUSE)
GstStateChangeReturn ret = gst_element_set_state (pipeline, desired_state);
GstStateChangeReturn ret = gst_element_set_state (pipeline_, desired_state_);
if (ret == GST_STATE_CHANGE_FAILURE) {
Log::Warning("MediaPlayer %s Could not open %s", id.c_str(), uri.c_str());
Log::Warning("MediaPlayer %s Could not open %s", id_.c_str(), uri_.c_str());
return;
}
// all good
Log::Info("MediaPlayer %s Open %s (%s %d x %d)", id.c_str(), uri.c_str(), codec_name.c_str(), width, height);
ready = true;
Log::Info("MediaPlayer %s Open %s (%s %d x %d)", id_.c_str(), uri_.c_str(), codec_name_.c_str(), width_, height_);
ready_ = true;
}
bool MediaPlayer::isOpen() const
{
return ready;
return ready_;
}
void MediaPlayer::Close()
void MediaPlayer::close()
{
// stop discovering stream
if (discoverer != nullptr) {
gst_discoverer_stop (discoverer);
g_object_unref (discoverer);
discoverer = nullptr;
if (discoverer_ != nullptr) {
gst_discoverer_stop (discoverer_);
g_object_unref (discoverer_);
discoverer_ = nullptr;
}
if (!ready)
if (!ready_)
return;
// clean up GST
if (pipeline != nullptr) {
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
pipeline = nullptr;
if (pipeline_ != nullptr) {
gst_element_set_state (pipeline_, GST_STATE_NULL);
gst_object_unref (pipeline_);
pipeline_ = nullptr;
}
// nothing to display
textureindex = blackTexture();
textureindex_ = blackTexture();
// un-ready the media player
ready = false;
ready_ = false;
}
GstClockTime MediaPlayer::Duration()
GstClockTime MediaPlayer::duration()
{
if (duration == GST_CLOCK_TIME_NONE && pipeline != nullptr) {
if (duration_ == GST_CLOCK_TIME_NONE && pipeline_ != nullptr) {
gint64 d = GST_CLOCK_TIME_NONE;
if ( gst_element_query_duration(pipeline, GST_FORMAT_TIME, &d) )
duration = d;
if ( gst_element_query_duration(pipeline_, GST_FORMAT_TIME, &d) )
duration_ = d;
}
return duration;
return duration_;
}
GstClockTime MediaPlayer::FrameDuration()
GstClockTime MediaPlayer::frameDuration()
{
return frame_duration;
return frame_duration_;
}
guint MediaPlayer::Width() const
guint MediaPlayer::width() const
{
return width;
return width_;
}
guint MediaPlayer::Height() const
guint MediaPlayer::height() const
{
return height;
return height_;
}
float MediaPlayer::AspectRatio() const
float MediaPlayer::aspectRatio() const
{
return static_cast<float>(par_width) / static_cast<float>(height);
return static_cast<float>(par_width_) / static_cast<float>(height_);
}
GstClockTime MediaPlayer::Position()
GstClockTime MediaPlayer::position()
{
GstClockTime pos = position;
GstClockTime pos = position_;
if (pos == GST_CLOCK_TIME_NONE && pipeline != nullptr) {
if (pos == GST_CLOCK_TIME_NONE && pipeline_ != nullptr) {
gint64 p = GST_CLOCK_TIME_NONE;
if ( gst_element_query_position (pipeline, GST_FORMAT_TIME, &p) )
if ( gst_element_query_position (pipeline_, GST_FORMAT_TIME, &p) )
pos = p;
}
return pos - start_position;
return pos - start_position_;
}
void MediaPlayer::Play(bool on)
void MediaPlayer::play(bool on)
{
// cannot play an image
if (isimage)
if (isimage_)
return;
// request state
GstState requested_state = on ? GST_STATE_PLAYING : GST_STATE_PAUSED;
// ignore if requesting twice same state
if (desired_state == requested_state)
if (desired_state_ == requested_state)
return;
// accept request to the desired state
desired_state = requested_state;
desired_state_ = requested_state;
// if not ready yet, the requested state will be handled later
if ( pipeline == nullptr )
if ( pipeline_ == nullptr )
return;
// requesting to play, but stopped at end of stream : rewind first !
if ( desired_state == GST_STATE_PLAYING) {
if ( ( rate>0.0 ? duration - Position() : Position() ) < 2 * frame_duration )
Rewind();
if ( desired_state_ == GST_STATE_PLAYING) {
if ( ( rate_>0.0 ? duration_ - position() : position() ) < 2 * frame_duration_ )
rewind();
}
// all ready, apply state change immediately
GstStateChangeReturn ret = gst_element_set_state (pipeline, desired_state);
GstStateChangeReturn ret = gst_element_set_state (pipeline_, desired_state_);
if (ret == GST_STATE_CHANGE_FAILURE) {
Log::Warning("MediaPlayer %s Failed to start", gst_element_get_name(pipeline));
Log::Warning("MediaPlayer %s Failed to start", gst_element_get_name(pipeline_));
}
#ifdef MEDIA_PLAYER_DEBUG
else if (on)
Log::Info("MediaPlayer %s Start", gst_element_get_name(pipeline));
Log::Info("MediaPlayer %s Start", gst_element_get_name(pipeline_));
else
Log::Info("MediaPlayer %s Stop", gst_element_get_name(pipeline));
Log::Info("MediaPlayer %s Stop", gst_element_get_name(pipeline_));
#endif
// reset time counter on stop
if (!on)
timecount.reset();
timecount_.reset();
}
bool MediaPlayer::isPlaying() const
{
// image cannot play
if (isimage)
if (isimage_)
return false;
// if not ready yet, answer with requested state
if ( pipeline == nullptr )
return desired_state == GST_STATE_PLAYING;
if ( pipeline_ == nullptr )
return desired_state_ == GST_STATE_PLAYING;
// if ready, answer with actual state
GstState state;
gst_element_get_state (pipeline, &state, NULL, GST_CLOCK_TIME_NONE);
gst_element_get_state (pipeline_, &state, NULL, GST_CLOCK_TIME_NONE);
return state == GST_STATE_PLAYING;
// return desired_state == GST_STATE_PLAYING;
}
MediaPlayer::LoopMode MediaPlayer::Loop() const
MediaPlayer::LoopMode MediaPlayer::loop() const
{
return loop;
return loop_;
}
void MediaPlayer::setLoop(MediaPlayer::LoopMode mode)
{
loop = mode;
loop_ = mode;
}
void MediaPlayer::Rewind()
void MediaPlayer::rewind()
{
if (!seekable)
if (!seekable_)
return;
if (rate > 0.0)
if (rate_ > 0.0)
// playing forward, loop to begin
execute_seek_command(0);
else
// playing backward, loop to end
execute_seek_command(duration);
execute_seek_command(duration_);
}
void MediaPlayer::SeekNextFrame()
void MediaPlayer::seekNextFrame()
{
// useful only when Paused
if (isPlaying())
return;
if ( loop != LOOP_NONE) {
if ( loop_ != LOOP_NONE) {
// eventually loop if mode allows
if ( ( rate>0.0 ? duration - Position() : Position() ) < 2 * frame_duration )
need_loop = true;
if ( ( rate_>0.0 ? duration_ - position() : position() ) < 2 * frame_duration_ )
need_loop_ = true;
}
// step
gst_element_send_event (pipeline, gst_event_new_step (GST_FORMAT_BUFFERS, 1, ABS(rate), TRUE, FALSE));
gst_element_send_event (pipeline_, gst_event_new_step (GST_FORMAT_BUFFERS, 1, ABS(rate_), TRUE, FALSE));
}
void MediaPlayer::SeekTo(GstClockTime pos)
void MediaPlayer::seekTo(GstClockTime pos)
{
if (!seekable)
if (!seekable_)
return;
// remember pos
GstClockTime previous_pos = Position();
GstClockTime previous_pos = position();
// apply seek
GstClockTime target = CLAMP(pos, 0, duration);
GstClockTime target = CLAMP(pos, 0, duration_);
execute_seek_command(target);
}
void MediaPlayer::FastForward()
void MediaPlayer::fastForward()
{
if (!seekable)
if (!seekable_)
return;
double step = SIGN(rate) * 0.01 * static_cast<double>(duration);
GstClockTime target = Position() + static_cast<GstClockTime>(step);
double step = SIGN(rate_) * 0.01 * static_cast<double>(duration_);
GstClockTime target = position() + static_cast<GstClockTime>(step);
// manage loop
if ( target > duration ) {
if (loop == LOOP_NONE)
target = duration;
if ( target > duration_ ) {
if (loop_ == LOOP_NONE)
target = duration_;
else
target = target - duration;
target = target - duration_;
}
SeekTo(target);
seekTo(target);
}
@@ -418,7 +418,7 @@ bool MediaPlayer::addPlaySegment(GstClockTime begin, GstClockTime end)
bool MediaPlayer::addPlaySegment(MediaSegment s)
{
if ( s.is_valid() )
return segments.insert(s).second;
return segments_.insert(s).second;
return false;
}
@@ -431,10 +431,10 @@ bool MediaPlayer::removeAllPlaySegmentOverlap(MediaSegment s)
bool MediaPlayer::removePlaySegmentAt(GstClockTime t)
{
MediaSegmentSet::const_iterator s = std::find_if(segments.begin(), segments.end(), containsTime(t));
MediaSegmentSet::const_iterator s = std::find_if(segments_.begin(), segments_.end(), containsTime(t));
if ( s != segments.end() ) {
segments.erase(s);
if ( s != segments_.end() ) {
segments_.erase(s);
return true;
}
@@ -444,70 +444,70 @@ bool MediaPlayer::removePlaySegmentAt(GstClockTime t)
std::list< std::pair<guint64, guint64> > MediaPlayer::getPlaySegments() const
{
std::list< std::pair<guint64, guint64> > ret;
for (MediaSegmentSet::iterator it = segments.begin(); it != segments.end(); it++)
for (MediaSegmentSet::iterator it = segments_.begin(); it != segments_.end(); it++)
ret.push_back( std::make_pair( it->begin, it->end ) );
return ret;
}
void MediaPlayer::Update()
void MediaPlayer::update()
{
// discard
if (!ready)
if (!ready_)
return;
// done discovering stream
if (discoverer != nullptr) {
gst_discoverer_stop (discoverer);
g_object_unref (discoverer);
discoverer = nullptr;
if (discoverer_ != nullptr) {
gst_discoverer_stop (discoverer_);
g_object_unref (discoverer_);
discoverer_ = nullptr;
}
// apply texture
if (v_frame_is_full) {
if (v_frame_is_full_) {
// first occurence; create texture
if (textureindex==0) {
if (textureindex_==0) {
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &textureindex);
glBindTexture(GL_TEXTURE_2D, textureindex);
glGenTextures(1, &textureindex_);
glBindTexture(GL_TEXTURE_2D, textureindex_);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height,
0, GL_RGBA, GL_UNSIGNED_BYTE, v_frame.data[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_,
0, GL_RGBA, GL_UNSIGNED_BYTE, v_frame_.data[0]);
}
else // bind texture
{
glBindTexture(GL_TEXTURE_2D, textureindex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height,
GL_RGBA, GL_UNSIGNED_BYTE, v_frame.data[0]);
glBindTexture(GL_TEXTURE_2D, textureindex_);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width_, height_,
GL_RGBA, GL_UNSIGNED_BYTE, v_frame_.data[0]);
}
// sync with callback_pull_last_sample_video
v_frame_is_full = false;
v_frame_is_full_ = false;
}
// manage loop mode
if (need_loop && !isimage) {
if (need_loop_ && !isimage_) {
execute_loop_command();
need_loop = false;
need_loop_ = false;
}
// all other updates below are only for playing mode
if (desired_state != GST_STATE_PLAYING)
if (desired_state_ != GST_STATE_PLAYING)
return;
// test segments
if ( segments.begin() != segments.end()) {
if ( segments_.begin() != segments_.end()) {
if ( current_segment == segments.end() )
current_segment = segments.begin();
if ( current_segment_ == segments_.end() )
current_segment_ = segments_.begin();
if ( Position() > current_segment->end) {
if ( position() > current_segment_->end) {
g_print("switch to next segment ");
current_segment++;
if ( current_segment == segments.end() )
current_segment = segments.begin();
SeekTo(current_segment->begin);
current_segment_++;
if ( current_segment_ == segments_.end() )
current_segment_ = segments_.begin();
seekTo(current_segment_->begin);
}
}
@@ -516,21 +516,21 @@ void MediaPlayer::Update()
void MediaPlayer::execute_loop_command()
{
if (loop==LOOP_REWIND) {
Rewind();
if (loop_==LOOP_REWIND) {
rewind();
}
else if (loop==LOOP_BIDIRECTIONAL) {
rate *= - 1.f;
else if (loop_==LOOP_BIDIRECTIONAL) {
rate_ *= - 1.f;
execute_seek_command();
}
else {
Play(false);
play(false);
}
}
void MediaPlayer::execute_seek_command(GstClockTime target)
{
if ( pipeline == nullptr || !seekable)
if ( pipeline_ == nullptr || !seekable_)
return;
GstEvent *seek_event = nullptr;
@@ -541,12 +541,12 @@ void MediaPlayer::execute_seek_command(GstClockTime target)
// no target given
if (target == GST_CLOCK_TIME_NONE)
// create seek event with current position (rate changed ?)
seek_pos = Position();
seek_pos = position();
// target is given but useless
else if ( ABS_DIFF(target, Position()) < frame_duration) {
else if ( ABS_DIFF(target, position()) < frame_duration_) {
// ignore request
#ifdef MEDIA_PLAYER_DEBUG
Log::Info("MediaPlayer %s Ignored seek to current position", id.c_str());
Log::Info("MediaPlayer %s Ignored seek to current position", id_.c_str());
#endif
return;
}
@@ -554,61 +554,61 @@ void MediaPlayer::execute_seek_command(GstClockTime target)
// seek with flush (always)
int seek_flags = GST_SEEK_FLAG_FLUSH;
// seek with trick mode if fast speed
if ( ABS(rate) > 2.0 )
if ( ABS(rate_) > 2.0 )
seek_flags |= GST_SEEK_FLAG_TRICKMODE;
// create seek event depending on direction
if (rate > 0) {
seek_event = gst_event_new_seek (rate, GST_FORMAT_TIME, (GstSeekFlags) seek_flags,
if (rate_ > 0) {
seek_event = gst_event_new_seek (rate_, GST_FORMAT_TIME, (GstSeekFlags) seek_flags,
GST_SEEK_TYPE_SET, seek_pos, GST_SEEK_TYPE_END, 0);
} else {
seek_event = gst_event_new_seek (rate, GST_FORMAT_TIME, (GstSeekFlags) seek_flags,
seek_event = gst_event_new_seek (rate_, GST_FORMAT_TIME, (GstSeekFlags) seek_flags,
GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_SET, seek_pos);
}
// Send the event (ASYNC)
if (seek_event && !gst_element_send_event(pipeline, seek_event) )
Log::Warning("MediaPlayer %s Seek failed", gst_element_get_name(pipeline));
if (seek_event && !gst_element_send_event(pipeline_, seek_event) )
Log::Warning("MediaPlayer %s Seek failed", gst_element_get_name(pipeline_));
#ifdef MEDIA_PLAYER_DEBUG
else
Log::Info("MediaPlayer %s Seek %ld %f", gst_element_get_name(pipeline), seek_pos, rate);
Log::Info("MediaPlayer %s Seek %ld %f", gst_element_get_name(pipeline_), seek_pos, rate_);
#endif
}
void MediaPlayer::SetPlaySpeed(double s)
void MediaPlayer::setPlaySpeed(double s)
{
if (isimage)
if (isimage_)
return;
// bound to interval [-MAX_PLAY_SPEED MAX_PLAY_SPEED]
rate = CLAMP(s, -MAX_PLAY_SPEED, MAX_PLAY_SPEED);
rate_ = CLAMP(s, -MAX_PLAY_SPEED, MAX_PLAY_SPEED);
// skip interval [-MIN_PLAY_SPEED MIN_PLAY_SPEED]
if (ABS(rate) < MIN_PLAY_SPEED)
rate = SIGN(rate) * MIN_PLAY_SPEED;
if (ABS(rate_) < MIN_PLAY_SPEED)
rate_ = SIGN(rate_) * MIN_PLAY_SPEED;
// apply with seek
execute_seek_command();
}
double MediaPlayer::PlaySpeed() const
double MediaPlayer::playSpeed() const
{
return rate;
return rate_;
}
std::string MediaPlayer::Codec() const
std::string MediaPlayer::codec() const
{
return codec_name;
return codec_name_;
}
double MediaPlayer::FrameRate() const
double MediaPlayer::frameRate() const
{
return framerate;
return framerate_;
}
double MediaPlayer::UpdateFrameRate() const
double MediaPlayer::updateFrameRate() const
{
return timecount.framerate();
return timecount_.frameRate();
}
@@ -617,33 +617,33 @@ double MediaPlayer::UpdateFrameRate() const
bool MediaPlayer::fill_v_frame(GstBuffer *buf)
{
// always empty frame before filling it again
if (v_frame.buffer)
gst_video_frame_unmap(&v_frame);
if (v_frame_.buffer)
gst_video_frame_unmap(&v_frame_);
// get the frame from buffer
if ( !gst_video_frame_map (&v_frame, &v_frame_video_info, buf, GST_MAP_READ ) ) {
if ( !gst_video_frame_map (&v_frame_, &v_frame_video_info_, buf, GST_MAP_READ ) ) {
Log::Info("MediaPlayer %s Failed to map the video buffer");
return false;
}
// validate frame format
if( GST_VIDEO_INFO_IS_RGB(&(v_frame).info) && GST_VIDEO_INFO_N_PLANES(&(v_frame).info) == 1) {
if( GST_VIDEO_INFO_IS_RGB(&(v_frame_).info) && GST_VIDEO_INFO_N_PLANES(&(v_frame_).info) == 1) {
// validate time
if (position != buf->pts) {
if (position_ != buf->pts) {
// got a new RGB frame !
v_frame_is_full = true;
v_frame_is_full_ = true;
// get presentation time stamp
position = buf->pts;
position_ = buf->pts;
// set start position (i.e. pts of first frame we got)
if (start_position == GST_CLOCK_TIME_NONE)
start_position = position;
if (start_position_ == GST_CLOCK_TIME_NONE)
start_position_ = position_;
// keep update time (i.e. actual FPS of update)
timecount.tic();
timecount_.tic();
}
}
@@ -655,7 +655,7 @@ GstFlowReturn MediaPlayer::callback_pull_sample_video (GstElement *bin, MediaPla
{
GstFlowReturn ret = GST_FLOW_OK;
if (m && !m->v_frame_is_full) {
if (m && !m->v_frame_is_full_) {
// get last sample (non blocking)
GstSample *sample = nullptr;
@@ -692,7 +692,7 @@ void MediaPlayer::callback_end_of_video (GstElement *bin, MediaPlayer *m)
{
if (m) {
// reached end of stream (eos) : might need to loop !
m->need_loop = true;
m->need_loop_ = true;
}
}
@@ -706,22 +706,22 @@ void MediaPlayer::callback_discoverer_process (GstDiscoverer *discoverer, GstDis
GstDiscovererResult result = gst_discoverer_info_get_result (info);
switch (result) {
case GST_DISCOVERER_URI_INVALID:
m->discoverer_message << "Invalid URI: " << uri;
m->discoverer_message_ << "Invalid URI: " << uri;
break;
case GST_DISCOVERER_ERROR:
m->discoverer_message << "Error: " << err->message;
m->discoverer_message_ << "Error: " << err->message;
break;
case GST_DISCOVERER_TIMEOUT:
m->discoverer_message << "Time out";
m->discoverer_message_ << "Time out";
break;
case GST_DISCOVERER_BUSY:
m->discoverer_message << "Busy";
m->discoverer_message_ << "Busy";
break;
case GST_DISCOVERER_MISSING_PLUGINS:
{
const GstStructure *s = gst_discoverer_info_get_misc (info);
gchar *str = gst_structure_to_string (s);
m->discoverer_message << "Unknown file format / " << str;
m->discoverer_message_ << "Unknown file format / " << str;
g_free (str);
}
break;
@@ -741,26 +741,26 @@ void MediaPlayer::callback_discoverer_process (GstDiscoverer *discoverer, GstDis
{
// found a video / image stream : fill-in information
GstDiscovererVideoInfo* vinfo = GST_DISCOVERER_VIDEO_INFO(tmpinf);
m->width = gst_discoverer_video_info_get_width(vinfo);
m->height = gst_discoverer_video_info_get_height(vinfo);
m->isimage = gst_discoverer_video_info_is_image(vinfo);
m->interlaced = gst_discoverer_video_info_is_interlaced(vinfo);
m->width_ = gst_discoverer_video_info_get_width(vinfo);
m->height_ = gst_discoverer_video_info_get_height(vinfo);
m->isimage_ = gst_discoverer_video_info_is_image(vinfo);
m->interlaced_ = gst_discoverer_video_info_is_interlaced(vinfo);
guint parn = gst_discoverer_video_info_get_par_num(vinfo);
guint pard = gst_discoverer_video_info_get_par_denom(vinfo);
m->par_width = (m->width * parn) / pard;
m->par_width_ = (m->width_ * parn) / pard;
// if its a video, it duration, framerate, etc.
if ( !m->isimage ) {
m->duration = gst_discoverer_info_get_duration (info);
m->seekable = gst_discoverer_info_get_seekable (info);
if ( !m->isimage_ ) {
m->duration_ = gst_discoverer_info_get_duration (info);
m->seekable_ = gst_discoverer_info_get_seekable (info);
guint frn = gst_discoverer_video_info_get_framerate_num(vinfo);
guint frd = gst_discoverer_video_info_get_framerate_denom(vinfo);
m->framerate = static_cast<double>(frn) / static_cast<double>(frd);
m->frame_duration = (GST_SECOND * static_cast<guint64>(frd)) / (static_cast<guint64>(frn));
m->framerate_ = static_cast<double>(frn) / static_cast<double>(frd);
m->frame_duration_ = (GST_SECOND * static_cast<guint64>(frd)) / (static_cast<guint64>(frn));
}
// try to fill-in the codec information
GstCaps *caps = gst_discoverer_stream_info_get_caps (tmpinf);
if (caps) {
m->codec_name = std::string( gst_pb_utils_get_codec_description(caps) );
m->codec_name_ = std::string( gst_pb_utils_get_codec_description(caps) );
gst_caps_unref (caps);
}
// const GstTagList *tags = gst_discoverer_stream_info_get_tags(tmpinf);
@@ -780,7 +780,7 @@ void MediaPlayer::callback_discoverer_process (GstDiscoverer *discoverer, GstDis
gst_discoverer_stream_info_list_free(streams);
if (!foundvideostream) {
m->discoverer_message << "No video stream.";
m->discoverer_message_ << "No video stream.";
}
}
@@ -791,11 +791,11 @@ void MediaPlayer::callback_discoverer_finished(GstDiscoverer *discoverer, MediaP
// finished the discoverer : finalize open status
if (m) {
// no error message, open media
if ( m->discoverer_message.str().empty())
if ( m->discoverer_message_.str().empty())
m->execute_open();
else {
Log::Warning("MediaPlayer %s Failed to open %s\n%s", m->id.c_str(), m->uri.c_str(), m->discoverer_message.str().c_str());
m->discoverer_message.clear();
Log::Warning("MediaPlayer %s Failed to open %s\n%s", m->id_.c_str(), m->uri_.c_str(), m->discoverer_message_.str().c_str());
m->discoverer_message_.clear();
}
}
}
@@ -837,7 +837,7 @@ void TimeCounter::reset ()
fps = 0.f;
}
float TimeCounter::framerate() const
float TimeCounter::frameRate() const
{
return fps;
}

108
MediaPlayer.h
View File

@@ -28,7 +28,7 @@ public:
TimeCounter();
void tic();
void reset();
float framerate() const;
float frameRate() const;
};
struct MediaSegment
@@ -101,7 +101,7 @@ public:
/**
* Open a media using gstreamer URI
* */
void Open( std::string uri);
void open( std::string uri_);
/**
* True if a media was oppenned
* */
@@ -109,17 +109,17 @@ public:
/**
* Close the Media
* */
void Close();
void close();
/**
* Update status
* Must be called in update loop
* */
void Update();
void update();
/**
* Pause / Play
* Can play backward if play speed is negative
* */
void Play(bool on);
void play(bool on);
/**
* Get Pause / Play
* */
@@ -128,12 +128,12 @@ public:
* Speed factor for playing
* Can be negative.
* */
double PlaySpeed() const;
double playSpeed() const;
/**
* Set the speed factor for playing
* Can be negative.
* */
void SetPlaySpeed(double s);
void setPlaySpeed(double s);
/**
* True if the player will loop when at begin or end
* */
@@ -142,7 +142,7 @@ public:
LOOP_REWIND = 1,
LOOP_BIDIRECTIONAL = 2
} LoopMode;
LoopMode Loop() const;
LoopMode loop() const;
/**
* Set the player to loop
* */
@@ -150,58 +150,58 @@ public:
/**
* Restart from zero
* */
void Rewind();
void rewind();
/**
* Seek to next frame when paused
* Can go backward if play speed is negative
* */
void SeekNextFrame();
void seekNextFrame();
/**
* Seek to any position in media
* pos in nanoseconds.
* */
void SeekTo(GstClockTime pos);
void seekTo(GstClockTime pos);
/**
* Jump by 10% of the duration
* */
void FastForward();
void fastForward();
/**
* Get position time
* */
GstClockTime Position();
GstClockTime position();
/**
* Get total duration time
* */
GstClockTime Duration();
GstClockTime duration();
/**
* Get duration of one frame
* */
GstClockTime FrameDuration();
GstClockTime frameDuration();
/**
* Get framerate of the media
* */
double FrameRate() const;
double frameRate() const;
/**
* Get name of Codec of the media
* */
std::string Codec() const;
std::string codec() const;
/**
* Get rendering update framerate
* measured during play
* */
double UpdateFrameRate() const;
double updateFrameRate() const;
/**
* Bind / Get the OpenGL texture
* Must be called in OpenGL context
* */
void Bind();
guint Texture() const;
void bind();
guint texture() const;
/**
* Get Image properties
* */
guint Width() const;
guint Height() const;
float AspectRatio() const;
guint width() const;
guint height() const;
float aspectRatio() const;
/**
* Accept visitors
@@ -216,37 +216,37 @@ private:
bool removeAllPlaySegmentOverlap(MediaSegment s);
std::list< std::pair<guint64, guint64> > getPlaySegments() const;
std::string id;
std::string uri;
guint textureindex;
guint width;
guint height;
guint par_width; // width to match pixel aspect ratio
GstClockTime position;
GstClockTime start_position;
GstClockTime duration;
GstClockTime frame_duration;
gdouble rate;
LoopMode loop;
TimeCounter timecount;
gdouble framerate;
GstState desired_state;
GstElement *pipeline;
GstDiscoverer *discoverer;
std::stringstream discoverer_message;
std::string codec_name;
GstVideoFrame v_frame;
GstVideoInfo v_frame_video_info;
std::atomic<bool> v_frame_is_full;
std::atomic<bool> need_loop;
std::string id_;
std::string uri_;
guint textureindex_;
guint width_;
guint height_;
guint par_width_; // width to match pixel aspect ratio
GstClockTime position_;
GstClockTime start_position_;
GstClockTime duration_;
GstClockTime frame_duration_;
gdouble rate_;
LoopMode loop_;
TimeCounter timecount_;
gdouble framerate_;
GstState desired_state_;
GstElement *pipeline_;
GstDiscoverer *discoverer_;
std::stringstream discoverer_message_;
std::string codec_name_;
GstVideoFrame v_frame_;
GstVideoInfo v_frame_video_info_;
std::atomic<bool> v_frame_is_full_;
std::atomic<bool> need_loop_;
MediaSegmentSet segments;
MediaSegmentSet::iterator current_segment;
MediaSegmentSet segments_;
MediaSegmentSet::iterator current_segment_;
bool ready;
bool seekable;
bool isimage;
bool interlaced;
bool ready_;
bool seekable_;
bool isimage_;
bool interlaced_;
void execute_open();
void execute_loop_command();
@@ -255,8 +255,8 @@ private:
static GstFlowReturn callback_pull_sample_video (GstElement *bin, MediaPlayer *m);
static void callback_end_of_video (GstElement *bin, MediaPlayer *m);
static void callback_discoverer_process (GstDiscoverer *discoverer, GstDiscovererInfo *info, GError *err, MediaPlayer *m);
static void callback_discoverer_finished(GstDiscoverer *discoverer, MediaPlayer *m);
static void callback_discoverer_process (GstDiscoverer *discoverer_, GstDiscovererInfo *info, GError *err, MediaPlayer *m);
static void callback_discoverer_finished(GstDiscoverer *discoverer_, MediaPlayer *m);
};