Example #1
0
 def write_end(self):
     if _debug:
         print('write_end')
     driver_listener.lock()
     driver_listener.sync_operation(
         pa.pa_stream_trigger(self.stream, self._success_cb_func, None))
     driver_listener.unlock()
     self._ended = True
Example #2
0
 def write_end(self):
     if _debug:
         print('write_end')
     driver_listener.lock()
     driver_listener.sync_operation(
         pa.pa_stream_trigger(self.stream, self._success_cb_func, None)
     )
     driver_listener.unlock()
     self._ended = True
Example #3
0
 def play(self):
     if _debug:
         print('play')
     driver_listener.lock()
     driver_listener.async_operation(
         pa.pa_stream_cork(self.stream, 0, pa.pa_stream_success_cb_t(0),
                           None))
     if self._ended:
         driver_listener.async_operation(
             pa.pa_stream_trigger(self.stream, pa.pa_stream_success_cb_t(0),
                                  None))
     driver_listener.unlock()
Example #4
0
    def play(self):
        if _debug:
            print "play"
        context.lock()
        context.async_operation(pa.pa_stream_cork(self.stream, 0, pa.pa_stream_success_cb_t(0), None))

        # If whole stream has already been written, trigger immediate
        # playback.
        if self._underflow_is_eos:
            context.async_operation(pa.pa_stream_trigger(self.stream, pa.pa_stream_success_cb_t(0), None))
        context.unlock()

        self._playing = True
Example #5
0
 def play(self):
     if _debug:
         print('play')
     driver_listener.lock()
     driver_listener.async_operation(
         pa.pa_stream_cork(self.stream, 0,
                           pa.pa_stream_success_cb_t(0), None)
     )
     if self._ended:
         driver_listener.async_operation(
             pa.pa_stream_trigger(self.stream,
                                  pa.pa_stream_success_cb_t(0), None)
         )
     driver_listener.unlock()
    def play(self):
        if _debug:
            print 'play'
        context.lock()
        context.async_operation(
            pa.pa_stream_cork(self.stream, 0, pa.pa_stream_success_cb_t(0),
                              None))

        # If whole stream has already been written, trigger immediate
        # playback.
        if self._underflow_is_eos:
            context.async_operation(
                pa.pa_stream_trigger(self.stream, pa.pa_stream_success_cb_t(0),
                                     None))
        context.unlock()

        self._playing = True
    def play(self):
        if _debug:
            print 'play'
        with context.lock:
            context.async_operation(
                pa.pa_stream_cork(self.stream, 0,
                                pa.pa_stream_success_cb_t(0), None)
            )

            # If whole stream has already been written, trigger immediate
            # playback.        
            if self._underflow_is_eos:
                context.async_operation(
                    pa.pa_stream_trigger(self.stream, 
                                        pa.pa_stream_success_cb_t(0), None)
                )

            if self._buffer_underflow:
                self._write_cb(self.stream, None, None)

        self._playing = True
