OpenShot Library | libopenshot  0.2.6
QtPlayer.cpp
Go to the documentation of this file.
1 /**
2  * @file
3  * @brief Source file for QtPlayer class
4  * @author Duzy Chan <code@duzy.info>
5  * @author Jonathan Thomas <jonathan@openshot.org>
6  *
7  * @ref License
8  */
9 
10 /* LICENSE
11  *
12  * Copyright (c) 2008-2019 OpenShot Studios, LLC
13  * <http://www.openshotstudios.com/>. This file is part of
14  * OpenShot Library (libopenshot), an open-source project dedicated to
15  * delivering high quality video editing and animation solutions to the
16  * world. For more information visit <http://www.openshot.org/>.
17  *
18  * OpenShot Library (libopenshot) is free software: you can redistribute it
19  * and/or modify it under the terms of the GNU Lesser General Public License
20  * as published by the Free Software Foundation, either version 3 of the
21  * License, or (at your option) any later version.
22  *
23  * OpenShot Library (libopenshot) is distributed in the hope that it will be
24  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26  * GNU Lesser General Public License for more details.
27  *
28  * You should have received a copy of the GNU Lesser General Public License
29  * along with OpenShot Library. If not, see <http://www.gnu.org/licenses/>.
30  */
31 
32 #include "Clip.h"
33 #include "FFmpegReader.h"
34 #include "Timeline.h"
35 #include "QtPlayer.h"
36 #include "Qt/PlayerPrivate.h"
37 #include "Qt/VideoRenderer.h"
38 
39 namespace openshot
40 {
41  // Delegating constructor
44  { }
45 
46  // Constructor
48  : PlayerBase()
49  , p(new openshot::PlayerPrivate(rb))
50  , threads_started(false)
51  {
52  reader = NULL;
53  }
54 
56  {
57  if (mode != PLAYBACK_STOPPED)
58  Stop();
59 
60  delete p;
61  }
62 
64  {
65  // Close audio device (only do this once, when all audio playback is finished)
67  }
68 
69  // Return any error string during initialization
70  std::string QtPlayer::GetError() {
71  if (reader && threads_started) {
72  // Get error from audio thread (if any)
73  return p->audioPlayback->getError();
74  } else {
75  return "";
76  }
77  }
78 
79  /// Get Audio Devices from JUCE
80  std::vector<openshot::AudioDeviceInfo> QtPlayer::GetAudioDeviceNames() {
81  if (reader && threads_started) {
82  return p->audioPlayback->getAudioDeviceNames();
83  } else {
84  return std::vector<openshot::AudioDeviceInfo>();
85  }
86  }
87 
88  void QtPlayer::SetSource(const std::string &source)
89  {
90  FFmpegReader *ffreader = new FFmpegReader(source);
91  ffreader->DisplayInfo();
92 
93  // Use default sample rate (or use the FFmpegReader's audio settings if any)
94  int sample_rate = 44100;
95  if (ffreader->info.sample_rate > 0)
96  sample_rate = ffreader->info.sample_rate;
97 
98  // Use default channels (or use the FFmpegReader's audio settings if any)
99  int channels = 2;
100  if (ffreader->info.channels > 0)
101  channels = ffreader->info.channels;
102 
103  // Use default channel layout (or use the FFmpegReader's audio settings if any)
105  if (channels != 2)
106  channel_layout = ffreader->info.channel_layout;
107 
108  // Create timeline instance (720p, since we have no re-scaling in this player yet)
109  reader = new Timeline(1280, 720, ffreader->info.fps, sample_rate, channels, channel_layout);
110  Clip *c = new Clip(source);
111 
112  Timeline* tm = (Timeline*)reader;
113  tm->AddClip(c);
114  tm->Open();
115 
116  // Set the reader
117  Reader(reader);
118  }
119 
121  {
122  // Set mode to playing, and speed to normal
124  Speed(1);
125 
126  if (reader && !threads_started) {
127  // Start thread only once
128  p->startPlayback();
129  threads_started = true;
130  }
131  }
132 
134  {
136  }
137 
138  /// Get the current mode
140  {
141  return mode;
142  }
143 
145  {
147  Speed(0);
148  }
149 
151  {
152  return p->video_position;
153  }
154 
155  void QtPlayer::Seek(int64_t new_frame)
156  {
157  // Check for seek
158  if (reader && threads_started && new_frame > 0) {
159  // Notify cache thread that seek has occurred
160  p->videoCache->Seek(new_frame);
161 
162  // Update current position
163  p->video_position = new_frame;
164 
165  // Clear last position (to force refresh)
166  p->last_video_position = 0;
167 
168  // Notify audio thread that seek has occurred
169  p->audioPlayback->Seek(new_frame);
170  }
171  }
172 
174  {
175  // Change mode to stopped
177 
178  // Notify threads of stopping
179  if (reader && threads_started) {
180  p->videoCache->Stop();
181  p->audioPlayback->Stop();
182 
183  // Kill all threads
184  p->stopPlayback();
185  }
186 
187  p->video_position = 0;
188  threads_started = false;
189  }
190 
191  // Set the reader object
193  {
194  // Set new reader. Note: Be sure to close and dispose of the old reader after calling this
195  reader = new_reader;
196  p->reader = new_reader;
197  p->videoCache->Reader(new_reader);
198  p->audioPlayback->Reader(new_reader);
199  }
200 
201  // Get the current reader, such as a FFmpegReader
203  return reader;
204  }
205 
206  // Set the QWidget pointer to display the video on (as a LONG pointer id)
207  void QtPlayer::SetQWidget(int64_t qwidget_address) {
208  // Update override QWidget address on the video renderer
209  p->renderer->OverrideWidget(qwidget_address);
210  }
211 
212  // Get the Renderer pointer address (for Python to cast back into a QObject)
214  return (int64_t)(VideoRenderer*)p->renderer;
215  }
216 
217  // Get the Playback speed
218  float QtPlayer::Speed() {
219  return speed;
220  }
221 
222  // Set the Playback speed multiplier (1.0 = normal speed, <1.0 = slower, >1.0 faster)
223  void QtPlayer::Speed(float new_speed) {
224  speed = new_speed;
225  p->speed = new_speed;
226  p->videoCache->setSpeed(new_speed);
227  if (p->reader->info.has_audio)
228  p->audioPlayback->setSpeed(new_speed);
229  }
230 
231  // Get the Volume
233  return volume;
234  }
235 
236  // Set the Volume multiplier (1.0 = normal volume, <1.0 = quieter, >1.0 louder)
237  void QtPlayer::Volume(float new_volume) {
238  volume = new_volume;
239  }
240 }
static AudioDeviceManagerSingleton * Instance()
Override with no channels and no preferred audio device.
void setSpeed(int new_speed)
Set Speed (The speed and direction to playback a reader (1=normal, 2=fast, 3=faster, -1=rewind, etc...)
float Speed()
Get the Playback speed.
Definition: QtPlayer.cpp:218
void CloseAudioDevice()
Close audio device.
void Loading()
Display a loading animation.
Definition: QtPlayer.cpp:133
This class is used to playback a video from a reader.
Definition: QtPlayer.h:47
Header file for QtPlayer class.
virtual void OverrideWidget(int64_t qwidget_address)=0
Allow manual override of the QWidget that is used to display.
Header file for Video Renderer class.
Header file for FFmpegReader class.
float Volume()
Get the Volume.
Definition: QtPlayer.cpp:232
QtPlayer()
Default constructor.
Definition: QtPlayer.cpp:42
Loading the video (display a loading animation)
Definition: PlayerBase.h:48
Stop playing the video (clear cache, done with player)
Definition: PlayerBase.h:49
openshot::ReaderBase * Reader()
Get the current reader, such as a FFmpegReader.
Definition: QtPlayer.cpp:202
This abstract class is the base class, used by all readers in libopenshot.
Definition: ReaderBase.h:97
Header file for Timeline class.
This is the base class of all Players in libopenshot.
Definition: PlayerBase.h:59
openshot::ReaderBase * reader
Definition: PlayerBase.h:64
bool has_audio
Determines if this file has an audio stream.
Definition: ReaderBase.h:63
This class uses the FFmpeg libraries, to open video files and audio files, and return openshot::Frame...
Definition: FFmpegReader.h:93
This class represents a clip (used to arrange readers on the timeline)
Definition: Clip.h:109
void Pause()
Pause the video.
Definition: QtPlayer.cpp:144
void SetSource(const std::string &source)
Set the source URL/path of this player (which will create an internal Reader)
Definition: QtPlayer.cpp:88
void Reader(ReaderBase *new_reader)
Set the current thread&#39;s reader.
void Stop()
Stop the audio playback.
Pause the video (holding the last displayed frame)
Definition: PlayerBase.h:47
Header file for Clip class.
Source file for PlayerPrivate class.
void AddClip(openshot::Clip *clip)
Add an openshot::Clip to the timeline.
Definition: Timeline.cpp:356
The private part of QtPlayer class, which contains an audio thread and video thread, and controls the video timing and audio synchronization code.
Definition: PlayerPrivate.h:48
openshot::ChannelLayout channel_layout
The channel layout (mono, stereo, 5 point surround, etc...)
Definition: ReaderBase.h:84
ChannelLayout
This enumeration determines the audio channel layout (such as stereo, mono, 5 point surround...
std::string GetError()
Get Error (if any)
Definition: QtPlayer.cpp:70
int64_t Position()
Get the current frame number being played.
Definition: QtPlayer.cpp:150
void SetQWidget(int64_t qwidget_address)
Definition: QtPlayer.cpp:207
std::vector< openshot::AudioDeviceInfo > GetAudioDeviceNames()
Get Audio Devices from JUCE.
Definition: QtPlayer.cpp:80
openshot::ReaderInfo info
Information about the current media file.
Definition: ReaderBase.h:111
void Play()
Play the video.
Definition: QtPlayer.cpp:120
void Seek(int64_t new_frame)
Seek to a specific frame in the player.
Definition: QtPlayer.cpp:155
This namespace is the default namespace for all code in the openshot library.
Definition: Compressor.h:46
void Open() override
Open the reader (and start consuming resources)
Definition: Timeline.cpp:759
openshot::PlaybackMode Mode()
Get the current mode.
Definition: QtPlayer.cpp:139
void Seek(int64_t new_position)
Seek the reader to a particular frame number.
void CloseAudioDevice()
Close audio device.
Definition: QtPlayer.cpp:63
int64_t GetRendererQObject()
Get the Renderer pointer address (for Python to cast back into a QObject)
Definition: QtPlayer.cpp:213
PlaybackMode
This enumeration determines the mode of the video player (i.e. playing, paused, etc...)
Definition: PlayerBase.h:44
This is the base class of all Renderers in libopenshot.
Definition: RendererBase.h:48
void DisplayInfo()
Display file information in the standard output stream (stdout)
Definition: ReaderBase.cpp:70
int channels
The number of audio channels used in the audio stream.
Definition: ReaderBase.h:83
void Stop()
Stop the video player and clear the cached frames.
Definition: QtPlayer.cpp:173
openshot::Fraction fps
Frames per second, as a fraction (i.e. 24/1 = 24 fps)
Definition: ReaderBase.h:70
Play the video normally.
Definition: PlayerBase.h:46
virtual ~QtPlayer()
Default destructor.
Definition: QtPlayer.cpp:55
int sample_rate
The number of audio samples per second (44100 is a common sample rate)
Definition: ReaderBase.h:82
PlaybackMode mode
Definition: PlayerBase.h:65
This class represents a timeline.
Definition: Timeline.h:168