def __init__(self):
super(Reproductor, self).__init__(parent=None)
self.setWindowTitle("Python Simple Player")
self.gridLayout = QtGui.QGridLayout(self)
loader = QtUiTools.QUiLoader()
# QtCore.QFile
file = QtCore.QFile("repro.ui")
file.open(QtCore.QFile.ReadOnly)
self.ui = loader.load(file, self)
file.close()
self.gridLayout.addWidget(self.ui, 0, 0, 1, 1)
# seccion multimedia
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.mediaObject = Phonon.MediaObject(self)
Phonon.createPath(self.mediaObject, self.audioOutput)
self.mediaObject.setTickInterval(1000)
#
self.ui.lcdAvance.display("00:00")
QtCore.QObject.connect(
self.ui.btnArchivo,
QtCore.SIGNAL("clicked()"),
self.openFile)
QtCore.QObject.connect(
self.ui.btnPlay,
QtCore.SIGNAL("clicked()"),
self.play)
self.mediaObject.tick.connect(self.alAvanzar)
self.mediaObject.stateChanged.connect(self.alCambiarEstado)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowFilePath('No file')
# the media object controls the playback
self.media = Phonon.MediaObject(self)
# the audio output does the actual sound playback
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, self)
# a slider to seek to any given position in the playback
self.seeker = Phonon.SeekSlider(self)
self.setCentralWidget(self.seeker)
# link media objects together. The seeker will seek in the created
# media object
self.seeker.setMediaObject(self.media)
# audio data from the media object goes to the audio output object
Phonon.createPath(self.media, self.audio_output)
# set up actions to control the playback
self.actions = self.addToolBar('Actions')
for name, label, icon_name in self.ACTIONS:
icon = self.style().standardIcon(icon_name)
action = QAction(icon, label, self)
action.setObjectName(name)
self.actions.addAction(action)
if name == 'open':
action.triggered.connect(self._ask_open_filename)
else:
action.triggered.connect(getattr(self.media, name))
# whenever the playback state changes, show a message to the user
self.media.stateChanged.connect(self._show_state_message)
def initializeAudioPhonon(self):
if self.DEBUG:
print "INFO: [Plugin:Orbit] Using Phonon Audio Framework"
self.initializeAudioFilePath()
self.media = Phonon.MediaObject()
#print dir(self.media)
audio = Phonon.AudioOutput(Phonon.MusicCategory)
Phonon.createPath(self.media, audio)
f = QtCore.QFile(self.audio_file)
if f.exists():
source = Phonon.MediaSource(self.audio_file)
if source.type() != -1: # -1 stands for invalid file
self.media.setCurrentSource(source)
self.media.play()
else:
if self.DEBUG:
print "ERROR: [Plugin:Orbit] Audio control file invalid:",
print self.audio_file
else:
if self.DEBUG:
print "ERROR: [Plugin:Orbit] Audio control file does not exist:,"
print self.audio_file
def play_sound(self, alias):
""" Plays a sound
CHECK
When exporting sound over HDMI, the first time the first sound is
played, the beginning of it gets cut off.
It might be worth including a 1 millisecond silent .wave and playing
it with the volume turned to 0 on app load (init_sound() or some
such), to ensure the sound system has been initialized. Or something.
This doesn't seem to happen when the sound is local.
Arguments:
alias (str): The name of a sound file alias as specified in a .qrc
file, eg "mysound.wav"
"""
speakers = Phonon.AudioOutput(Phonon.MusicCategory, self)
media = Phonon.MediaObject(self)
speakers.setVolume(0.5)
Phonon.createPath(media, speakers)
media.setCurrentSource( ":/{}".format(alias) )
### If we let the media file play all the way through, we get a nasty
### static squelch at the end. Set it to stop playing 30 milliseconds
### before the end.
media.setPrefinishMark(30)
media.prefinishMarkReached.connect( media.stop )
media.play()
def init(self, prefinishMark):
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self.app)
self.player = Phonon.MediaObject(self.app)
self.player.setPrefinishMark(prefinishMark)
self.player.setTickInterval(1000)
Phonon.createPath(self.player, self.audioOutput)
self._bindEvents()
def __init__(self):
super(Tramendo, self).__init__()
# Menu
self.trayIconMenu = QMenu(self)
# Build media player
self.audioOuptut = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.player = Phonon.MediaObject(self)
Phonon.createPath(self.player, self.audioOuptut)
# Jamendo Actions
self.jamendo = JamendoRadio()
self.radioActions = QActionGroup(self)
self.radioActions.setExclusive(True)
self.radioActions.triggered.connect(self.play_stream_event)
radio_stations = self.jamendo.get_radio_list()
for radio in radio_stations:
action = QAction(radio["dispname"], self)
action.setCheckable(True)
action.setData(radio["id"])
self.radioActions.addAction(action)
self.trayIconMenu.addAction(action)
# Exit Action
self.quitAction = QAction("&Exit", self)
self.quitAction.triggered.connect(self.exit_event)
self.trayIconMenu.addAction(self.quitAction)
# Icon setting
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
self.trayIcon.setIcon(QApplication.style().standardIcon(QStyle.SP_MediaPlay))
self.trayIcon.show()
def initializeAudioPhonon(self): if self.DEBUG: print "INFO: [Plugin:Orbit] Using Phonon Audio Framework" self.initializeAudioFilePath() self.media = Phonon.MediaObject() #print dir(self.media) audio = Phonon.AudioOutput(Phonon.MusicCategory) Phonon.createPath(self.media, audio) f = QtCore.QFile(self.audio_file) if f.exists(): source = Phonon.MediaSource(self.audio_file) if source.type() != -1: # -1 stands for invalid file self.media.setCurrentSource(source) self.media.play() else: if self.DEBUG: print "ERROR: [Plugin:Orbit] Audio control file invalid:", print self.audio_file else: if self.DEBUG: print "ERROR: [Plugin:Orbit] Audio control file does not exist:," print self.audio_file
def __init__(self, parent=None):
super(Movie, self).__init__(parent)
self.audioOutput = Phonon.AudioOutput(Phonon.VideoCategory)
self.mediaObject = Phonon.MediaObject(self)
self.mediaObject.setTickInterval(1)
Phonon.createPath(self.mediaObject, self)
Phonon.createPath(self.mediaObject, self.audioOutput)
self.overlay = DrawWidge(self)
self.overlay.resize(self.width(), self.height())
self.overlay.hide()
self.overlay_showing = False
self.image = DrawWidge(self)
self.image.resize(self.width(), self.height())
self.image.hide()
self.image_showing = False
self.fulled = False
self.subtitler = SubtitleWidge(self)
self.subtitler.resize(self.width(), self.height())
self.subtitler.hide()
self.subtitler_showing = False
self.save_timer = SaveCloser()
self.save_timer.start()
self.setupActions()
def go(self, what2do, folder):
'''This function is called from javascript when clicking
the tracks, info or play all buttons'''
print('what 2 to',str(what2do))
what2do = str(what2do)
# stop playback when exiting the page
self.eval_js(self.doc,
'''window.addEventListener("unload", setup_files.stop, false);''')
if what2do == 'play_all':
tracks, folder_wrapper = self.get_folder_tracks(folder)
self.curtrack = 0
self.playlist = tracks
self.cur_folder = folder_wrapper
self.create_player()
self.create_buttons_events()
self.media_object = Phonon.MediaObject(self)
self.audio = Phonon.AudioOutput(Phonon.MusicCategory)
self.media_object.setTickInterval(1000)
self.media_object.tick.connect(self.draw_time)
self.media_object.stateChanged.connect(self.stateChanged)
self.media_object.finished.connect(self.next)
Phonon.createPath(self.media_object, self.audio)
if what2do == 'show_info':
self.show_hide_info(folder,'div.info')
if what2do == 'show_tracks':
self.show_hide_info(folder,'div.files_table_wrapper')
def __init__(self, url=None, parent=None):
QWidget.__init__(self)
self.setWindowTitle('Audio Player')
# 再生ファイル
self.url = url
# Phonon Objects
# ***************
self.media = Phonon.MediaObject(self)
self.audio = Phonon.AudioOutput(Phonon.VideoCategory, self)
Phonon.createPath(self.media, self.audio)
# Set SOURCE
source = Phonon.MediaSource(self.url)
self.media.setCurrentSource(source)
# Timer
# *****
self.media.setTickInterval(1 / 30 * 1000) # [ms]
self.media.tick.connect(self.tock)
self.time = 0
# UI 生成
# ***************
self.setupUI()
def __init__(self,parent=None):
QtGui.QWidget.__init__(self,parent)
self.ui=Ui_toolBoxWidget()
self.ui.setupUi(self)
# volumeSlider_bombMusic
self.media = Phonon.MediaObject(self)
self.media.setCurrentSource(Phonon.MediaSource())
self.media.setTickInterval(10)
self.output = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(self.media, self.output)
self.ui.volumeSlider_music.setAudioOutput(self.output)
self.ui.seekSlider_musicProgress.setMediaObject(self.media)
self.ui.lcdNumber.display("00:00")
self.media.stateChanged.connect(self.stateChanged)
self.media.tick.connect(self.tick)
self.ui.pushButton_musicPlay.clicked.connect(self.changePlayPause)
self.ui.pushButton_musicStop.clicked.connect(self.changeStop)
self.ui.timeEdit_music.timeChanged.connect(self.timeEditTimeChanged)
self.path = None
self.signal = FileChoosedSignal()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowFilePath('No file')
# the media object controls the playback
self.media = Phonon.MediaObject(self)
# the audio output does the actual sound playback
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, self)
# a slider to seek to any given position in the playback
self.seeker = Phonon.SeekSlider(self)
self.setCentralWidget(self.seeker)
# link media objects together. The seeker will seek in the created
# media object
self.seeker.setMediaObject(self.media)
# audio data from the media object goes to the audio output object
Phonon.createPath(self.media, self.audio_output)
# set up actions to control the playback
self.actions = self.addToolBar('Actions')
for name, label, icon_name in self.ACTIONS:
icon = self.style().standardIcon(icon_name)
action = QAction(icon, label, self)
action.setObjectName(name)
self.actions.addAction(action)
if name == 'open':
action.triggered.connect(self._ask_open_filename)
else:
action.triggered.connect(getattr(self.media, name))
# whenever the playback state changes, show a message to the user
self.media.stateChanged.connect(self._show_state_message)
def setupUI(self):
"""UI生成シーケンス.
可視性を高めるため別に記述
"""
# Ctrl UI
self.btn_start = QPushButton('PLAY', self)
self.volume_slider = Phonon.VolumeSlider(self)
self.volume_slider.setAudioOutput(self.audio)
self.seek_slider = Phonon.SeekSlider(self.media, self)
self.seek_slider.setSingleStep(1 / 30 * 1000) # [ms]
# Status Label
self.status_label = QLabel("00:00:00", self)
self.status_label.setAlignment(Qt.AlignRight | Qt.AlignCenter)
# Layout
layout = QGridLayout(self)
# 一段目
layout.addWidget(self.btn_start, 0, 0)
layout.addWidget(self.volume_slider, 0, 1)
layout.addWidget(self.status_label, 0, 2)
# 二段目
layout.addWidget(self.seek_slider, 1, 0, 1, 3)
# Signal
self.media.stateChanged.connect(self._handle_StateChanged)
self.media.aboutToFinish.connect(self.restart)
self.btn_start.clicked.connect(self._handle_BtnStart)
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.mediaObject = Phonon.MediaObject(self)
self.metaInformationResolver = Phonon.MediaObject(self)
self.mediaObject.setTickInterval(1000)
self.connect(self.mediaObject, QtCore.SIGNAL('tick(qint64)'),
self.tick)
self.connect(self.mediaObject,
QtCore.SIGNAL('stateChanged(Phonon::State, Phonon::State)'),
self.stateChanged)
self.connect(self.metaInformationResolver,
QtCore.SIGNAL('stateChanged(Phonon::State, Phonon::State)'),
self.metaStateChanged)
self.connect(self.mediaObject,
QtCore.SIGNAL('currentSourceChanged(Phonon::MediaSource)'),
self.sourceChanged)
self.connect(self.mediaObject, QtCore.SIGNAL('aboutToFinish()'),
self.aboutToFinish)
Phonon.createPath(self.mediaObject, self.audioOutput)
self.setupActions()
self.setupMenus()
self.setupUi()
self.timeLcd.display("00:00")
self.sources = []
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.mediaObject = Phonon.MediaObject(self)
self.metaInformationResolver = Phonon.MediaObject(self)
self.mediaObject.setTickInterval(1000)
self.connect(self.mediaObject, QtCore.SIGNAL('tick(qint64)'),
self.tick)
self.connect(
self.mediaObject,
QtCore.SIGNAL('stateChanged(Phonon::State, Phonon::State)'),
self.stateChanged)
self.connect(
self.metaInformationResolver,
QtCore.SIGNAL('stateChanged(Phonon::State, Phonon::State)'),
self.metaStateChanged)
self.connect(
self.mediaObject,
QtCore.SIGNAL('currentSourceChanged(Phonon::MediaSource)'),
self.sourceChanged)
self.connect(self.mediaObject, QtCore.SIGNAL('aboutToFinish()'),
self.aboutToFinish)
Phonon.createPath(self.mediaObject, self.audioOutput)
self.setupActions()
self.setupMenus()
self.setupUi()
self.timeLcd.display("00:00")
self.sources = []
def setupUi(self):
bar = QtGui.QToolBar()
bar.addAction(self.playAction)
bar.addAction(self.pauseAction)
bar.addAction(self.stopAction)
self.seekSlider = Phonon.SeekSlider(self)
self.seekSlider.setMediaObject(self.mediaObject)
self.volumeSlider = Phonon.VolumeSlider(self)
self.volumeSlider.setAudioOutput(self.audioOutput)
self.volumeSlider.setSizePolicy(QtGui.QSizePolicy.Maximum,
QtGui.QSizePolicy.Maximum)
volumeLabel = QtGui.QLabel()
volumeLabel.setPixmap(QtGui.QPixmap('images/volume.png'))
palette = QtGui.QPalette()
palette.setBrush(QtGui.QPalette.Light, QtCore.Qt.darkGray)
self.timeLcd = QtGui.QLCDNumber()
self.timeLcd.setPalette(palette)
headers = [
self.tr("Title"),
self.tr("Artist"),
self.tr("Album"),
self.tr("Year")
]
self.musicTable = QtGui.QTableWidget(0, 4)
self.musicTable.setHorizontalHeaderLabels(headers)
self.musicTable.setSelectionMode(
QtGui.QAbstractItemView.SingleSelection)
self.musicTable.setSelectionBehavior(
QtGui.QAbstractItemView.SelectRows)
self.connect(self.musicTable, QtCore.SIGNAL('cellPressed(int, int)'),
self.tableClicked)
seekerLayout = QtGui.QHBoxLayout()
seekerLayout.addWidget(self.seekSlider)
seekerLayout.addWidget(self.timeLcd)
playbackLayout = QtGui.QHBoxLayout()
playbackLayout.addWidget(bar)
playbackLayout.addStretch()
playbackLayout.addWidget(volumeLabel)
playbackLayout.addWidget(self.volumeSlider)
mainLayout = QtGui.QVBoxLayout()
mainLayout.addWidget(self.musicTable)
mainLayout.addLayout(seekerLayout)
mainLayout.addLayout(playbackLayout)
widget = QtGui.QWidget()
widget.setLayout(mainLayout)
self.setCentralWidget(widget)
self.setWindowTitle("Phonon Music Player")
def getMusicTime(self):
from PySide.phonon import Phonon
self.media2 = Phonon.MediaObject(self)
self.media2.setCurrentSource(Phonon.MediaSource())
self.media2.setCurrentSource(Phonon.MediaSource(self.path))
output = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(self.media2, output)
self.media2.stateChanged.connect(self.stateChanged2)
def setup(self, parent):
self.media = Phonon.MediaObject(parent)
videoWidget = Phonon.VideoWidget(parent)
Phonon.createPath(self.media, videoWidget)
self.layout().addWidget(videoWidget)
self.seekSlider = Phonon.SeekSlider(self.media, parent)
self.layout().addWidget(self.seekSlider)
self.seekSlider.setIconVisible(False)
self.media.finished.connect(self.mediaFinished)
def play_sound_helper(self, sound_file, sound_loop, sound_loop_times):
self.media = Phonon.createPlayer(Phonon.MusicCategory,
Phonon.MediaSource(sound_file))
if sound_loop_times > 0 and sound_loop:
for i in range(sound_loop_times):
self.media.enqueue(Phonon.MediaSource(sound_file))
self.media.play()
def __init__(self): self.backend = 'Phonon' QtCore.QObject.__init__(self) self.audioOuptut = Phonon.AudioOutput(Phonon.MusicCategory, self) self.player = Phonon.MediaObject(self) Phonon.createPath(self.player, self.audioOuptut) self.connectedWidgets = [] self.player.aboutToFinish.connect(self.onPlaybackEnded)
def __init__(self, setup=False, **kwargs):
QMainWindow.__init__(self)
self.setWindowTitle('...')
# time to syncronize plot and media object
self.tShift = 0
self.t = 0
self.mpl = {}
self.ca_widget_handle = []
self.ca_bar_handle = []
# bools to know if the timer is to be activated
# refresh timer
self.refresh = 15 # ms
self.timer = QtCore.QTimer()
self.timer.setInterval(self.refresh)
self.lcd = QtGui.QLCDNumber(self)
self.lcd.setDigitCount(5)
self.lcd.display("{:+05.1f}".format(self.t))
# phonon
# the media object controls the playback
self.media = Phonon.MediaObject(self)
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.seeker = Phonon.SeekSlider(self)
self.seeker.setFixedHeight(35)
self.seeker.setMediaObject(self.media)
self.media.setTickInterval(20)
# audio data from the media object goes to the audio output object
Phonon.createPath(self.media, self.audio_output)
# set up actions to control the playback
ACTIONS = [
('play', 'Play', QStyle.SP_MediaPlay),
('pause', 'Pause', QStyle.SP_MediaPause),
('stop', 'Stop', QStyle.SP_MediaStop)]
self.actions = self.addToolBar('Actions')
for name, label, icon_name in ACTIONS:
icon = self.style().standardIcon(icon_name)
action = QtGui.QAction(icon, label, self, )
action.setObjectName(name)
self.actions.addAction(action)
action.triggered.connect(getattr(self.media, name))
self.actions.addSeparator()
# show help
helpAction = QtGui.QAction('&Help', self)
helpAction.setObjectName(name)
self.actions.addAction(helpAction)
helpAction.triggered.connect(self.show_help)
# layout
self.vBox = QtGui.QVBoxLayout()
hBox = QtGui.QHBoxLayout()
hBox.addWidget(self.lcd)
hBox.addWidget(self.seeker)
self.vBox.addLayout(hBox)
# finish setup
if setup:
self.setup(**kwargs)
def __init__(self,audio=True,vibra=True):
_d = NotifierDebug();
self._d = _d.d;
self.manager = MNotificationManager('wazappnotify','WazappNotify');
self.vibra = vibra
self.personalRingtone = WAConstants.DEFAULT_SOUND_NOTIFICATION;
self.personalVibrate = True;
self.groupRingtone = WAConstants.DEFAULT_SOUND_NOTIFICATION;
self.groupVibrate = True;
QCoreApplication.setApplicationName("Wazapp");
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, None)
self.mediaObject = Phonon.MediaObject(None)
Phonon.createPath(self.mediaObject, self.audioOutput)
self.profileChanged(0, 0, self.getCurrentProfile(), 0)
bus = dbus.SessionBus()
mybus = bus.get_object('com.nokia.profiled', '/com/nokia/profiled')
self.nface = dbus.Interface(mybus, 'com.nokia.profiled')
self.nface.connect_to_signal("profile_changed", self.profileChanged)
#prof = self.getCurrentProfile()
#reply = self.nface.get_value(prof,"ringing.alert.volume");
#self.currentProfile = prof
#self.currentVolume = "1.0" if reply=="100" else "0." + reply
#self._d("Checking current profile: " + prof + " - Volume: " + self.currentVolume)
#self.audioOutput.setVolume(float(self.currentVolume))
#self.newMessageSound = WAConstants.DEFAULT_SOUND_NOTIFICATION #fetch from settings
self.devInfo = QSystemDeviceInfo();
#self.devInfo.currentProfileChanged.connect(self.profileChanged);
self.audio = True
'''if audio:
self.audio = QMediaPlayer(None,QMediaPlayer.LowLatency);
self.audio.setVolume(100);
else:
self.audio = False'''
self.enabled = True
self.notifications = {}
# vibration comes too early here, now handled by ui.py when the message is already added in QML
# well, the truth is that sound comes too late... :D
#>> Any notification should be handler by the notifier, not UI :P I don't feel it's too early though,
# but if necessary connect to a signal and vibrate from here.
if self.vibra:
self.vibra = QFeedbackHapticsEffect();
self.vibra.setIntensity(1.0);
self.vibra.setDuration(200);
def get_widget_player(file_path, audio):
media_src = Phonon.MediaSource(file_path)
media_obj = Phonon.MediaObject()
media_obj.setCurrentSource(media_src)
video_widget = Phonon.VideoWidget()
Phonon.createPath(media_obj, video_widget)
if audio:
audio_out = Phonon.AudioOutput(Phonon.VideoCategory)
Phonon.createPath(media_obj, audio_out)
return media_obj, video_widget
def __init__(self, window):
"""
Creates a new AudioService
:param window:
QObject of the story ui
"""
self.media_object = Phonon.MediaObject(window)
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, window)
Phonon.createPath(self.media_object, self.audio_output)
self.filename_list = []
def __init__(self, window):
"""
Creates a new AudioService
:param window:
QObject of the story ui
"""
self.media_object = Phonon.MediaObject(window)
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, window)
Phonon.createPath(self.media_object, self.audio_output)
self.filename_list = []
def init_video(main_window):
file_path = Utilities.OUTPUT_FOLDER + Utilities.CAMERA_FILE
media_src = Phonon.MediaSource(file_path)
main_window.media_obj = Phonon.MediaObject(main_window.wdgVideo)
main_window.media_obj.setCurrentSource(media_src)
main_window.video_widget = Phonon.VideoWidget(main_window.wdgVideo)
Phonon.createPath(main_window.media_obj, main_window.video_widget)
main_window.video_widget.setGeometry(main_window.wdgVideo.geometry())
main_window.video_widget.show()
main_window.media_obj.play()
main_window.media_obj.pause()
def play(self, filepath):
global video_widget
media_source = Phonon.MediaSource(filepath)
media_obj = Phonon.MediaObject()
media_obj.setCurrentSource(media_source)
video_widget = Phonon.VideoWidget()
Phonon.createPath(media_obj, video_widget)
audio_out = Phonon.AudioOutput(Phonon.VideoCategory)
Phonon.createPath(media_obj, audio_out)
video_widget.show()
media_obj.play()
def delayedInit(self):
"""
from http://techbase.kde.org/Development/Tutorials/Phonon/Introduction/Python
"""
if not self.m_media:
self.m_media = Phonon.MediaObject(self)
audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(self.m_media, audioOutput)
self.m_media.setCurrentSource(
Phonon.MediaSource(\
self.separateInstance.files['inputAudioFilename']))
self.m_media.prefinishMarkReached.connect(self.playStop)
def __init__(self):
Home.server = requests.session()
self.output = Phonon.AudioOutput(Phonon.MusicCategory)
self.m_media = Phonon.MediaObject()
Phonon.createPath(self.m_media, self.output)
QObject.connect(self.m_media, SIGNAL('finished()'),
self.enqueueNextSource)
self.home = HomeView()
self.home.showNormal()
self.home.setWindowTitle(u'customers caller app')
self.home.label.setText(u"غير متصل")
self.WS_OPEN()
def delayedInit(self):
"""
from http://techbase.kde.org/Development/Tutorials/Phonon/Introduction/Python
"""
if not self.m_media:
self.m_media = Phonon.MediaObject(self)
audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(self.m_media, audioOutput)
self.m_media.setCurrentSource(
Phonon.MediaSource(\
self.separateInstance.files['inputAudioFilename']))
self.m_media.prefinishMarkReached.connect(self.playStop)
def __init__(self, parent = None ): super(Botonera, self).__init__(parent) self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, self) self.media_obj = Phonon.MediaObject(self) self.setObjectName( 'Botonera' ) self.grid = flowlayout.FlowLayout() self.fillUi( PYFILEDIR + '/sounds' ) self.setupUi(self) wid = QtGui.QWidget() wid.setLayout( self.grid ) self.buttons_lay.addWidget( wid ) QtCore.QObject.connect( self.actionOpen_Folder, QtCore.SIGNAL( "triggered()" ), self.openFolder )
def __init__(self, parent, mediaFiles):
"""
@type parent: QtGui.QWidget
@type mediaFiles: gui.media.MediaFiles
"""
self.mediaObject = Phonon.MediaObject(parent)
self.audioOutput = Phonon.AudioOutput(Phonon.NotificationCategory, parent)
Phonon.createPath(self.mediaObject, self.audioOutput)
self._sounds = {
JobStatus.FAILING: Phonon.MediaSource(mediaFiles.failing_sound_path()),
JobStatus.OK: Phonon.MediaSource(mediaFiles.ok_sound_path()),
}
def __init__(self):
super(MainWindow, self).__init__()
self.media = Phonon.MediaObject(self)
self.audio = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.video = Phonon.VideoWidget(self)
self.metaInformationResolver = Phonon.MediaObject(self)
Phonon.createPath(self.media, self.audio)
Phonon.createPath(self.media, self.video)
self.media.setTickInterval(1000)
self.sources = []
self.setupActions()
self.setupConnections()
self.setupUi()
self.setWindowTitle("BLue PLayer")
self.setMinimumSize(245,245)
self.resize(680,400)
def setUp(self):
super(TestSimplePlaying, self).setUp()
self.app.setApplicationName('Dummy')
self.source = Phonon.MediaSource(sample_file)
self.media = Phonon.MediaObject()
self.media.setCurrentSource(self.source)
self.media.finished.connect(self.app.quit)
self.called = False
# prevent locking with:
# request to play a stream, but no valid audio ...
self.output = Phonon.AudioOutput()
self.path = Phonon.createPath(self.media, self.output)
def open(self):
dialog = QFileDialog()
dialog.setViewMode(QFileDialog.Detail)
filename = dialog.getOpenFileName(self, 'Open audio file', '/home',
"Audio Files (*.mp3 *.wav *.ogg)")[0]
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(self.media_obj, self.audio_output)
self.media_obj.setCurrentSource(Phonon.MediaSource(filename))
self.media_obj.tick.connect(self.time_change)
self.media_obj.totalTimeChanged.connect(self.total_time_change)
self.media_obj.play()
self.button.setEnabled(True)
self.button.setText("Pause")
self.horizontalSlider.setEnabled(True)
def create_media_object(self): """ Creates an instance of Phonon for playing songs in the parent application. PhononInstance.create_media_object() -> Phonon.MediaObject """ self._media_object = Phonon.MediaObject(self.parent) self._media_object.setTickInterval(1000) # Set the tick time to 1 sec self._media_object.tick.connect(self.on_tick) self._media_object.prefinishMarkReached.connect(self.halfway_reached) self.audio_output = Phonon.AudioOutput( Phonon.MusicCategory, self.parent) Phonon.createPath(self._media_object, self.audio_output) return self._media_object
def create_media_object(self):
""" Creates an instance of Phonon for playing songs in the parent
application.
PhononInstance.create_media_object() -> Phonon.MediaObject
"""
self._media_object = Phonon.MediaObject(self.parent)
self._media_object.setTickInterval(1000) # Set the tick time to 1 sec
self._media_object.tick.connect(self.on_tick)
self._media_object.prefinishMarkReached.connect(self.halfway_reached)
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory,
self.parent)
Phonon.createPath(self._media_object, self.audio_output)
return self._media_object
def open_file(self):
dialog = QFileDialog()
dialog.setViewMode(QFileDialog.Detail)
self.filename = dialog.getOpenFileName(self,
'Open audio file', '/home',
"Audio Files (*.mp3 *.wav *.ogg)")[0]
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(self.media_obj, self.audio_output)
self.media_obj.setCurrentSource(Phonon.MediaSource(self.filename))
self.media_obj.tick.connect(self._time_change)
self.media_obj.totalTimeChanged.connect(self._total_time_change)
self.media_obj.play()
self.playButton.setText("Pause")
self.seeker.setEnabled(True)
self.playing = True
def play(file_name):
audio.setCurrentSource(Phonon.MediaSource(file_name))
audio.play()
loop = QEventLoop()
audio.finished.connect(loop.quit)
loop.exec_()
def set_source(self, file_path):
""" Creates a media source object from the filepath provided.
Args:
file_path (str): The file path of the media object.
"""
self.media_source_obj = Phonon.MediaSource(file_path)
def set_url(self, url):
"""外部から再生ファイルをセット.
ファイルがセットされると状態遷移しStateChangedがコールされる"""
self.url = url
assert os.path.exists(url)
self.media.setCurrentSource(Phonon.MediaSource(url))
def test_phonon():
from PySide.phonon import Phonon
a = app()
# http://qt-project.org/doc/qt-4.8/phonon-overview.html#audio
url = "z:/Users/jichi/tmp/test.mp3"
print os.path.exists(url)
mo = Phonon.MediaObject()
audioOutput = Phonon.AudioOutput(Phonon.MusicCategory)
path = Phonon.createPath(mo, audioOutput)
#mo.setCurrentSource(Phonon.MediaSource(url))
mo.setCurrentSource(url)
print mo.play()
a.exec_()
class Snorter():
transform = lambda aList: list(map(lambda x: Phonon.MediaSource(x), aList))
MEDIA_FILES = transform(
['./pig1.mp3', './pig2.mp3', './pig3.mp3', './pig4.mp3'])
PANIC_MEDIA_FILES = transform([
'./pig1_panic.mp3', './pig2_panic.mp3', './pig3_panic.mp3',
'./pig4_panic.mp3', './pig5_panic.mp3'
])
def __init__(self, pig):
audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, pig)
self.mediaObject = Phonon.MediaObject(pig)
Phonon.createPath(self.mediaObject, audioOutput)
self.calmDown()
def snort(self):
if self.mediaObject.state() == Phonon.StoppedState:
random.shuffle(self.mediaFiles)
self.mediaObject.enqueue(self.mediaFiles[0])
self.mediaObject.play()
def panic(self):
self.mediaFiles = self.PANIC_MEDIA_FILES
def calmDown(self):
self.mediaFiles = self.MEDIA_FILES
def loadFile(self, path):
"""
Prepares and sets MediaPlayer source.
:param path: path to source
:type path: str
"""
if path is None:
logger.error("Video source is 'None'")
self.errorOccurred.emit()
QMessageBox(QMessageBox.Critical, self.error_title,
self.loading_error).exec_()
return
self.source = path
mediaSource = Phonon.MediaSource(self.source)
if mediaSource.type() != Phonon.MediaSource.LocalFile:
logger.error("Video source '%s' could not be loaded" % path)
self.errorOccurred.emit()
QMessageBox(QMessageBox.Critical, self.error_title,
self.source_error).exec_()
return
self.setCurrentSource(mediaSource) # create the media
self.validMedia = True
logger.debug("Video source was loaded")
def _ask_open_filename(self):
# ask the user for a filename
filename, _ = QFileDialog.getOpenFileName(
self, 'Open audio file ...', '',
'Audio Files (*.mp3 *.ogg *.wav);;All files (*)')
if filename:
# load (but don't play!) the file
self.media.setCurrentSource(Phonon.MediaSource(filename))
def play_sound_helper(self, sound_file, sound_loop, sound_loop_times):
self.media = Phonon.createPlayer(Phonon.MusicCategory, Phonon.MediaSource(sound_file))
if sound_loop_times > 0 and sound_loop:
for i in range(sound_loop_times):
self.media.enqueue(Phonon.MediaSource(sound_file))
self.media.play()
def __init__(self):
super(MusicWidget, self).__init__()
self.songs = []
self.mediaObject = Phonon.MediaObject(self)
self.mediaObject.finished.connect(self.onFinished)
self.mediaObject.tick.connect(self.onTick)
self.mediaObject.totalTimeChanged.connect(self.onTotalTimeChanged)
self.output = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.output.setVolume(50)
self.path = Phonon.createPath(self.mediaObject, self.output)
self.setWindowTitle("Media Player")
self.setObjectName("musicWidget")
self.setStyleSheet("#musicWidget { background-color: white; }")
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.started = False
self.prevSong = None
self.rightWidget = QtGui.QWidget()
self.rightLayout = QtGui.QVBoxLayout(self)
self.groupbox = SongPlayingGroup("Your Songs:")
self.rightLayout.addWidget(self.groupbox)
self.rightGroup = URLDownloadingGroup(self)
self.rightGroup.songAdded.connect(self.groupbox.onSongAdded)
self.groupbox.playing.connect(self.onPlaying)
mediaLayout = QtGui.QVBoxLayout()
self.slider = Phonon.SeekSlider()
self.slider.setMediaObject(self.mediaObject)
self.sliderPressed = False
buttonLayout = QtGui.QHBoxLayout()
self.backButton = QtGui.QPushButton()
self.backButton.setIcon(QtGui.QIcon(os.path.join(os.path.dirname(__file__), "images", "back.png")))
self.backButton.setObjectName("backButton")
self.backButton.setStyleSheet(style.multimediaButton("backButton"))
self.backButton.setFont(StandardFont())
self.backButton.clicked.connect(self.backTriggered)
self.playing = False
self.playButton = QtGui.QPushButton()
self.playButton.setIcon(QtGui.QIcon(os.path.join(os.path.dirname(__file__), "images", "play.png")))
self.playButton.setObjectName("playButton")
self.playButton.setStyleSheet(style.multimediaButton("playButton"))
self.playButton.setFont(StandardFont())
self.playButton.clicked.connect(self.playTriggered)
self.forwardButton = QtGui.QPushButton()
self.forwardButton.setIcon(QtGui.QIcon(os.path.join(os.path.dirname(__file__), "images", "forward.png")))
self.forwardButton.setObjectName("forwardButton")
self.forwardButton.setStyleSheet(style.multimediaButton("forwardButton"))
self.forwardButton.setFont(StandardFont())
self.forwardButton.clicked.connect(self.forwardTriggered)
self.timeLabel = QtGui.QLabel("--:--/--:--")
self.timeLabel.setFont(StandardFont())
buttonLayout.addWidget(self.backButton)
buttonLayout.addWidget(self.playButton)
buttonLayout.addWidget(self.forwardButton)
buttonLayout.addStretch(1)
buttonLayout.addWidget(self.timeLabel)
mediaLayout.addWidget(self.slider)
mediaLayout.addLayout(buttonLayout)
self.rightLayout.addLayout(mediaLayout)
self.rightLayout.addLayout(self.rightGroup)
def get_widget_player(file_path, audio):
media_src = Phonon.MediaSource(file_path)
media_obj = Phonon.MediaObject()
media_obj.setCurrentSource(media_src)
video_widget = Phonon.VideoWidget()
Phonon.createPath(media_obj, video_widget)
if audio:
audio_out = Phonon.AudioOutput(Phonon.VideoCategory)
Phonon.createPath(media_obj, audio_out)
return media_obj, video_widget
def __init__(self,
parent=None,
data=None,
data_fs=None,
sample_freq=None,
bd='float32',
tick_interval=200):
if bd not in bit_depths.values():
raise ValueError('Unsupported bit depth: %s' % bd)
if tick_interval < 1:
raise ValueError('tick_interval must be greater than zero.')
super(PlayerToolBar, self).__init__(parent)
self._audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
self._mediaObject = Phonon.MediaObject(self)
self._mediaObject.setTickInterval(tick_interval)
self._mediaObject.aboutToFinish.connect(self.about_to_finish)
self._mediaObject.finished.connect(self.finished)
self._mediaObject.currentSourceChanged.connect(
self.current_source_changed)
self._mediaObject.tick.connect(self.on_tick)
self._mediaObject.stateChanged.connect(self.state_changed)
self.connected = False
self.connect_path()
self._buffer = QtCore.QBuffer()
self.buffer_loaded = False
self._start = 0
self._end = np.inf
self._interval_selected = False
self._raw_data = None
self.bd = bd
if sample_freq is not None:
self.sample_freq = float(sample_freq)
else:
self.sample_freq = None
self._real_freq = None
if data is not None:
self.load_data(data, data_fs)
else:
self.data = None
self._data_fs = None
self.data_loaded = False
self._init_ui()
def __init__(self, url=None, parent=None):
QWidget.__init__(self)
self.setWindowTitle('Video Player')
# 再生ファイル
self.url = url
# Phonon Objects
# ***************
self.media = Phonon.MediaObject(self)
self.video = Phonon.VideoWidget(self)
# self.video.setMinimumSize(180, 280)
self.audio = Phonon.AudioOutput(Phonon.VideoCategory, self)
Phonon.createPath(self.media, self.audio)
Phonon.createPath(self.media, self.video)
# Timer
# *****
self.media.setTickInterval(1 / 30 * 1000) # [ms]
self.media.tick.connect(self.tock)
self.time = 0
# UI 生成
# ***************
self.setupUI()
def updateWidgets(self):
# Output devices.
devices = Phonon.BackendCapabilities.availableAudioOutputDevices()
model = Phonon.AudioOutputDeviceModel(devices)
self.devicesListView.setModel(model)
# MIME types.
self.mimeListWidget.clear()
for mimeType in Phonon.BackendCapabilities.availableMimeTypes():
item = QtGui.QListWidgetItem(self.mimeListWidget)
item.setText(mimeType)
# Effects.
self.effectsTreeWidget.clear()
for effect in Phonon.BackendCapabilities.availableAudioEffects():
item = QtGui.QTreeWidgetItem(self.effectsTreeWidget)
item.setText(0, "Effect")
item.setText(1, effect.name())
item.setText(2, effect.description())
# Effects parameters.
for parameter in Phonon.Effect(effect, self).parameters():
defaultValue = parameter.defaultValue()
minimumValue = parameter.minimumValue()
maximumValue = parameter.maximumValue()
valueString = "%s / %s / %s" % (defaultValue, minimumValue,
maximumValue)
parameterItem = QtGui.QTreeWidgetItem(item)
parameterItem.setText(0, "Parameter")
parameterItem.setText(1, parameter.name())
parameterItem.setText(2, parameter.description())
parameterItem.setText(3, str(parameter.type()))
parameterItem.setText(4, valueString)
for i in range(self.effectsTreeWidget.columnCount()):
if i == 0:
self.effectsTreeWidget.setColumnWidth(0, 150)
elif i == 2:
self.effectsTreeWidget.setColumnWidth(2, 350)
else:
self.effectsTreeWidget.resizeColumnToContents(i)
def __init__(self):
#QtGui.QWidget.__init__(self)
super(QPlayer, self).__init__()
self.audioOuptut=Phonon.AudioOutput(Phonon.MusicCategory, self)
self.player=Phonon.MediaObject(self)
Phonon.createPath(self.player, self.audioOuptut)
self.videoWidget=Phonon.VideoWidget(self)
Phonon.createPath(self.player, self.videoWidget)
self.player.setTickInterval(1000)
self.connect(self.player, QtCore.SIGNAL("tick(qint64)"), self.tick)
self.seekSlider=Phonon.SeekSlider(self.player, self)
self.volumeSlider=Phonon.VolumeSlider(self.audioOuptut, self)
self.buildGUI()
self.setupConnections()
def __init__(self, modem):
super(ModemIndicator, self).__init__()
self._modem = modem
self.signalLevelChanged(0)
menu = self.createMenu()
self.setContextMenu(menu)
self.player = Phonon.createPlayer(Phonon.MusicCategory)
self.player.stateChanged.connect(self._playerLog)
def __init__(self):
super(mediaObject,self).__init__()
import os
import sys
path = os.path.abspath(os.path.dirname(sys.argv[0]))
path2 = ''
for index in xrange(len(path)):
if path[index]=='\\':
path2 += '/'
else:
path2 += path[index]
path = path2+'/Fire.wav'
self.media2 = Phonon.MediaObject(self)
self.media2.setCurrentSource(Phonon.MediaSource())
self.output = Phonon.AudioOutput(Phonon.MusicCategory,self)
Phonon.createPath(self.media2, self.output)
self.media2.setCurrentSource(Phonon.MediaSource(path))
def play_sound(self, alias):
""" Plays a sound
Arguments:
alias (str): The name of a sound file alias as specified in a .qrc
file, eg "mysound.wav"
"""
speakers = Phonon.AudioOutput(Phonon.MusicCategory, self)
media = Phonon.MediaObject(self)
speakers.setVolume(0.5)
Phonon.createPath(media, speakers)
media.setCurrentSource( ":/{}".format(alias) )
### If we let the media file play all the way through, we get a nasty
### static squelch at the end. Set it to stop playing 30 milliseconds
### before the end.
media.setPrefinishMark(30)
media.prefinishMarkReached.connect( media.stop )
media.play()
def play_sound(self, alias):
""" Plays a sound
Arguments:
alias (str): The name of a sound file alias as specified in a .qrc
file, eg "mysound.wav"
"""
speakers = Phonon.AudioOutput(Phonon.MusicCategory, self)
media = Phonon.MediaObject(self)
speakers.setVolume(0.5)
Phonon.createPath(media, speakers)
media.setCurrentSource( ":/{}".format(alias) )
### If we let the media file play all the way through, we get a nasty
### static squelch at the end. Set it to stop playing 30 milliseconds
### before the end.
media.setPrefinishMark(30)
media.prefinishMarkReached.connect( media.stop )
media.play()
def __init__(self, parent = None):
QtGui.QWidget.__init__(self, parent)
self.media = Phonon.MediaObject(self)
self.media.stateChanged.connect(self.handleStateChanged)
self.video = Phonon.VideoWidget(self)
self.video.setMinimumSize(400, 400)
self.audio = Phonon.AudioOutput(Phonon.VideoCategory, self)
Phonon.createPath(self.media, self.audio)
Phonon.createPath(self.media, self.video)
self.button = QtGui.QPushButton('Choose File', self)
self.buttonPlay = QtGui.QPushButton('Play', self)
self.buttonPlay.clicked.connect(self.play)
self.button.clicked.connect(self.handleButton)
self.list = QtGui.QListWidget(self)
self.list.addItems(Phonon.BackendCapabilities.availableMimeTypes())
layout = QtGui.QVBoxLayout(self)
layout.addWidget(self.video, 1)
layout.addWidget(self.button)
layout.addWidget(self.buttonPlay)
layout.addWidget(self.list)
def __init__(self):
"""
Ticks are not implemented because we don't need them but in case we do it is fairly simple.
"""
super().__init__()
# set up audio output and media object and connect both
self.audio_output = Phonon.AudioOutput(Phonon.MusicCategory, self)
self.media_object = Phonon.MediaObject(self)
Phonon.createPath(self.media_object, self.audio_output)
# connect signal of media object
self.media_object.stateChanged.connect(self.state_changed)
self.media_object.aboutToFinish.connect(self.before_finish)
# default values
self.playlist = []
self.auto_rewind = True
