lywsvip/WindowsMusicPlayer-TheUntamedMusicPlayer
1
0
Fork 0
mirror of https://github.com/LanZhan-Harmony/WindowsMusicPlayer-TheUntamedMusicPlayer.git synced 2026-05-06 19:20:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

修复独占播放错误

Browse Source
This commit is contained in:
LanZhan-Harmony
2026-05-06 17:02:33 +08:00
parent 508fec363a
commit 8fe6ff874e
16 changed files with 1493 additions and 765 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
BassAudioEngine/BassAudioEngine.vcxproj
View File

@@ -128,12 +128,13 @@
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
<LanguageStandard_C>stdclatest</LanguageStandard_C>
<FloatingPointModel>Fast</FloatingPointModel>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<AdditionalDependencies>bass.lib;bass_fx.lib;basswasapi.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>bass.lib;bass_fx.lib;basswasapi.lib;bassmix.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(ProjectDir)Libraries\$(Platform)</AdditionalLibraryDirectories>
</Link>
<PostBuildEvent>
@@ -157,6 +158,7 @@ if exist "$(OutDir)$(TargetName).exp" del "$(OutDir)$(TargetName).exp"</Command>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<OmitFramePointers>true</OmitFramePointers>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
@@ -183,12 +185,13 @@ if exist "$(OutDir)$(TargetName).exp" del "$(OutDir)$(TargetName).exp"</Command>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
<LanguageStandard_C>stdclatest</LanguageStandard_C>
<FloatingPointModel>Fast</FloatingPointModel>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<AdditionalDependencies>bass.lib;bass_fx.lib;basswasapi.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>bass.lib;bass_fx.lib;basswasapi.lib;bassmix.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(ProjectDir)Libraries\$(Platform)</AdditionalLibraryDirectories>
</Link>
<PostBuildEvent>
@@ -207,12 +210,13 @@ if exist "$(OutDir)$(TargetName).exp" del "$(OutDir)$(TargetName).exp"</Command>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
<LanguageStandard_C>stdclatest</LanguageStandard_C>
<FloatingPointModel>Fast</FloatingPointModel>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<AdditionalDependencies>bass.lib;bass_fx.lib;basswasapi.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>bass.lib;bass_fx.lib;basswasapi.lib;bassmix.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(ProjectDir)Libraries\$(Platform)</AdditionalLibraryDirectories>
</Link>
<PostBuildEvent>
@@ -236,6 +240,7 @@ if exist "$(OutDir)$(TargetName).exp" del "$(OutDir)$(TargetName).exp"</Command>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<OmitFramePointers>true</OmitFramePointers>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
@@ -266,6 +271,7 @@ if exist "$(OutDir)$(TargetName).exp" del "$(OutDir)$(TargetName).exp"</Command>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<OmitFramePointers>true</OmitFramePointers>
<AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>

800
BassAudioEngine/bass_audio_engine.cpp
View File

