cohere-transcribe 0.1.2 → 0.1.3

data/lib/cohere/transcribe/audio/decoder.rb

@@ -63,6 +63,7 @@ module Cohere
                           ])
           extern "void* sf_open(const char*, int, void*)"
           extern "long long sf_readf_float(void*, void*, long long)"
+          extern "int sf_command(void*, int, void*, int)"
           extern "int sf_close(void*)"
           extern "const char* sf_strerror(void*)"
           AVAILABLE = true
@@ -115,8 +116,70 @@ module Cohere
         module_function
 
         SFM_READ = 0x10
+        SFC_GET_CHANNEL_MAP_INFO = 0x1100
         SRC_SINC_FASTEST = 2
         BACKENDS = %w[auto ffmpeg torchcodec librosa libsndfile].freeze
+        SQRT_HALF = Math.sqrt(0.5)
+        DEFAULT_MONO_MIXES = {
+          1 => [1.0],
+          2 => [SQRT_HALF, SQRT_HALF],
+          3 => [SQRT_HALF, SQRT_HALF, 0.0], # FFmpeg's unspecified 3-channel default is 2.1, not 3.0
+          4 => [SQRT_HALF, SQRT_HALF, 1.0, 0.5],
+          5 => [SQRT_HALF, SQRT_HALF, 1.0, 0.5, 0.5],
+          6 => [SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5],
+          7 => [SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5, 0.5],
+          8 => [SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5, 0.5, 0.5],
+          10 => [SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5, SQRT_HALF, SQRT_HALF, 0.0, 0.0],
+          12 => [
+            SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5, 0.5, 0.5,
+            SQRT_HALF, SQRT_HALF, 0.0, 0.0
+          ],
+          16 => [
+            SQRT_HALF, SQRT_HALF, 1.0, 0.5, 0.5, 0.5, 0.5, 0.5,
+            SQRT_HALF, 0.0, SQRT_HALF, 0.0, 0.0, 0.0, 0.0, 0.0
+          ],
+          24 => [
+            SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5, SQRT_HALF, SQRT_HALF,
+            0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
+          ]
+        }.transform_values(&:freeze).freeze
+        FFMPEG_7_DEFAULT_MONO_MIXES = {
+          14 => [
+            SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5, SQRT_HALF, SQRT_HALF,
+            0.5, 0.5, SQRT_HALF, SQRT_HALF, 0.0, 0.0
+          ]
+        }.transform_values(&:freeze).freeze
+        FFMPEG_8_DEFAULT_MONO_MIXES = {
+          16 => [
+            SQRT_HALF, SQRT_HALF, 1.0, 0.0, 0.5, 0.5, SQRT_HALF, SQRT_HALF,
+            0.5, 0.5, SQRT_HALF, SQRT_HALF, 0.0, 0.0, 0.0, 0.0
+          ]
+        }.transform_values(&:freeze).freeze
+        CHANNEL_POSITION_MONO_MIXES = {
+          1 => 1.0,       # mono
+          2 => SQRT_HALF, # left
+          3 => SQRT_HALF, # right
+          4 => 1.0,       # center
+          5 => SQRT_HALF, # front left
+          6 => SQRT_HALF, # front right
+          7 => 1.0,       # front center
+          8 => 0.5,       # rear center
+          9 => 0.5,       # rear left
+          10 => 0.5,      # rear right
+          11 => 0.0,      # low-frequency effects
+          12 => SQRT_HALF, # front left of center
+          13 => SQRT_HALF, # front right of center
+          14 => 0.5,      # side left
+          15 => 0.5,      # side right
+          16 => 0.0,      # top center
+          17 => SQRT_HALF, # top front left
+          18 => SQRT_HALF, # top front right
+          19 => 0.0,      # top front center
+          20 => 0.0,      # top rear left
+          21 => 0.0,      # top rear right
+          22 => 0.0       # top rear center
+        }.freeze
 
         # Best-effort metadata probe used for public skipped-result parity. It
         # may inspect container headers and demuxer probe packets but never
@@ -131,8 +194,7 @@ module Cohere
           end
           return nil unless SoundFileABI::AVAILABLE
 
