beeps 0.4.0 → 0.5.1

data/src/win32/beeps.cpp

@@ -10,12 +10,27 @@ namespace Beeps
 {
 
 
+	namespace global
+	{
+
+		static bool     initialized = false;
+
+		static bool com_initialized = false;
+
+	}// global
+
+
 	void
 	Beeps_init ()
 	{
+		if (global::initialized)
+			beeps_error(__FILE__, __LINE__, "already initialized.");
+		global::initialized = true;
+
 		check_media_foundation_error(
-			CoInitializeEx(NULL, COINIT_MULTITHREADED),
+			CoInitializeEx(NULL, COINIT_APARTMENTTHREADED),
 			__FILE__, __LINE__);
+		global::com_initialized = true;
 
 		check_media_foundation_error(
 			MFStartup(MF_VERSION, MFSTARTUP_NOSOCKET),
@@ -25,11 +40,19 @@ namespace Beeps
 	void
 	Beeps_fin ()
 	{
+		if (!global::initialized)
+			beeps_error(__FILE__, __LINE__, "not initialized.");
+		global::initialized = false;
+
 		check_media_foundation_error(
 			MFShutdown(),
 			__FILE__, __LINE__);
 
-		CoUninitialize();
+		if (global::com_initialized)
+		{
+			CoUninitialize();
+			global::com_initialized = false;
+		}
 	}
 
 

data/src/win32/signals.cpp

@@ -1,12 +1,14 @@
 #include "../signals.h"
 
 
+#include <stdint.h>
 #include <mfapi.h>
 #include <mfidl.h>
 #include <mfreadwrite.h>
 #include <xot/noncopyable.h>
 #include <xot/string.h>
 #include <xot/windows.h>
+#include <mmreg.h>// must be after windows.h
 #include "exception.h"
 
 
@@ -64,25 +66,63 @@ namespace Beeps
 	}
 
 	static void
-	load_bytes (WAVEFORMATEX* format, std::vector<BYTE>* bytes, const char* path)
+	set_decoded_media_type (IMFMediaType* decoded, IMFSourceReader* source_reader)
 	{
-		std::wstring wpath = Xot::String(path).to_wstr();
-
-		ReleasePtr<IMFMediaType> pcm_media_type;
+		ReleasePtr<IMFMediaType> native;
 		check_media_foundation_error(
-			MFCreateMediaType(&pcm_media_type.ptr),
+			source_reader->GetNativeMediaType(
+				MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, &native.ptr),
 			__FILE__, __LINE__);
-		pcm_media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
-		pcm_media_type->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_PCM);
+
+		GUID subtype = {};// all zeros, as GUID_NULL, which needs libuuid
+		UINT32 bits  = 0;
+		native->GetGUID(MF_MT_SUBTYPE, &subtype);
+		native->GetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, &bits);
+
+		bool is_float = subtype == MFAudioFormat_Float;
+		if (is_float)
+			bits = 32;
+		else if (subtype != MFAudioFormat_PCM || (bits != 8 && bits != 24 && bits != 32))
+			bits = 16;
+
+		decoded->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
+		decoded->SetGUID(MF_MT_SUBTYPE, is_float ? MFAudioFormat_Float : MFAudioFormat_PCM);
+		decoded->SetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, bits);
+	}
+
+	static bool
+	is_float_format (const WAVEFORMATEX& format)
+	{
+		if (format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
+			return true;
+		if (format.wFormatTag != WAVE_FORMAT_EXTENSIBLE)
+			return false;
+
+		const auto& extensible = (const WAVEFORMATEXTENSIBLE&) format;
+		return extensible.SubFormat.Data1 == WAVE_FORMAT_IEEE_FLOAT;
+	}
+
+	static void
+	load_bytes (
+		WAVEFORMATEX* format, bool* is_float, std::vector<BYTE>* bytes,
+		const char* path)
+	{
+		std::wstring wpath = Xot::String(path).to_wstr();
 
 		ReleasePtr<IMFSourceReader> source_reader;
 		check_media_foundation_error(
 			MFCreateSourceReaderFromURL(wpath.c_str(), NULL, &source_reader.ptr),
 			__FILE__, __LINE__);
 
+		ReleasePtr<IMFMediaType> decoded_media_type;
+		check_media_foundation_error(
+			MFCreateMediaType(&decoded_media_type.ptr),
+			__FILE__, __LINE__);
+		set_decoded_media_type(decoded_media_type.ptr, source_reader.ptr);
+
 		check_media_foundation_error(
 			source_reader->SetCurrentMediaType(
-				MF_SOURCE_READER_FIRST_AUDIO_STREAM, NULL, pcm_media_type.ptr),
+				MF_SOURCE_READER_FIRST_AUDIO_STREAM, NULL, decoded_media_type.ptr),
 			__FILE__, __LINE__);
 
 		ReleasePtr<IMFMediaType> media_type;
@@ -96,9 +136,15 @@ namespace Beeps
 			MFCreateWaveFormatExFromMFMediaType(media_type.ptr, &format_.ptr, NULL),
 			__FILE__, __LINE__);
 
