rb-edge-tts 1.0.0

data/exe/rb-edge-playback

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/rb_edge_tts'
+require_relative '../lib/edge_playback/version'
+require 'optparse'
+require 'tempfile'
+require 'open3'
+
+module EdgePlayback
+  module CLI
+    class << self
+      def run(args)
+        options = parse_options(args)
+        check_dependencies(options[:use_mpv])
+
+        debug = ENV['EDGE_PLAYBACK_DEBUG']
+        keep = ENV['EDGE_PLAYBACK_KEEP_TEMP']
+        mp3_file = ENV['EDGE_PLAYBACK_MP3_FILE']
+        srt_file = ENV['EDGE_PLAYBACK_SRT_FILE']
+
+        begin
+          mp3_file, srt_file = create_temp_files(options[:use_mpv], mp3_file, srt_file, debug)
+          run_edge_tts(mp3_file, srt_file, args)
+          play_media(options[:use_mpv], mp3_file, srt_file)
+        ensure
+          cleanup(mp3_file, srt_file, keep)
+        end
+      end
+
+      private
+
+      def parse_options(args)
+        options = { use_mpv: !Gem.win_platform? }
+        remaining_args = []
+
+        while (arg = args.shift)
+          case arg
+          when '--mpv'
+            options[:use_mpv] = true
+          when '--version'
+            puts "rb-edge-playback #{EdgePlayback::VERSION}"
+            exit 0
+          when '-h', '--help'
+            puts "Usage: rb-edge-playback [options] [rb-edge-tts options]"
+            puts ""
+            puts "Options:"
+            puts "    --mpv                            Use mpv to play audio"
+            puts "    --version                        Show version"
+            puts "    -h, --help                       Show this help message"
+            puts ""
+            puts "See 'rb-edge-tts --help' for additional arguments"
+            exit 0
+          else
+            remaining_args << arg
+          end
+        end
+
+        # Restore request arguments
+        remaining_args.each { |a| args << a }
+
+        options
+      end
+
+      def check_dependencies(use_mpv)
+        missing = []
+
+        missing << 'rb-edge-tts' unless system('which rb-edge-tts > /dev/null 2>&1')
+        missing << 'mpv' if use_mpv && !system('which mpv > /dev/null 2>&1')
+
+        return if missing.empty?
+
+        missing.each { |dep| warn "#{dep} is not installed." }
+        warn 'Please install the missing dependencies.'
+        exit 1
+      end
+
+      def create_temp_files(use_mpv, mp3_fname, srt_fname, debug)
+        unless mp3_fname
+          media = Tempfile.new(['rb-edge-playback-', '.mp3'])
+          media.close
+          mp3_fname = media.path
+          puts "Media file: #{mp3_fname}" if debug
+        end
+
+        unless srt_fname || !use_mpv
+          subtitle = Tempfile.new(['rb-edge-playback-', '.srt'])
+          subtitle.close
+          srt_fname = subtitle.path
+          puts "Subtitle file: #{srt_fname}" if debug
+        end
+
+        [mp3_fname, srt_fname]
+      end
+
+      def run_edge_tts(mp3_fname, srt_fname, tts_args)
+        edge_tts_cmd = ['rb-edge-tts', "--write-media=#{mp3_fname}"]
+        edge_tts_cmd << "--write-subtitles=#{srt_fname}" if srt_fname
+        edge_tts_cmd.concat(tts_args)
+
+        status = system(*edge_tts_cmd)
+        raise "rb-edge-tts failed with status #{$?.exitstatus}" unless status
+      end
+
+      def play_media(use_mpv, mp3_fname, srt_fname)
+        if Gem.win_platform? && !use_mpv
+          play_mp3_win32(mp3_fname)
+          return
+        end
+
+        mpv_cmd = %w[mpv --msg-level=all=error,statusline=status]
+        mpv_cmd << "--sub-file=#{srt_fname}" if srt_fname
+        mpv_cmd << mp3_fname
+
+        status = system(*mpv_cmd)
+        warn "mpv failed with status #{$?.exitstatus}" unless status
+      end
+
+      def play_mp3_win32(mp3_fname)
+        require 'fiddle'
+
+        kernel32 = Fiddle::Handle.new('kernel32')
+        winmm = Fiddle::Handle.new('winmm')
+
+        get_short_path_name_w = Fiddle::Function.new(
+          kernel32['GetShortPathNameW'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_DWORD],
+          Fiddle::TYPE_DWORD
+        )
+
+        get_long_path_name_w = Fiddle::Function.new(
+          kernel32['GetLongPathNameW'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_DWORD],
+          Fiddle::TYPE_DWORD
+        )
+
+        mci_send_string_w = Fiddle::Function.new(
+          winmm['mciSendStringW'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_DWORD, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_DWORD
+        )
+
+        mp3_path = mp3_fname.encode('utf-16le')
+        buffer = "\0" * 260 * 2
+
+        get_short_path_name_w.call(mp3_path, buffer, 260)
+        short_name = buffer.strip.encode('utf-8')
+
+        mci_send_string_w.call('Close All', nil, 0, nil)
+        mci_send_string_w.call("Open \"#{short_name}\" Type MPEGVideo Alias theMP3", nil, 0, nil)
+        mci_send_string_w.call('Play theMP3 Wait', nil, 0, nil)
+        mci_send_string_w.call('Close theMP3', nil, 0, nil)
+      rescue LoadError => e
+        warn "Error loading Windows libraries: #{e.message}"
+        exit 1
+      end
+
+      def cleanup(mp3_fname, srt_fname, keep)
+        return if keep
+
+        File.delete(mp3_fname) if mp3_fname && File.exist?(mp3_fname)
+        File.delete(srt_fname) if srt_fname && File.exist?(srt_fname)
+      end
+    end
+  end
+end
+
+EdgePlayback::CLI.run(ARGV)

data/exe/rb-edge-tts

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/rb_edge_tts'
+require 'optparse'
+require 'fileutils'
+
+module RbEdgeTTS
+  module CLI
+    class << self
+      def run(args)
+        options = parse_options(args)
+
+        if options[:list_voices]
+          print_voices(options)
+          exit 0
+        end
+
+        text = get_text(options)
+        run_tts(text, options)
+      end
+
+      private
+
+      def parse_options(args)
+        options = {
+          voice: RbEdgeTTS::DEFAULT_VOICE,
+          rate: '+0%',
+          volume: '+0%',
+          pitch: '+0Hz'
+        }
+
+        OptionParser.new do |opts|
+          opts.banner = "Usage: rb-edge-tts [options]"
+          opts.separator ""
+          opts.separator "Options:"
+
+          opts.on('-t', '--text TEXT', 'What TTS will say') do |t|
+            options[:text] = t
+          end
+
+          opts.on('-f', '--file FILE', 'Read text from file') do |f|
+            options[:file] = f
+          end
+
+          opts.on('-v', '--voice VOICE', "Voice for TTS (default: #{DEFAULT_VOICE})") do |v|
+            options[:voice] = v
+          end
+
+          opts.on('-l', '--list-voices', 'List available voices and exit') do
+            options[:list_voices] = true
+          end
+
+          opts.on('--rate RATE', 'Set TTS rate (e.g., +20%, -50%)') do |r|
+            options[:rate] = r
+          end
+
+          opts.on('--volume VOLUME', 'Set TTS volume (e.g., +10%, -20%)') do |v|
+            options[:volume] = v
+          end
+
+          opts.on('--pitch PITCH', 'Set TTS pitch (e.g., +5Hz, -10Hz)') do |p|
+            options[:pitch] = p
+          end
+
+          opts.on('--write-media FILE', 'Write media output to file instead of stdout') do |w|
+            options[:write_media] = w
+          end
+
+          opts.on('--write-subtitles FILE', 'Write subtitle output to file instead of stderr') do |w|
+            options[:write_subtitles] = w
+          end
+
+          opts.on('--proxy URL', 'Use a proxy for TTS and voice list') do |p|
+            options[:proxy] = p
+          end
+
+          opts.on('--verbose', 'Show debug information') do
+            options[:verbose] = true
+          end
+
+          opts.on('--version', 'Show version') do
+            puts "rb-edge-tts #{VERSION}"
+            exit 0
+          end
+
+          opts.on('-h', '--help', 'Show this help message') do
+            puts opts
+            exit 0
+          end
+        end.parse!(args)
+
+        raise OptionParser::MissingArgument, 'Must specify --text or --file' unless options[:text] || options[:file] || options[:list_voices]
+
+        options
+      rescue OptionParser::ParseError => e
+        warn "Error: #{e.message}"
+        warn "Use --help for usage information"
+        exit 1
+      end
+
+      def get_text(options)
+        if options[:file]
+          if options[:file] == '-' || options[:file] == '/dev/stdin'
+            STDIN.read
+          else
+            File.read(options[:file], encoding: 'utf-8')
+          end
+        else
+          options[:text]
+        end
+      end
+
+      def print_voices(options)
+        voices = RbEdgeTTS.list_voices(proxy: options[:proxy])
+        voices = voices.sort_by(&:short_name)
+
+        require 'terminal-table'
+        table = Terminal::Table.new(
+          headings: %w[Name Gender ContentCategories VoicePersonalities],
+          rows: voices.map do |v|
+            [
+              v.short_name,
+              v.gender,
+              v.voice_tag.content_categories.join(', '),
+              v.voice_tag.voice_personalities.join(', ')
+            ]
+          end
+        )
+
+        puts table
+      end
+
+      def run_tts(text, options)
+        if STDIN.tty? && STDOUT.tty? && !options[:write_media]
+          warn 'Warning: TTS output will be written to the terminal.'
+          warn 'Use --write-media to write to a file.'
+          warn 'Press Ctrl+C to cancel the operation.'
+          warn 'Press Enter to continue.'
+          STDIN.gets
+        end
+
+        communicate = RbEdgeTTS::Communicate.new(
+          text,
+          options[:voice],
+          rate: options[:rate],
+          volume: options[:volume],
+          pitch: options[:pitch],
+          proxy: options[:proxy],
+          verbose: options[:verbose]
+        )
+
+        submaker = RbEdgeTTS::SubMaker.new
+
+        audio_file = if options[:write_media] && options[:write_media] != '-'
+                       File.open(options[:write_media], 'wb')
+                     else
+                       STDOUT.binmode
+                       STDOUT
+                     end
+
+        sub_file = if options[:write_subtitles] && options[:write_subtitles] != '-'
+                     File.open(options[:write_subtitles], 'w', encoding: 'utf-8')
+                   elsif options[:write_subtitles] == '-'
+                     STDERR
+                   else
+                     nil
+                   end
+
+        begin
+          communicate.stream do |chunk|
+            if chunk.type == 'audio'
+              audio_file.write(chunk.data)
+            elsif %w[WordBoundary SentenceBoundary].include?(chunk.type) && sub_file
+              submaker.feed(chunk)
+            end
+          end
+
+          sub_file.puts(submaker.get_srt) if sub_file
+        ensure
+          audio_file.close if audio_file != STDOUT
+          sub_file.close if sub_file && sub_file != STDERR
+        end
+      rescue Interrupt
+        warn "\nOperation canceled."
+        exit 1
+      end
+    end
+  end
+end
+
+RbEdgeTTS::CLI.run(ARGV)

data/lib/edge_playback/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EdgePlayback
+  VERSION = RbEdgeTTS::VERSION
+end

data/lib/rb_edge_tts/communicate.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require 'eventmachine'
+require 'faye/websocket'
+require 'json'
+require 'openssl'
+require 'time'
+require 'securerandom'
+
+require_relative 'typing'
+require_relative 'constants'
+require_relative 'drm'
+require_relative 'util'
+require_relative 'srt_composer'
+require_relative 'submaker'
+require_relative 'voices_manager'
+
+module RbEdgeTTS
+  class Communicate
+    attr_accessor :texts, :proxy, :state, :tts_config
+
+    def initialize(text,
+                   voice = RbEdgeTTS::DEFAULT_VOICE,
+                   rate: '+0%',
+                   volume: '+0%',
+                   pitch: '+0Hz',
+                   boundary: 'SentenceBoundary',
+                   proxy: nil,
+                   connect_timeout: 10,
+                   receive_timeout: 60,
+                   verbose: false)
+      raise TypeError, 'text must be a string' unless text.is_a?(String)
+
+      @tts_config = TTSConfig.new(voice, rate, volume, pitch, boundary)
+
+      @texts = Util.split_text_by_byte_length(Util.escape_xml(Util.remove_incompatible_characters(text)), 4096).to_a
+
+      @proxy = proxy
+      raise TypeError, 'proxy must be a string' if proxy && !proxy.is_a?(String)
+
+      raise TypeError, 'connect_timeout must be an integer' unless connect_timeout.is_a?(Integer)
+      raise TypeError, 'receive_timeout must be an integer' unless receive_timeout.is_a?(Integer)
+
+      @connect_timeout = connect_timeout
+      @receive_timeout = receive_timeout
+      @verbose = verbose
+
+      @state = CommunicateState.new(
+        partial_text: '',
+        offset_compensation: 0,
+        last_duration_offset: 0,
+        stream_was_called: false
+      )
+    end
+
+    def stream(&block)
+      raise 'stream can only be called once.' if @state.stream_was_called
+
+      @state.stream_was_called = true
+
+      @texts.each do |partial_text|
+        @state.partial_text = partial_text
+        stream_internal(&block)
+      end
+    end
+
+    def stream_sync
+      queue = Thread::Queue.new
+
+      thread = Thread.new do
+        stream do |chunk|
+          queue.push(chunk)
+        end
+        queue.push(nil)
+      end
+
+      Enumerator.new do |yielder|
+        loop do
+          chunk = queue.pop
+          break if chunk.nil?
+
+          yielder << chunk
+        end
+      ensure
+        thread&.join
+      end
+    end
+
+    def save(audio_fname, metadata_fname = nil, &block)
+      raise TypeError, 'audio_fname must be a string' unless audio_fname.is_a?(String)
+      raise TypeError, 'metadata_fname must be a string' if metadata_fname && !metadata_fname.is_a?(String)
+
+      File.open(audio_fname, 'wb') do |audio_file|
+        metadata_file = metadata_fname ? File.open(metadata_fname, 'w', encoding: 'utf-8') : nil
+
+        stream do |chunk|
+          if chunk.type == 'audio'
+            audio_file.write(chunk.data)
+          elsif metadata_file && %w[WordBoundary SentenceBoundary].include?(chunk.type)
+            metadata_file.puts(JSON.generate(chunk.to_h))
+            block.call(chunk) if block_given?
+          end
+        end
+      ensure
+        metadata_file&.close if metadata_file && metadata_file != audio_file
+        audio_file.close
+      end
+    end
+
+    def save_sync(audio_fname, metadata_fname = nil, &block)
+      raise TypeError, 'audio_fname must be a string' unless audio_fname.is_a?(String)
+      raise TypeError, 'metadata_fname must be a string' if metadata_fname && !metadata_fname.is_a?(String)
+
+      Thread.new { save(audio_fname, metadata_fname, &block) }.join
+    end
+
+    private
+
+    def stream_internal
+      audio_was_received = false
+      @ws = nil
+
+      begin
+        EventMachine.run do
+          url = "#{RbEdgeTTS::WSS_URL}&ConnectionId=#{Util.connect_id}&Sec-MS-GEC=#{DRM.generate_sec_ms_gec}&Sec-MS-GEC-Version=#{RbEdgeTTS::SEC_MS_GEC_VERSION}"
+
+          options = {
+            headers: DRM.headers_with_muid(RbEdgeTTS::WSS_HEADERS),
+            tls: {
+              verify_peer: true,
+              ca_file: OpenSSL::X509::DEFAULT_CERT_FILE
+            }
+          }
+
+          @ws = Faye::WebSocket::Client.new(url, [], options)
+
+          @ws.on :open do |_event|
+            log 'WebSocket connection opened'
+            send_command_request(@ws)
+            send_ssml_request(@ws)
+          end
+
+          @ws.on :message do |event|
+            handle_message(event.data) do |result|
+              if result.type == 'audio'
+                audio_was_received = true
+              end
+              yield result
+            end
+          end
+
+
+          @ws.on :close do |event|
+            # 1006 is common after successful transmission
+            log "WebSocket connection closed: #{event.code} #{event.reason}" unless event.code == 1006
+            EventMachine.stop
+          end
+
+          @ws.on :error do |event|
+            # Ignore ECONNRESET as it often happens at the end of stream
+            log "WebSocket Error: #{event.message}" unless event.message.to_s.include?('ECONNRESET')
+            EventMachine.stop
+          end
+
+          EventMachine.add_timer(@receive_timeout) do
+            puts "Timeout: No response in #{@receive_timeout} seconds"
+            EventMachine.stop
+          end
+        end
+      rescue StandardError => e
+        raise unless e.message.include?('403')
+
+        DRM.handle_client_response_error(e)
+        retry
+      end
+    end
+
+    def send_command_request(ws)
+      log 'Sending command request:'
+      request = DRM.command_request(@tts_config.boundary)
+      log request
+      ws.send(request)
+    end
+
+    def send_ssml_request(ws)
+      ssml = Util.mkssml(@tts_config, @state.partial_text)
+
+      request = "X-RequestId:#{Util.connect_id}\r\n" \
+                "Content-Type:application/ssml+xml\r\n" \
+                "X-Timestamp:#{Util.date_to_string}Z\r\n" \
+                "Path:ssml\r\n\r\n" \
+                "#{ssml}"
+
+      ws.send(request)
+    end
+
+    def handle_message(data, &block)
+      case data
+      when String
+        handle_text_message(data, &block)
+      when Array
+        handle_binary_message(data, &block)
+      else
+        handle_binary_message(data, &block)
+      end
+    end
+
+    def handle_text_message(data, &block)
+      return if data.nil? || data.empty?
+
+      header_end = data.index("\r\n\r\n")
+      unless header_end
+        if data.length > 2
+           handle_binary_message(data.bytes, &block)
+           return
+        end
+      end
+      return unless header_end
+
+      headers = data[0...header_end]
+      body = data[(header_end + 4)..-1]
+
+      path = extract_header_value(headers, 'Path')
+      if path.nil?
+        if headers.include?('Path:audio')
+           handle_binary_message(data.bytes, &block)
+           return
+        end
+      end
+      return unless path
+
+      case path
+      when 'audio.metadata'
+        handle_metadata(body, &block)
+        update_last_duration_offset(body)
+      when 'audio'
+        handle_binary_message(data.bytes, &block)
+      when 'turn.end'
+        update_offset_compensation
+        @ws&.close
+      when 'response', 'turn.start', 'path', 'SessionEnd'
+        nil
+      else
+        raise UnknownResponse, "Unknown path received: #{path}"
+      end
+    end
+
+    def handle_binary_message(data)
+      return if data.nil? || data.length < 2
+
+      header_length = (data[0] << 8) | data[1]
+
+      if header_length > data.length
+        raise UnexpectedResponse, 'The header length is greater than the length of the data.'
+      end
+
+      header_end = 2 + header_length
+      headers = data[2...header_end].pack('C*').force_encoding('utf-8')
+      body = data[header_end..-1].pack('C*')
+
+      path = extract_header_value(headers, 'Path')
+
+      raise UnexpectedResponse, "Received binary message, but the path is not audio: #{path}" if path != 'audio'
+
+      content_type = extract_header_value(headers, 'Content-Type')
+
+      if content_type && content_type != 'audio/mpeg'
+        raise UnexpectedResponse, "Received binary message, but with an unexpected Content-Type: #{content_type}"
+      end
+
+      return if content_type.nil? && body.nil?
+
+      return if body.nil? || body.empty?
+
+      yield TTSChunk.new(type: 'audio', data: body)
+    end
+
+    def handle_metadata(data)
+      return if data.nil? || data.empty?
+
+      begin
+        metadata = JSON.parse(data)
+        return unless metadata.is_a?(Hash) && metadata['Metadata'].is_a?(Array)
+
+        metadata['Metadata'].each do |meta_obj|
+          meta_type = meta_obj['Type']
+          next unless %w[WordBoundary SentenceBoundary].include?(meta_type)
+
+          data_obj = meta_obj['Data']
+          current_offset = (data_obj['Offset'] || 0) + @state.offset_compensation
+          current_duration = data_obj['Duration'] || 0
+
+          yield TTSChunk.new(
+            type: meta_type,
+            offset: current_offset,
+            duration: current_duration,
+            text: Util.unescape_xml(data_obj.dig('text', 'Text') || '')
+          )
+        end
+      rescue JSON::ParserError => e
+        puts "JSON parse error: #{e.message}"
+      end
+    end
+
+    def extract_header_value(headers, key)
+      return nil unless headers.is_a?(String)
+
+      match = headers.match(/^#{Regexp.escape(key)}:([^\r\n]*)/i)
+      match ? match[1].strip : nil
+    end
+
+    def update_last_duration_offset(data)
+      metadata = JSON.parse(data)
+      return unless metadata.is_a?(Hash) && metadata['Metadata'].is_a?(Array)
+
+      metadata['Metadata'].each do |meta_obj|
+        next unless %w[WordBoundary SentenceBoundary].include?(meta_obj['Type'])
+
+        data_obj = meta_obj['Data']
+        @state.last_duration_offset = (data_obj['Offset'] || 0) + (data_obj['Duration'] || 0)
+      end
+    rescue JSON::ParserError
+      nil
+    end
+
+    def update_offset_compensation
+      @state.offset_compensation = @state.last_duration_offset
+      @state.offset_compensation += 8_750_000
+    end
+
+    def log(message)
+      puts message if @verbose
+    end
+  end
+end
+