lame 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f9c8a30dc79a2724fb0a6361ee9d3e7d04524a8
+  data.tar.gz: 9a104153f78a75fcf6dbece38724d53a6f4b70c5
+SHA512:
+  metadata.gz: 3dc02e4a9f569481f0c5d071150f882f284f5509a341ccd797431318034061b2a54a56da0de88a36e4a770d37c7ac6af90bbbaca0ccf14d31948654e58473db5
+  data.tar.gz: 2fa5a1aa873a10ec03538953260a0dde515b32dde49d464022d097d28ba7f480541923efff32d50fc551bfbe5aba530a52658f86b926fc92e5afb7748c0a8c8f

data/.travis.yml

@@ -1,13 +1,12 @@
 language: ruby
 rvm:
+  - 2.2.0
+  - 2.1.5
   - 2.0.0
   - 1.9.3
-  - 1.8.7
-  - rbx-18mode
-  - rbx-19mode
+  - rbx-2.2.7
   - ruby-head
   - jruby-19mode
-  - jruby-18mode
   - jruby-head
 before_install:
 - sudo apt-get install -qq libmp3lame-dev

data/README.md

@@ -1,13 +1,17 @@
 # LAME
 
+[![Gem Version](https://badge.fury.io/rb/lame.png)](http://badge.fury.io/rb/lame)
 [![Build Status](https://travis-ci.org/rdvdijk/lame.png?branch=master)](https://travis-ci.org/rdvdijk/lame)
 [![Code Climate](https://codeclimate.com/github/rdvdijk/lame.png)](https://codeclimate.com/github/rdvdijk/lame)
 [![Coverage Status](https://coveralls.io/repos/rdvdijk/lame/badge.png?branch=master)](https://coveralls.io/r/rdvdijk/lame)
+[![Dependency Status](https://gemnasium.com/rdvdijk/lame.png)](https://gemnasium.com/rdvdijk/lame)
 
 FFI powered library for the [LAME MP3 encoder](http://lame.sourceforge.net/).
 
 ## Installation
 
+### Installing the gem
+
 Add this line to your application's Gemfile:
 
     gem 'lame'
@@ -20,6 +24,16 @@ Or install it yourself as:
 
     $ gem install lame
 
+### Installing LAME
+
+To use this gem, you need to have the LAME development library (`libmp3lame-dev`) installed.
+
+Ubuntu/Debian: `sudo apt-get install libmp3lame-dev`
+
+Mac OS X with Homebrew: `brew install lame`
+
+Or build it from source, visit the [LAME website](http://lame.sourceforge.net/).
+
 ## Usage
 
 Create a default `LAME::Encoder` with default settings:
@@ -54,27 +68,28 @@ See all encoding methods in the Encoding section below.
 
 ### Configuration
 
-(work in progress)
+Here are all the encoding configuration options. The values use here are the
+defaults. You can set any option prior to encoding.
 
 ```ruby
-# These are the defaults:
 encoder.configure do |config|
+  config.bitrate                     = 128
+  config.quality                     = 3
+  config.mode                        = :join_stereo
+
   config.number_of_samples           = 4294967295
-  config.input_samplerate            = 44100
   config.number_of_channels          = 2
+  config.input_samplerate            = 44100
+  config.output_samplerate           = 44100
   config.scale                       = 0.95
   config.scale_left                  = 1.0
   config.scale_left                  = 1.0
-  config.output_samplerate           = 44100
   config.analysis                    = false
   config.decode_only                 = false
-  config.quality                     = 3
-  config.mode                        = :join_stereo
   config.force_mid_side              = false
   config.free_format                 = false
   config.replay_gain                 = false
   config.decode_on_the_fly           = false
-  config.bitrate                     = 128
   config.preset                      = :EXTREME # no LAME default
   config.copyright                   = false
   config.original                    = true
@@ -89,11 +104,11 @@ encoder.configure do |config|
   config.emphasis                    = false
 
   # auto-detected by default
-  config.asm_optimization.mmx     = true
-  config.asm_optimization.amd3now = true
-  config.asm_optimization.sse     = true
+  config.asm_optimization.mmx       = true
+  config.asm_optimization.amd_3dnow = true
+  config.asm_optimization.sse       = true
 
-  # these values can't be "unset" once set to true
+  # these options can't be "unset" once set to true
   config.id3.v2              = false
   config.id3.v1_only         = false
   config.id3.v2_only         = false
@@ -101,6 +116,15 @@ encoder.configure do |config|
   config.id3.v2_padding      = false
   config.id3.v2_padding_size = 128
 
+  config.id3.write_automatic = true
+  config.id3.title           = nil
+  config.id3.artist          = nil
+  config.id3.album           = nil
+  config.id3.year            = nil
+  config.id3.comment         = nil
+  config.id3.track           = nil
+  config.id3.genre           = nil
+
   config.quantization.reservoir      = true
   config.quantization.comp           = 9
   config.quantization.comp_short     = 9
@@ -136,8 +160,8 @@ end
 
 ### Encoding
 
-See `spec/integration/encoding_spec.rb` for an example how to encode a WAV file
-to an MP3 file.
+See [`encoding_spec.rb`](spec/integration/encoding_spec.rb) for examples how
+to encode a WAV file to an MP3 file.
 
 The available encoding functions are:
 
@@ -174,13 +198,23 @@ The `left` and `right` are arrays of sample values for the given data type.
 
 ### Decoding
 
-See `spec/integration/decoding_spec.rb` for an example how to decode an MP3 file
-to an WAV file.
+See [`decoding_spec.rb`](spec/integration/decoding_spec.rb) for examples how
+to decode an MP3 file to an WAV file.
 
 ### Development
 
 This section contains some references used during development of this gem.
 
+#### Testing
+
+Run the unit tests with rspec:
+
+    $ rspec
+
+Run the integration tests by using the `slow` tag:
+
+    $ rspec -t slow
+
 #### ID3v2 tags
 
 To use ID3v2 tags in files, see this post on the `lame-dev` mailing list:
@@ -195,7 +229,7 @@ So:
 4. Write id3v1 tag at end of file
 5. Write vbr 'lametag' at start of audio (using the size of the id3v2 tag)
 
-See the example code in `spec/integration/encoding_spec.rb` for an example.
+See the example code in [`encoding_spec.rb`](spec/integration/encoding_spec.rb).
 
 #### Decoding
 
@@ -225,7 +259,7 @@ After this, we are ready to decode MP3 data.
 5. Handle the decoded audio.
 6. Now repeat this process (`GOTO 1`) until the end of the MP3 file.
 
-See the example code in `spec/integration/decoding_spec.rb` for an example.
+See the example code in [`decoding_spec.rb`](spec/integration/decoding_spec.rb).
 
 ## Contributing
 

data/lib/lame.rb

@@ -1,4 +1,5 @@
 require "ffi"
+require "forwardable"
 require "lame/version"
 require "lame/ffi"
 require "lame/error"

data/lib/lame/buffer.rb

@@ -3,7 +3,7 @@ module LAME
 
     def self.create(type, input)
       buffer = ::FFI::MemoryPointer.new(type, input.size)
-      buffer.put_array_of_short(0, input)
+      buffer.send(:"put_array_of_#{type}", 0, input)
       buffer
     end
 

data/lib/lame/encoder.rb

@@ -1,15 +1,12 @@
 module LAME
   class Encoder
 
-    STEREO_ENCODERS = {
+    BUFFER_ENCODERS = {
       :short => Encoding::ShortBufferEncoder,
       :float => Encoding::FloatBufferEncoder,
-      :long => Encoding::LongBufferEncoder
-    }
-
-    INTERLEAVED_ENCODERS = {
-      :short => Encoding::InterleavedShortBufferEncoder,
-      :float => Encoding::InterleavedFloatBufferEncoder
+      :long  => Encoding::LongBufferEncoder,
+      :short_interleaved => Encoding::InterleavedShortBufferEncoder,
+      :float_interleaved => Encoding::InterleavedFloatBufferEncoder
     }
 
     attr_reader :global_flags
@@ -36,11 +33,11 @@ module LAME
     end
 
     def encode_interleaved_short(samples, &block)
-      encode_interleaved(samples, :short, &block)
+      encode_interleaved(samples, :short_interleaved, &block)
     end
 
     def encode_interleaved_float(samples, &block)
-      encode_interleaved(samples, :float, &block)
+      encode_interleaved(samples, :float_interleaved, &block)
     end
 
     def flush(&block)
@@ -81,7 +78,8 @@ module LAME
       apply_configuration
 
       each_frame(left, right) do |left_frame, right_frame|
-        mp3_data = STEREO_ENCODERS[data_type].new(configuration).encode_frame(left_frame, right_frame)
+        encoder = BUFFER_ENCODERS[data_type].new(configuration)
+        mp3_data = encoder.encode_frame(left_frame, right_frame)
         yield mp3_data
       end
     end
@@ -90,7 +88,8 @@ module LAME
       apply_configuration
 
       each_interleaved_frame(interleaved_samples) do |interleaved_frame|
-        mp3_data = INTERLEAVED_ENCODERS[data_type].new(configuration).encode_frame(interleaved_frame)
+        encoder = BUFFER_ENCODERS[data_type].new(configuration)
+        mp3_data = encoder.encode_frame(interleaved_frame)
         yield mp3_data
       end
     end

data/lib/lame/encoding/long_buffer_encoder.rb

@@ -3,7 +3,7 @@ module LAME
     class LongBufferEncoder < StereoBufferEncoder
 
       def data_type
-        :long
+        :"int#{::LAME::FFI::LONG_SIZE}"
       end
 
       def lame_function

data/lib/lame/encoding/stereo_buffer_encoder.rb

@@ -14,6 +14,7 @@ module LAME
       def encode_frame(left, right)
         left_buffer  = Buffer.create(data_type, left)
         right_buffer = Buffer.create(data_type, right)
+
         output       = Buffer.create_empty(:uchar, output_buffer_size)
 
         mp3_size = LAME.send(lame_function, global_flags,

data/lib/lame/ffi.rb

@@ -9,6 +9,8 @@ require 'lame/ffi/mp3_data'
 module LAME
   module FFI
 
+    LONG_SIZE = ::FFI.type_size(:long) * 8
+
     def self.included(base)
       base.class_eval do
         include Enums

data/lib/lame/version.rb

@@ -1,3 +1,3 @@
 module LAME
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/buffer_spec.rb

@@ -7,19 +7,19 @@ module LAME
       input = [-42, 0, 42]
       buffer = Buffer.create(:short, input)
 
-      buffer.should be_a(::FFI::MemoryPointer)
-      buffer.size.should eql 6 # shorts are two bytes
-      buffer.type_size.should eql 2
-      buffer.get_array_of_short(0, 3).should eql [-42, 0, 42]
+      expect(buffer).to be_a(::FFI::MemoryPointer)
+      expect(buffer.size).to eql 6 # shorts are two bytes
+      expect(buffer.type_size).to eql 2
+      expect(buffer.get_array_of_short(0, 3)).to eql [-42, 0, 42]
     end
 
     it "creates an empty buffer" do
       buffer = Buffer.create_empty(:uchar, 100)
 
-      buffer.should be_a(::FFI::MemoryPointer)
-      buffer.size.should eql 100
-      buffer.type_size.should eql 1
-      buffer.get_array_of_uchar(0, 100).should eql [0]*100
+      expect(buffer).to be_a(::FFI::MemoryPointer)
+      expect(buffer.size).to eql 100
+      expect(buffer.type_size).to eql 1
+      expect(buffer.get_array_of_uchar(0, 100)).to eql [0]*100
     end
 
   end

data/spec/configuration_spec.rb

@@ -4,84 +4,84 @@ module LAME
   describe Configuration do
 
     context "intialization" do
-      let(:global_flags) { stub }
+      let(:global_flags) { double("global_flags") }
 
       subject(:configuration) { Configuration.new(global_flags) }
 
       it "initializes with global flags" do
-        configuration.global_flags.should eql global_flags
+        expect(configuration.global_flags).to eql global_flags
       end
 
       it "initializes a AsmOptimization configuration object" do
-        Configuration::AsmOptimization.should_receive(:new).with(global_flags)
+        expect(Configuration::AsmOptimization).to receive(:new).with(global_flags)
         configuration.asm_optimization
       end
 
       it "memoizes one AsmOptimization configuration object" do
-        Configuration::AsmOptimization.stub(:new).and_return(stub)
-        Configuration::AsmOptimization.should_receive(:new).exactly(:once)
+        allow(Configuration::AsmOptimization).to receive(:new).and_return(double)
+        expect(Configuration::AsmOptimization).to receive(:new).exactly(:once)
         2.times { configuration.asm_optimization }
       end
 
       it "initializes a Id3 configuration object" do
-        Configuration::Id3.should_receive(:new).with(global_flags)
+        expect(Configuration::Id3).to receive(:new).with(global_flags)
         configuration.id3
       end
 
       it "memoizes one Id3 configuration object" do
-        Configuration::Id3.stub(:new).and_return(stub)
-        Configuration::Id3.should_receive(:new).exactly(:once)
+        allow(Configuration::Id3).to receive(:new).and_return(double)
+        expect(Configuration::Id3).to receive(:new).exactly(:once)
         2.times { configuration.id3 }
       end
 
       it "initializes a Quantization configuration object" do
-        Configuration::Quantization.should_receive(:new).with(global_flags)
+        expect(Configuration::Quantization).to receive(:new).with(global_flags)
         configuration.quantization
       end
 
       it "memoizes one Quantization configuration object" do
-        Configuration::Quantization.stub(:new).and_return(stub)
-        Configuration::Quantization.should_receive(:new).exactly(:once)
+        allow(Configuration::Quantization).to receive(:new).and_return(double)
+        expect(Configuration::Quantization).to receive(:new).exactly(:once)
         2.times { configuration.quantization }
       end
 
       it "initializes a VBR configuration object" do
-        Configuration::VBR.should_receive(:new).with(global_flags)
+        expect(Configuration::VBR).to receive(:new).with(global_flags)
         configuration.vbr
       end
 
       it "memoizes one VBR configuration object" do
-        Configuration::VBR.stub(:new).and_return(stub)
-        Configuration::VBR.should_receive(:new).exactly(:once)
+        allow(Configuration::VBR).to receive(:new).and_return(double)
+        expect(Configuration::VBR).to receive(:new).exactly(:once)
         2.times { configuration.vbr }
       end
 
       it "initializes a Filtering configuration object" do
-        Configuration::Filtering.should_receive(:new).with(global_flags)
+        expect(Configuration::Filtering).to receive(:new).with(global_flags)
         configuration.filtering
       end
 
       it "memoizes one Filtering configuration object" do
-        Configuration::Filtering.stub(:new).and_return(stub)
-        Configuration::Filtering.should_receive(:new).exactly(:once)
+        allow(Configuration::Filtering).to receive(:new).and_return(double)
+        expect(Configuration::Filtering).to receive(:new).exactly(:once)
         2.times { configuration.filtering }
       end
 
       it "initializes a PsychoAcoustics configuration object" do
-        Configuration::PsychoAcoustics.should_receive(:new).with(global_flags)
+        expect(Configuration::PsychoAcoustics).to receive(:new).with(global_flags)
         configuration.psycho_acoustics
       end
 
       it "memoizes one PsychoAcoustics configuration object" do
-        Configuration::PsychoAcoustics.stub(:new).and_return(stub)
-        Configuration::PsychoAcoustics.should_receive(:new).exactly(:once)
+        allow(Configuration::PsychoAcoustics).to receive(:new).and_return(double)
+        expect(Configuration::PsychoAcoustics).to receive(:new).exactly(:once)
         2.times { configuration.psycho_acoustics }
       end
 
       context "Id3" do
 
         it "initializes the Id3 tag" do
-          LAME.should_receive(:id3tag_init).with(global_flags)
+          expect(LAME).to receive(:id3tag_init).with(global_flags)
           Configuration::Id3.new(global_flags)
         end
 
@@ -89,17 +89,17 @@ module LAME
 
       describe "#apply! / #applied?" do
         it "is not applied by default" do
-          configuration.should_not be_applied
+          expect(configuration).not_to be_applied
         end
 
         it "applies the configuration" do
-          LAME.should_receive(:lame_init_params).with(global_flags)
+          expect(LAME).to receive(:lame_init_params).with(global_flags)
           configuration.apply!
-          configuration.should be_applied
+          expect(configuration).to be_applied
         end
 
         it "raises an error if configuration could not be applied" do
-          LAME.stub(:lame_init_params).and_return(-1)
+          allow(LAME).to receive(:lame_init_params).and_return(-1)
           expect {
             configuration.apply!
           }.to raise_error(ConfigurationError)
@@ -109,12 +109,12 @@ module LAME
       describe "#framesize" do
 
         it "gets framesize from LAME if configuration was applied" do
-          LAME.stub(:lame_init_params)
+          allow(LAME).to receive(:lame_init_params)
           configuration.apply!
 
-          LAME.stub(:lame_get_framesize).and_return(42)
-          LAME.should_receive(:lame_get_framesize).with(global_flags)
-          configuration.framesize.should eql 42
+          allow(LAME).to receive(:lame_get_framesize).and_return(42)
+          expect(LAME).to receive(:lame_get_framesize).with(global_flags)
+          expect(configuration.framesize).to eql 42
         end
 
         it "raises an error if configuration was not applied" do
@@ -124,12 +124,12 @@ module LAME
         end
 
         it "calculates the output buffer size based on the framesize" do
-          LAME.stub(:lame_init_params)
+          allow(LAME).to receive(:lame_init_params)
           configuration.apply!
 
-          LAME.stub(:lame_get_framesize).and_return(1152)
-          LAME.should_receive(:lame_get_framesize).with(global_flags)
-          configuration.output_buffer_size.should eql 8640
+          allow(LAME).to receive(:lame_get_framesize).and_return(1152)
+          expect(LAME).to receive(:lame_get_framesize).with(global_flags)
+          expect(configuration.output_buffer_size).to eql 8640
         end
 
       end
@@ -148,7 +148,7 @@ module LAME
     # 
     context "set/get delegation" do
 
-      let(:global_flags) { stub(GlobalFlags) }
+      let(:global_flags) { double(GlobalFlags) }
       subject(:configuration) { Configuration.new(global_flags) }
 
       context "basic fields" do
@@ -183,8 +183,8 @@ module LAME
         it { should delegate(:emphasis) }
 
         it "delegates #preset= to LAME.lame_set_preset" do
-          LAME.should_receive(:lame_set_preset).with(global_flags, anything)
-          configuration.preset = stub
+          expect(LAME).to receive(:lame_set_preset).with(global_flags, anything)
+          configuration.preset = double
         end
 
       end
@@ -193,17 +193,17 @@ module LAME
         subject(:asm_optimization) { configuration.asm_optimization }
 
         it "delegates #mmx to LAME.lame_set_asm_optimizations" do
-          LAME.should_receive(:lame_set_asm_optimizations).with(global_flags, :MMX, 1)
+          expect(LAME).to receive(:lame_set_asm_optimizations).with(global_flags, :MMX, 1)
           asm_optimization.mmx = true
         end
 
         it "delegates #amd_3dnow to LAME.lame_set_asm_optimizations" do
-          LAME.should_receive(:lame_set_asm_optimizations).with(global_flags, :AMD_3DNOW, 1)
+          expect(LAME).to receive(:lame_set_asm_optimizations).with(global_flags, :AMD_3DNOW, 1)
           asm_optimization.amd_3dnow = true
         end
 
         it "delegates #sse to LAME.lame_set_asm_optimizations" do
-          LAME.should_receive(:lame_set_asm_optimizations).with(global_flags, :SSE, 1)
+          expect(LAME).to receive(:lame_set_asm_optimizations).with(global_flags, :SSE, 1)
           asm_optimization.sse = true
         end
       end
@@ -215,37 +215,37 @@ module LAME
         it { should delegate(:write_automatic).to(:write_id3tag_automatic) }
 
         before do
-          LAME.stub(:id3tag_init)
+          allow(LAME).to receive(:id3tag_init)
         end
 
         it "delegates #v2= to LAME.id3tag_add_v2" do
-          LAME.should_receive(:id3tag_add_v2).with(global_flags)
+          expect(LAME).to receive(:id3tag_add_v2).with(global_flags)
           id3.v2 = true
         end
 
         it "delegates #v1_only= to LAME.id3tag_v1_only" do
-          LAME.should_receive(:id3tag_v1_only).with(global_flags)
+          expect(LAME).to receive(:id3tag_v1_only).with(global_flags)
           id3.v1_only = true
         end
 
         it "delegates #v2_only= to LAME.id3tag_v2_only" do
-          LAME.should_receive(:id3tag_v2_only).with(global_flags)
+          expect(LAME).to receive(:id3tag_v2_only).with(global_flags)
           id3.v2_only = true
         end
 
         it "delegates #v1_space= to LAME.id3tag_v1_space" do
-          LAME.should_receive(:id3tag_space_v1).with(global_flags)
+          expect(LAME).to receive(:id3tag_space_v1).with(global_flags)
           id3.v1_space = true
         end
 
         it "delegates #v2_padding= to LAME.id3tag_pad_v2" do
-          LAME.should_receive(:id3tag_pad_v2).with(global_flags)
+          expect(LAME).to receive(:id3tag_pad_v2).with(global_flags)
           id3.v2_padding = true
         end
 
         it "delegates #v2_padding_size= to LAME.id3tag_set_pad" do
-          value = stub
-          LAME.should_receive(:id3tag_set_pad).with(global_flags, value)
+          value = double
+          expect(LAME).to receive(:id3tag_set_pad).with(global_flags, value)
           id3.v2_padding_size = value
         end
 
@@ -253,10 +253,10 @@ module LAME
         [ :title, :artist, :album, :year, :comment ].each do |field|
 
           it "sets the #{field} with string buffer" do
-            LAME.should_receive(:"id3tag_set_#{field}") do |flags, string_buffer|
-              flags.should eql global_flags
-              string_buffer.should be_a(::FFI::MemoryPointer)
-              string_buffer.get_string(0).should eql "Some #{field}"
+            expect(LAME).to receive(:"id3tag_set_#{field}") do |flags, string_buffer|
+              expect(flags).to eql global_flags
+              expect(string_buffer).to be_a(::FFI::MemoryPointer)
+              expect(string_buffer.get_string(0)).to eql "Some #{field}"
             end
             id3.send(:"#{field}=", "Some #{field}")
           end
@@ -264,37 +264,37 @@ module LAME
         end
 
         it "sets the track" do
-          LAME.should_receive(:"id3tag_set_track") do |flags, value|
-            flags.should eql global_flags
-            value.should eql 42
+          expect(LAME).to receive(:"id3tag_set_track") do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to eql 42
           end
           id3.track = 42
         end
 
         it "sets the genre by name" do
-          LAME.should_receive(:id3tag_set_genre) do |flags, value|
-            flags.should eql global_flags
-            value.should be_a(::FFI::MemoryPointer)
-            value.get_string(0).should eql "147"
+          expect(LAME).to receive(:id3tag_set_genre) do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to be_a(::FFI::MemoryPointer)
+            expect(value.get_string(0)).to eql "147"
           end
           id3.genre = "SynthPop"
         end
 
         it "sets the genre by id" do
-          LAME.should_receive(:id3tag_set_genre) do |flags, value|
-            flags.should eql global_flags
-            value.should be_a(::FFI::MemoryPointer)
-            value.get_string(0).should eql "81"
+          expect(LAME).to receive(:id3tag_set_genre) do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to be_a(::FFI::MemoryPointer)
+            expect(value.get_string(0)).to eql "81"
           end
 
           id3.genre = 81
         end
 
         it "sets non-standard genre name" do
-          LAME.should_receive(:id3tag_set_genre) do |flags, value|
-            flags.should eql global_flags
-            value.should be_a(::FFI::MemoryPointer)
-            value.get_string(0).should eql "Ruby FFI Rock"
+          expect(LAME).to receive(:id3tag_set_genre) do |flags, value|
+            expect(flags).to eql global_flags
+            expect(value).to be_a(::FFI::MemoryPointer)
+            expect(value.get_string(0)).to eql "Ruby FFI Rock"
           end
           id3.genre = "Ruby FFI Rock"
         end
@@ -312,23 +312,23 @@ module LAME
         it { should delegate(:msfix) }
 
         it "delegates #reservoir= to LAME.lame_set_disable_reservoir" do
-          LAME.should_receive(:lame_set_disable_reservoir).with(global_flags, 1)
+          expect(LAME).to receive(:lame_set_disable_reservoir).with(global_flags, 1)
           quantization.reservoir = false
         end
 
         it "delegates #reservoir to LAME.lame_get_disable_reservoir" do
-          LAME.should_receive(:lame_get_disable_reservoir).with(global_flags)
+          expect(LAME).to receive(:lame_get_disable_reservoir).with(global_flags)
           quantization.reservoir
         end
 
         it "delegates #reservoir? to LAME.lame_get_disable_reservoir" do
-          LAME.should_receive(:lame_get_disable_reservoir).with(global_flags)
+          expect(LAME).to receive(:lame_get_disable_reservoir).with(global_flags)
           quantization.reservoir?
         end
 
         it "converts the return value 0 for #reservoir? to false" do
-          LAME.stub(:lame_get_disable_reservoir).and_return(0)
-          quantization.reservoir?.should be_false
+          allow(LAME).to receive(:lame_get_disable_reservoir).and_return(0)
+          expect(quantization.reservoir?).to be_falsy
         end
       end
 
@@ -365,23 +365,23 @@ module LAME
         it { should delegate(:athaa_sensitivity) }
 
         it "delegates #ath= to LAME.lame_set_noATH" do
-          LAME.should_receive(:lame_set_noATH).with(global_flags, 1)
+          expect(LAME).to receive(:lame_set_noATH).with(global_flags, 1)
           psycho_acoustics.ath = false
         end
 
         it "delegates #ath to LAME.lame_get_noATH" do
-          LAME.should_receive(:lame_get_noATH).with(global_flags)
+          expect(LAME).to receive(:lame_get_noATH).with(global_flags)
           psycho_acoustics.ath
         end
 
         it "delegates #ath? to LAME.lame_get_noATH" do
-          LAME.should_receive(:lame_get_noATH).with(global_flags)
+          expect(LAME).to receive(:lame_get_noATH).with(global_flags)
           psycho_acoustics.ath?
         end
 
         it "converts the return value 0 for #ath? to true" do
-          LAME.stub(:lame_get_noATH).and_return(0)
-          psycho_acoustics.ath?.should be_true
+          allow(LAME).to receive(:lame_get_noATH).and_return(0)
+          expect(psycho_acoustics.ath?).to be_truthy
         end
       end