-		*format = *format_.ptr;
-		if (format->wFormatTag != WAVE_FORMAT_PCM)
+		*format   = *format_.ptr;
+		*is_float = is_float_format(*format_.ptr);
+		if (
+			format->wFormatTag != WAVE_FORMAT_PCM &&
+			format->wFormatTag != WAVE_FORMAT_IEEE_FLOAT &&
+			format->wFormatTag != WAVE_FORMAT_EXTENSIBLE)
+		{
 			beeps_error(__FILE__, __LINE__, "'%s' is not a PCM file.", path);
+		}
 
 		while (true)
 		{
@@ -123,7 +169,7 @@ namespace Beeps
 				__FILE__, __LINE__);
 
 			bytes->resize(bytes->size() + size);
-			memcpy(&(*bytes)[0] + bytes->size() - size, data, size);
+			memcpy(bytes->data() + bytes->size() - size, data, size);
 
 			check_media_foundation_error(
 				buffer->Unlock(),
@@ -138,35 +184,70 @@ namespace Beeps
 			beeps_error(__FILE__, __LINE__, "'%s' not found.", path);
 
 		WAVEFORMATEX format = {0};
+		bool is_float       = false;
 		std::vector<BYTE> bytes;
-		load_bytes(&format, &bytes, path);
+		load_bytes(&format, &is_float, &bytes, path);
 		if (bytes.empty())
 			beeps_error(__FILE__, __LINE__, "failed to read bytes: '%s'", path);
 
 		uint Bps       = format.wBitsPerSample / 8;
 		uint nchannels = format.nChannels;
-		uint nsamples  = bytes.size() / Bps / nchannels;
+		if (is_float ? Bps != 4 : (Bps < 1 || 4 < Bps))
+		{
+			beeps_error(
+				__FILE__, __LINE__, "'%s' has samples of %d bits.",
+				path, format.wBitsPerSample);
+		}
+		if (nchannels == 0)
+			beeps_error(__FILE__, __LINE__, "'%s' has no channels.", path);
+
+		uint nsamples = bytes.size() / Bps / nchannels;
 		Signals signals(nsamples, nchannels, format.nSamplesPerSec);
 
+		uint step = nchannels * Bps;
 		for (uint ch = 0; ch < nchannels; ++ch)
 		{
+			Sample*        to_p = Signals_at(&signals, 0, ch);
+			const uchar* from_p = ((uchar*) bytes.data()) + ch * Bps;
 			switch (Bps)
 			{
 				case 1:
 				{
-					Sample*        to_p = Signals_at(&signals, 0, ch);
-					const uchar* from_p = ((uchar*) &bytes[0]) + ch;
-					for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += nchannels)
-						*to_p = (*to_p - 128) / 128.f;
+					for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += step)
+						*to_p = (*from_p - 128) / 128.f;
 					break;
 				}
 
 				case 2:
 				{
-					Sample*         to_p = Signals_at(&signals, 0, ch);
-					const ushort* from_p = ((ushort*) &bytes[0]) + ch;
-					for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += nchannels)
-						*to_p = *from_p / 32768.f;
+					for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += step)
+						*to_p = *(const short*) from_p / 32768.f;
+					break;
+				}
+
+				case 3:
+				{
+					for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += step)
+					{
+						int32_t value = from_p[0] | (from_p[1] << 8) | (from_p[2] << 16);
+						if (value & 0x800000) value -= 0x1000000;// sign extension
+						*to_p = value / 8388608.f;
+					}
+					break;
+				}
+
+				case 4:
+				{
+					if (is_float)
+					{
+						for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += step)
+							*to_p = *(const float*) from_p;
+					}
+					else
+					{
+						for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += step)
+							*to_p = *(const int32_t*) from_p / 2147483648.f;
+					}
 					break;
 				}
 			}

data/test/test_file_in.rb

@@ -14,6 +14,22 @@ class TestFileIn < Test::Unit::TestCase
     B::Oscillator.new(...)
   end
 
