diff --git a/FrameBuffer.cpp b/FrameBuffer.cpp new file mode 100644 index 0000000..71af317 --- /dev/null +++ b/FrameBuffer.cpp @@ -0,0 +1,6 @@ +#include "FrameBuffer.h" + +FrameBuffer::FrameBuffer() +{ + +} diff --git a/FrameBuffer.h b/FrameBuffer.h new file mode 100644 index 0000000..aa268ff --- /dev/null +++ b/FrameBuffer.h @@ -0,0 +1,11 @@ +#ifndef FRAMEBUFFER_H +#define FRAMEBUFFER_H + + +class FrameBuffer +{ +public: + FrameBuffer(); +}; + +#endif // FRAMEBUFFER_H \ No newline at end of file diff --git a/MediaPlayer.cpp b/MediaPlayer.cpp index 29bfa49..26fbfc7 100644 --- a/MediaPlayer.cpp +++ b/MediaPlayer.cpp @@ -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(par_width) / static_cast(height); + return static_cast(par_width_) / static_cast(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(duration); - GstClockTime target = Position() + static_cast(step); + double step = SIGN(rate_) * 0.01 * static_cast(duration_); + GstClockTime target = position() + static_cast(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 > MediaPlayer::getPlaySegments() const { std::list< std::pair > 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(frn) / static_cast(frd); - m->frame_duration = (GST_SECOND * static_cast(frd)) / (static_cast(frn)); + m->framerate_ = static_cast(frn) / static_cast(frd); + m->frame_duration_ = (GST_SECOND * static_cast(frd)) / (static_cast(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; } diff --git a/MediaPlayer.h b/MediaPlayer.h index 43e2c4e..30e6fc3 100644 --- a/MediaPlayer.h +++ b/MediaPlayer.h @@ -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 > 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 v_frame_is_full; - std::atomic 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 v_frame_is_full_; + std::atomic 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); };