@@ -4,390 +4,632 @@
namespace
{
struct EngineState final
{
HSTREAM mainHandle{};
HSTREAM fxHandle{};
bool bassInitialized{};
bool wasapiInitialized{};
bool pluginsLoaded{};
BassAudioEngineCallback playbackEndedCallback{};
BassAudioEngineCallback playbackFailedCallback{};
};
// =====================================================================
// WASAPI Exclusive Mode Audio pipeline architecture:
//
// [Source decode stream]
// -> [BASS_FX tempo stream] (decode mode, handles speed/pitch)
// -> [BASSmix mixer stream] (decode mode, handles resampling + volume)
// -> [WASAPI exclusive output] (native device format)
//
// In shared mode, the mixer is skipped and fxHandle plays directly.
//
// Volume in exclusive mode is applied via BASS_ATTRIB_VOLDSP on the mixer stream.
// This is a DSP-level volume that modifies PCM samples before they reach WASAPI, avoiding system endpoint volume issues.
// =====================================================================
EngineState g_engine{};
std::mutex g_engineMutex{};
struct EngineState final
{
HSTREAM mainHandle{}; // Source decode stream
HSTREAM fxHandle{}; // BASS_FX tempo stream (always decode in exclusive mode)
HSTREAM mixerHandle{}; // BASSmix mixer stream (exclusive mode only, decode mode)
bool bassInitialized{};
bool wasapiInitialized{};
bool pluginsLoaded{};
bool exclusiveMode{};
float currentVolume{1.0F};
BassAudioEngineCallback playbackEndedCallback{};
BassAudioEngineCallback playbackFailedCallback{};
};
[[nodiscard]] std::wstring GetAppDirectory()
{
std::array<wchar_t, MAX_PATH> buffer{};
DWORD length = GetModuleFileNameW(nullptr, buffer.data(), static_cast<DWORD>(buffer.size()));
if (length == 0) [[unlikely]]
{
return {};
}
EngineState g_engine{};
std::mutex g_engineMutex{};
std::filesystem::path appPath{std::wstring_view{buffer.data(), length}};
return appPath.parent_path().wstring();
}
// -----------------------------------------------------------------
// Utility: application directory for plugin loading
// -----------------------------------------------------------------
void LoadBassPlugins()
{
if (g_engine.pluginsLoaded) [[unlikely]]
{
return;
}
[[nodiscard]] std::wstring GetAppDirectory()
{
std::array<wchar_t, MAX_PATH> buffer{};
DWORD length = GetModuleFileNameW(nullptr, buffer.data(), static_cast<DWORD>(buffer.size()));
if (length == 0) [[unlikely]]
{
return {};
}
const std::wstring appDirectory = GetAppDirectory();
if (appDirectory.empty()) [[unlikely]]
{
return;
}
std::filesystem::path appPath{std::wstring_view{buffer.data(), length}};
return appPath.parent_path().wstring();
}
constexpr std::array pluginNames{
L"bassape.dll",
L"basscd.dll",
L"bassdsd.dll",
L"bassflac.dll",
L"basshls.dll",
L"bassmidi.dll",
L"bassopus.dll",
L"basswebm.dll",
L"basswv.dll",
};
void LoadBassPlugins()
{
if (g_engine.pluginsLoaded) [[unlikely]]
{
return;
}
const std::filesystem::path baseDir{appDirectory};
for (const wchar_t *const name : pluginNames)
{
BASS_PluginLoad((baseDir / name).c_str(), 0);
}
const std::wstring appDirectory = GetAppDirectory();
if (appDirectory.empty()) [[unlikely]]
{
return;
}
g_engine.pluginsLoaded = true;
}
constexpr std::array pluginNames{
L"bassape.dll",
L"basscd.dll",
L"bassdsd.dll",
L"bassflac.dll",
L"basshls.dll",
L"bassmidi.dll",
L"bassopus.dll",
L"basswebm.dll",
L"basswv.dll",
};
[[nodiscard]] bool EnsureBassInitialized()
{
if (g_engine.bassInitialized) [[likely]]
{
return true;
}
const std::filesystem::path baseDir{appDirectory};
for (const wchar_t *const name : pluginNames)
{
BASS_PluginLoad((baseDir / name).c_str(), 0);
}
if (!BASS_Init(-1, 44100, 0, nullptr, nullptr)) [[unlikely]]
{
return false;
}
g_engine.pluginsLoaded = true;
}
g_engine.bassInitialized = true;
LoadBassPlugins();
return true;
}
// -----------------------------------------------------------------
// BASS initialization
// -----------------------------------------------------------------
void FreeStreamsUnsafe()
{
if (BASS_WASAPI_IsStarted())
{
BASS_WASAPI_Stop(TRUE);
}
[[nodiscard]] bool EnsureBassInitialized()
{
if (g_engine.bassInitialized) [[likely]]
{
return true;
}
if (g_engine.wasapiInitialized)
{
BASS_WASAPI_Free();
g_engine.wasapiInitialized = false;
}
if (!BASS_Init(-1, 44100, 0, nullptr, nullptr)) [[unlikely]]
{
return false;
}
if (g_engine.fxHandle != 0) [[likely]]
{
BASS_StreamFree(g_engine.fxHandle);
g_engine.fxHandle = 0;
}
g_engine.bassInitialized = true;
LoadBassPlugins();
return true;
}
if (g_engine.mainHandle != 0) [[likely]]
{
BASS_StreamFree(g_engine.mainHandle);
g_engine.mainHandle = 0;
}
}
// -----------------------------------------------------------------
// Sync callbacks
// -----------------------------------------------------------------
void CALLBACK OnPlaybackEndedSync(HSYNC, DWORD, DWORD, void *)
{
const BassAudioEngineCallback callback = g_engine.playbackEndedCallback;
if (callback != nullptr) [[likely]]
{
callback();
}
}
void CALLBACK OnPlaybackEndedSync(HSYNC, DWORD, DWORD, void *)
{
const BassAudioEngineCallback callback = g_engine.playbackEndedCallback;
if (callback != nullptr) [[likely]]
{
callback();
}
}
void CALLBACK OnPlaybackFailedSync(HSYNC, DWORD, DWORD, void *)
{
const BassAudioEngineCallback callback = g_engine.playbackFailedCallback;
if (callback != nullptr) [[likely]]
{
callback();
}
}
void CALLBACK OnPlaybackFailedSync(HSYNC, DWORD, DWORD, void *)
{
const BassAudioEngineCallback callback = g_engine.playbackFailedCallback;
if (callback != nullptr) [[likely]]
{
callback();
}
}
DWORD CALLBACK WasapiProc(void *buffer, DWORD length, void *)
{
if (g_engine.fxHandle == 0) [[unlikely]]
{
return 0;
}
// -----------------------------------------------------------------
// WASAPI output callback — pulls PCM data from the mixer stream
// -----------------------------------------------------------------
return BASS_ChannelGetData(g_engine.fxHandle, buffer, length);
}
DWORD CALLBACK WasapiProc(void *buffer, DWORD length, void *)
{
const HSTREAM source = g_engine.mixerHandle;
if (source == 0) [[unlikely]]
{
return 0;
}
[[nodiscard]] HSTREAM CreateMainStream(const wchar_t *path, BOOL isOnline)
{
if (isOnline)
{
constexpr DWORD streamFlags = BASS_UNICODE | BASS_SAMPLE_FLOAT | BASS_STREAM_DECODE;
return BASS_StreamCreateURL(reinterpret_cast<const char *>(path), 0, streamFlags, nullptr, nullptr);
}
const DWORD got = BASS_ChannelGetData(source, buffer, length);
if (got == -1) [[unlikely]]
{
return 0;
}
constexpr DWORD streamFlags = BASS_UNICODE | BASS_SAMPLE_FLOAT | BASS_ASYNCFILE | BASS_STREAM_DECODE;
return BASS_StreamCreateFile(FALSE, path, 0, 0, streamFlags);
}
return got;
}
// -----------------------------------------------------------------
// Stream creation helpers
// -----------------------------------------------------------------
[[nodiscard]] HSTREAM CreateMainStream(const wchar_t *path, BOOL isOnline)
{
if (isOnline)
{
constexpr DWORD streamFlags = BASS_UNICODE | BASS_SAMPLE_FLOAT | BASS_STREAM_DECODE;
return BASS_StreamCreateURL(reinterpret_cast<const char *>(path), 0, streamFlags, nullptr, nullptr);
}
constexpr DWORD streamFlags = BASS_UNICODE | BASS_SAMPLE_FLOAT | BASS_ASYNCFILE | BASS_STREAM_DECODE;
return BASS_StreamCreateFile(FALSE, path, 0, 0, streamFlags);
}
// -----------------------------------------------------------------
// Query the WASAPI default device's native format
// -----------------------------------------------------------------
struct DeviceFormat
{
DWORD freq{};
DWORD chans{};
};
[[nodiscard]] bool QueryDefaultDeviceFormat(DeviceFormat &out)
{
BASS_WASAPI_DEVICEINFO info{};
for (DWORD device = 0; BASS_WASAPI_GetDeviceInfo(device, &info); ++device)
{
if ((info.flags & BASS_DEVICE_ENABLED) && !(info.flags & BASS_DEVICE_INPUT) && (info.flags & BASS_DEVICE_DEFAULT))
{
out.freq = info.mixfreq;
out.chans = info.mixchans;
return out.freq > 0 && out.chans > 0;
}
}
return false;
}
// -----------------------------------------------------------------
// Try to find a supported exclusive format for the device.
// Prefers the source's native format, falls back to the device's default mix format.
// -----------------------------------------------------------------
[[nodiscard]] DeviceFormat NegotiateExclusiveFormat(DWORD sourceFreq, DWORD sourceChans)
{
// First, try the source's native sample rate + channels
if (BASS_WASAPI_CheckFormat(-1, sourceFreq, sourceChans, BASS_WASAPI_EXCLUSIVE) == BASS_OK) [[likely]]
{
return {sourceFreq, sourceChans};
}
// Fall back to device's native format
DeviceFormat deviceFmt{};
if (QueryDefaultDeviceFormat(deviceFmt))
{
if (BASS_WASAPI_CheckFormat(-1, deviceFmt.freq, deviceFmt.chans, BASS_WASAPI_EXCLUSIVE) == BASS_OK)
{
return deviceFmt;
}
}
// Try common sample rates as last resort
constexpr DWORD commonRates[] = {192000, 96000, 48000, 44100};
for (const DWORD rate : commonRates)
{
if (BASS_WASAPI_CheckFormat(-1, rate, sourceChans, BASS_WASAPI_EXCLUSIVE) == BASS_OK)
{
return {rate, sourceChans};
}
}
// Absolute fallback — return device defaults and let WASAPI_Init report if it truly cannot work
if (deviceFmt.freq > 0)
{
return deviceFmt;
}
return {sourceFreq, sourceChans};
}
// -----------------------------------------------------------------
// Resource cleanup
// -----------------------------------------------------------------
void FreeStreamsUnsafe()
{
if (BASS_WASAPI_IsStarted())
{
BASS_WASAPI_Stop(TRUE);
}
if (g_engine.wasapiInitialized)
{
BASS_WASAPI_Free();
g_engine.wasapiInitialized = false;
}
if (g_engine.mixerHandle != 0)
{
BASS_StreamFree(g_engine.mixerHandle);
g_engine.mixerHandle = 0;
}
if (g_engine.fxHandle != 0) [[likely]]
{
BASS_StreamFree(g_engine.fxHandle);
g_engine.fxHandle = 0;
}
if (g_engine.mainHandle != 0) [[likely]]
{
BASS_StreamFree(g_engine.mainHandle);
g_engine.mainHandle = 0;
}
g_engine.exclusiveMode = false;
}
// -----------------------------------------------------------------
// Apply volume to the appropriate handle depending on mode
// -----------------------------------------------------------------
void ApplyVolumeUnsafe(float volume)
{
g_engine.currentVolume = volume;
if (g_engine.exclusiveMode && g_engine.mixerHandle != 0)
{
// In exclusive mode, use BASS_ATTRIB_VOLDSP on the mixer stream.
// This applies volume as a DSP effect on the PCM data before it
// reaches WASAPI, so it doesn't touch the system endpoint volume.
BASS_ChannelSetAttribute(g_engine.mixerHandle, BASS_ATTRIB_VOLDSP, volume);
}
else if (g_engine.fxHandle != 0)
{
// In shared mode, standard BASS_ATTRIB_VOL works fine
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_VOL, volume);
}
}
// -----------------------------------------------------------------
// Initialize WASAPI exclusive output with the mixer pipeline
// -----------------------------------------------------------------
[[nodiscard]] bool InitWasapiExclusive()
{
if (g_engine.fxHandle == 0) [[unlikely]]
{
return false;
}
// Get source format info from the tempo stream
BASS_CHANNELINFO channelInfo{};
if (!BASS_ChannelGetInfo(g_engine.fxHandle, &channelInfo)) [[unlikely]]
{
return false;
}
// Negotiate a format the device actually supports in exclusive mode
const DeviceFormat deviceFmt = NegotiateExclusiveFormat(channelInfo.freq, channelInfo.chans);
// Create a BASSmix mixer stream at the device's native format.
// The mixer runs in decode mode so WASAPI pulls from it.
// BASS_MIXER_NONSTOP keeps the mixer running even when the source temporarily has no data (prevents glitches during seeks).
constexpr DWORD mixerFlags = BASS_STREAM_DECODE | BASS_SAMPLE_FLOAT | BASS_MIXER_NONSTOP;
g_engine.mixerHandle = BASS_Mixer_StreamCreate(deviceFmt.freq, deviceFmt.chans, mixerFlags);
if (g_engine.mixerHandle == 0) [[unlikely]]
{
return false;
}
// Add the tempo stream as a source into the mixer.
// BASSmix will automatically resample from the source rate to the mixer rate, which eliminates the pitch/speed problems.
constexpr DWORD addFlags = BASS_MIXER_CHAN_NORAMPIN | BASS_MIXER_CHAN_BUFFER;
if (!BASS_Mixer_StreamAddChannel(g_engine.mixerHandle, g_engine.fxHandle, addFlags)) [[unlikely]]
{
BASS_StreamFree(g_engine.mixerHandle);
g_engine.mixerHandle = 0;
return false;
}
// Set syncs on the source channel through the mixer
BASS_Mixer_ChannelSetSync(g_engine.fxHandle, BASS_SYNC_END | BASS_SYNC_MIXTIME, 0, OnPlaybackEndedSync, nullptr);
BASS_Mixer_ChannelSetSync(g_engine.fxHandle, BASS_SYNC_STALL, 0, OnPlaybackFailedSync, nullptr);
// Initialize WASAPI in exclusive mode — NO BASS_WASAPI_AUTOFORMAT.
// We've already negotiated a supported format, and BASSmix handles all the resampling, so WASAPI doesn't need to convert anything.
constexpr DWORD wasapiFlags = BASS_WASAPI_EXCLUSIVE | BASS_WASAPI_EVENT;
if (!BASS_WASAPI_Init(-1, deviceFmt.freq, deviceFmt.chans, wasapiFlags, 0.05F, 0, WasapiProc, nullptr)) [[unlikely]]
{
// Fall back without EVENT flag
constexpr DWORD wasapiFlagsFallback = BASS_WASAPI_EXCLUSIVE;
if (!BASS_WASAPI_Init(-1, deviceFmt.freq, deviceFmt.chans, wasapiFlagsFallback, 0.1F, 0.025F, WasapiProc, nullptr))
{
BASS_Mixer_ChannelRemove(g_engine.fxHandle);
BASS_StreamFree(g_engine.mixerHandle);
g_engine.mixerHandle = 0;
return false;
}
}
g_engine.wasapiInitialized = true;
g_engine.exclusiveMode = true;
// Apply saved volume via DSP volume on the mixer
ApplyVolumeUnsafe(g_engine.currentVolume);
return true;
}
}
// =====================================================================
// Exported API
// =====================================================================
void WINAPI BaeSetCallbacks(BassAudioEngineCallback playbackEndedCallback, BassAudioEngineCallback playbackFailedCallback)
{
const std::lock_guard lock{g_engineMutex};
g_engine.playbackEndedCallback = playbackEndedCallback;
g_engine.playbackFailedCallback = playbackFailedCallback;
const std::lock_guard lock{g_engineMutex};
g_engine.playbackEndedCallback = playbackEndedCallback;
g_engine.playbackFailedCallback = playbackFailedCallback;
}
BOOL WINAPI BaeInitialize()
{
const std::lock_guard lock{g_engineMutex};
return EnsureBassInitialized() ? TRUE : FALSE;
const std::lock_guard lock{g_engineMutex};
return EnsureBassInitialized() ? TRUE : FALSE;
}
void WINAPI BaeShutdown()
{
const std::lock_guard lock{g_engineMutex};
const std::lock_guard lock{g_engineMutex};
FreeStreamsUnsafe();
FreeStreamsUnsafe();
if (g_engine.bassInitialized) [[likely]]
{
BASS_Free();
g_engine.bassInitialized = false;
}
if (g_engine.bassInitialized) [[likely]]
{
BASS_Free();
g_engine.bassInitialized = false;
}
g_engine.playbackEndedCallback = nullptr;
g_engine.playbackFailedCallback = nullptr;
g_engine.playbackEndedCallback = nullptr;
g_engine.playbackFailedCallback = nullptr;
}
BOOL WINAPI BaeLoadSong(const wchar_t *path, BOOL isOnline, BOOL isExclusiveMode, double volume, double speed, double *totalSeconds)
{
const std::lock_guard lock{g_engineMutex};
const std::lock_guard lock{g_engineMutex};
FreeStreamsUnsafe();
FreeStreamsUnsafe();
if (!EnsureBassInitialized()) [[unlikely]]
{
return FALSE;
}
if (!EnsureBassInitialized()) [[unlikely]]
{
return FALSE;
}
g_engine.mainHandle = CreateMainStream(path, isOnline);
if (g_engine.mainHandle == 0 && BASS_ErrorGetCode() == BASS_ERROR_INIT) [[unlikely]]
{
g_engine.bassInitialized = false;
if (!EnsureBassInitialized()) [[unlikely]]
{
return FALSE;
}
g_engine.mainHandle = CreateMainStream(path, isOnline);
if (g_engine.mainHandle == 0 && BASS_ErrorGetCode() == BASS_ERROR_INIT) [[unlikely]]
{
g_engine.bassInitialized = false;
if (!EnsureBassInitialized()) [[unlikely]]
{
return FALSE;
}
g_engine.mainHandle = CreateMainStream(path, isOnline);
}
g_engine.mainHandle = CreateMainStream(path, isOnline);
}
if (g_engine.mainHandle == 0) [[unlikely]]
{
return FALSE;
}
if (g_engine.mainHandle == 0) [[unlikely]]
{
return FALSE;
}
const DWORD tempoFlags = isExclusiveMode ? BASS_STREAM_DECODE : BASS_FX_FREESOURCE;
g_engine.fxHandle = BASS_FX_TempoCreate(g_engine.mainHandle, tempoFlags);
if (g_engine.fxHandle == 0) [[unlikely]]
{
BASS_StreamFree(g_engine.mainHandle);
g_engine.mainHandle = 0;
return FALSE;
}
// In exclusive mode, the tempo stream must be in decode mode so it can be fed into the BASSmix mixer.
// In shared mode, use BASS_FX_FREESOURCE for normal playback.
const DWORD tempoFlags = isExclusiveMode ? BASS_STREAM_DECODE : BASS_FX_FREESOURCE;
g_engine.fxHandle = BASS_FX_TempoCreate(g_engine.mainHandle, tempoFlags);
if (g_engine.fxHandle == 0) [[unlikely]]
{
BASS_StreamFree(g_engine.mainHandle);
g_engine.mainHandle = 0;
return FALSE;
}
BASS_ChannelSetSync(g_engine.fxHandle, BASS_SYNC_END, 0, OnPlaybackEndedSync, nullptr);
BASS_ChannelSetSync(g_engine.fxHandle, BASS_SYNC_STALL, 0, OnPlaybackFailedSync, nullptr);
// Set tempo (speed change as percentage)
const float tempoPercent = static_cast<float>((speed - 1.0) * 100.0);
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_TEMPO, tempoPercent);
const float tempoPercent = static_cast<float>((speed - 1.0) * 100.0);
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_TEMPO, tempoPercent);
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_VOL, static_cast<float>(volume));
// Save the requested volume; it will be applied when the pipeline is fully constructed (in BaePlay for exclusive, or here for shared).
g_engine.currentVolume = static_cast<float>(volume);
if (totalSeconds != nullptr) [[likely]]
{
const QWORD lengthBytes = BASS_ChannelGetLength(g_engine.fxHandle, BASS_POS_BYTE);
*totalSeconds = BASS_ChannelBytes2Seconds(g_engine.fxHandle, lengthBytes);
}
if (!isExclusiveMode)
{
// For shared mode, set up syncs on the fxHandle directly
BASS_ChannelSetSync(g_engine.fxHandle, BASS_SYNC_END, 0, OnPlaybackEndedSync, nullptr);
BASS_ChannelSetSync(g_engine.fxHandle, BASS_SYNC_STALL, 0, OnPlaybackFailedSync, nullptr);
return TRUE;
// Apply volume directly for shared mode
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_VOL, g_engine.currentVolume);
}
if (totalSeconds != nullptr) [[likely]]
{
const QWORD lengthBytes = BASS_ChannelGetLength(g_engine.fxHandle, BASS_POS_BYTE);
*totalSeconds = BASS_ChannelBytes2Seconds(g_engine.fxHandle, lengthBytes);
}
return TRUE;
}
void WINAPI BaeStop()
{
const std::lock_guard lock{g_engineMutex};
FreeStreamsUnsafe();
const std::lock_guard lock{g_engineMutex};
FreeStreamsUnsafe();
}
BOOL WINAPI BaePlay(BOOL isExclusiveMode)
{
const std::lock_guard lock{g_engineMutex};
const std::lock_guard lock{g_engineMutex};
if (g_engine.fxHandle == 0) [[unlikely]]
{
return FALSE;
}
if (g_engine.fxHandle == 0) [[unlikely]]
{
return FALSE;
}
if (isExclusiveMode)
{
if (BASS_WASAPI_IsStarted()) [[unlikely]]
{
return TRUE;
}
if (isExclusiveMode)
{
// If WASAPI is already running, nothing to do
if (BASS_WASAPI_IsStarted()) [[unlikely]]
{
return TRUE;
}
if (g_engine.wasapiInitialized)
{
return BASS_WASAPI_Start() ? TRUE : FALSE;
}
// If WASAPI was initialized (paused state), just restart it
if (g_engine.wasapiInitialized)
{
return BASS_WASAPI_Start() ? TRUE : FALSE;
}
BASS_CHANNELINFO channelInfo{};
if (!BASS_ChannelGetInfo(g_engine.fxHandle, &channelInfo)) [[unlikely]]
{
return FALSE;
}
// First-time setup: build the full mixer pipeline and init WASAPI
if (!InitWasapiExclusive()) [[unlikely]]
{
return FALSE;
}
// Use AUTOFORMAT flag to let BASS handle sample rate conversion automatically
// Try to initialize with the original frequency first
const DWORD baseFlags = BASS_WASAPI_EXCLUSIVE | BASS_WASAPI_AUTOFORMAT;
if (!BASS_WASAPI_Init(-1, channelInfo.freq, channelInfo.chans, baseFlags | BASS_WASAPI_EVENT, 0.1F, 0, WasapiProc, nullptr))
{
// If it fails, try not using the EVENT flag
if (!BASS_WASAPI_Init(-1, channelInfo.freq, channelInfo.chans, baseFlags, 0.1F, 0.025F, WasapiProc, nullptr))
{
return FALSE;
}
}
return BASS_WASAPI_Start() ? TRUE : FALSE;
}
g_engine.wasapiInitialized = true;
return BASS_WASAPI_Start() ? TRUE : FALSE;
}
// Shared mode playback
if (BASS_ChannelIsActive(g_engine.fxHandle) == BASS_ACTIVE_PLAYING) [[unlikely]]
{
return TRUE;
}
if (BASS_ChannelIsActive(g_engine.fxHandle) == BASS_ACTIVE_PLAYING) [[unlikely]]
{
return TRUE;
}
if (BASS_ChannelPlay(g_engine.fxHandle, FALSE)) [[likely]]
{
return TRUE;
}
if (BASS_ChannelPlay(g_engine.fxHandle, FALSE)) [[likely]]
{
return TRUE;
}
if (BASS_ErrorGetCode() == BASS_ERROR_START && BASS_Start())
{
return BASS_ChannelPlay(g_engine.fxHandle, FALSE) ? TRUE : FALSE;
}
if (BASS_ErrorGetCode() == BASS_ERROR_START && BASS_Start())
{
return BASS_ChannelPlay(g_engine.fxHandle, FALSE) ? TRUE : FALSE;
}
return FALSE;
return FALSE;
}
void WINAPI BaePause(BOOL isExclusiveMode)
{
const std::lock_guard lock{g_engineMutex};
const std::lock_guard lock{g_engineMutex};
if (g_engine.fxHandle == 0) [[unlikely]]
{
return;
}
if (g_engine.fxHandle == 0) [[unlikely]]
{
return;
}
if (isExclusiveMode)
{
if (BASS_WASAPI_IsStarted()) [[likely]]
{
BASS_WASAPI_Stop(FALSE);
}
if (isExclusiveMode)
{
if (BASS_WASAPI_IsStarted()) [[likely]]
{
BASS_WASAPI_Stop(FALSE);
}
return;
}
return;
}
BASS_ChannelPause(g_engine.fxHandle);
BASS_ChannelPause(g_engine.fxHandle);
}
void WINAPI BaeSetSpeed(double speed)
{
const std::lock_guard lock{g_engineMutex};
const std::lock_guard lock{g_engineMutex};
if (g_engine.fxHandle == 0) [[unlikely]]
{
return;
}
if (g_engine.fxHandle == 0) [[unlikely]]
{
return;
}
const float tempoPercent = static_cast<float>((speed - 1.0) * 100.0);
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_TEMPO, tempoPercent);
const float tempoPercent = static_cast<float>((speed - 1.0) * 100.0);
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_TEMPO, tempoPercent);
}
void WINAPI BaeSetVolume(double volume)
{
const std::lock_guard lock{g_engineMutex};
if (g_engine.fxHandle == 0) [[unlikely]]
{
return;
}
BASS_ChannelSetAttribute(g_engine.fxHandle, BASS_ATTRIB_VOL, static_cast<float>(volume));
const std::lock_guard lock{g_engineMutex};
ApplyVolumeUnsafe(static_cast<float>(volume));
}
double WINAPI BaeGetPositionSeconds()
{
const std::lock_guard lock{g_engineMutex};
const std::lock_guard lock{g_engineMutex};
if (g_engine.fxHandle == 0) [[unlikely]]
{
return -1.0;
}
if (g_engine.fxHandle == 0) [[unlikely]]
{
return -1.0;
}
const QWORD positionBytes = BASS_ChannelGetPosition(g_engine.fxHandle, BASS_POS_BYTE);
return BASS_ChannelBytes2Seconds(g_engine.fxHandle, positionBytes);
if (g_engine.exclusiveMode && g_engine.mixerHandle != 0)
{
// When using a mixer, get the position of the source channel through the mixer for accurate timing
const QWORD positionBytes = BASS_Mixer_ChannelGetPosition(g_engine.fxHandle, BASS_POS_BYTE);
return BASS_ChannelBytes2Seconds(g_engine.fxHandle, positionBytes);
}
const QWORD positionBytes = BASS_ChannelGetPosition(g_engine.fxHandle, BASS_POS_BYTE);
return BASS_ChannelBytes2Seconds(g_engine.fxHandle, positionBytes);
}
BOOL WINAPI BaeSetPositionSeconds(double targetSeconds)
{
const std::lock_guard lock{g_engineMutex};
const std::lock_guard lock{g_engineMutex};
if (g_engine.fxHandle == 0) [[unlikely]]
{
return FALSE;
}
if (g_engine.fxHandle == 0) [[unlikely]]
{
return FALSE;
}
const QWORD targetBytes = BASS_ChannelSeconds2Bytes(g_engine.fxHandle, targetSeconds);
BOOL result = BASS_ChannelSetPosition(g_engine.fxHandle, targetBytes, BASS_POS_BYTE);
const QWORD targetBytes = BASS_ChannelSeconds2Bytes(g_engine.fxHandle, targetSeconds);
if (!result && BASS_ErrorGetCode() == BASS_ERROR_POSITION) [[unlikely]]
{
for (int retryCount = 0; retryCount < 5 && !result; ++retryCount)
{
std::this_thread::sleep_for(std::chrono::milliseconds{200});
result = BASS_ChannelSetPosition(g_engine.fxHandle, targetBytes, BASS_POS_BYTE);
}
}
BOOL result{};
if (g_engine.exclusiveMode && g_engine.mixerHandle != 0)
{
// Seek through the mixer for proper buffer management
result = BASS_Mixer_ChannelSetPosition(g_engine.fxHandle, targetBytes, BASS_POS_BYTE | BASS_POS_MIXER_RESET);
}
else
{
result = BASS_ChannelSetPosition(g_engine.fxHandle, targetBytes, BASS_POS_BYTE);
}
return result ? TRUE : FALSE;
if (!result && BASS_ErrorGetCode() == BASS_ERROR_POSITION) [[unlikely]]
{
for (int retryCount = 0; retryCount < 5 && !result; ++retryCount)
{
std::this_thread::sleep_for(std::chrono::milliseconds{200});
if (g_engine.exclusiveMode && g_engine.mixerHandle != 0)
{
result = BASS_Mixer_ChannelSetPosition(g_engine.fxHandle, targetBytes, BASS_POS_BYTE | BASS_POS_MIXER_RESET);
}
else
{
result = BASS_ChannelSetPosition(g_engine.fxHandle, targetBytes, BASS_POS_BYTE);
}
}
}
return result ? TRUE : FALSE;
}
int WINAPI BaeGetLastError()
{
return BASS_ErrorGetCode();
return BASS_ErrorGetCode();
}
BOOL WINAPI BaeIsLastErrorBusy()
{
return BASS_ErrorGetCode() == BASS_ERROR_BUSY ? TRUE : FALSE;
return BASS_ErrorGetCode() == BASS_ERROR_BUSY ? TRUE : FALSE;
}