+  def wav(tag, bits, rate, data)
+    align = bits / 8
+    fmt   = [tag, 1, rate, rate * align, align, bits].pack('vvVVvv')
+    ['RIFF', 36 + data.bytesize, 'WAVE', 'fmt ', 16].pack('a4Va4a4V') + fmt +
+      ['data', data.bytesize].pack('a4V') + data
+  end
+
+  def save_wav(filename, *wav_args, &block)
+    Tempfile.create ["#{filename}", '.wav'] do |file|
+      file.binmode
+      file.write wav(*wav_args)
+      file.close
+      block.call file.path
+    end
+  end
+
   def test_load_file()
     Tempfile.create 'tmp.wav' do |file|
       file.close
@@ -26,6 +42,28 @@ class TestFileIn < Test::Unit::TestCase
     end
   end
 
+  def test_load_formats()
+    rate   = B.sample_rate
+    values = (0...rate / 10).map {Math.sin(2 * Math::PI * _1 / 100) * 0.5}
+    {
+      pcm8:    [1, 8,  0.01,   values.map {(_1 * 128 + 128).round}.pack('C*')],
+      pcm16:   [1, 16, 0.0001, values.map {(_1 * 32768).round}.pack('s<*')],
+      pcm24:   [1, 24, 0.0001, values.map {(_1 * 8388608).round}
+                                     .flat_map {[_1, _1 >> 8, _1 >> 16]}
+                                     .map {_1 & 0xff}.pack('C*')],
+      pcm32:   [1, 32, 0.0001, values.map {(_1 * 2147483648).round}.pack('l<*')],
+      float32: [3, 32, 0.0001, values.pack('e*')]
+    }.each do |name, (tag, bits, delta, data)|
+      save_wav name, tag, bits, rate, data do |path|
+        samples = B::Processor
+          .get_signals(filein(path), seconds: values.size.to_f / rate)
+          .to_a
+        assert_equal values.size, samples.size, name
+        assert_each_in_delta values, samples, delta, name
+      end
+    end
+  end
+
   def test_file_not_found()
     assert_raise(B::BeepsError) {B::FileIn.new 'nofile.wav'}
   end

data/test/test_sound.rb

@@ -38,17 +38,17 @@ class TestSound < Test::Unit::TestCase
     assert_nothing_raised {B::Sound.load PATH}
   end
 
+  def test_nchannels()
+    assert_equal 1, sound              .nchannels
+    assert_equal 2, sound(nchannels: 2).nchannels
+  end
+
   def test_sample_rate()
     assert_in_epsilon 44100, sound                    .sample_rate
     assert_in_epsilon 48000, sound(sample_rate: 48000).sample_rate
     assert_in_epsilon 96000, sound(sample_rate: 96000).sample_rate
   end
 
-  def test_nchannels()
-    assert_equal 1, sound              .nchannels
-    assert_equal 2, sound(nchannels: 2).nchannels
-  end
-
   def test_seconds()
     assert_in_epsilon 0.2,  sound(0.2).seconds
     assert_in_epsilon (-1), sound(0)  .seconds
@@ -90,8 +90,8 @@ class TestSound < Test::Unit::TestCase
     }
 
     s = B::Sound.load PATH
-    assert_in_epsilon 96000, s.sample_rate
     assert_equal      2,     s.nchannels
+    assert_in_epsilon 96000, s.sample_rate
     assert_in_epsilon 0.1,   s.seconds
     assert_nothing_raised {s.play}
   end

data/test/test_sound_player.rb

@@ -1,3 +1,4 @@
+require 'tempfile'
 require_relative 'helper'
 
 
@@ -5,23 +6,20 @@ class TestSoundPlayer < Test::Unit::TestCase
 
   B = Beeps
 
-  PATH = 'test.wav'
-
   def sound(seconds = 0.1, processor: B::Oscillator.new, **kwargs)
     B::Sound.new processor >> B::Gain.new(gain: 0), seconds, **kwargs
   end
 
-  def stream_sound(**kwargs)
-    sound 0, processor: B::FileIn.new(PATH), **kwargs
-  end
-
-  def setup()
-    sound.save PATH
+  def stream_sound(seconds = 0.1, **kwargs)
+    Tempfile.create ['stream', '.wav'] do |file|
+      file.close
+      sound(seconds).save file.path
+      sound 0, processor: B::FileIn.new(file.path), **kwargs
+    end
   end
 
   def teardown()
     B::SoundPlayer.stop_all
-    File.delete PATH if File.exist?(PATH)
   end
 
   def test_initialize()
@@ -66,7 +64,7 @@ class TestSoundPlayer < Test::Unit::TestCase
     sleep sec * 2
     assert_equal :stopped, p.state
 
