async def setup(self) -> None: await super().setup() self.__cmdline = self.get_cmd_line() logger.info("Starting encoder process: %s", ' '.join(self.__cmdline)) self.__stderr = [] transport, protocol = await self.event_loop.subprocess_exec( functools.partial(EncoderProtocol, data_handler=self.data_handler, stderr_handler=self.__stderr.append, failure_handler=self.__fail, event_loop=self.event_loop), *self.__cmdline, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) self.__transport = down_cast(asyncio.SubprocessTransport, transport) self.__protocol = down_cast(EncoderProtocol, protocol) self.__stdin = asyncio.StreamWriter( transport=self.__transport.get_pipe_transport(0), protocol=self.__protocol, reader=None, loop=self.event_loop)
def create_empty_measure( self, ref: Optional[base_track.Measure]) -> ScoreMeasure: measure = down_cast(ScoreMeasure, super().create_empty_measure(ref)) if ref is not None: ref = down_cast(ScoreMeasure, ref) measure.key_signature = ref.key_signature measure.clef = ref.clef return measure
def _add_measure_listeners(self, mref: base_track.MeasureReference) -> None: measure = down_cast(BeatMeasure, mref.measure) self._listeners['measure:%s:beats' % mref.id] = measure.content_changed.add( lambda _=None: self.__measure_beats_changed(mref) ) # type: ignore[misc]
def remove_connections(self) -> None: node = down_cast(BaseNode, self.parent) if node is not None: for conn in node.connections: if (conn.source_node is node and conn.source_port == self.name or conn.dest_node is node and conn.dest_port == self.name): self.project.remove_node_connection(conn)
def _create_events( self, time: audioproc.MusicalTime, measure: base_track.Measure ) -> Iterator[base_track.PianoRollInterval]: measure = down_cast(BeatMeasure, measure) for beat in measure.beats: beat_time = time + beat.time event = base_track.PianoRollInterval( beat_time, beat_time + audioproc.MusicalDuration(1, 4), self._node.pitch, 127) yield event
def parent(self, index: QtCore.QModelIndex) -> QtCore.QModelIndex: # type: ignore[override] if not index.isValid(): return QtCore.QModelIndex() item = down_cast(ModelItem, index.internalPointer()) parent = item.parent if parent is self.__root: return QtCore.QModelIndex() return self.createIndex(parent.index, 0, parent)
def _create_events( self, time: audioproc.MusicalTime, measure: base_track.Measure ) -> Iterator[base_track.PianoRollInterval]: measure = down_cast(ScoreMeasure, measure) for note in measure.notes: if not note.is_rest: for pitch in note.pitches: pitch = pitch.transposed( octaves=self._node.transpose_octaves) event = base_track.PianoRollInterval( time, time + note.duration, pitch, 127) yield event time += note.duration
async def setup_testcase(self): with self.project.apply_mutations('test'): self.node = self.project.create_node('builtin://custom-csound') with self.project.apply_mutations('test'): self.node.create_port(0, 'port1') self.node.create_port(1, 'port2') self.node.create_port(2, 'port3') self.port_list_editor = node_ui.PortListEditor( node=self.node, context=self.context) self.table = self.port_list_editor.findChild( QtWidgets.QTableView, "object_table", Qt.FindChildrenRecursively) self.model = down_cast(object_list_editor.ObjectListModel, self.table.model()) self.delegate = self.table.itemDelegate()
def pipe_data_received(self, fd: int, data: Union[bytes, Text]) -> None: data = down_cast(bytes, data) if fd == 1: logger.debug("Writing %d encoded bytes", len(data)) self.__data_handler(data) else: assert fd == 2 self.__stderr_buf.extend(data) while True: eol = self.__stderr_buf.find(b'\n') if eol < 0: break line = self.__stderr_buf[:eol].decode('utf-8') del self.__stderr_buf[:eol + 1] self.__stderr_handler(line)
def paste_segments( self, data: clipboard_pb2.PianoRollSegments, time: audioproc.MusicalTime) -> List[PianoRollSegmentRef]: segment_map = {} # type: Dict[int, PianoRollSegment] for serialized_segment in data.segments: segment = down_cast(PianoRollSegment, self._pool.clone_tree(serialized_segment)) self.segment_heap.append(segment) segment_map[serialized_segment.root] = segment segment_refs = [] # type: List[PianoRollSegmentRef] for serialized_segment_ref in data.segment_refs: ref_time = audioproc.MusicalTime.from_proto( serialized_segment_ref.time) ref = self._pool.create( PianoRollSegmentRef, time=time + (ref_time - audioproc.MusicalTime(0, 1)), segment=segment_map[serialized_segment_ref.segment]) self.segments.append(ref) segment_refs.append(ref) return segment_refs
def project(self) -> music.Project: return down_cast(music.Project, self.__project_connection.client.project)
def midi_cc_to_cv(self) -> 'MidiCCtoCV': return down_cast(MidiCCtoCV, self.parent)
def track_editor(self) -> 'BeatTrackEditor': return down_cast(BeatTrackEditor, super().track_editor)
def connection_made(self, transport: asyncio.BaseTransport) -> None: self.__transport = down_cast(asyncio.SubprocessTransport, transport)
def measure(self) -> model.ScoreMeasure: return down_cast(model.ScoreMeasure, super().measure)
def track_editor(self) -> 'ScoreTrackEditor': return down_cast(ScoreTrackEditor, super().track_editor)
def track(self) -> model.ControlTrack: return down_cast(model.ControlTrack, super().track)
def prev_sibling(self) -> 'MeasureReference': return down_cast(MeasureReference, super().prev_sibling)
def track(self) -> 'ScoreTrack': return down_cast(ScoreTrack, super().track)
def next_sibling(self) -> 'MeasureReference': return down_cast(MeasureReference, super().next_sibling)
def track(self) -> music.MeasuredTrack: return down_cast(music.MeasuredTrack, self.__track_editor.track)
def item(self, index: QtCore.QModelIndex = QtCore.QModelIndex()) -> Item: if not index.isValid(): return self.__root else: return down_cast(Item, index.internalPointer())
def track(self) -> music.MeasuredTrack: return down_cast(music.MeasuredTrack, super().track)
def __currentToolChanged(self, tool: tools.ToolType) -> None: self.setDelegatedCopyable( down_cast(MeasuredTrackToolBase, self.currentTool()))
def enterEvent(self, evt: QtCore.QEvent) -> None: evt = down_cast(QtGui.QEnterEvent, evt) self.setHoverMeasureEditor(self.measureEditorAt(evt.pos()), evt)
def track(self) -> model.ScoreTrack: return down_cast(model.ScoreTrack, super().track)
def node(self) -> 'CustomCSound': return down_cast(CustomCSound, self.parent)
def paintBackground(self, painter: QtGui.QPainter) -> None: ymid = self.height() // 2 painter.setPen(Qt.black) painter.setBrush(Qt.black) for l in range(-2, 3): painter.drawLine(0, ymid + 20 * l, self.width() - 1, ymid + 20 * l) if self.is_first: painter.fillRect(0, ymid - 40, 2, 20 * 4, Qt.black) painter.drawLine(self.width() - 1, ymid - 40, self.width() - 1, ymid + 40) if not self.measure_reference.is_first: prev_sibling = down_cast( model.ScoreMeasure, self.measure_reference.prev_sibling.measure) else: prev_sibling = None base_stave_line = self.measure.clef.center_pitch.stave_line base_octave = self.measure.clef.base_octave x = 0 paint_clef = prev_sibling is None or self.measure.clef != prev_sibling.clef if paint_clef and self.width() - x > 200: svg_symbol.paintSymbol( painter, 'clef-%s' % self.measure.clef.symbol, QtCore.QPoint( x + 30, ymid - 10 * (self.measure.clef.base_pitch.stave_line - base_stave_line) )) x += 60 acc_map = { 'C#': 'C%d' % (base_octave + 1), 'D#': 'D%d' % (base_octave + 1), 'E#': 'E%d' % (base_octave + 1), 'F#': 'F%d' % (base_octave + 1), 'G#': 'G%d' % (base_octave + 1), 'A#': 'A%d' % base_octave, 'B#': 'B%d' % base_octave, 'Cb': 'C%d' % (base_octave + 1), 'Db': 'D%d' % (base_octave + 1), 'Eb': 'E%d' % (base_octave + 1), 'Fb': 'F%d' % base_octave, 'Gb': 'G%d' % base_octave, 'Ab': 'A%d' % base_octave, 'Bb': 'B%d' % base_octave, } paint_key_signature = ( prev_sibling is None or self.measure.key_signature != prev_sibling.key_signature) if paint_key_signature and self.width() - x > 200: for acc in self.measure.key_signature.accidentals: value = acc_map[acc] stave_line = value_types.Pitch( value).stave_line - base_stave_line svg_symbol.paintSymbol( painter, self._accidental_map[acc[1:]], QtCore.QPoint(x + 10, ymid - 10 * stave_line)) x += 10 if self.measure.key_signature.accidentals: x += 10 paint_time_signature = ( prev_sibling is None or self.measure.time_signature != prev_sibling.time_signature) if paint_time_signature and self.width() - x > 200: font = QtGui.QFont('FreeSerif', 30, QtGui.QFont.Black) font.setStretch(120) painter.setFont(font) painter.drawText(x, ymid - 5, '%d' % self.measure.time_signature.upper) painter.drawText(x, ymid + 32, '%d' % self.measure.time_signature.lower) x += 40 if self.width() - x > 100: self._note_area = (x + 20, self.width() - x - 20) else: self._note_area = (0, self.width())
def sequencer(self) -> 'StepSequencer': return down_cast(StepSequencer, self.parent)