-          SoundFileABI::SFInfo.malloc(Fiddle::RUBY_FREE) do |info|
-            handle = SoundFileABI.sf_open(source.to_s, SFM_READ, info.to_ptr)
+          with_sound_file(source) do |handle, info|
             return nil if handle.null?
 
             frames = Integer(info.frames)
@@ -146,8 +208,6 @@ module Cohere
           end
         rescue Fiddle::DLError, SystemCallError, TranscriptionRuntimeError
           nil
-        ensure
-          SoundFileABI.sf_close(handle) if defined?(handle) && handle && !handle.null?
         end
 
         # Best-effort upper bound for the buffers governed by max_decoded_bytes.
@@ -161,10 +221,7 @@ module Cohere
           source = Pathname(path).expand_path
           return unless source.file?
 
-          native_ffmpeg_available = %w[auto librosa].include?(requested) && FFmpegNative.available?
-          use_ffmpeg = requested == "ffmpeg" || requested == "torchcodec" ||
-                       (%w[auto librosa].include?(requested) && native_ffmpeg_available)
-          if use_ffmpeg
+          if ffmpeg_backend?(requested)
             duration = FFmpegNative.duration(source)
             return unless duration&.finite? && duration >= 0.0
 
@@ -172,8 +229,7 @@ module Cohere
           end
           return unless SoundFileABI::AVAILABLE
 
-          SoundFileABI::SFInfo.malloc(Fiddle::RUBY_FREE) do |info|
-            handle = SoundFileABI.sf_open(source.to_s, SFM_READ, info.to_ptr)
+          with_sound_file(source) do |handle, info|
             next if handle.null?
 
             frames = Integer(info.frames)
@@ -181,14 +237,10 @@ module Cohere
             source_rate = Integer(info.samplerate)
             next unless frames >= 0 && channels.positive? && source_rate.positive?
 
-            input_bytes = frames * channels * Fiddle::SIZEOF_FLOAT
-            output_frames = (frames * sample_rate.fdiv(source_rate)).ceil + 64
-            [input_bytes, output_frames * Fiddle::SIZEOF_FLOAT].max
+            projected_decoded_bytes(frames, channels, source_rate, sample_rate)
           end
         rescue Fiddle::DLError, SystemCallError, TranscriptionRuntimeError
           nil
-        ensure
-          SoundFileABI.sf_close(handle) if defined?(handle) && handle && !handle.null?
         end
 
         def decode(path, backend: "auto", sample_rate: SAMPLE_RATE, max_decoded_bytes: 4 * (1024**3))
@@ -205,10 +257,7 @@ module Cohere
           raise TranscriptionInputError, "Input does not exist: #{source}" unless source.exist?
           raise TranscriptionInputError, "Input is not a regular file: #{source}" unless source.file?
 