-    s = stream_sound
+    s = stream_sound sec
     p = s.play
     assert_equal :playing, p.state
     sleep sec * 2
@@ -87,6 +85,18 @@ class TestSoundPlayer < Test::Unit::TestCase
     assert_equal :playing, p.state
   end
 
+  def test_play_after_stop()
+    p = sound.play
+    p.stop
+    p.play
+    assert_equal :playing, p.state
+
+    p = stream_sound.play
+    p.stop
+    p.play
+    assert_equal :playing, p.state
+  end
+
   def test_stop_after_pause()
     p = sound.play
     p.pause
@@ -102,6 +112,8 @@ class TestSoundPlayer < Test::Unit::TestCase
   end
 
   def test_state()
+    assert_equal :none, B::SoundPlayer.new.state
+
     p = sound.play
     assert_equal :playing, p.state
     assert_equal [true,  false, false], [p.playing?, p.paused?, p.stopped?]
@@ -155,32 +167,67 @@ class TestSoundPlayer < Test::Unit::TestCase
     assert_equal 200, p.position
   end
 
+  def test_play_from_position_after_stop()
+    p = sound(1).play
+    p.stop
+    p.position = 22050
+    assert_equal 22050, p.position
+    p.play
+    sleep 0.05
+    assert_equal :playing, p.state
+    assert_operator p.position, :>=, 22050
+
+    p = stream_sound(1).play
+    p.stop
+    p.position = 1000
+    assert_equal 1000, p.position
+    p.play
+    sleep 0.05
+    assert_equal :playing, p.state
+    assert_operator p.position, :>=, 1000
+  end
+
+  def test_position_over_length()
+    p = sound.play
+    assert_raise(ArgumentError) {p.position = 100_000}
+    p.stop
+    assert_raise(ArgumentError) {p.position = 100_000}
+    p.play
+    assert_equal :playing, p.state
+
+    p = stream_sound.play
+    p.stop
+    p.position = 100_000
+    p.play
+    assert_equal :stopped, p.state
+  end
+
   def test_time()
     p = sound.play
     p.pause
-    assert_in_epsilon 0,    p.time
+    assert_in_epsilon 0,     p.time
 
-    p.time =          0.05
+    p.time =          0.025
     sleep 0.05
-    assert_in_epsilon 0.05, p.time
+    assert_in_epsilon 0.025, p.time
 
-    p.time            0.1
+    p.time            0.05
     sleep 0.05
-    assert_in_epsilon 0.1,  p.time
+    assert_in_epsilon 0.05,  p.time
   end
 
   def test_time_stream()
     p = stream_sound.play
     p.pause
-    assert_in_epsilon 0,    p.time
+    assert_in_epsilon 0,     p.time
 
-    p.time =          0.05
+    p.time =          0.025
     sleep 0.05
-    assert_in_epsilon 0.05, p.time
+    assert_in_epsilon 0.025, p.time
 
-    p.time            0.1
+    p.time            0.05
     sleep 0.05
-    assert_in_epsilon 0.1,  p.time
+    assert_in_epsilon 0.05,  p.time
   end
 
   def test_time_scale()
@@ -228,4 +275,23 @@ class TestSoundPlayer < Test::Unit::TestCase
     assert_true players.all? {|p| p.stopped?}
   end
 
+  def test_players_over_limit()
+    s = sound 1
+
+    paused = s.play
+    paused.pause
+    paused.time = 0.5
+
+    players = 300.times.map {s.play}
+    assert_true players.none? {|p| p.state == :none}
+    assert_equal :paused, paused.state
+    assert_in_epsilon 0.5, paused.time
+
+    paused.play
+    assert_equal :playing, paused.state
+
+    players.first.play
+    assert_equal :playing, players.first.state
+  end
+
 end# TestSoundPlayer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beeps
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 description: Synthesize and play beep sounds.
 email: xordog@gmail.com
 executables: []
@@ -93,7 +93,6 @@ files:
 - ".github/workflows/release-gem.yml"
 - ".github/workflows/tag.yml"
 - ".github/workflows/test.yml"
-- ".github/workflows/utils.rb"
 - CLAUDE.md
 - CONTRIBUTING.md
 - ChangeLog.md
@@ -233,7 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Plays beep sound.

data/.github/workflows/utils.rb