3
UntamedMusicPlayer/Strings/ar/Resources.resw
View File

@@ -222,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>يقلل من تأخير الصوت. موصى به للأجهزة متوسطة إلى العالية. قم بتعطيل هذا إذا واجهت تقطعا أو مشاكل في التشغيل.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>بمجرد تفعيلها، لن يكون التحكم في مستوى الصوت داخل التطبيق متاحا. يرجى ضبط مستوى الصوت عبر نظام التشغيل.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>إذا كنت في صفحة الأغاني في مكتبة الموسيقى مع تفعيل فرز المجلدات، فإن النقر على أغنية سيضيف فقط الأغاني من نفس المجلد إلى قائمة التشغيل.</value>
</data>

159
UntamedMusicPlayer/Strings/bn/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>অডিও বিলম্ব হ্রাস করে। মাঝারি থেকে উচ্চ-প্রান্তের ডিভাইসগুলির জন্য সুপারিশ করা হয়েছে। আপনি তোতলামি বা প্লেব্যাক সমস্যাগুলি অনুভব করলে এটি অক্ষম করুন।</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>একবার সক্ষম হয়ে গেলে, ইন-অ্যাপ ভলিউম নিয়ন্ত্রণ অসুলভ হবে। দয়া করে অপারেটিং সিস্টেমের মাধ্যমে ভলিউম সামঞ্জস্য করুন।</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>আপনি যদি ফোল্ডার বাছাই সক্ষম করে সংগীত লাইব্রেরির গানের পৃষ্ঠায় থাকেন তবে কোনও গানে ক্লিক করলে কেবল একই ফোল্ডার থেকে প্লেব্যাক সারিতে গান যুক্ত হবে।</value>
</data>

