hornetseye-alsa 1.0.0 → 1.1.0

data/COPYING

@@ -1,5 +1,5 @@
   This is the license for the computer vision library Hornetseye.
- Copyright (C) 2006 - 2010 Jan Wedekind, Sheffield, United Kingdom.
+ Copyright (C) 2006 - 2012 Jan Wedekind, Sheffield, United Kingdom.
 
 
 		    GNU GENERAL PUBLIC LICENSE

data/README.md

@@ -2,7 +2,7 @@ hornetseye-alsa
 ===============
 
 **Author**:       Jan Wedekind
-**Copyright**:    2010
+**Copyright**:    2012
 **License**:      GPL
 
 Synopsis

data/Rakefile

@@ -7,7 +7,7 @@ require 'rake/loaders/makefile'
 require 'rbconfig'
 
 PKG_NAME = 'hornetseye-alsa'
-PKG_VERSION = '1.0.0'
+PKG_VERSION = '1.1.0'
 CFG = RbConfig::CONFIG
 CXX = ENV[ 'CXX' ] || 'g++'
 RB_FILES = FileList[ 'lib/**/*.rb' ]

data/ext/alsaoutput.cc

@@ -1,5 +1,5 @@
 /* HornetsEye - Computer Vision with Ruby
-   Copyright (C) 2006, 2007, 2008, 2009, 2010   Jan Wedekind
+   Copyright (C) 2012  Jan Wedekind
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -19,46 +19,52 @@ using namespace std;
 
 VALUE AlsaOutput::cRubyClass = Qnil;
 
-AlsaOutput::AlsaOutput( const string &pcmName, unsigned int rate,
-                        unsigned int channels, int periods,
-                        snd_pcm_uframes_t frames ) throw (Error):
-  m_pcmHandle(NULL), m_pcmName( pcmName ), m_rate( rate ), m_channels( channels )
+AlsaOutput::AlsaOutput(const string &pcmName, unsigned int rate,
+                       unsigned int channels) throw (Error):
+  m_pcmHandle(NULL), m_pcmName(pcmName), m_rate(rate), m_channels(channels),
+  m_periodSize(1024), m_threadInitialised(false), m_start(0), m_count(0),
+  m_size(rate)
 {
   try {
     snd_pcm_hw_params_t *hwParams;
-    snd_pcm_hw_params_alloca( &hwParams );
-    int err = snd_pcm_open( &m_pcmHandle, m_pcmName.c_str(), SND_PCM_STREAM_PLAYBACK,
-                            0 );// SND_PCM_NONBLOCK
-    ERRORMACRO( err >= 0, Error, , "Error opening PCM device \"" << m_pcmName
-                << "\": " << snd_strerror( err ) );
-    err = snd_pcm_hw_params_any( m_pcmHandle, hwParams );
-    ERRORMACRO( err >= 0, Error, , "Unable to configure the PCM device \""
-                << m_pcmName << "\": " << snd_strerror( err ) );
-    err = snd_pcm_hw_params_set_access( m_pcmHandle, hwParams,
-                                        SND_PCM_ACCESS_RW_INTERLEAVED );
-    ERRORMACRO( err >= 0, Error, , "Error setting PCM device \""
-                << m_pcmName << "\" to interlaced access: " << snd_strerror( err ) );
-    err = snd_pcm_hw_params_set_format( m_pcmHandle, hwParams,
-                                        SND_PCM_FORMAT_S16_LE );
-    ERRORMACRO( err >= 0, Error, , "Error setting PCM device \"" << m_pcmName
-                << "\" to 16-bit signed integer format: " << snd_strerror( err ) );
+    snd_pcm_hw_params_alloca(&hwParams);
+    int err = snd_pcm_open(&m_pcmHandle, m_pcmName.c_str(), SND_PCM_STREAM_PLAYBACK,
+                           0);//SND_PCM_NONBLOCK);
+    ERRORMACRO(err >= 0, Error, , "Error opening PCM device \"" << m_pcmName
+               << "\": " << snd_strerror(err));
+    err = snd_pcm_hw_params_any(m_pcmHandle, hwParams);
+    ERRORMACRO(err >= 0, Error, , "Unable to configure the PCM device \""
+               << m_pcmName << "\": " << snd_strerror(err));
+    err = snd_pcm_hw_params_set_access(m_pcmHandle, hwParams,
+                                       SND_PCM_ACCESS_RW_INTERLEAVED);
+    ERRORMACRO(err >= 0, Error, , "Error setting PCM device \""
+               << m_pcmName << "\" to interlaced access: " << snd_strerror(err));
+    err = snd_pcm_hw_params_set_format(m_pcmHandle, hwParams, SND_PCM_FORMAT_S16_LE);
+    ERRORMACRO(err >= 0, Error, , "Error setting PCM device \"" << m_pcmName
+               << "\" to 16-bit signed integer format: " << snd_strerror(err));
     err = snd_pcm_hw_params_set_rate_near( m_pcmHandle, hwParams, &m_rate, 0 );
-    ERRORMACRO( err >= 0, Error, , "Error setting sampling rate of PCM device \""
-                << m_pcmName << "\" to " << rate << " Hz: " << snd_strerror( err ) );
-    err = snd_pcm_hw_params_set_channels( m_pcmHandle, hwParams, channels );
-    ERRORMACRO( err >= 0, Error, , "Error setting number of channels of PCM device \""
-                << m_pcmName << "\" to " << channels << ": " << snd_strerror( err ) );
-    err = snd_pcm_hw_params_set_periods( m_pcmHandle, hwParams, periods, 0 );
-    ERRORMACRO( err >= 0, Error, , "Error setting number of periods of PCM device \""
-                << m_pcmName << "\" to " << periods << ": " << snd_strerror( err ) );
-    err = snd_pcm_hw_params_set_buffer_size_near( m_pcmHandle, hwParams, &frames );
-    ERRORMACRO( err >= 0, Error, , "Error setting buffer size of PCM device \""
-                << m_pcmName << "\" to " << frames << " frames: "
-                << snd_strerror( err ) );
+    ERRORMACRO(err >= 0, Error, , "Error setting sampling rate of PCM device \""
+               << m_pcmName << "\" to " << rate << " Hz: " << snd_strerror(err));
+    err = snd_pcm_hw_params_set_channels(m_pcmHandle, hwParams, channels);
+    ERRORMACRO(err >= 0, Error, , "Error setting number of channels of PCM device \""
+               << m_pcmName << "\" to " << channels << ": " << snd_strerror(err));
+    unsigned int bufferTime = 500000;
+    err = snd_pcm_hw_params_set_buffer_time_near(m_pcmHandle, hwParams, &bufferTime, NULL);
+    ERRORMACRO(err >= 0, Error, , "Error setting buffer time of PCM device \""
+               << m_pcmName << "\" to " << bufferTime << " us: " << snd_strerror(err));
+    unsigned int periods = 16;
+    err = snd_pcm_hw_params_set_periods_near(m_pcmHandle, hwParams, &periods, NULL);
+    ERRORMACRO(err >= 0, Error, , "Error setting periods of PCM device \""
+               << m_pcmName << "\" to " << periods << ": " << snd_strerror(err));
     err = snd_pcm_hw_params( m_pcmHandle, hwParams );
     ERRORMACRO( err >= 0, Error, , "Error setting parameters of PCM device \""
                 << m_pcmName << "\": " << snd_strerror( err ) );
-  } catch ( Error &e ) {
+    err = snd_pcm_hw_params_get_period_size(hwParams, &m_periodSize, NULL);
+    ERRORMACRO( err >= 0, Error, , "Error getting period size of PCM device \""
+                << m_pcmName << "\": " << snd_strerror( err ) );
+    err = pthread_mutex_init(&m_mutex, NULL);
+    ERRORMACRO(err == 0, Error, , "Error initialising mutex: " << strerror(err));
+  } catch (Error &e) {
     close();
     throw e;
   };
@@ -72,40 +78,71 @@ AlsaOutput::~AlsaOutput(void)
 void AlsaOutput::close(void)
 {
   if ( m_pcmHandle != NULL ) {
-    drop();
+    drain();
+    pthread_mutex_destroy(&m_mutex);
     snd_pcm_close( m_pcmHandle );
     m_pcmHandle = NULL;
   };
 }
 
-void AlsaOutput::write( SequencePtr frame ) throw (Error)
+void AlsaOutput::write(SequencePtr frame) throw (Error)
 {
-  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
-              << "\" is not open. Did you call \"close\" before?" );
-  int n = frame->size() / ( 2 * m_channels );
-  int err;
-  while ( ( err = snd_pcm_writei( m_pcmHandle, (short int *)frame->data(),
-                                  n ) ) < 0 ) {
-    err = snd_pcm_recover( m_pcmHandle, err, 1 );
-    ERRORMACRO( err >= 0, Error, , "Error writing audio frames to PCM device \""
-                << m_pcmName << "\": " << snd_strerror( err ) );
+  ERRORMACRO(m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+             << "\" is not open. Did you call \"close\" before?");
+  int n = frame->size() / (2 * m_channels);
+  lock();
+  if (!m_data.get()) {
+    if (m_threadInitialised) pthread_detach(m_thread);
+    while(m_size < n) m_size = 2 * m_size;
+    m_data = boost::shared_array<short int>(new short int[m_size * m_channels]);
+    m_start = 0;
+    m_count = 0;
+    pthread_create(&m_thread, NULL, staticThreadFunc, this);
+  };
+  if (m_count + n > m_size) {
+    int m_size_new = m_size;
+    while(m_size_new < m_count + n) m_size_new = 2 * m_size_new;
+    boost::shared_array<short int> data(new short int[m_size_new * m_channels]);
+    if (m_start + m_count > m_size) {
+      memcpy(data.get(), m_data.get() + m_start * m_channels, (m_size - m_start) * 2 * m_channels);
+      memcpy(data.get() + (m_size - m_start) * m_channels, m_data.get(), (m_start + m_count - m_size) * 2 * m_channels);
+    } else
+      memcpy(data.get(), m_data.get() + m_start * m_channels, m_count * 2 * m_channels);
+    m_data = data;
+    m_start = 0;
+    m_size = m_size_new;
   };
-  ERRORMACRO( n == err, Error, , "Only managed to write " << err << " of " << n
-              << " frames to PCM device \"" << m_pcmName << "\"" ); 
+  int offset = m_start + m_count;
+  if (offset > m_size) offset -= m_size;
+  if (offset + n > m_size) {
+    memcpy(m_data.get() + offset * m_channels, frame->data(), (m_size - offset) * 2 * m_channels);
+    memcpy(m_data.get(), frame->data() + (m_size - offset) * m_channels, (n + m_size - offset) * 2 * m_channels);
+  } else
+    memcpy(m_data.get() + offset * m_channels, frame->data(), n * 2 * m_channels);
+  m_count += n;
+  unlock();
 }
 
 void AlsaOutput::drop(void) throw (Error)
 {
   ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
               << "\" is not open. Did you call \"close\" before?" );
-  snd_pcm_drop( m_pcmHandle );
+  lock();
+  m_data.reset();
+  m_count = 0;
+  unlock();
+  snd_pcm_drop(m_pcmHandle);
 }
 
 void AlsaOutput::drain(void) throw (Error)
 {
-  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
-              << "\" is not open. Did you call \"close\" before?" );
-  snd_pcm_drain( m_pcmHandle );
+  if (m_threadInitialised) {
+    pthread_join(m_thread, NULL);
+    m_threadInitialised = false;
+  }
+  ERRORMACRO(m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+             << "\" is not open. Did you call \"close\" before?");
+  snd_pcm_drain(m_pcmHandle);
 }
 
 unsigned int AlsaOutput::rate(void)
@@ -120,8 +157,6 @@ unsigned int AlsaOutput::channels(void)
 
 int AlsaOutput::avail(void) throw (Error)
 {
-  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
-              << "\" is not open. Did you call \"close\" before?" );
   snd_pcm_sframes_t frames;
   int err = 0;
   while ( ( frames = snd_pcm_avail( m_pcmHandle ) ) < 0 ) {
@@ -135,42 +170,94 @@ int AlsaOutput::avail(void) throw (Error)
 
 int AlsaOutput::delay(void) throw (Error)
 {
-  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
-              << "\" is not open. Did you call \"close\" before?" );
+  ERRORMACRO(m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+             << "\" is not open. Did you call \"close\" before?");
+  lock();
   snd_pcm_sframes_t frames;
   int err;
-  while ( ( err = snd_pcm_delay( m_pcmHandle, &frames ) ) < 0 ) {
-    err = snd_pcm_recover( m_pcmHandle, err, 1 );
-    ERRORMACRO( err >= 0, Error, , "Error querying number of available frames for "
-                "update of PCM device \"" << m_pcmName << "\": "
-                << snd_strerror( err ) );
+  while ((err = snd_pcm_delay(m_pcmHandle, &frames)) < 0) {
+    err = snd_pcm_recover(m_pcmHandle, err, 1);
+    if (err < 0) {
+      unlock();
+      ERRORMACRO(false, Error, , "Error querying number of available frames for "
+                 "update of PCM device \"" << m_pcmName << "\": "
+                 << snd_strerror(err));
+    };
   };
+  frames += m_count;
+  unlock();
   return frames;
 }
 
-void AlsaOutput::prepare(void) throw (Error)
+void AlsaOutput::lock(void)
 {
-  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
-              << "\" is not open. Did you call \"close\" before?" );
-  int err = snd_pcm_prepare( m_pcmHandle );
-  ERRORMACRO( err >= 0, Error, , "Error preparing PCM device \"" << m_pcmName
-              << "\": " << snd_strerror( err ) );
+  pthread_mutex_lock( &m_mutex );
+}
+
+void AlsaOutput::unlock(void)
+{
+  pthread_mutex_unlock( &m_mutex );
+}
+
+void AlsaOutput::writei(short int *data, int count) throw (Error)
+{
+  int err;
+  while ((err = snd_pcm_writei(m_pcmHandle, data, count)) < 0) {
+    err = snd_pcm_recover(m_pcmHandle, err, 1);
+    ERRORMACRO(err >= 0, Error, , "Error writing audio frames to PCM device \""
+               << m_pcmName << "\": " << snd_strerror(err));
+  };
+  ERRORMACRO(count == err, Error, , "Only managed to write " << err << " of " << count
+             << " frames to PCM device \"" << m_pcmName << "\"");
+}
+
+void AlsaOutput::threadFunc(void)
+{
+  bool quit = false;
+  while (!quit) {
+    try {
+      lock();
+      int n = m_periodSize;
+      if (n > m_count) n = m_count;
+      if (m_count <= 0) m_data.reset();
+      if (m_start >= m_size) m_start -= m_size;
+      if (m_data.get()) {
+        if (m_start + n > m_size) {
+          writei(m_data.get() + m_start * m_channels, m_size - m_start);
+          writei(m_data.get(), m_start + n - m_size);
+        } else {
+          writei(m_data.get() + m_start * m_channels, n);
+        };
+        m_start += n;
+        m_count -= n;
+      } else
+        quit = true;
+      unlock();
+      snd_pcm_wait(m_pcmHandle, 1000);
+    } catch (Error &e) {
+      quit = true;
+      unlock();
+    }
+  };
+}
+
+void *AlsaOutput::staticThreadFunc( void *self )
+{
+  ((AlsaOutput *)self)->threadFunc();
+  return self;
 }
 
 VALUE AlsaOutput::registerRubyClass( VALUE rbModule )
 {
   cRubyClass = rb_define_class_under( rbModule, "AlsaOutput", rb_cObject );
-  rb_define_singleton_method( cRubyClass, "new",
-                              RUBY_METHOD_FUNC( wrapNew ), 5 );
+  rb_define_singleton_method(cRubyClass, "new", RUBY_METHOD_FUNC(wrapNew), 3);
   rb_define_method( cRubyClass, "close", RUBY_METHOD_FUNC( wrapClose ), 0 );
   rb_define_method( cRubyClass, "write", RUBY_METHOD_FUNC( wrapWrite ), 1 );
   rb_define_method( cRubyClass, "drop", RUBY_METHOD_FUNC( wrapDrop ), 0 );
   rb_define_method( cRubyClass, "drain", RUBY_METHOD_FUNC( wrapDrain ), 0 );
   rb_define_method( cRubyClass, "rate", RUBY_METHOD_FUNC( wrapRate ), 0 );
   rb_define_method( cRubyClass, "channels", RUBY_METHOD_FUNC( wrapChannels ), 0 );
-  rb_define_method( cRubyClass, "avail", RUBY_METHOD_FUNC( wrapAvail ), 0 );
   rb_define_method( cRubyClass, "delay", RUBY_METHOD_FUNC( wrapDelay ), 0 );
-  rb_define_method( cRubyClass, "prepare", RUBY_METHOD_FUNC( wrapPrepare ), 0 );
 }
 
 void AlsaOutput::deleteRubyObject( void *ptr )
@@ -178,15 +265,13 @@ void AlsaOutput::deleteRubyObject( void *ptr )
   delete (AlsaOutputPtr *)ptr;
 }
 
-VALUE AlsaOutput::wrapNew( VALUE rbClass, VALUE rbPCMName, VALUE rbRate,
-                           VALUE rbChannels, VALUE rbPeriods, VALUE rbFrames )
+VALUE AlsaOutput::wrapNew(VALUE rbClass, VALUE rbPCMName, VALUE rbRate, VALUE rbChannels)
 {
   VALUE retVal = Qnil;
   try {
     rb_check_type( rbPCMName, T_STRING );
-    AlsaOutputPtr ptr( new AlsaOutput( StringValuePtr( rbPCMName ),
-                                       NUM2UINT( rbRate ), NUM2UINT( rbChannels ),
-                                       NUM2INT( rbPeriods ), NUM2INT( rbFrames ) ) );
+    AlsaOutputPtr ptr(new AlsaOutput(StringValuePtr(rbPCMName),
+                                     NUM2UINT(rbRate), NUM2UINT(rbChannels)));
     retVal = Data_Wrap_Struct( rbClass, 0, deleteRubyObject,
                                new AlsaOutputPtr( ptr ) );
   } catch ( exception &e ) {
@@ -248,18 +333,6 @@ VALUE AlsaOutput::wrapChannels( VALUE rbSelf )
   return UINT2NUM( (*self)->channels() );
 }
 
-VALUE AlsaOutput::wrapAvail( VALUE rbSelf )
-{
-  VALUE rbRetVal = Qnil;
-  try {
-    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
-    rbRetVal = INT2NUM( (*self)->avail() );
-  } catch ( exception &e ) {
-    rb_raise( rb_eRuntimeError, "%s", e.what() );
-  };
-  return rbRetVal;
-}
-
 VALUE AlsaOutput::wrapDelay( VALUE rbSelf )
 {
   VALUE rbRetVal = Qnil;
@@ -271,15 +344,3 @@ VALUE AlsaOutput::wrapDelay( VALUE rbSelf )
   };
   return rbRetVal;
 }
-
-VALUE AlsaOutput::wrapPrepare( VALUE rbSelf )
-{
-  try {
-    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
-    (*self)->prepare();
-  } catch ( exception &e ) {
-    rb_raise( rb_eRuntimeError, "%s", e.what() );
-  };
-  return rbSelf;
-}
-

data/ext/alsaoutput.hh

@@ -1,5 +1,5 @@
 /* HornetsEye - Computer Vision with Ruby
-   Copyright (C) 2006, 2007, 2008, 2009, 2010   Jan Wedekind
+   Copyright (C) 2012  Jan Wedekind
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -25,9 +25,8 @@
 class AlsaOutput
 {
 public:
-  AlsaOutput( const std::string &pcmName = "default:0",
-              unsigned int rate = 48000, unsigned int channels = 2,
-              int periods = 16, snd_pcm_uframes_t frames = 1024 ) throw (Error);
+  AlsaOutput(const std::string &pcmName = "default:0",
+             unsigned int rate = 48000, unsigned int channels = 2) throw (Error);
   virtual ~AlsaOutput(void);
   void close(void);
   void write( SequencePtr sequence ) throw (Error);
@@ -35,28 +34,38 @@ public:
   void drain(void) throw (Error);
   unsigned int rate(void);
   unsigned int channels(void);
-  int avail(void) throw (Error);
   int delay(void) throw (Error);
-  void prepare(void) throw (Error);
+  void lock(void);
+  void unlock(void);
   static VALUE cRubyClass;
   static VALUE registerRubyClass( VALUE rbModule );
   static void deleteRubyObject( void *ptr );
-  static VALUE wrapNew( VALUE rbClass, VALUE rbPCMName, VALUE rbRate,
-                        VALUE rbChannels, VALUE rbPeriods, VALUE rbFrames );
+  static VALUE wrapNew(VALUE rbClass, VALUE rbPCMName, VALUE rbRate,
+                       VALUE rbChannels);
   static VALUE wrapClose( VALUE rbSelf );
   static VALUE wrapWrite( VALUE rbSelf, VALUE rbSequence );
   static VALUE wrapDrop( VALUE rbSelf );
   static VALUE wrapDrain( VALUE rbSelf );
   static VALUE wrapRate( VALUE rbSelf );
   static VALUE wrapChannels( VALUE rbSelf );
-  static VALUE wrapAvail( VALUE rbSelf );
   static VALUE wrapDelay( VALUE rbSelf );
-  static VALUE wrapPrepare( VALUE rbSelf );
 protected:
+  int avail(void) throw (Error);
+  void writei(short int *data, int count) throw (Error);
+  void threadFunc(void);
+  static void *staticThreadFunc( void *self );
   snd_pcm_t *m_pcmHandle;
   std::string m_pcmName;
   unsigned int m_rate;
   unsigned int m_channels;
+  snd_pcm_uframes_t m_periodSize;
+  bool m_threadInitialised;
+  boost::shared_array<short int> m_data;
+  int m_start;
+  int m_count;
+  int m_size;
+  pthread_t m_thread;
+  pthread_mutex_t m_mutex;
 };
 
 typedef boost::shared_ptr< AlsaOutput > AlsaOutputPtr;

data/lib/hornetseye-alsa/alsaoutput.rb

@@ -1,5 +1,5 @@
 # hornetseye-alsa - Play audio data using libalsa
-# Copyright (C) 2010 Jan Wedekind
+# Copyright (C) 2012 Jan Wedekind
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -45,14 +45,11 @@ module Hornetseye
       # @param [String] pcm_name Name of the PCM device
       # @param [Integer] rate Desired sampling rate.
       # @param [Integer] channels Number of channels (1=mono, 2=stereo).
-      # @param [Integer] periods Number of audio frames of the output buffer.
-      # @param [Integer] frames Size of the audio frames of the output buffer.
       # @return [AlsaOutput] An object for accessing the speakers.
       #
       # @see #rate
-      def new( pcm_name = 'default', rate = 48000, channels = 2, periods = 8,
-               frames = 1024 )
-        orig_new pcm_name, rate, channels, periods, frames
+      def new(pcm_name = 'default', rate = 48000, channels = 2)
+        orig_new pcm_name, rate, channels
       end
 
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hornetseye-alsa
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-08 00:00:00 Z
+date: 2012-11-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: malloc