wavify 0.1.0 → 0.2.0

data/lib/wavify/codecs/base.rb

@@ -7,6 +7,9 @@ module Wavify
     #
     # Concrete codecs implement the class methods below.
     class Base
+      READ_CHUNK_SIZE = 64 * 1024
+      private_constant :READ_CHUNK_SIZE
+
       class << self
         # Returns whether this codec can read the given path/IO.
         #
@@ -31,7 +34,7 @@ module Wavify
         # @param _sample_buffer [Wavify::Core::SampleBuffer]
         # @param format [Wavify::Core::Format]
         # @return [String, IO]
-        def write(_io_or_path, _sample_buffer, format:)
+        def write(_io_or_path, _sample_buffer, format:, **_codec_options)
           raise NotImplementedError
         end
 
@@ -49,7 +52,7 @@ module Wavify
         # @param _io_or_path [String, IO]
         # @param format [Wavify::Core::Format]
         # @return [Enumerator, String, IO]
-        def stream_write(_io_or_path, format:)
+        def stream_write(_io_or_path, format:, **_codec_options)
           raise NotImplementedError
         end
 
@@ -61,6 +64,13 @@ module Wavify
           raise NotImplementedError
         end
 
+        # Returns whether optional runtime dependencies for this codec are present.
+        #
+        # @return [Boolean]
+        def available?
+          true
+        end
+
         private
 
         def open_input(io_or_path)
@@ -79,11 +89,81 @@ module Wavify
           [File.open(io_or_path, "wb"), true]
         end
 
+        def prepare_output!(io, owned:)
+          io.binmode if io.respond_to?(:binmode)
+          return io.pos if owned
+          return nil unless io.respond_to?(:pos)
+
+          start_position = io.pos
+          if io.respond_to?(:size) && io.size > start_position && !io.respond_to?(:truncate)
+            raise StreamError, "caller-owned IO with trailing data must support truncate"
+          end
+          start_position
+        rescue IOError, SystemCallError => e
+          raise StreamError, "output IO position is unavailable: #{e.message}"
+        end
+
+        def finalize_output!(io, owned:)
+          io.flush if io.respond_to?(:flush)
+          return unless io.respond_to?(:pos)
+
+          end_position = io.pos
+          io.truncate(end_position) if !owned && io.respond_to?(:truncate)
+        rescue IOError, SystemCallError => e
+          raise StreamError, "failed to finalize output IO: #{e.message}"
+        end
+
         def read_exact(io, size, message)
-          data = io.read(size)
-          raise InvalidFormatError, message if data.nil? || data.bytesize != size
+          data = +"".b
+          while data.bytesize < size
+            chunk = io.read([size - data.bytesize, READ_CHUNK_SIZE].min)
+            break if chunk.nil? || chunk.empty?
+
+            data << chunk
+          end
+          raise InvalidFormatError, message if data.bytesize != size
+
+          data
+        end
+
+        def read_to_end(io, chunk_size: 16_384)
+          data = +"".b
+          loop do
+            chunk = io.read(chunk_size)
+            break if chunk.nil? || chunk.empty?
+
+            data << chunk
+          end
+          data
+        end
 
+        def probe_bytes(io, size)
+          ensure_seekable!(io)
+          original_position = io.pos
+          data = +"".b
+          while data.bytesize < size
+            chunk = io.read(size - data.bytesize)
+            break if chunk.nil? || chunk.empty?
+
+            data << chunk
+          end
           data
+        ensure
+          io.seek(original_position, IO::SEEK_SET) if defined?(original_position) && original_position
+        end
+
+        def write_all(io, data)
+          bytes = data.b
+          offset = 0
+          while offset < bytes.bytesize
+            written = io.write(bytes.byteslice(offset, bytes.bytesize - offset))
+            unless written.is_a?(Integer) && written.positive?
+              raise IOError, "write returned #{written.inspect} before all bytes were written"
+            end
+
+            offset += written
+          end
+          bytes.bytesize
         end
 
         def skip_bytes(io, count)
@@ -98,9 +178,22 @@ module Wavify
         end
 
         def ensure_seekable!(io)
-          return if io.respond_to?(:seek) && io.respond_to?(:pos)
+          if io.respond_to?(:seek) && io.respond_to?(:pos)
+            position = io.pos
+            io.seek(position, IO::SEEK_SET)
+            return
+          end
 
           raise StreamError, "codec requires seekable IO"
+        rescue IOError, SystemCallError => e
+          raise StreamError, "codec requires seekable IO: #{e.message}"
+        end
+
+        def validate_no_codec_options!(codec_options, operation:)
+          return if codec_options.empty?
+
+          names = codec_options.keys.map(&:inspect).join(", ")
+          raise InvalidParameterError, "unsupported #{operation} codec_options: #{names}"
         end
       end
     end