159
UntamedMusicPlayer/Strings/de/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>Reduziert die Audio-Latenz. Empfohlen für Geräte im mittleren bis hohen Preissegment. Deaktivieren Sie dies, wenn Sie Ruckler oder Wiedergabeprobleme haben.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>Sobald aktiviert, ist die Lautstärkeregelung in der App nicht mehr verfügbar. Bitte stellen Sie die Lautstärke über das Betriebssystem ein.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>Wenn du auf der Musikbibliotheksseite mit aktivierter Ordnersortierung bist, fügt ein Klick auf ein Lied nur Songs aus demselben Ordner in die Wiedergabewarteschlange hinzu.</value>
</data>

3
UntamedMusicPlayer/Strings/en/Resources.resw
View File

@@ -222,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>Reduces audio latency. Recommended for mid-to-high-end devices. Disable this if you experience stuttering or playback issues.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>Once enabled, in-app volume control will be unavailable. Please adjust the volume through the operating system.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>If you are on the music library's song page with folder sorting enabled, clicking a song will only add songs from that same folder to the playback queue.</value>
</data>

159
UntamedMusicPlayer/Strings/es/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>Reduce la latencia de audio. Recomendado para dispositivos de gama media a alta. Desactiva esto si experimentas tirones o problemas de reproducción.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>Una vez activado, el control de volumen dentro de la app no estará disponible. Por favor, ajusta el volumen a través del sistema operativo.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>Si estás en la página de canciones de la biblioteca de música con la ordenación de carpetas activada, hacer clic en una canción solo añadirá canciones de esa misma carpeta a la cola de reproducción.</value>
</data>