@@ -1,127 +0,0 @@
-require 'shellwords'
-
-ALL_REPO        = 'xord/all'
-ALL_DIR         = '../all'
-ALL_FETCH_DEPTH = 100
-
-RENAMES = {reflex: 'reflexion'}
-
-def sh(cmd)
-  puts cmd
-  system cmd
-end
-
-def setup_dependencies(only: nil)
-  gemspec_path = `git ls-files`.lines(chomp: true).find {|l| l =~ /\.gemspec$/}
-  return unless gemspec_path
-
-  gemspec = File.read gemspec_path
-  name    = File.basename gemspec_path, '.gemspec'
-
-  exts = File.readlines('Rakefile')
-    .map {|l| l[%r|^\s*require\W+([\w\-\_]+)/extension\W+$|, 1]}
-    .compact
-    .reject {|ext| ext == name}
-  exts = exts & [only].flatten.map(&:to_s) if only
-  return if exts.empty?
-
-  unless setup_dependencies_via_monorepo(exts)
-    setup_dependencies_via_each_repo_by_version(gemspec, exts)
-  end
-
-  exts.each {|ext| sh %( cd ../#{ext} && rake ext )}
-end
-
-def setup_dependencies_via_monorepo(exts)
-  return false unless checkout_monorepo
-  exts.each {|ext| sh %( ln -snf all/#{ext} ../#{ext} )}
-  true
-end
-
-def checkout_monorepo()
-  uuid = `git log -1 --format=%B`[/^\[\[([0-9a-fA-F-]+)\]\]$/, 1]
-  return false unless uuid
-
-  commit = setup_monorepo uuid
-  return false unless commit
-
-  Dir.chdir(ALL_DIR) {sh %( git checkout -q #{commit} )}
-  true
-end
-
-def setup_monorepo(uuid)
-  unless File.directory? ALL_DIR
-    url = "https://github.com/#{ALL_REPO}.git"
-    sh %( git clone --no-tags --depth #{ALL_FETCH_DEPTH} #{url} #{ALL_DIR} )
-  end
-  loop do
-    commit = find_monorepo_commit uuid
-    return commit if commit
-
-    deepened = Dir.chdir ALL_DIR do
-      before = `git rev-list --count HEAD`.to_i
-      sh %( git fetch --deepen #{ALL_FETCH_DEPTH} )
-      `git rev-list --count HEAD`.to_i > before
-    end
-    return nil unless deepened
-  end
-end
-
-def find_monorepo_commit(uuid)
-  Dir.chdir ALL_DIR do
-    out = `git log origin/HEAD -F --grep="[[#{uuid}]]" --format=%H -1`.strip
-    out.empty? ? nil : out
-  end
-end
-
-def setup_dependencies_via_each_repo_by_version(gemspec, exts)
-  exts.each do |ext|
-    gem   = RENAMES[ext.to_sym].then {|s| s || ext}
-    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*~>\s*([\d\.]+)\s*['"]/, 1]
-    opts  = '-c advice.detachedHead=false --depth 1'
-    clone = "git clone #{opts} https://github.com/xord/#{ext}.git ../#{ext}"
-
-    # 'rake subtree:push' pushes all subrepos, so cloning by new tag
-    # often fails before tagging each new tag
-    sh %( #{clone} --branch v#{ver} || #{clone} )
-  end
-end
-
-def tag_versions()
-  changes = changelogs
-  tags    = `git tag`.lines chomp: true
-  vers    = `git log --oneline ./VERSION`
-    .lines(chomp: true)
-    .map {|line| line.split.first[/^\w+$/]}
-    .map {|sha| [`git cat-file -p #{sha}:./VERSION 2>/dev/null`[/[\d\.]+/], sha]}
-    .select {|ver, sha| ver && sha}
-    .reverse
-    .to_h
-
-  vers.to_a.reverse.each do |ver, sha|
-    tag = "v#{ver}"
-    break if tags.include?(tag)
-    sh %( git tag -a -m \"#{changes[tag]&.gsub '"', '\\"'}\" #{tag} #{sha} )
-  end
-end
-
-def release(*paths)
-  tag   = ENV['GITHUB_REF']&.sub(%r|^refs/tags/|, '') || raise('GITHUB_REF tag not set')
-  notes = (changelogs[tag] || '').shellescape
-  paths = paths.flatten.join ' '
-
-  sh(%( gh release create #{tag} #{paths} --notes #{notes} )) ||
-    sh(%( gh release upload #{tag} #{paths} --clobber )) ||
-    raise('failed to upload to releases')
-end
-
-def changelogs()
-  File.read('ChangeLog.md')
-    .split(/^\s*##\s*\[\s*(v[\d\.]+)\s*\].*$/)
-    .slice(1..)
-    .each_slice(2)
-    .to_h
-    .transform_values(&:strip!)
-rescue Errno::ENOENT
-  raise 'failed to get changelogs'
-end