Example #8
0
    def _write_cb(self, stream, bytes, data):
        if _debug:
            print 'write callback: %d bytes' % bytes

        # Asynchronously update time
        if self._events:
            context.async_operation(
                pa.pa_stream_update_timing_info(self.stream, 
                                                self._success_cb_func, None)
            )

        # Grab next audio packet, or leftovers from last callback.
        if self._buffered_audio_data:
            audio_data = self._buffered_audio_data
            self._buffered_audio_data = None
        else:
            audio_data = self.source_group.get_audio_data(bytes)

        seek_flag = pa.PA_SEEK_RELATIVE
        if self._clear_write:
            if _debug:
                print 'seek PA_SEEK_RELATIVE_ON_READ'
            seek_flag = pa.PA_SEEK_RELATIVE_ON_READ
            self._clear_write = False

        # Keep writing packets until `bytes` is depleted
        while audio_data and bytes > 0:
            if _debug:
                print 'packet', audio_data.timestamp
            if _debug and audio_data.events:
                print 'events', audio_data.events
            for event in audio_data.events:
                event_index = self._write_index + event.timestamp * \
                    self.source_group.audio_format.bytes_per_second
                self._events.append((event_index, event))

            consumption = min(bytes, audio_data.length)
            
            check(
                pa.pa_stream_write(self.stream,
                                   audio_data.data,
                                   consumption,
                                   pa.pa_free_cb_t(0),  # Data is copied
                                   0,
                                   seek_flag)
            )

            seek_flag = pa.PA_SEEK_RELATIVE
            self._read_index_valid = True
            self._timestamps.append((self._write_index, audio_data.timestamp))
            self._write_index += consumption
            self._underflow_is_eos = False

            if _debug:
                print 'write', consumption
            if consumption < audio_data.length:
                audio_data.consume(consumption, self.source_group.audio_format)
                self._buffered_audio_data = audio_data
                break

            bytes -= consumption
            if bytes > 0:
                audio_data = self.source_group.get_audio_data(bytes) #XXX name change

        if not audio_data:
            # Whole source group has been written.  Any underflow encountered
            # after now is the EOS.
            self._underflow_is_eos = True
            
            # In case the source group wasn't long enough to prebuffer stream
            # to PA's satisfaction, trigger immediate playback (has no effect
            # if stream is already playing).
            if self._playing:
                context.async_operation(
                     pa.pa_stream_trigger(self.stream, 
                                          pa.pa_stream_success_cb_t(0), None)
                )

        self._process_events()
    def _write_cb(self, stream, bytes, data):
        if _debug:
            print 'write callback: %d bytes' % bytes

        # Asynchronously update time
        if self._events:
            context.async_operation(
                pa.pa_stream_update_timing_info(self.stream,
                                                self._success_cb_func, None))

        # Grab next audio packet, or leftovers from last callback.
        if self._buffered_audio_data:
            audio_data = self._buffered_audio_data
            self._buffered_audio_data = None
        else:
            audio_data = self.source_group.get_audio_data(bytes)

        seek_flag = pa.PA_SEEK_RELATIVE
        if self._clear_write:
            if _debug:
                print 'seek PA_SEEK_RELATIVE_ON_READ'
            seek_flag = pa.PA_SEEK_RELATIVE_ON_READ
            self._clear_write = False

        # Keep writing packets until `bytes` is depleted
        while audio_data and bytes > 0:
            if _debug:
                print 'packet', audio_data.timestamp
            if _debug and audio_data.events:
                print 'events', audio_data.events
            for event in audio_data.events:
                event_index = self._write_index + event.timestamp * \
                    self.source_group.audio_format.bytes_per_second
                self._events.append((event_index, event))

            consumption = min(bytes, audio_data.length)

            check(
                pa.pa_stream_write(
                    self.stream,
                    audio_data.data,
                    consumption,
                    pa.pa_free_cb_t(0),  # Data is copied
                    0,
                    seek_flag))

            seek_flag = pa.PA_SEEK_RELATIVE
            self._read_index_valid = True
            self._timestamps.append((self._write_index, audio_data.timestamp))
            self._write_index += consumption
            self._underflow_is_eos = False

            if _debug:
                print 'write', consumption
            if consumption < audio_data.length:
                audio_data.consume(consumption, self.source_group.audio_format)
                self._buffered_audio_data = audio_data
                break

            bytes -= consumption
            if bytes > 0:
                audio_data = self.source_group.get_audio_data(
                    bytes)  #XXX name change

        if not audio_data:
            # Whole source group has been written.  Any underflow encountered
            # after now is the EOS.
            self._underflow_is_eos = True

            # In case the source group wasn't long enough to prebuffer stream
            # to PA's satisfaction, trigger immediate playback (has no effect
            # if stream is already playing).
            if self._playing:
                context.async_operation(
                    pa.pa_stream_trigger(self.stream,
                                         pa.pa_stream_success_cb_t(0), None))

        self._process_events()