159
UntamedMusicPlayer/Strings/fr/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>Réduit la latence audio. Recommandé pour les appareils milieu à haut de gamme. Désactivez cela si vous rencontrez des saccades ou des problèmes de lecture.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>Une fois activé, le contrôle du volume dans l’application sera indisponible. Veuillez ajuster le volume via le système d’exploitation.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>Si vous êtes sur la page des chansons de la bibliothèque musicale avec le tri des dossiers activé, cliquer sur une chanson n’ajoutera que des chansons de ce même dossier à la file de lecture.</value>
</data>

159
UntamedMusicPlayer/Strings/hi/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>ऑडियो विलंबता को कम करता है। मध्य-से-उच्च-अंत उपकरणों के लिए अनुशंसित। यदि आप हकलाने या प्लेबैक समस्याओं का अनुभव करते हैं, तो इसे अक्षम करें।</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>एक बार सक्षम होने के बाद, इन-ऐप वॉल्यूम नियंत्रण अनुपलब्ध होगा। कृपया ऑपरेटिंग सिस्टम के माध्यम से वॉल्यूम समायोजित करें।</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>यदि आप फ़ोल्डर सॉर्टिंग सक्षम के साथ संगीत लाइब्रेरी के गीत पृष्ठ पर हैं, तो किसी गीत पर क्लिक करने से केवल उसी फ़ोल्डर से प्लेबैक कतार में गाने जुड़ जाएंगे।</value>
</data>