-          native_ffmpeg_available = %w[auto librosa].include?(requested) && FFmpegNative.available?
-          use_ffmpeg = requested == "ffmpeg" || requested == "torchcodec" ||
-                       (%w[auto librosa].include?(requested) && native_ffmpeg_available)
-          if use_ffmpeg
+          if ffmpeg_backend?(requested)
             samples = FFmpegNative.decode(
               source,
               sample_rate: sample_rate,
@@ -239,67 +288,54 @@ module Cohere
             raise TranscriptionRuntimeError, "libsndfile is required for native audio decoding: #{sound_file_error}"
           end
 
-          SoundFileABI::SFInfo.malloc(Fiddle::RUBY_FREE) do |info|
-            handle = SoundFileABI.sf_open(source.to_s, SFM_READ, info.to_ptr)
+          with_sound_file(source) do |handle, info|
             raise TranscriptionRuntimeError, "Cannot decode #{source}: #{SoundFileABI.sf_strerror(handle)}" if handle.null?
 
-            begin
-              frames = Integer(info.frames)
-              channels = Integer(info.channels)
-              source_rate = Integer(info.samplerate)
-              unless frames >= 0 && channels.positive? && source_rate.positive?
-                raise TranscriptionRuntimeError, "Decoder returned invalid audio metadata for #{source}"
-              end
+            frames = Integer(info.frames)
+            channels = Integer(info.channels)
+            source_rate = Integer(info.samplerate)
+            unless frames >= 0 && channels.positive? && source_rate.positive?
+              raise TranscriptionRuntimeError, "Decoder returned invalid audio metadata for #{source}"
+            end
 
-              input_bytes = frames * channels * Fiddle::SIZEOF_FLOAT
-              output_frames = (frames * sample_rate.fdiv(source_rate)).ceil + 64
-              projected_bytes = [input_bytes, output_frames * Fiddle::SIZEOF_FLOAT].max
-              if max_decoded_bytes && projected_bytes > max_decoded_bytes
-                raise TranscriptionRuntimeError,
-                      "Decoded audio exceeds the configured memory limit for #{source} " \
-                      "(#{projected_bytes} > #{max_decoded_bytes} bytes)"
-              end
+            input_bytes = frames * channels * Fiddle::SIZEOF_FLOAT
+            projected_bytes = projected_decoded_bytes(frames, channels, source_rate, sample_rate)
+            if max_decoded_bytes && projected_bytes > max_decoded_bytes
+              raise DecodedAudioLimitError,
+                    "Decoded audio exceeds the configured memory limit for #{source} " \
+                    "(#{projected_bytes} > #{max_decoded_bytes} bytes)"
+            end
 
-              raw = Fiddle::Pointer.malloc([input_bytes, 1].max, Fiddle::RUBY_FREE)
-              read_frames = SoundFileABI.sf_readf_float(handle, raw, frames)
-              raise TranscriptionRuntimeError, "Cannot decode #{source}: #{SoundFileABI.sf_strerror(handle)}" if read_frames.negative?
-              raise TranscriptionRuntimeError, "Decoder returned more frames than allocated for #{source}" if read_frames > frames
+            raw = Fiddle::Pointer.malloc([input_bytes, 1].max, Fiddle::RUBY_FREE)
+            channel_map = sound_file_channel_map(handle, channels)
+            read_frames = SoundFileABI.sf_readf_float(handle, raw, frames)
+            raise TranscriptionRuntimeError, "Cannot decode #{source}: #{SoundFileABI.sf_strerror(handle)}" if read_frames.negative?
+            raise TranscriptionRuntimeError, "Decoder returned more frames than allocated for #{source}" if read_frames > frames
 
-              frames = read_frames
-              begin
-                require "numo/narray"
-              rescue LoadError => e
-                raise TranscriptionRuntimeError, "numo-narray is required for decoded audio: #{e.message}"
-              end
-              interleaved = if frames.zero?
-                              nil
-                            else
-                              Numo::SFloat.from_binary(raw[0, frames * channels * Fiddle::SIZEOF_FLOAT])
-                            end
-              mono = if frames.zero?
-                       Numo::SFloat.zeros(0)
-                     elsif channels == 1
-                       interleaved
-                     elsif channels == 2
-                       (interleaved.reshape(frames, channels).sum(1) * Math.sqrt(0.5)).cast_to(Numo::SFloat)
-                     else
-                       interleaved.reshape(frames, channels).mean(1).cast_to(Numo::SFloat)
-                     end
-              samples = source_rate == sample_rate ? mono : resample(mono, source_rate, sample_rate, max_decoded_bytes)
-              validate_finite!(samples)
-              Decoded.new(
-                samples: samples.freeze,
-                sample_rate: sample_rate,
-                backend: "libsndfile",
-                fallback_reason: if %w[auto libsndfile].include?(requested)
-                                   nil
-                                 else
-                                   "Ruby #{requested} compatibility mode uses the native libsndfile ABI"
-                                 end
-              )
-            ensure
-              SoundFileABI.sf_close(handle)
+            frames = read_frames
+            begin
+              require "numo/narray"
+            rescue LoadError => e
+              raise TranscriptionRuntimeError, "numo-narray is required for decoded audio: #{e.message}"
             end
+            interleaved = if frames.zero?
+                            nil
+                          else
+                            Numo::SFloat.from_binary(raw[0, frames * channels * Fiddle::SIZEOF_FLOAT])
+                          end
+            mono = downmix(interleaved, frames, channels, channel_map)
+            samples = source_rate == sample_rate ? mono : resample(mono, source_rate, sample_rate, max_decoded_bytes)
+            validate_finite!(samples)
+            Decoded.new(
+              samples: samples.freeze,
+              sample_rate: sample_rate,
+              backend: "libsndfile",
+              fallback_reason: if %w[auto libsndfile].include?(requested)
+                                 nil
+                               else
+                                 "Ruby #{requested} compatibility mode uses the native libsndfile ABI"
+                               end
+            )
           end
         end
 
@@ -318,7 +354,7 @@ module Cohere
           output_capacity = (samples.length * ratio).ceil + 64
           bytes = output_capacity * Fiddle::SIZEOF_FLOAT
           if max_decoded_bytes && bytes > max_decoded_bytes
-            raise TranscriptionRuntimeError, "Resampled audio exceeds the configured memory limit"
+            raise DecodedAudioLimitError, "Resampled audio exceeds the configured memory limit"
           end
 
           input_string = samples.to_binary
@@ -357,6 +393,79 @@ module Cohere
           samples
         end
         private_class_method :validate_finite!
+
+        def ffmpeg_backend?(requested)
+          return true if %w[ffmpeg torchcodec].include?(requested)
+
+          %w[auto librosa].include?(requested) && FFmpegNative.available?
+        end
+        private_class_method :ffmpeg_backend?
+
+        def projected_decoded_bytes(frames, channels, source_rate, target_rate)
+          input_bytes = frames * channels * Fiddle::SIZEOF_FLOAT
+          output_frames = (frames * target_rate.fdiv(source_rate)).ceil + 64
+          [input_bytes, output_frames * Fiddle::SIZEOF_FLOAT].max
+        end
+        private_class_method :projected_decoded_bytes
+
+        def with_sound_file(source)
+          SoundFileABI::SFInfo.malloc(Fiddle::RUBY_FREE) do |info|
+            Thread.handle_interrupt(Object => :never) do
+              handle = SoundFileABI.sf_open(source.to_s, SFM_READ, info.to_ptr)
+              begin
+                Thread.handle_interrupt(Object => :immediate) { yield handle, info }
+              ensure
+                SoundFileABI.sf_close(handle) unless handle.null?
+              end
+            end
+          end
+        end
+        private_class_method :with_sound_file
+
+        # libswresample's default mono matrix. Explicit libsndfile positions
+        # preserve height-channel layouts, while the numeric fallbacks mirror
+        # the first standard layout selected by av_channel_layout_default.
+        def downmix(interleaved, frames, channels, channel_map)
+          return Numo::SFloat.zeros(0) if frames.zero?
+          return interleaved if channels == 1
+
+          matrix = interleaved.reshape(frames, channels)
+          weights = channel_map&.map { |position| CHANNEL_POSITION_MONO_MIXES[position] }
+          weights = nil if weights&.any?(&:nil?)
+          weights ||= default_mono_mix(channels)
+          return matrix.mean(1).cast_to(Numo::SFloat) unless weights
+
+          matrix.dot(Numo::SFloat[*weights]).cast_to(Numo::SFloat)
+        end
+        private_class_method :downmix
+
+        def default_mono_mix(channels)
+          case channels
+          when 14, 16
+            avutil_major = FFmpegNative.avutil_major
+            if avutil_major && avutil_major >= 60 && (weights = FFMPEG_8_DEFAULT_MONO_MIXES[channels])
+              return weights
+            end
+            if avutil_major && avutil_major >= 59 && (weights = FFMPEG_7_DEFAULT_MONO_MIXES[channels])
+              return weights
+            end
+          end
+
+          DEFAULT_MONO_MIXES[channels]
+        end
+        private_class_method :default_mono_mix
+
+        def sound_file_channel_map(handle, channels)
+          buffer = Array.new(channels, 0).pack("i!*")
+          available = SoundFileABI.sf_command(
+            handle,
+            SFC_GET_CHANNEL_MAP_INFO,
+            Fiddle::Pointer[buffer],
+            buffer.bytesize
+          )
+          available == 1 ? buffer.unpack("i!*") : nil
+        end
+        private_class_method :sound_file_channel_map
       end
     end
   end

data/lib/cohere/transcribe/audio/ffmpeg_native.rb

@@ -4,16 +4,21 @@ require "fiddle"
 require "rbconfig"
 
 require_relative "../errors"
+require_relative "../internal/interruptible_native_call"
 
 module Cohere
   module Transcribe
     module Audio
+      class DecodedAudioLimitError < TranscriptionRuntimeError; end
+
       # Lazy binding for the gem's subprocess-free libav decoder adapter. The
       # adapter itself dynamically selects a compatible FFmpeg 4-8 runtime;
       # Ruby never launches ffmpeg and does not retain a Python codec runtime.
       module FFmpegNative
         ERROR_CAPACITY = 1_024
         CANCELLED_STATUS = 6
+        DECODED_AUDIO_LIMIT_STATUS = 4
+        CANCELLATION_JOIN_INTERVAL = 0.01
 
         class Library
           FUNCTIONS = {
@@ -24,6 +29,10 @@ module Cohere
             free: [[:voidp], :void]
           }.freeze
 
+          OPTIONAL_FUNCTIONS = {
+            versions: [%i[voidp size_t], :int]
+          }.freeze
+
           TYPE_MAP = {
             void: Fiddle::TYPE_VOID,
             voidp: Fiddle::TYPE_VOIDP,
@@ -35,6 +44,9 @@ module Cohere
           class << self
             def load
               @mutex ||= Mutex.new
+              # A failed load is deliberately retryable. Embedders may set an
+              # adapter override or make a packaged/system library available
+              # after an earlier best-effort audio probe.
               @mutex.synchronize { @instance ||= load_uncached }
             end
 
@@ -84,20 +96,20 @@ module Cohere
             end
           end
 
-          attr_reader :path, :diagnostic
+          attr_reader :path, :diagnostic, :ffmpeg_versions, :avutil_major
 
           def initialize(path)
             @path = path
             @handle = Fiddle::Handle.new(path, Fiddle::RTLD_NOW)
-            @functions = FUNCTIONS.to_h do |name, (arguments, result)|
-              address = @handle["cohere_audio_ffmpeg_#{name}"]
-              function = Fiddle::Function.new(
-                address,
-                arguments.map { |type| TYPE_MAP.fetch(type) },
-                TYPE_MAP.fetch(result)
-              )
-              [name, function]
-            end.freeze
+            functions = FUNCTIONS.to_h do |name, signature|
+              [name, bind_function(name, signature)]
+            end
+            OPTIONAL_FUNCTIONS.each do |name, signature|
+              functions[name] = bind_function(name, signature)
+            rescue Fiddle::DLError
+              nil
+            end
+            @functions = functions.freeze
           end
 
           def probe!
@@ -105,31 +117,41 @@ module Cohere
             message[0, ERROR_CAPACITY] = "\0" * ERROR_CAPACITY
             status = @functions.fetch(:probe).call(message, ERROR_CAPACITY)
             @diagnostic = message.to_s.force_encoding(Encoding::UTF_8).scrub.freeze
-            return self if status.zero?
+            raise TranscriptionRuntimeError, "Native FFmpeg libraries are unavailable: #{@diagnostic}" unless status.zero?
 
-            raise TranscriptionRuntimeError, "Native FFmpeg libraries are unavailable: #{@diagnostic}"
+            versions = @functions[:versions]
+            return clear_ffmpeg_versions unless versions
+
+            tuple_bytes = 4 * Fiddle::SIZEOF_INT
+            tuple = Fiddle::Pointer.malloc(tuple_bytes, Fiddle::RUBY_FREE)
+            tuple[0, tuple_bytes] = [0, 0, 0, 0].pack("i!*")
+            version_status = versions.call(tuple, 4)
+            unless version_status.zero?
+              raise TranscriptionRuntimeError,
+                    "Native FFmpeg libraries did not report their version tuple: #{@diagnostic}"
+            end
+
+            @ffmpeg_versions = tuple[0, tuple_bytes].unpack("i!4").freeze
+            unless @ffmpeg_versions.all?(&:positive?)
+              raise TranscriptionRuntimeError,
+                    "Native FFmpeg libraries reported an invalid version tuple: #{@ffmpeg_versions.inspect}"
+            end
+
+            @avutil_major = @ffmpeg_versions.fetch(2)
+            self
           end
 
           def decode(path, sample_rate:, max_decoded_bytes:)
-            worker = Thread.new do
+            Internal::InterruptibleNativeCall.run(
+              cancel: -> { @functions.fetch(:cancel).call },
+              join_interval: CANCELLATION_JOIN_INTERVAL,
+              missing_outcome: TranscriptionRuntimeError.new(
+                "Native FFmpeg decode worker exited without reporting an outcome"
+              ),
+              thread_name: "cohere-ffmpeg-decode"
+            ) do
               decode_owned(path, sample_rate: sample_rate, max_decoded_bytes: max_decoded_bytes)
             end
-            worker.name = "cohere-ffmpeg-decode" if worker.respond_to?(:name=)
-            worker.report_on_exception = false
-            completed = false
-            result = worker.value
-            completed = true
-            result
-          ensure
-            if defined?(worker) && worker && !completed
-              Thread.handle_interrupt(Exception => :never) do
-                @functions.fetch(:cancel).call if worker.alive?
-              rescue StandardError
-                nil
-              ensure
-                worker.join
-              end
-            end
           end
 
           def decode_owned(path, sample_rate:, max_decoded_bytes:)
@@ -142,7 +164,7 @@ module Cohere
             maximum = max_decoded_bytes || 0
 
             address = 0
-            Thread.handle_interrupt(Exception => :never) do
+            Thread.handle_interrupt(Object => :never) do
               status = @functions.fetch(:decode).call(
                 c_string(path.to_s),
                 sample_rate,
@@ -154,11 +176,14 @@ module Cohere
               )
               address = output_slot[0, Fiddle::SIZEOF_VOIDP].unpack1("J")
               begin
-                Thread.handle_interrupt(Exception => :immediate) do
+                Thread.handle_interrupt(Object => :immediate) do
                   count = count_slot[0, Fiddle::SIZEOF_INT64_T].unpack1("q")
                   detail = message.to_s.force_encoding(Encoding::UTF_8).scrub
                   unless status.zero?
                     raise Interrupt, "Native FFmpeg decode was cancelled for #{path}: #{detail}" if status == CANCELLED_STATUS
+                    if status == DECODED_AUDIO_LIMIT_STATUS
+                      raise DecodedAudioLimitError, "Cannot decode #{path} through native FFmpeg: #{detail}"
+                    end
 
                     raise TranscriptionRuntimeError, "Cannot decode #{path} through native FFmpeg: #{detail}"
                   end
@@ -168,7 +193,7 @@ module Cohere
 
                   bytes = count * Fiddle::SIZEOF_FLOAT
                   if max_decoded_bytes && bytes > max_decoded_bytes
-                    raise TranscriptionRuntimeError,
+                    raise DecodedAudioLimitError,
                           "Native FFmpeg exceeded the configured decoded-audio memory limit for #{path}"
                   end
 
@@ -223,6 +248,21 @@ module Cohere
 
           private :decode_owned
 
+          def bind_function(name, (arguments, result))
+            address = @handle["cohere_audio_ffmpeg_#{name}"]
+            Fiddle::Function.new(
+              address,
+              arguments.map { |type| TYPE_MAP.fetch(type) },
+              TYPE_MAP.fetch(result)
+            )
+          end
+
+          def clear_ffmpeg_versions
+            @ffmpeg_versions = nil
+            @avutil_major = nil
+            self
+          end
+
           def c_string(value)
             Fiddle::Pointer["#{value}\0"]
           end
@@ -247,6 +287,18 @@ module Cohere
           e.message
         end
 
+        def avutil_major
+          library.avutil_major
+        rescue TranscriptionRuntimeError
+          nil
+        end
+
+        def ffmpeg_versions
+          library.ffmpeg_versions
+        rescue TranscriptionRuntimeError
+          nil
+        end
+
         def decode(path, sample_rate:, max_decoded_bytes:)
           library.decode(path, sample_rate: sample_rate, max_decoded_bytes: max_decoded_bytes)
         end

data/lib/cohere/transcribe/audio/segmentation.rb

@@ -33,6 +33,7 @@ module Cohere
             start_time = Float(raw_start)
             end_time = Float(raw_end)
             raise ArgumentError, "Segment #{index} has non-finite bounds" unless start_time.finite? && end_time.finite?
+            raise ArgumentError, "Segment #{index} has inverted bounds" if end_time < start_time
             if start_time < -tolerance || end_time > duration + tolerance
               raise ArgumentError,
                     format("Segment %<index>d lies outside the audio: %<start>.6f..%<end>.6f for %<duration>.6fs",