src/renderw.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4
   5 # Imports
   6 import jack
   7 from PyQt4.QtCore import QTime, QTimer, SIGNAL
   8 from PyQt4.QtGui import QDialog
   9 from PyKDE4.kdeui import KIcon
  10 from PyKDE4.kdecore import i18n
  11 import ui_renderw, shared
  12
  13
  14 # Main Window
  15 class KlaudiaRenderW(QDialog, ui_renderw.Ui_KlaudiaRenderW):
  16     def __init__(self, *args):
  17         QDialog.__init__(self, *args)
  18         self.setupUi(self)
  19
  20         # Internal timers
  21         self.timer = QTimer()
  22
  23         # Load Variables
  24         t_start = shared.p_time_start.split(":")
  25         t_end = shared.p_time_end.split(":")
  26         self.timeStart.setTime(QTime(int(t_start[0]), int(t_start[1]), int(t_start[2])))
  27         self.timeEnd.setTime(QTime(int(t_end[0]), int(t_end[1]), int(t_end[2])))
  28         self.SampleRate = jack.get_sample_rate()
  29
  30         # Set Buffer Size according to Jack
  31         bf_size = jack.get_buffer_size()
  32         if (bf_size == 32 or bf_size == 64 or bf_size == 128 or bf_size == 256 or bf_size == 512 or \
  33             bf_size == 1024 or bf_size == 2048 or bf_size == 4096 or bf_size == 8192):
  34           i = 0
  35           while (i < self.co_BufferSize.count()):
  36             if (str(bf_size) == self.co_BufferSize.itemText(i)):
  37               self.co_BufferSize.setCurrentIndex(i)
  38             i += 1
  39         else:
  40           self.co_BufferSize.addItem(str(rate)+" Hz")
  41           self.co_BufferSize.setCurrentIndex(self.co_BufferSize.count()-1)
  42         self.BufferSize = bf_size
  43
  44         # Initial set of Variables (will be changed on render)
  45         self.MinTime = 0
  46         self.MaxTime = 0
  47         self.Finished = False
  48
  49         # Set-up GUI
  50         self.b_stop.setIcon(KIcon("media-playback-stop"))
  51         self.b_render.setIcon(KIcon("media-record"))
  52         self.b_close.setIcon(KIcon("window-close"))
  53         self.b_stop.setVisible(False)
  54
  55         self.connect(self.b_low, SIGNAL("clicked()"), self.P_low)
  56         self.connect(self.b_high, SIGNAL("clicked()"), self.P_high)
  57         self.connect(self.b_render, SIGNAL("clicked()"), self.Render)
  58         self.connect(self.b_stop, SIGNAL("clicked()"), self.stopRender)
  59         self.connect(self.timer, SIGNAL("timeout()"), self.updateProgress)
  60         self.connect(self.timeStart, SIGNAL("timeChanged(const QTime)"), self.updateStartTime)
  61         self.connect(self.timeEnd, SIGNAL("timeChanged(const QTime)"), self.updateEndTime)
  62         self.connect(self.prioritySlider, SIGNAL("valueChanged(int)"), self.updatePriority)
  63
  64
  65     def P_low(self):
  66         value = self.prioritySlider.value()-1
  67         if (value < -19): value = -19
  68         self.prioritySlider.setValue(value)
  69
  70     def P_high(self):
  71         value = self.prioritySlider.value()+1
  72         if (value > 20): value = 20
  73         self.prioritySlider.setValue(value)
  74
  75     def Render(self):
  76         # Disable GUI stuff
  77         self.gr_options.setEnabled(False)
  78         self.gr_time.setEnabled(False)
  79         self.gr_encoding.setEnabled(False)
  80         self.b_close.setEnabled(False)
  81
  82         # Change to stop button
  83         self.b_stop.setVisible(True)
  84         self.b_render.setVisible(False)
  85
  86         # Update Variables
  87         self.Finished = False
  88         self.SampleRate = jack.get_sample_rate()
  89
  90         # Check for Render Type
  91         #NOT IMPLEMENTED YET (and maybe never will)
  92
  93         # Check/Set for Buffer Size
  94         jack.set_buffer_size(int(str(self.co_BufferSize.currentText())))
  95
  96         # Check for Priority
  97         priority = "nice -n "+str(self.prioritySlider.value())
  98
  99         # Check for time
 100         timeStart = self.timeStart.time()
 101         timeEnd   = self.timeEnd.time()
 102         self.MinTime = (timeStart.hour()*3600)+(timeStart.minute()*60)+(timeStart.second())
 103         self.MaxTime = (timeEnd.hour()*3600)+(timeEnd.minute()*60)+(timeEnd.second())
 104         self.progressBar.setMinimum(self.MinTime)
 105         self.progressBar.setMaximum(self.MaxTime)
 106         self.progressBar.setValue(self.MinTime)
 107         duration = " -d "+str(self.MaxTime - self.MinTime)
 108
 109         # Check for encoding
 110         text = str(self.co_type.currentText())
 111         if (text == "FLAC"):
 112           ext = "flac"
 113         elif (text == "MP3"):
 114           ext = "mp3"
 115         elif (text == "Ogg"):
 116           ext = "ogg"
 117         elif (text == "WAV"):
 118           ext = "wav"
 119
 120         # Check for stereo
 121         if self.r_stereo.isChecked():
 122           channels = " --channels 2"
 123         else:
 124           channels = " --channels 1"
 125
 126         # Check for preview
 127         if self.ch_preview.isChecked():
 128           meter = " --meterbridge"
 129         else:
 130           meter = " "
 131
 132         # Check for fly
 133         if (self.ch_fly.isChecked()):
 134           on_the_fly = True
 135         else:
 136           on_the_fly = False
 137
 138         # Start capture
 139         jack.transport_stop()
 140         jack.transport_locate(self.MinTime*self.SampleRate)
 141         print priority, "jack-capture -silent", duration, channels, meter
 142         jack.transport_start()
 143
 144         self.timer.start(250)
 145
 146     def stopRender(self, clean=False):
 147         # Stop render
 148         #system("killall -TERM jack_capture")
 149         self.timer.stop()
 150         jack.transport_stop()
 151
 152         # Restore GUI components
 153         self.gr_options.setEnabled(True)
 154         self.gr_time.setEnabled(True)
 155         self.gr_encoding.setEnabled(True)
 156         self.b_close.setEnabled(True)
 157
 158         # Change to render button
 159         self.b_stop.setVisible(False)
 160         self.b_render.setVisible(True)
 161
 162         # Restore Progress Bar State
 163         if (not clean):
 164           self.progressBar.setValue(0)
 165           self.progressBar.setMinimum(0)
 166           self.progressBar.setMaximum(0)
 167
 168     def updatePriority(self, value):
 169         value = - value
 170         self.prioritySpin.setValue(value)
 171
 172     def updateProgress(self):
 173         time = jack.get_current_transport_frame()/self.SampleRate
 174         if (time > self.MaxTime or self.Finished):
 175           self.stopRender(True)
 176         else:
 177           self.progressBar.setValue(time)
 178           if (time == self.MaxTime): self.Finished = True
 179
 180     def updateStartTime(self, time):
 181         if (time >= self.timeEnd.time()):
 182           self.timeEnd.setTime(time)
 183           self.b_render.setEnabled(False)
 184         else:
 185           self.b_render.setEnabled(True)
 186
 187     def updateEndTime(self, time):
 188         if (time <= self.timeStart.time()):
 189           time = self.timeStart.setTime(time)
 190           self.b_render.setEnabled(False)
 191         else:
 192           self.b_render.setEnabled(True)
 193
 194