159
UntamedMusicPlayer/Strings/id/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>Mengurangi latensi audio. Direkomendasikan untuk perangkat kelas menengah hingga atas. Nonaktifkan ini jika Anda mengalami masalah gagap atau pemutaran.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>Setelah diaktifkan, kontrol volume dalam aplikasi tidak akan tersedia. Silakan sesuaikan volume melalui sistem operasi.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>Jika Anda berada di halaman lagu perpustakaan musik dengan pengurutan folder diaktifkan, mengklik lagu hanya akan menambahkan lagu dari folder yang sama ke antrean pemutaran.</value>
</data>

3
UntamedMusicPlayer/Strings/ja/Resources.resw
View File

@@ -222,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>音声遅延を減らします。中〜高価格帯のデバイスにおすすめです。カクつきや再生の問題がある場合は、これを無効にしてください。</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>一度有効になると、アプリ内の音量コントロールは使えなくなります。OSを通じて音量を調整してください。</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>もし音楽ライブラリの曲のページでフォルダのソートが有効なら、曲をクリックすると同じフォルダの曲だけが再生キューに追加されます。</value>
</data>

159
UntamedMusicPlayer/Strings/ko/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>오디오 지연 시간을 줄여줍니다. 중고급 기기에 추천합니다. 끊김이나 재생 문제가 있으면 이 기능을 비활성화하세요.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>활성화되면 앱 내 볼륨 조절은 불가능해집니다. 운영체제를 통해 볼륨을 조정해 주세요.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>음악 라이브러리의 노래 페이지에서 폴더 정렬이 활성화되어 있다면, 노래를 클릭하면 같은 폴더의 노래만 재생 큐에 추가됩니다.</value>
</data>

159
UntamedMusicPlayer/Strings/pt/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>Reduz a latência do áudio. Recomendado para dispositivos de médio a alto desempenho. Desative isso se você tiver problemas de engasgo ou reprodução.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>Uma vez ativado, o controle de volume dentro do app não estará disponível. Por favor, ajuste o volume pelo sistema operacional.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>Se você estiver na página de músicas da biblioteca de músicas com a ordenação de pastas ativada, clicar em uma música só adicionará músicas dessa mesma pasta à fila de reprodução.</value>
</data>

159
UntamedMusicPlayer/Strings/ru/Resources.resw
View File

@@ -1,52 +1,110 @@
<?xml version='1.0' encoding='utf-8'?>
<root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:schema id="root">
<xs:import namespace="http://www.w3.org/XML/1998/namespace" />
<xs:element name="root" ns1:IsDataSet="true">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="metadata">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" />
</xs:sequence>
<xs:attribute name="name" use="required" type="xsd:string" />
<xs:attribute name="type" type="xsd:string" />
<xs:attribute name="mimetype" type="xsd:string" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="assembly">
<xs:complexType>
<xs:attribute name="alias" type="xsd:string" />
<xs:attribute name="name" type="xsd:string" />
</xs:complexType>
</xs:element>
<xs:element name="data">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
<xs:element name="comment" type="xsd:string" minOccurs="0" ns1:Ordinal="2" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" ns1:Ordinal="1" />
<xs:attribute name="type" type="xsd:string" ns1:Ordinal="3" />
<xs:attribute name="mimetype" type="xsd:string" ns1:Ordinal="4" />
<xs:attribute ref="xml:space" />
</xs:complexType>
</xs:element>
<xs:element name="resheader">
<xs:complexType>
<xs:sequence>
<xs:element name="value" type="xsd:string" minOccurs="0" ns1:Ordinal="1" />
</xs:sequence>
<xs:attribute name="name" type="xsd:string" use="required" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
@@ -164,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>Снижает задержку звука. Рекомендуется для устройств среднего и высокого класса. Отключите это, если возникают подтормаживания или воспроизведение.</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>После включения управление громкостью в приложении будет недоступно. Пожалуйста, регулируйте громкость через операционную систему.</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>Если вы находитесь на странице песен музыкальной библиотеки с включенной сортировкой папок, нажатие на песню добавит в очередь воспроизведения только песни из той же папки.</value>
</data>

3
UntamedMusicPlayer/Strings/zh-Hans/Resources.resw
View File

@@ -222,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>可降低音频延迟。建议在中高性能设备上启用。若遇到声音卡顿或播放异常，请关闭。</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>开启后，应用内音量调节不可用，请在操作系统调节音量。</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>如果当前位于音乐库歌曲页面且使用文件夹排序方式，点击歌曲仅会将其所在文件夹内的歌曲加入播放队列。</value>
</data>

3
UntamedMusicPlayer/Strings/zh-Hant/Resources.resw
View File

@@ -222,9 +222,6 @@
<data name="Settings_LowLatencyMode.Description" xml:space="preserve">
<value>可降低音訊延遲。 建議在中高性能設備上啟用。 若遇到聲音卡頓或播放異常，請關閉。</value>
</data>
<data name="Settings_ExclusiveMode.Description" xml:space="preserve">
<value>開啟后，應用內音量調節不可用，請在操作系統調節音量。</value>
</data>
<data name="Settings_OnlyAddSpecificFolder.Description" xml:space="preserve">
<value>如果當前位於音樂庫歌曲頁面且使用資料夾排序方式，點擊歌曲僅會將其所在資料夾內的歌曲加入播放佇列。</value>
</data>