[ { "path": ".github/FUNDING.yml", "content": "github: jpochyla\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.md", "content": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: \"\"\nlabels: bug\nassignees: \"\"\n---\n\n**Describe the bug**\nA clear and concise description of what the bug is.\n\n**To Reproduce**\nSteps to reproduce the behavior.\n\n**Expected behavior**\nA clear and concise description of what you expected to happen.\n\n**Screenshots**\nIf applicable, add screenshots to help explain your problem.\n\n**Environment**\n\n- OS:\n- Version:\n\n**Additional context**\nAdd any other context about the problem here.\n" }, { "path": ".github/ISSUE_TEMPLATE/feature_request.md", "content": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: \"\"\nlabels: \"\"\nassignees: \"\"\n---\n\n**Is your feature request related to a problem? Please describe.**\nA clear and concise description of what the problem is. Ex. I'm always frustrated when [...]\n\n**Describe the solution you'd like**\nA clear and concise description of what you want to happen.\n\n**Describe alternatives you've considered**\nA clear and concise description of any alternative solutions or features you've considered.\n\n**Additional context**\nAdd any other context or screenshots about the feature request here.\n" }, { "path": ".github/workflows/build.yml", "content": "name: CI\n\non:\n push:\n branches: [main]\n pull_request:\n branches: [main]\n\npermissions:\n contents: read\n\nenv:\n CARGO_TERM_COLOR: always\n VERSION_DATE: ${{ format('{0}.{1}.{2}', github.run_number, github.run_id, github.run_attempt) }}\n VERSION_TIMESTAMP: ${{ github.event.repository.updated_at }}\n\njobs:\n code-style:\n runs-on: ubuntu-latest\n steps:\n - name: Checkout Repository\n uses: actions/checkout@v4\n\n - name: Setup Cache\n uses: Swatinem/rust-cache@v2\n\n - name: Install Linux Dependencies\n if: runner.os == 'Linux'\n run: sudo apt-get update && sudo apt-get install -y libgtk-3-dev libssl-dev libasound2-dev\n\n - name: Check Formatting\n run: cargo clippy -- -D warnings\n\n build:\n strategy:\n fail-fast: false\n matrix:\n include:\n - os: ubuntu-latest\n target: x86_64-unknown-linux-gnu\n - os: ubuntu-latest\n target: aarch64-unknown-linux-gnu\n - os: macos-latest\n - os: windows-latest\n\n runs-on: ${{ matrix.os }}\n env:\n MACOSX_DEPLOYMENT_TARGET: 11.0\n steps:\n - name: Checkout Repository\n uses: actions/checkout@v4\n\n - name: Set Version Info\n id: version\n shell: bash\n env:\n FULL_SHA: ${{ github.sha }}\n run: |\n echo \"BUILD_DATE=$(date +'%Y%m%d')\" >> $GITHUB_ENV\n echo \"VERSION=0.1.0,$(date +'%Y%m%d.%H%M%S')\" >> $GITHUB_ENV\n SHORT_SHA=${FULL_SHA::7}\n echo \"RELEASE_VERSION=$(date +'%Y.%m.%d')-$SHORT_SHA\" >> $GITHUB_ENV\n\n - name: Setup Rust Cache\n uses: Swatinem/rust-cache@v2\n with:\n key: ${{ hashFiles('Cross.toml') }}\n\n - name: Install Cross\n if: runner.os == 'Linux'\n run: cargo install cross\n\n - name: Build (Linux)\n if: runner.os == 'Linux'\n run: cross build --release --target ${{ matrix.target }}\n\n - name: Build Release (macOS)\n if: runner.os == 'macOS'\n run: |\n rustup target add x86_64-apple-darwin aarch64-apple-darwin\n cargo build --release --target x86_64-apple-darwin --target aarch64-apple-darwin\n\n - name: Build Release (Windows)\n if: runner.os == 'Windows'\n run: cargo build --release\n\n - name: Cache cargo-bundle and Homebrew\n id: cache-tools\n uses: actions/cache@v4\n with:\n path: |\n ~/.cargo/bin/cargo-bundle\n ~/Library/Caches/Homebrew\n key: ${{ runner.os }}-tools-${{ hashFiles('**/Cargo.lock', '.github/workflows/build.yml') }}\n restore-keys: |\n ${{ runner.os }}-tools-\n\n - name: Install cargo-bundle\n if: runner.os == 'macOS' && !steps.cache-tools.outputs.cache-hit\n run: cargo install cargo-bundle\n\n - name: Install create-dmg\n if: runner.os == 'macOS'\n run: brew install -q create-dmg\n\n - name: Create macOS universal binary\n if: runner.os == 'macOS'\n run: |\n mkdir -p target/release\n lipo -create \\\n -arch x86_64 target/x86_64-apple-darwin/release/psst-gui \\\n -arch arm64 target/aarch64-apple-darwin/release/psst-gui \\\n -output target/release/psst-gui\n\n - name: Bundle macOS Release\n if: runner.os == 'macOS'\n env:\n CARGO_BUNDLE_SKIP_BUILD: \"true\"\n run: |\n cargo bundle --release -p psst-gui\n\n - name: Create DMG\n if: runner.os == 'macOS'\n run: |\n create-dmg \\\n --volname \"Psst\" \\\n --volicon \"psst-gui/assets/logo.icns\" \\\n --window-pos 200 120 \\\n --window-size 600 400 \\\n --icon-size 100 \\\n --icon \"Psst.app\" 150 160 \\\n --hide-extension \"Psst.app\" \\\n --app-drop-link 450 160 \\\n \"Psst.dmg\" \\\n \"target/release/bundle/osx/Psst.app\"\n\n - name: Upload macOS DMG\n uses: actions/upload-artifact@v4\n if: runner.os == 'macOS'\n with:\n name: Psst.dmg\n path: Psst.dmg\n\n - name: Make Linux Binary Executable\n if: runner.os == 'Linux'\n run: chmod +x target/${{ matrix.target }}/release/psst-gui\n\n - name: Rename Linux Binary\n if: runner.os == 'Linux'\n run: mv target/${{ matrix.target }}/release/psst-gui target/${{ matrix.target }}/release/psst\n\n - name: Upload Linux Binary\n uses: actions/upload-artifact@v4\n if: runner.os == 'Linux'\n with:\n name: psst-${{ matrix.target }}\n path: target/${{ matrix.target }}/release/psst\n\n - name: Upload Windows Executable\n uses: actions/upload-artifact@v4\n if: runner.os == 'Windows'\n with:\n name: Psst.exe\n path: target/release/psst-gui.exe\n\n deb:\n runs-on: ubuntu-latest\n needs: build\n strategy:\n matrix:\n include:\n - arch: amd64\n target: x86_64-unknown-linux-gnu\n - arch: arm64\n target: aarch64-unknown-linux-gnu\n steps:\n - name: Checkout Repository\n uses: actions/checkout@v4\n with:\n fetch-depth: 0 # Get full history to count number of commits for package version\n\n - name: Download Linux Binaries\n uses: actions/download-artifact@v4\n with:\n name: psst-${{ matrix.target }}\n path: binaries\n\n - name: Move Binary\n run: |\n mkdir -p pkg/usr/bin/\n mv binaries/psst pkg/usr/bin/\n\n - name: Move Desktop Entry\n run: mkdir -p pkg/usr/share/applications/; mv .pkg/psst.desktop pkg/usr/share/applications/\n\n - name: Add Icons\n run: |\n LOGOS=$(cd ./psst-gui/assets/ && ls logo_*.png)\n for LOGO in $LOGOS\n do\n LOGO_SIZE=$(echo \"${LOGO}\" | grep -oE '[[:digit:]]{2,}')\n mkdir -p \"pkg/usr/share/icons/hicolor/${LOGO_SIZE}x${LOGO_SIZE}/\"\n cp \"./psst-gui/assets/${LOGO}\" \"pkg/usr/share/icons/hicolor/${LOGO_SIZE}x${LOGO_SIZE}/psst.png\"\n done\n mkdir -p \"pkg/usr/share/icons/hicolor/scalable/apps/\"\n cp \"./psst-gui/assets/logo.svg\" \"pkg/usr/share/icons/hicolor/scalable/apps/psst.svg\"\n\n - name: Set Permissions\n run: chmod 755 pkg/usr/bin/psst\n\n - name: Move License\n run: mkdir -p pkg/usr/share/doc/psst-gui/; mv .pkg/copyright pkg/usr/share/doc/psst-gui/\n\n - name: Write Package Config\n run: |\n mkdir -p pkg/DEBIAN\n export ARCHITECTURE=${{ matrix.arch }}\n SANITIZED_BRANCH=\"$(echo ${GITHUB_HEAD_REF:+.$GITHUB_HEAD_REF}|tr '_/' '-')\"\n export VERSION=0.1.0\"$SANITIZED_BRANCH\"+r\"$(git rev-list --count HEAD)\"-0\n envsubst < .pkg/DEBIAN/control > pkg/DEBIAN/control\n\n - name: Build Package\n run: |\n cat pkg/DEBIAN/control\n dpkg-deb -b pkg/ psst-${{ matrix.arch }}.deb\n\n - name: Upload Debian Package\n uses: actions/upload-artifact@v4\n with:\n name: psst-deb-${{ matrix.arch }}\n path: \"*.deb\"\n\n appimage:\n if: false # Disable temporarily: https://github.com/jpochyla/psst/actions/runs/3897410142/jobs/6655282029\n runs-on: ubuntu-latest\n needs: deb\n steps:\n - name: Checkout Repository\n uses: actions/checkout@v4\n\n - name: Download Debian Package\n uses: actions/download-artifact@v4\n with:\n name: psst-deb\n # Downloads to the root of the workspace by default if path is omitted or '.',\n # so removing explicit path to ${{github.workspace}}\n\n - name: Install Dependencies\n run: sudo apt-get update && sudo apt-get install -y libfuse2\n\n - name: Create Workspace\n run: mkdir -p appimage\n\n - name: Download the Latest pkg2appimage\n run: |\n latest_release_appimage_url=$(wget -q https://api.github.com/repos/AppImageCommunity/pkg2appimage/releases/latest -O - | jq -r '.assets[0].browser_download_url')\n wget --directory-prefix=appimage -c $latest_release_appimage_url\n\n - name: Create Path to pkg2appimage\n run: |\n pkg2appimage_executable=$(ls appimage)\n app_path=appimage/${pkg2appimage_executable}\n chmod +x ${app_path}\n echo \"app_path=${app_path}\" >> $GITHUB_ENV\n\n - name: Create Path to pkg2appimage's Recipe File\n run: |\n recipe_path=psst/.pkg/APPIMAGE/pkg2appimage-ingredients.yml\n echo \"recipe_path=${recipe_path}\" >> $GITHUB_ENV\n\n - name: Run pkg2appimage\n run: |\n ${{env.app_path}} ${{env.recipe_path}}\n\n - name: Upload AppImage\n uses: actions/upload-artifact@v4\n with:\n name: psst-appimage\n path: out/*.AppImage\n\n release:\n needs: [build, deb]\n runs-on: ubuntu-latest\n permissions:\n contents: write\n if: github.ref == 'refs/heads/main' && github.event_name == 'push'\n steps:\n - name: Set Version Info and Paths\n id: set_paths\n env:\n FULL_SHA: ${{ github.sha }}\n run: |\n echo \"BUILD_DATE=$(date +'%Y%m%d')\" >> $GITHUB_ENV\n echo \"VERSION=0.1.0,$(date +'%Y%m%d.%H%M%S')\" >> $GITHUB_ENV\n SHORT_SHA=${FULL_SHA::7}\n echo \"RELEASE_VERSION=$(date +'%Y.%m.%d')-$SHORT_SHA\" >> $GITHUB_ENV\n\n - name: Download All Artifacts\n uses: actions/download-artifact@v4\n with:\n path: artifacts\n\n - name: Prepare Release Body Data\n id: release_data\n run: |\n echo \"CURRENT_DATE_STR=$(date)\" >> $GITHUB_ENV\n\n - name: Prepare Release Assets\n id: prep_assets\n run: |\n set -e\n mkdir -p artifacts_final\n\n find artifacts -type f -name 'Psst.dmg' -exec mv {} artifacts_final/Psst.dmg \\;\n find artifacts -type f -name 'psst-gui.exe' -exec mv {} artifacts_final/Psst.exe \\;\n find artifacts -type f -name 'psst-amd64.deb' -exec mv {} artifacts_final/psst-amd64.deb \\;\n find artifacts -type f -name 'psst-arm64.deb' -exec mv {} artifacts_final/psst-arm64.deb \\;\n\n find artifacts -type f -name 'psst' -path '*/psst-x86_64-unknown-linux-gnu/*' -exec mv {} artifacts_final/psst-linux-x86_64 \\;\n find artifacts -type f -name 'psst' -path '*/psst-aarch64-unknown-linux-gnu/*' -exec mv {} artifacts_final/psst-linux-aarch64 \\;\n\n rm -rf artifacts\n mv artifacts_final artifacts\n ls -l artifacts/\n\n - name: Create Main Release\n uses: softprops/action-gh-release@v2\n with:\n name: Continuous release (${{ env.RELEASE_VERSION }})\n tag_name: rolling\n make_latest: true\n prerelease: false\n body: |\n This is a rolling release of Psst, published automatically on every commit to main.\n\n Version: ${{ env.RELEASE_VERSION }}\n Commit: ${{ github.sha }}\n Built: ${{ env.CURRENT_DATE_STR }}\n Workflow: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n\n See the release assets for SHA256 checksums.\n files: artifacts/*\n generate_release_notes: false\n" }, { "path": ".gitignore", "content": "config.json\ntarget\ncache\n.cargo\n.idea\n.DS_Store\n.env\n*.iml\nrust-toolchain\n*.ico" }, { "path": ".homebrew/generate_formula.sh", "content": "#!/bin/bash\n\nset -eo pipefail\n\nREPO_OWNER=\"jpochyla\"\nREPO_NAME=\"psst\"\n\ncat <= :big_sur\"\n\n app \"Psst.app\"\n\n zap trash: [\n \"~/Library/Application Support/Psst\",\n \"~/Library/Caches/com.jpochyla.psst\",\n \"~/Library/Caches/Psst\",\n \"~/Library/HTTPStorages/com.jpochyla.psst\",\n \"~/Library/Preferences/com.jpochyla.psst.plist\",\n \"~/Library/Saved Application State/com.jpochyla.psst.savedState\",\n ]\nend\nEOF\n" }, { "path": ".pkg/APPIMAGE/pkg2appimage-ingredients.yml", "content": "ingredients:\n dist: focal\n sources:\n - deb http://us.archive.ubuntu.com/ubuntu/ focal main universe\n debs:\n - ../*.deb\n script:\n - mkdir -p /home/runner/work/psst/psst/.AppDir/\n - cp /home/runner/work/psst/psst/psst-gui/assets/logo_256.png /home/runner/work/psst/psst/.AppDir/psst.png\n" }, { "path": ".pkg/DEBIAN/control", "content": "Package: psst-gui\nVersion: $VERSION\nArchitecture: $ARCHITECTURE\nMaintainer: Jan Pochyla \nSection: sound\nPriority: optional\nHomepage: https://github.com/jpochyla/psst\nPackage-Type: deb\nDepends: libssl3 | libssl1.1, libgtk-3-0, libcairo2\nDescription: Fast and native Spotify client\n" }, { "path": ".pkg/copyright", "content": "Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/\nUpstream-Name: Psst\nSource: https://github.com/jpochyla/psst\n\nFiles: *\nCopyright: (c) 2020 Jan Pochyla\nLicense: MIT\n\nLicense: MIT\n Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n" }, { "path": ".pkg/psst.desktop", "content": "[Desktop Entry]\nType=Application\nName=Psst\nComment=Fast and native Spotify client\nGenericName=Music Player\nIcon=psst\nTryExec=psst-gui\nExec=psst-gui %U\nTerminal=false\nMimeType=x-scheme-handler/psst;\nCategories=Audio;Music;Player;AudioVideo;\nStartupWMClass=psst-gui\n" }, { "path": ".rustfmt.toml", "content": "imports_granularity = \"Crate\"\nwrap_comments = true\n" }, { "path": "Cargo.toml", "content": "[workspace]\nresolver = \"2\"\nmembers = [\"psst-core\", \"psst-cli\", \"psst-gui\"]\n\n[profile.dev]\nopt-level = 1\ndebug = true\nlto = false\n\n[profile.release]\nopt-level = 3\nstrip = true\nlto = true\ncodegen-units = 1\n\n[profile.dev.package.symphonia]\nopt-level = 2\n\n[profile.dev.package.libsamplerate]\nopt-level = 2\n" }, { "path": "Cross.toml", "content": "[build]\npre-build = [\"\"\"\n dpkg --add-architecture $CROSS_DEB_ARCH && \\\n apt-get update && \\\n apt-get --assume-yes install \\\n libgtk-3-dev:$CROSS_DEB_ARCH \\\n libssl-dev:$CROSS_DEB_ARCH \\\n libasound2-dev:$CROSS_DEB_ARCH\n\"\"\"]\n\n[target.x86_64-unknown-linux-gnu]\nimage = \"ghcr.io/cross-rs/x86_64-unknown-linux-gnu:edge\"\n\n[target.aarch64-unknown-linux-gnu]\nimage = \"ghcr.io/cross-rs/aarch64-unknown-linux-gnu:edge\"\n" }, { "path": "LICENSE.md", "content": "MIT License\n\nCopyright (c) 2020 Jan Pochyla\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "README.md", "content": "# Psst\n\nA fast Spotify client with a native GUI written in Rust, without Electron.\nPsst is still very early in development, lacking in features, stability, and general user experience.\nIt's fully cross-platform, supporting Windows, Linux, and macOS.\nContributions are welcome!\n\n**Note:** A Spotify Premium account is required.\n\n[![Build](https://github.com/jpochyla/psst/actions/workflows/build.yml/badge.svg)](https://github.com/jpochyla/psst/actions)\n\n![Screenshot](./psst-gui/assets/screenshot.png)\n\n## Download\n\nGitHub Actions automatically builds and releases new versions when changes are pushed to the `main` branch.\nYou can download the latest release for Windows, Linux, and macOS from the [GitHub Releases page](https://github.com/jpochyla/psst/releases/latest).\n\n| Platform | Download Link |\n| ---------------------- | ---------------------------------------------------------------------------------------- |\n| Linux (x86_64) | [Download](https://github.com/jpochyla/psst/releases/latest/download/psst-linux-x86_64) |\n| Linux (aarch64) | [Download](https://github.com/jpochyla/psst/releases/latest/download/psst-linux-aarch64) |\n| Debian Package (amd64) | [Download](https://github.com/jpochyla/psst/releases/latest/download/psst-amd64.deb) |\n| Debian Package (arm64) | [Download](https://github.com/jpochyla/psst/releases/latest/download/psst-arm64.deb) |\n| macOS | [Download](https://github.com/jpochyla/psst/releases/latest/download/Psst.dmg) |\n| Windows | [Download](https://github.com/jpochyla/psst/releases/latest/download/Psst.exe) |\n\nUnofficial builds of Psst are also available through the [AUR](https://aur.archlinux.org/packages/psst-git) and [Homebrew](https://formulae.brew.sh/cask/psst).\n\n## Building\n\nOn all platforms, the **latest [Rust](https://rustup.rs/) stable** (at least 1.65.0) is required.\nFor platform-specific requirements, see the dropdowns below.\n\n
\nLinux\n\nOur user-interface library, Druid, has two possible backends on Linux: GTK and pure X11, with a Wayland backend in the works.\nThe default Linux backend is GTK.\nBefore building on Linux, make sure the required dependencies are installed.\n\n### Debian/Ubuntu\n\n```shell\nsudo apt-get install libssl-dev libgtk-3-dev libcairo2-dev libasound2-dev\n```\n\n### RHEL/Fedora\n\n```shell\nsudo dnf install openssl-devel gtk3-devel cairo-devel alsa-lib-devel\n```\n\n
\n\n
\nOpenBSD (WIP)\n\nOpenBSD support is still a WIP, and things will likely not function as intended.\nSimilar to Linux, Druid defaults to GTK while also providing a pure X11 backend.\nFurthermore, bindgen must be able to find LLVM through the expected environment variable.\nOnly OpenBSD/amd64 has been tested so far.\n\n```shell\ndoas pkg_add gtk+3 cairo llvm\nexport LIBCLANG_PATH=/usr/local/lib\n```\n\nIn case rustc(1) fails building bigger crates\n\n```shell\nmemory allocation of xxxx bytes failed\nerror: could not compile `gtk`\nCaused by:\n process didn't exit successfully: `rustc --crate-name gtk [...]` (signal: 6, SIGABRT: process abort signal)\nwarning: build failed, waiting for other jobs to finish...\n```\n\ntry increasing your user's maximum heap size:\n\n```shell\nulimit -d $(( 2 * `ulimit -d` ))\n```\n\n
\n\n---\n\n#### Build from Source\n\n```shell\ncargo build\n# Append `--release` for a release build.\n```\n\n#### Run from Source\n\n```shell\ncargo run --bin psst-gui\n# Append `--release` for a release build.\n```\n\n#### Build Installation Bundle (i.e., macOS .app)\n\n```shell\ncargo install cargo-bundle\ncargo bundle --release\n```\n\n## Roadmap\n\n- [x] Vorbis track playback\n- [x] Browsing saved albums and tracks\n- [x] Save / unsave albums and tracks\n- [x] Browsing followed playlists\n- [x] Search for artists, albums, and tracks\n- [x] Podcast support\n- [x] Media keys control\n- [x] Open Spotify links through the search bar\n- [x] Audio volume control\n- [x] Audio loudness normalization\n- [x] Genre playlists and \"For You\" content\n- [x] Dark theme\n- [x] Credits support\n- [ ] Resilience to network errors (automatically retry timed-out requests)\n- [ ] Managing playlists\n - Follow/unfollow\n - Add/remove tracks\n - Reorder tracks\n - Rename playlist\n - Playlist folders\n- [x] Playback queue\n- [ ] React to audio output device events\n - Pause after disconnecting headphones\n - Transfer playback after connecting headphones\n- [ ] Better caching\n - Cache as many WebAPI responses as possible\n - Visualize cache utilization\n - Total cache usage in the config dialog\n - Show time origin of cached data, allow to refresh\n- [ ] Trivia on the artist page, Wikipedia links\n- [ ] Downloading encrypted tracks\n- [ ] Reporting played tracks to Spotify servers\n- [ ] OS-specific application bundles\n- UI\n - [ ] Rethink the current design, consider a two-pane layout\n - Left pane for browsing\n - Right pane for current playback\n - [ ] Detect light/dark OS theme\n - [ ] Robust error states, ideally with a retry button\n - [ ] Correct playback highlight\n - Highlight now-playing track only in the correct album/playlist\n - Keep highlighted track in viewport\n - [ ] Paging or virtualized lists for albums and tracks\n - [ ] Grid for albums and artists\n - [ ] Robust active/inactive menu visualization\n - [ ] Save playback state\n\n## Development\n\nContributions are very welcome! \nHere's the basic project structure:\n\n- `/psst-core` - Core library, takes care of Spotify TCP session, audio file retrieval, decoding, audio output, playback queue, etc.\n- `/psst-gui` - GUI application built with [Druid](https://github.com/linebender/druid)\n- `/psst-cli` - Example CLI that plays a track. Credentials must be configured in the code.\n\n## Privacy Policy\n\nPsst connects only to the official Spotify servers and does not call home.\nCaches of various things are stored locally and can be deleted anytime.\nUser credentials are not stored at all; instead, a re-usable authentication token from Spotify is used.\n\n## Thanks\n\nThis project would not exist without the following:\n\n- Big thank you to [`librespot`](https://github.com/librespot-org/librespot), the Open Source Spotify client library for Rust. Most of `psst-core` is directly inspired by the ideas and code of `librespot`, although with a few differences:\n - Spotify Connect (remote control) is not supported yet.\n - Psst is completely synchronous, without `tokio` or other `async` runtime, although it will probably change in the future.\n - Psst is using HTTPS-based CDN audio file retrieval, similar to the official Web client or [`librespot-java`](https://github.com/librespot-org/librespot-java), instead of the channel-based approach in `librespot`.\n- [`druid`](https://github.com/linebender/druid) native GUI library for Rust.\n- [`ncspot`](https://github.com/hrkfdn/ncspot) cross-platform ncurses Spotify client written in Rust, using `librespot`.\n- ...and of course other libraries and projects.\n" }, { "path": "psst-cli/Cargo.toml", "content": "[package]\nname = \"psst-cli\"\nversion = \"0.1.0\"\nauthors = [\"Jan Pochyla \"]\nedition = \"2021\"\n\n[features]\ndefault = [\"cpal\"]\ncpal = [\"psst-core/cpal\"]\ncubeb = [\"psst-core/cubeb\"]\n\n[dependencies]\npsst-core = { path = \"../psst-core\" }\n\nenv_logger = \"0.11.5\"\nlog = \"0.4.22\"\n" }, { "path": "psst-cli/src/main.rs", "content": "use psst_core::{\n audio::{\n normalize::NormalizationLevel,\n output::{AudioOutput, AudioSink, DefaultAudioOutput},\n },\n cache::{Cache, CacheHandle},\n cdn::{Cdn, CdnHandle},\n connection::Credentials,\n error::Error,\n item_id::{ItemId, ItemIdType},\n player::{item::PlaybackItem, PlaybackConfig, Player, PlayerCommand, PlayerEvent},\n session::{SessionConfig, SessionService},\n};\nuse std::{env, io, io::BufRead, path::PathBuf, thread};\n\nfn main() {\n env_logger::init();\n\n let args: Vec = env::args().collect();\n let track_id = args\n .get(1)\n .expect(\"Expected in the first parameter\");\n let login_creds = Credentials::from_username_and_password(\n env::var(\"SPOTIFY_USERNAME\").unwrap(),\n env::var(\"SPOTIFY_PASSWORD\").unwrap(),\n );\n let session = SessionService::with_config(SessionConfig {\n login_creds,\n proxy_url: None,\n });\n\n start(track_id, session).unwrap();\n}\n\nfn start(track_id: &str, session: SessionService) -> Result<(), Error> {\n let cdn = Cdn::new(session.clone(), None)?;\n let cache = Cache::new(PathBuf::from(\"cache\"))?;\n let item_id = ItemId::from_base62(track_id, ItemIdType::Track).unwrap();\n play_item(\n session,\n cdn,\n cache,\n PlaybackItem {\n item_id,\n norm_level: NormalizationLevel::Track,\n },\n )\n}\n\nfn play_item(\n session: SessionService,\n cdn: CdnHandle,\n cache: CacheHandle,\n item: PlaybackItem,\n) -> Result<(), Error> {\n let output = DefaultAudioOutput::open()?;\n let config = PlaybackConfig::default();\n\n let mut player = Player::new(session, cdn, cache, config, &output);\n\n let _ui_thread = thread::spawn({\n let player_sender = player.sender();\n\n player_sender\n .send(PlayerEvent::Command(PlayerCommand::LoadQueue {\n items: vec![item, item, item],\n position: 0,\n }))\n .unwrap();\n\n move || {\n for line in io::stdin().lock().lines() {\n match line.as_ref().map(|s| s.as_str()) {\n Ok(\"p\") => {\n player_sender\n .send(PlayerEvent::Command(PlayerCommand::Pause))\n .unwrap();\n }\n Ok(\"r\") => {\n player_sender\n .send(PlayerEvent::Command(PlayerCommand::Resume))\n .unwrap();\n }\n Ok(\"s\") => {\n player_sender\n .send(PlayerEvent::Command(PlayerCommand::Stop))\n .unwrap();\n }\n Ok(\"<\") => {\n player_sender\n .send(PlayerEvent::Command(PlayerCommand::Previous))\n .unwrap();\n }\n Ok(\">\") => {\n player_sender\n .send(PlayerEvent::Command(PlayerCommand::Next))\n .unwrap();\n }\n _ => log::warn!(\"unknown command\"),\n }\n }\n }\n });\n\n for event in player.receiver() {\n player.handle(event);\n }\n output.sink().close();\n\n Ok(())\n}\n" }, { "path": "psst-core/Cargo.toml", "content": "[package]\nname = \"psst-core\"\nversion = \"0.1.0\"\nauthors = [\"Jan Pochyla \"]\nedition = \"2021\"\n\n\n[build-dependencies]\ngix-config = \"0.45.1\"\ntime = { version = \"0.3.36\", features = [\"local-offset\"] }\n\n[dependencies]\n\n# Common\nbyteorder = { version = \"1.5.0\" }\ncrossbeam-channel = { version = \"0.5.13\" }\ngit-version = { version = \"0.3.9\" }\nlog = { version = \"0.4.22\" }\nnum-bigint = { version = \"0.4.6\", features = [\"rand\"] }\nnum-traits = { version = \"0.2.19\" }\noauth2 = { version = \"4.4.2\" }\nparking_lot = { version = \"0.12.3\" }\nlibrespot-protocol = \"0.7.1\"\nprotobuf = \"3\"\nsysinfo = \"0.35.0\"\ndata-encoding = \"2.9\"\nrand = { version = \"0.9.1\" }\nrangemap = { version = \"1.5.1\" }\nserde = { version = \"1.0.210\", features = [\"derive\"] }\nserde_json = { version = \"1.0.132\" }\nsocks = { version = \"0.3.4\" }\ntempfile = { version = \"3.13.0\" }\nrustfm-scrobble = \"1.1.1\"\nureq = { version = \"3.0.11\", features = [\"json\"] }\nurl = { version = \"2.5.2\" }\n\n# Cryptography\naes = { version = \"0.8.4\" }\nctr = { version = \"0.9.2\" }\nhmac = { version = \"0.12.1\" }\nsha-1 = { version = \"0.10.1\" }\nshannon = { version = \"0.2.0\" }\n\n# Audio\naudio_thread_priority = \"0.33.0\"\ncpal = { version = \"0.15.3\", optional = true }\ncubeb = { git = \"https://github.com/mozilla/cubeb-rs\", optional = true }\nlibsamplerate = { version = \"0.1.0\" }\nrb = { version = \"0.4.1\" }\nsymphonia = { version = \"0.5.4\", default-features = false, features = [\n \"ogg\",\n \"vorbis\",\n \"mp3\",\n] }\n\n[target.'cfg(target_os = \"windows\")'.dependencies]\nwindows = { version = \"0.61.1\", features = [\"Win32_System_Com\"], default-features = false }\n" }, { "path": "psst-core/build.rs", "content": "use gix_config::File;\nuse std::{env, fs, io::Write};\nuse time::OffsetDateTime;\n\nfn main() {\n let outdir = env::var(\"OUT_DIR\").unwrap();\n let outfile = format!(\"{outdir}/build-time.txt\");\n\n let mut fh = fs::File::create(outfile).unwrap();\n let now = OffsetDateTime::now_local().unwrap_or_else(|_| OffsetDateTime::now_utc());\n write!(fh, r#\"\"{now}\"\"#).ok();\n\n let git_config = File::from_git_dir(\"../.git/\".into()).expect(\"Git Config not found!\");\n // Get Git's 'Origin' URL\n let mut remote_url = git_config\n .raw_value(\"remote.origin.url\")\n .expect(\"Couldn't extract origin url!\")\n .to_string();\n\n // Check whether origin is accessed via ssh\n if remote_url.contains('@') {\n // If yes, strip the `git@` prefix and split the domain and path\n let mut split = remote_url\n .strip_prefix(\"git@\")\n .unwrap_or(&remote_url)\n .split(':');\n let domain = split\n .next()\n .expect(\"Couldn't extract domain from ssh-style origin\");\n let path = split\n .next()\n .expect(\"Couldn't expect path from ssh-style origin\");\n\n // And construct the http-style url\n remote_url = format!(\"https://{domain}/{path}\");\n }\n let trimmed_url = remote_url.trim_end_matches(\".git\");\n remote_url.clone_from(&String::from(trimmed_url));\n\n let outfile = format!(\"{outdir}/remote-url.txt\");\n let mut file = fs::File::create(outfile).unwrap();\n write!(file, r#\"\"{remote_url}\"\"#).ok();\n}\n" }, { "path": "psst-core/src/actor.rs", "content": "use std::{\n fmt::Display,\n thread::{self, JoinHandle},\n time::Duration,\n};\n\nuse crossbeam_channel::{\n bounded, unbounded, Receiver, RecvTimeoutError, SendError, Sender, TrySendError,\n};\n\npub enum Act {\n Continue,\n WaitOr {\n timeout: Duration,\n timeout_msg: T::Message,\n },\n Shutdown,\n}\n\npub trait Actor: Sized {\n type Message: Send + 'static;\n type Error: Display;\n\n fn handle(&mut self, msg: Self::Message) -> Result, Self::Error>;\n\n fn process(mut self, recv: Receiver) {\n let mut act = Act::Continue;\n loop {\n let msg = match act {\n Act::Continue => match recv.recv() {\n Ok(msg) => msg,\n Err(_) => {\n break;\n }\n },\n Act::WaitOr {\n timeout,\n timeout_msg,\n } => match recv.recv_timeout(timeout) {\n Ok(msg) => msg,\n Err(RecvTimeoutError::Timeout) => timeout_msg,\n Err(RecvTimeoutError::Disconnected) => {\n break;\n }\n },\n Act::Shutdown => {\n break;\n }\n };\n act = match self.handle(msg) {\n Ok(act) => act,\n Err(err) => {\n log::error!(\"error: {err}\");\n break;\n }\n };\n }\n }\n\n fn spawn(cap: Capacity, name: &str, factory: F) -> ActorHandle\n where\n F: FnOnce(Sender) -> Self + Send + 'static,\n {\n let (send, recv) = cap.to_channel();\n ActorHandle {\n sender: send.clone(),\n thread: thread::Builder::new()\n .name(name.to_string())\n .spawn(move || {\n factory(send).process(recv);\n })\n .unwrap(),\n }\n }\n\n fn spawn_with_default_cap(name: &str, factory: F) -> ActorHandle\n where\n F: FnOnce(Sender) -> Self + Send + 'static,\n {\n Self::spawn(Capacity::Bounded(128), name, factory)\n }\n}\n\npub struct ActorHandle {\n thread: JoinHandle<()>,\n sender: Sender,\n}\n\nimpl ActorHandle {\n pub fn sender(&self) -> Sender {\n self.sender.clone()\n }\n\n pub fn join(self) {\n let _ = self.thread.join();\n }\n\n pub fn send(&self, msg: M) -> Result<(), SendError> {\n self.sender.send(msg)\n }\n\n pub fn try_send(&self, msg: M) -> Result<(), TrySendError> {\n self.sender.try_send(msg)\n }\n}\n\npub enum Capacity {\n Sync,\n Bounded(usize),\n Unbounded,\n}\n\nimpl Capacity {\n pub fn to_channel(&self) -> (Sender, Receiver) {\n match self {\n Capacity::Sync => bounded(0),\n Capacity::Bounded(cap) => bounded(*cap),\n Capacity::Unbounded => unbounded(),\n }\n }\n}\n" }, { "path": "psst-core/src/audio/decode.rs", "content": "use std::{io, time::Duration};\n\nuse symphonia::{\n core::{\n audio::{SampleBuffer, SignalSpec},\n codecs::{CodecParameters, Decoder, DecoderOptions},\n conv::ConvertibleSample,\n errors::Error as SymphoniaError,\n formats::{FormatOptions, FormatReader, SeekMode, SeekTo},\n io::{MediaSource, MediaSourceStream, MediaSourceStreamOptions},\n units::TimeStamp,\n },\n default::{\n codecs::{MpaDecoder, VorbisDecoder},\n formats::{MpaReader, OggReader},\n },\n};\n\nuse crate::{error::Error, util::FileWithConstSize};\n\npub enum AudioCodecFormat {\n Mp3,\n OggVorbis,\n}\n\nimpl AudioCodecFormat {\n fn format_reader(\n &self,\n mss: MediaSourceStream,\n ) -> Result, SymphoniaError> {\n match self {\n Self::Mp3 => Ok(Box::new(MpaReader::try_new(\n mss,\n &FormatOptions::default(),\n )?)),\n Self::OggVorbis => Ok(Box::new(OggReader::try_new(\n mss,\n &FormatOptions::default(),\n )?)),\n }\n }\n\n fn decoder(&self, codec_params: &CodecParameters) -> Result, SymphoniaError> {\n match self {\n Self::Mp3 => Ok(Box::new(MpaDecoder::try_new(\n codec_params,\n &DecoderOptions::default(),\n )?)),\n Self::OggVorbis => Ok(Box::new(VorbisDecoder::try_new(\n codec_params,\n &DecoderOptions::default(),\n )?)),\n }\n }\n}\n\npub struct AudioDecoder {\n track_id: u32, // Internal track index.\n decoder: Box,\n format: Box,\n}\n\nimpl AudioDecoder {\n pub fn new(input: T, codec: AudioCodecFormat) -> Result\n where\n T: io::Read + io::Seek + Send + Sync + 'static,\n {\n let mss = MediaSourceStream::new(\n Box::new(FileWithConstSize::new(input)),\n MediaSourceStreamOptions::default(),\n );\n let format = codec.format_reader(mss)?;\n let track = format.default_track().unwrap();\n let decoder = codec.decoder(&track.codec_params)?;\n\n Ok(Self {\n track_id: track.id,\n decoder,\n format,\n })\n }\n\n pub fn codec_params(&self) -> &CodecParameters {\n self.decoder.codec_params()\n }\n\n pub fn signal_spec(&self) -> SignalSpec {\n SignalSpec {\n rate: self.codec_params().sample_rate.unwrap(),\n channels: self.codec_params().channels.unwrap(),\n }\n }\n\n pub fn seek(&mut self, time: Duration) -> Result {\n let seeked_to = self.format.seek(\n SeekMode::Accurate,\n SeekTo::Time {\n time: time.as_secs_f64().into(),\n track_id: Some(self.track_id),\n },\n )?;\n Ok(seeked_to.actual_ts)\n }\n\n /// Read a next packet of audio from this decoder. Returns `None` in case\n /// of EOF or internal error.\n pub fn read_packet(&mut self, samples: &mut SampleBuffer) -> Option\n where\n S: ConvertibleSample,\n {\n loop {\n // Demux an encoded packet from the media format.\n let packet = match self.format.next_packet() {\n Ok(packet) => packet,\n Err(SymphoniaError::IoError(io)) if io.kind() == io::ErrorKind::UnexpectedEof => {\n return None; // End of this stream.\n }\n Err(err) => {\n log::error!(\"format error: {err}\");\n return None; // We cannot recover from format errors, quit.\n }\n };\n while !self.format.metadata().is_latest() {\n // Consume any new metadata that has been read since the last\n // packet.\n }\n // If the packet does not belong to the selected track, skip over it.\n if packet.track_id() != self.track_id {\n continue;\n }\n // Decode the packet into an audio buffer.\n match self.decoder.decode(&packet) {\n Ok(decoded) => {\n // Interleave the samples into the buffer.\n samples.copy_interleaved_ref(decoded);\n return Some(packet.ts());\n }\n Err(SymphoniaError::IoError(err)) => {\n // The packet failed to decode due to an IO error, skip the packet.\n log::error!(\"io decode error: {err}\");\n continue;\n }\n Err(SymphoniaError::DecodeError(err)) => {\n // The packet failed to decode due to invalid data, skip the packet.\n log::error!(\"decode error: {err}\");\n continue;\n }\n Err(err) => {\n log::error!(\"fatal decode error: {err}\");\n return None;\n }\n };\n }\n }\n}\n\nimpl MediaSource for FileWithConstSize\nwhere\n T: io::Read + io::Seek + Send + Sync,\n{\n fn is_seekable(&self) -> bool {\n true\n }\n\n fn byte_len(&self) -> Option {\n Some(self.len())\n }\n}\n\nimpl From for Error {\n fn from(err: SymphoniaError) -> Error {\n Error::AudioDecodingError(Box::new(err))\n }\n}\n" }, { "path": "psst-core/src/audio/decrypt.rs", "content": "use std::{convert::TryInto, io};\n\nuse aes::{\n cipher::{generic_array::GenericArray, KeyIvInit, StreamCipher, StreamCipherSeek},\n Aes128,\n};\nuse ctr::Ctr128BE;\n\nconst AUDIO_AESIV: [u8; 16] = [\n 0x72, 0xe0, 0x67, 0xfb, 0xdd, 0xcb, 0xcf, 0x77, 0xeb, 0xe8, 0xbc, 0x64, 0x3f, 0x63, 0x0d, 0x93,\n];\n\n#[derive(Debug, Hash, PartialEq, Eq, Copy, Clone)]\npub struct AudioKey(pub [u8; 16]);\n\nimpl AudioKey {\n pub fn from_raw(data: &[u8]) -> Option {\n Some(AudioKey(data.try_into().ok()?))\n }\n}\n\npub struct AudioDecrypt {\n cipher: Ctr128BE,\n reader: T,\n}\n\nimpl AudioDecrypt {\n pub fn new(key: AudioKey, reader: T) -> AudioDecrypt {\n let cipher = Ctr128BE::::new(\n GenericArray::from_slice(&key.0),\n GenericArray::from_slice(&AUDIO_AESIV),\n );\n AudioDecrypt { cipher, reader }\n }\n}\n\nimpl io::Read for AudioDecrypt {\n fn read(&mut self, output: &mut [u8]) -> io::Result {\n let len = self.reader.read(output)?;\n\n self.cipher.apply_keystream(&mut output[..len]);\n\n Ok(len)\n }\n}\n\nimpl io::Seek for AudioDecrypt {\n fn seek(&mut self, pos: io::SeekFrom) -> io::Result {\n let newpos = self.reader.seek(pos)?;\n\n self.cipher.seek(newpos);\n\n Ok(newpos)\n }\n}\n" }, { "path": "psst-core/src/audio/mod.rs", "content": "pub mod decode;\npub mod decrypt;\npub mod normalize;\npub mod output;\npub mod probe;\npub mod resample;\npub mod source;\n" }, { "path": "psst-core/src/audio/normalize.rs", "content": "use std::{\n io,\n io::{Read, Seek, SeekFrom},\n};\n\nuse byteorder::{ReadBytesExt, LE};\n\n#[derive(Debug, Clone, Copy, Eq, PartialEq)]\npub enum NormalizationLevel {\n None,\n Track,\n Album,\n}\n\n#[derive(Clone, Copy)]\npub struct NormalizationData {\n track_gain_db: f32,\n track_peak: f32,\n album_gain_db: f32,\n album_peak: f32,\n}\n\nimpl NormalizationData {\n pub fn parse(mut file: impl Read + Seek) -> io::Result {\n const NORMALIZATION_OFFSET: u64 = 144;\n\n file.seek(SeekFrom::Start(NORMALIZATION_OFFSET))?;\n\n let track_gain_db = file.read_f32::()?;\n let track_peak = file.read_f32::()?;\n let album_gain_db = file.read_f32::()?;\n let album_peak = file.read_f32::()?;\n\n Ok(Self {\n track_gain_db,\n track_peak,\n album_gain_db,\n album_peak,\n })\n }\n\n pub fn factor_for_level(&self, level: NormalizationLevel, pregain: f32) -> f32 {\n match level {\n NormalizationLevel::None => 1.0,\n NormalizationLevel::Track => Self::factor(pregain, self.track_gain_db, self.track_peak),\n NormalizationLevel::Album => Self::factor(pregain, self.album_gain_db, self.album_peak),\n }\n }\n\n fn factor(pregain: f32, gain: f32, peak: f32) -> f32 {\n let mut nf = f32::powf(10.0, (pregain + gain) / 20.0);\n if nf * peak > 1.0 {\n nf = 1.0 / peak;\n }\n nf\n }\n}\n" }, { "path": "psst-core/src/audio/output/cpal.rs", "content": "use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};\nuse crossbeam_channel::{bounded, Receiver, Sender};\nuse num_traits::Pow;\n\nuse crate::{\n actor::{Act, Actor, ActorHandle},\n audio::{\n output::{AudioOutput, AudioSink},\n source::{AudioSource, Empty},\n },\n error::Error,\n};\n\npub struct CpalOutput {\n _handle: ActorHandle,\n sink: CpalSink,\n}\n\nimpl CpalOutput {\n pub fn open() -> Result {\n // Open the default output device.\n let device = cpal::default_host()\n .default_output_device()\n .ok_or(cpal::DefaultStreamConfigError::DeviceNotAvailable)?;\n\n if let Ok(name) = device.name() {\n log::info!(\"using audio device: {name:?}\");\n }\n\n // Get the default device config, so we know what sample format and sample rate\n // the device supports.\n let supported = Self::preferred_output_config(&device)?;\n\n let (callback_send, callback_recv) = bounded(16);\n\n let handle = Stream::spawn_with_default_cap(\"audio_output\", {\n let config = supported.config();\n // TODO: Support additional sample formats.\n move |this| Stream::open(device, config, callback_recv, this).unwrap()\n });\n let sink = CpalSink {\n channel_count: supported.channels(),\n sample_rate: supported.sample_rate(),\n stream_send: handle.sender(),\n callback_send,\n };\n\n Ok(Self {\n _handle: handle,\n sink,\n })\n }\n\n fn preferred_output_config(\n device: &cpal::Device,\n ) -> Result {\n const PREFERRED_SAMPLE_FORMAT: cpal::SampleFormat = cpal::SampleFormat::F32;\n const PREFERRED_SAMPLE_RATE: cpal::SampleRate = cpal::SampleRate(44_100);\n const PREFERRED_CHANNELS: cpal::ChannelCount = 2;\n\n for s in device.supported_output_configs()? {\n let rates = s.min_sample_rate()..=s.max_sample_rate();\n if s.channels() == PREFERRED_CHANNELS\n && s.sample_format() == PREFERRED_SAMPLE_FORMAT\n && rates.contains(&PREFERRED_SAMPLE_RATE)\n {\n return Ok(s.with_sample_rate(PREFERRED_SAMPLE_RATE));\n }\n }\n\n Ok(device.default_output_config()?)\n }\n}\n\nimpl AudioOutput for CpalOutput {\n type Sink = CpalSink;\n\n fn sink(&self) -> Self::Sink {\n self.sink.clone()\n }\n}\n\n#[derive(Clone)]\npub struct CpalSink {\n channel_count: cpal::ChannelCount,\n sample_rate: cpal::SampleRate,\n callback_send: Sender,\n stream_send: Sender,\n}\n\nimpl CpalSink {\n fn send_to_callback(&self, msg: CallbackMsg) {\n if self.callback_send.send(msg).is_err() {\n log::error!(\"output stream actor is dead\");\n }\n }\n\n fn send_to_stream(&self, msg: StreamMsg) {\n if self.stream_send.send(msg).is_err() {\n log::error!(\"output stream actor is dead\");\n }\n }\n}\n\nimpl AudioSink for CpalSink {\n fn channel_count(&self) -> usize {\n self.channel_count as usize\n }\n\n fn sample_rate(&self) -> u32 {\n self.sample_rate.0\n }\n\n fn set_volume(&self, volume: f32) {\n self.send_to_callback(CallbackMsg::SetVolume(volume));\n }\n\n fn play(&self, source: impl AudioSource) {\n self.send_to_callback(CallbackMsg::PlaySource(Box::new(source)));\n }\n\n fn pause(&self) {\n self.send_to_stream(StreamMsg::Pause);\n self.send_to_callback(CallbackMsg::Pause);\n }\n\n fn resume(&self) {\n self.send_to_stream(StreamMsg::Resume);\n self.send_to_callback(CallbackMsg::Resume);\n }\n\n fn stop(&self) {\n self.play(Empty);\n self.pause();\n }\n\n fn close(&self) {\n self.send_to_stream(StreamMsg::Close);\n }\n}\n\nstruct Stream {\n stream: cpal::Stream,\n _device: cpal::Device,\n}\n\nimpl Stream {\n fn open(\n device: cpal::Device,\n config: cpal::StreamConfig,\n callback_recv: Receiver,\n stream_send: Sender,\n ) -> Result {\n let mut callback = StreamCallback {\n callback_recv,\n stream_send,\n source: Box::new(Empty),\n volume: 1.0, // We start with the full volume.\n state: CallbackState::Paused,\n };\n\n log::info!(\"opening output stream: {config:?}\");\n let stream = device.build_output_stream(\n &config,\n move |output, _| {\n callback.write_samples(output);\n },\n |err| {\n log::error!(\"audio output error: {err}\");\n },\n None,\n )?;\n\n Ok(Self {\n _device: device,\n stream,\n })\n }\n}\n\nimpl Actor for Stream {\n type Message = StreamMsg;\n type Error = Error;\n\n fn handle(&mut self, msg: Self::Message) -> Result, Self::Error> {\n match msg {\n StreamMsg::Pause => {\n log::debug!(\"pausing audio output stream\");\n if let Err(err) = self.stream.pause() {\n log::error!(\"failed to stop stream: {err}\");\n }\n Ok(Act::Continue)\n }\n StreamMsg::Resume => {\n log::debug!(\"resuming audio output stream\");\n if let Err(err) = self.stream.play() {\n log::error!(\"failed to start stream: {err}\");\n }\n Ok(Act::Continue)\n }\n StreamMsg::Close => {\n log::debug!(\"closing audio output stream\");\n let _ = self.stream.pause();\n Ok(Act::Shutdown)\n }\n }\n }\n}\n\nenum StreamMsg {\n Pause,\n Resume,\n Close,\n}\n\nenum CallbackMsg {\n PlaySource(Box),\n SetVolume(f32),\n Pause,\n Resume,\n}\n\nenum CallbackState {\n Playing,\n Paused,\n}\n\nstruct StreamCallback {\n #[allow(unused)]\n stream_send: Sender,\n callback_recv: Receiver,\n source: Box,\n state: CallbackState,\n volume: f32,\n}\n\nimpl StreamCallback {\n fn write_samples(&mut self, output: &mut [f32]) {\n // Process any pending data messages.\n while let Ok(msg) = self.callback_recv.try_recv() {\n match msg {\n CallbackMsg::PlaySource(src) => {\n self.source = src;\n }\n CallbackMsg::SetVolume(volume) => {\n self.volume = volume;\n }\n CallbackMsg::Pause => {\n self.state = CallbackState::Paused;\n }\n CallbackMsg::Resume => {\n self.state = CallbackState::Playing;\n }\n }\n }\n\n let written = if matches!(self.state, CallbackState::Playing) {\n // Write out as many samples as possible from the audio source to the\n // output buffer.\n let written = self.source.write(output);\n\n // Apply scaled global volume level.\n let scaled_volume = self.volume.pow(4);\n output[..written]\n .iter_mut()\n .for_each(|s| *s *= scaled_volume);\n\n written\n } else {\n 0\n };\n\n // Mute any remaining samples.\n output[written..].iter_mut().for_each(|s| *s = 0.0);\n }\n}\n\nimpl From for Error {\n fn from(err: cpal::DefaultStreamConfigError) -> Error {\n Error::AudioOutputError(Box::new(err))\n }\n}\n\nimpl From for Error {\n fn from(err: cpal::SupportedStreamConfigsError) -> Error {\n Error::AudioOutputError(Box::new(err))\n }\n}\n\nimpl From for Error {\n fn from(err: cpal::BuildStreamError) -> Error {\n Error::AudioOutputError(Box::new(err))\n }\n}\n\nimpl From for Error {\n fn from(err: cpal::PlayStreamError) -> Error {\n Error::AudioOutputError(Box::new(err))\n }\n}\n\nimpl From for Error {\n fn from(err: cpal::PauseStreamError) -> Error {\n Error::AudioOutputError(Box::new(err))\n }\n}\n" }, { "path": "psst-core/src/audio/output/cubeb.rs", "content": "use std::{env, ffi::CString, ops::Deref};\n\nuse crossbeam_channel::{bounded, Receiver, Sender};\n\nuse crate::{\n actor::{Act, Actor, ActorHandle},\n audio::{\n output::{AudioOutput, AudioSink},\n source::{AudioSource, Empty},\n },\n error::Error,\n};\n\npub struct CubebOutput {\n #[allow(unused)]\n handle: ActorHandle,\n sink: CubebSink,\n}\n\nimpl CubebOutput {\n pub fn open() -> Result {\n let (callback_send, callback_recv) = bounded(16);\n\n let handle = Stream::spawn_with_default_cap(\"audio_output\", {\n move |_| Stream::open(callback_recv).unwrap()\n });\n let sink = CubebSink {\n callback_send,\n stream_send: handle.sender(),\n };\n\n Ok(Self { handle, sink })\n }\n}\n\nimpl AudioOutput for CubebOutput {\n type Sink = CubebSink;\n\n fn sink(&self) -> Self::Sink {\n self.sink.clone()\n }\n}\n\ntype Frame = cubeb::StereoFrame;\n\nconst STREAM_CHANNELS: usize = 2;\nconst SAMPLE_RATE: u32 = 44_100;\nconst STREAM_LATENCY: u32 = 0x1000;\n\nstruct Stream {\n #[allow(unused)]\n ctx: cubeb::Context,\n stream: cubeb::Stream,\n}\n\nimpl Stream {\n fn open(callback_recv: Receiver) -> Result {\n // Call CoInitialize() before any other calls to the API.\n #[cfg(target_os = \"windows\")]\n unsafe {\n let _ = windows::Win32::System::Com::CoInitialize(0 as *mut _);\n };\n\n let backend_name = env::var(\"CUBEB_BACKEND\")\n .ok()\n .and_then(|s| CString::new(s).ok());\n let ctx_name = CString::new(\"Psst\").ok();\n let ctx = cubeb::Context::init(ctx_name.as_deref(), backend_name.as_deref())?;\n\n let mut callback = StreamCallback {\n callback_recv,\n source: Box::new(Empty),\n state: CallbackState::Paused,\n buffer: vec![0.0; 1024 * 1024],\n };\n\n let params = cubeb::StreamParamsBuilder::new()\n .format(cubeb::SampleFormat::Float32NE)\n .rate(SAMPLE_RATE)\n .channels(STREAM_CHANNELS as u32)\n .layout(cubeb::ChannelLayout::STEREO)\n .take();\n\n let mut builder = cubeb::StreamBuilder::new();\n builder\n .name(\"Psst\")\n .default_output(¶ms)\n .latency(STREAM_LATENCY)\n .data_callback(move |_, output| {\n callback.write_samples(output);\n output.len() as isize\n })\n .state_callback(|state| {\n log::debug!(\"stream state: {:?}\", state);\n });\n let stream = builder.init(&ctx)?;\n\n Ok(Self { ctx, stream })\n }\n}\n\nenum StreamMsg {\n Pause,\n Resume,\n Close,\n SetVolume(f32),\n}\n\nimpl Actor for Stream {\n type Message = StreamMsg;\n type Error = Error;\n\n fn handle(&mut self, msg: Self::Message) -> Result, Self::Error> {\n match msg {\n StreamMsg::Pause => {\n log::debug!(\"pausing audio output stream\");\n if let Err(err) = self.stream.stop() {\n log::error!(\"failed to stop stream: {}\", err);\n }\n Ok(Act::Continue)\n }\n StreamMsg::Resume => {\n log::debug!(\"resuming audio output stream\");\n if let Err(err) = self.stream.start() {\n log::error!(\"failed to start stream: {}\", err);\n }\n Ok(Act::Continue)\n }\n StreamMsg::Close => {\n log::debug!(\"closing audio output stream\");\n let _ = self.stream.stop();\n Ok(Act::Shutdown)\n }\n StreamMsg::SetVolume(volume) => {\n log::debug!(\"setting volume\");\n if let Err(err) = self.stream.set_volume(volume) {\n log::error!(\"failed to set volume: {}\", err);\n }\n Ok(Act::Continue)\n }\n }\n }\n}\n\n#[derive(Clone)]\npub struct CubebSink {\n callback_send: Sender,\n stream_send: Sender,\n}\n\nimpl AudioSink for CubebSink {\n fn channel_count(&self) -> usize {\n STREAM_CHANNELS\n }\n\n fn sample_rate(&self) -> u32 {\n SAMPLE_RATE\n }\n\n fn set_volume(&self, volume: f32) {\n self.stream_send.send(StreamMsg::SetVolume(volume)).unwrap();\n }\n\n fn play(&self, source: impl AudioSource) {\n self.callback_send\n .send(CallbackMsg::PlaySource(Box::new(source)))\n .unwrap()\n }\n\n fn pause(&self) {\n self.callback_send.send(CallbackMsg::Pause).unwrap();\n self.stream_send.send(StreamMsg::Pause).unwrap();\n }\n\n fn resume(&self) {\n self.callback_send.send(CallbackMsg::Resume).unwrap();\n self.stream_send.send(StreamMsg::Resume).unwrap();\n }\n\n fn stop(&self) {\n self.pause();\n }\n\n fn close(&self) {\n self.stop();\n }\n}\n\nenum CallbackMsg {\n PlaySource(Box),\n Pause,\n Resume,\n}\n\nenum CallbackState {\n Playing,\n Paused,\n}\n\nstruct StreamCallback {\n callback_recv: Receiver,\n source: Box,\n state: CallbackState,\n buffer: Vec,\n}\n\nimpl StreamCallback {\n fn write_samples(&mut self, output: &mut [Frame]) {\n // Process any pending data messages.\n while let Ok(msg) = self.callback_recv.try_recv() {\n match msg {\n CallbackMsg::PlaySource(src) => {\n self.source = src;\n }\n CallbackMsg::Pause => {\n self.state = CallbackState::Paused;\n }\n CallbackMsg::Resume => {\n self.state = CallbackState::Playing;\n }\n }\n }\n\n let written = if matches!(self.state, CallbackState::Playing) {\n // Write out as many samples as possible from the audio source to the\n // output buffer.\n let n_output_frames = output.len();\n let n_output_samples = n_output_frames * STREAM_CHANNELS;\n let n_samples = self.source.write(&mut self.buffer[..n_output_samples]);\n let mut n_frames = 0;\n for (i, o) in self.buffer[..n_samples]\n .chunks(STREAM_CHANNELS)\n .zip(output.iter_mut())\n {\n o.l = i[0];\n o.r = i[1];\n n_frames += 1;\n }\n n_frames\n } else {\n 0\n };\n\n // Mute any remaining samples.\n output[written..].iter_mut().for_each(|s| {\n s.l = 0.0;\n s.r = 0.0;\n });\n }\n}\n\nunsafe impl Sync for StreamCallback {}\n\nimpl From for Error {\n fn from(err: cubeb::Error) -> Self {\n Error::AudioOutputError(Box::new(err))\n }\n}\n" }, { "path": "psst-core/src/audio/output/mod.rs", "content": "use crate::audio::source::AudioSource;\n\n#[cfg(feature = \"cpal\")]\npub mod cpal;\n#[cfg(feature = \"cubeb\")]\npub mod cubeb;\n\n#[cfg(feature = \"cubeb\")]\npub type DefaultAudioOutput = cubeb::CubebOutput;\n#[cfg(feature = \"cpal\")]\npub type DefaultAudioOutput = cpal::CpalOutput;\n\npub type DefaultAudioSink = ::Sink;\n\npub trait AudioOutput {\n type Sink: AudioSink;\n\n fn sink(&self) -> Self::Sink;\n}\n\npub trait AudioSink {\n fn channel_count(&self) -> usize;\n fn sample_rate(&self) -> u32;\n fn set_volume(&self, volume: f32);\n fn play(&self, source: impl AudioSource);\n fn pause(&self);\n fn resume(&self);\n fn stop(&self);\n fn close(&self);\n}\n" }, { "path": "psst-core/src/audio/probe.rs", "content": "use std::fs::File;\nuse std::path::PathBuf;\nuse std::time::Duration;\n\nuse symphonia::core::codecs::CodecType;\nuse symphonia::core::formats::FormatOptions;\nuse symphonia::core::io::{MediaSourceStream, MediaSourceStreamOptions};\nuse symphonia::core::meta::MetadataOptions;\nuse symphonia::core::probe::{Hint, Probe};\nuse symphonia::default::formats::{MpaReader, OggReader};\n\nuse crate::error::Error;\n\npub struct TrackProbe {\n pub codec: CodecType,\n pub duration: Option,\n}\n\nmacro_rules! probe_err {\n ($message:tt) => {\n // This is necessary to work around the fact that the two impls for From<&str> are:\n // Box\n // Box\n // And the trait bound on our error is:\n // Box\n // Normally we could just do `$message.into()`, but no impl exists for exactly\n // `Error + Send`, so we have to be explicit about which we want to use.\n Error::AudioProbeError(Box::::from($message))\n };\n}\n\nimpl TrackProbe {\n pub fn new(path: &PathBuf) -> Result {\n // Register all supported file formats for detection.\n let mut probe = Probe::default();\n probe.register_all::();\n probe.register_all::();\n\n let mut hint = Hint::new();\n if let Some(ext) = path.extension().and_then(|e| e.to_str()) {\n hint.with_extension(ext);\n }\n\n let file = File::open(path)?;\n let mss_opts = MediaSourceStreamOptions::default();\n let mss = MediaSourceStream::new(Box::new(file), mss_opts);\n\n let fmt_opts = FormatOptions::default();\n let meta_opts = MetadataOptions::default();\n let probe_result = probe\n .format(&hint, mss, &fmt_opts, &meta_opts)\n .map_err(|_| probe_err!(\"failed to probe file\"))?;\n let track = probe_result\n .format\n .default_track()\n .ok_or_else(|| probe_err!(\"file contained no tracks\"))?;\n let params = &track.codec_params;\n\n let duration =\n if let (Some(time_base), Some(n_frames)) = (params.time_base, params.n_frames) {\n let time = time_base.calc_time(n_frames);\n let secs = time.seconds;\n let ms = (time.frac * 1_000.0).round() as u64;\n Some(Duration::from_millis(secs * 1_000 + ms))\n } else {\n None\n };\n\n Ok(Self {\n codec: params.codec,\n duration,\n })\n }\n}\n" }, { "path": "psst-core/src/audio/resample.rs", "content": "use crate::error::Error;\n\n#[derive(Copy, Clone)]\npub enum ResamplingQuality {\n SincBestQuality = libsamplerate::SRC_SINC_BEST_QUALITY as isize,\n SincMediumQuality = libsamplerate::SRC_SINC_MEDIUM_QUALITY as isize,\n SincFastest = libsamplerate::SRC_SINC_FASTEST as isize,\n ZeroOrderHold = libsamplerate::SRC_ZERO_ORDER_HOLD as isize,\n Linear = libsamplerate::SRC_LINEAR as isize,\n}\n\n#[derive(Copy, Clone)]\npub struct ResamplingSpec {\n pub input_rate: u32,\n pub output_rate: u32,\n pub channels: usize,\n}\n\nimpl ResamplingSpec {\n pub fn output_size(&self, input_size: usize) -> usize {\n (self.output_rate as f64 / self.input_rate as f64 * input_size as f64) as usize\n }\n\n pub fn input_size(&self, output_size: usize) -> usize {\n (self.input_rate as f64 / self.output_rate as f64 * output_size as f64) as usize\n }\n\n pub fn ratio(&self) -> f64 {\n self.output_rate as f64 / self.input_rate as f64\n }\n}\n\npub struct AudioResampler {\n pub spec: ResamplingSpec,\n state: *mut libsamplerate::SRC_STATE,\n}\n\nimpl AudioResampler {\n pub fn new(quality: ResamplingQuality, spec: ResamplingSpec) -> Result {\n let mut error_int = 0i32;\n let state = unsafe {\n libsamplerate::src_new(\n quality as i32,\n spec.channels as i32,\n &mut error_int as *mut i32,\n )\n };\n if error_int != 0 {\n Err(Error::ResamplingError(error_int))\n } else {\n Ok(Self { state, spec })\n }\n }\n\n pub fn process(&mut self, input: &[f32], output: &mut [f32]) -> Result<(usize, usize), Error> {\n if self.spec.input_rate == self.spec.output_rate {\n // Bypass conversion completely in case the sample rates are equal.\n let output = &mut output[..input.len()];\n output.copy_from_slice(input);\n return Ok((input.len(), output.len()));\n }\n let mut src = libsamplerate::SRC_DATA {\n data_in: input.as_ptr(),\n data_out: output.as_mut_ptr(),\n input_frames: (input.len() / self.spec.channels) as _,\n output_frames: (output.len() / self.spec.channels) as _,\n src_ratio: self.spec.ratio(),\n end_of_input: 0, // TODO: Use this.\n input_frames_used: 0,\n output_frames_gen: 0,\n };\n let error_int = unsafe { libsamplerate::src_process(self.state, &mut src as *mut _) };\n if error_int != 0 {\n Err(Error::ResamplingError(error_int))\n } else {\n let processed_len = src.input_frames_used as usize * self.spec.channels;\n let output_len = src.output_frames_gen as usize * self.spec.channels;\n Ok((processed_len, output_len))\n }\n }\n}\n\nimpl Drop for AudioResampler {\n fn drop(&mut self) {\n unsafe { libsamplerate::src_delete(self.state) };\n }\n}\n\nunsafe impl Send for AudioResampler {}\n" }, { "path": "psst-core/src/audio/source.rs", "content": "use crate::audio::resample::ResamplingSpec;\n\nuse super::resample::{AudioResampler, ResamplingQuality};\n\n/// Types that can produce audio samples in `f32` format. `Send`able across\n/// threads.\npub trait AudioSource: Send + 'static {\n /// Write at most of `output.len()` samples into the `output`. Returns the\n /// number of written samples. Should take care to always output a full\n /// frame, and should _never_ block.\n fn write(&mut self, output: &mut [f32]) -> usize;\n fn channel_count(&self) -> usize;\n fn sample_rate(&self) -> u32;\n}\n\n/// Empty audio source. Does not produce any samples.\npub struct Empty;\n\nimpl AudioSource for Empty {\n fn write(&mut self, _output: &mut [f32]) -> usize {\n 0\n }\n\n fn channel_count(&self) -> usize {\n 0\n }\n\n fn sample_rate(&self) -> u32 {\n 0\n }\n}\n\npub struct StereoMappedSource {\n source: S,\n input_channels: usize,\n output_channels: usize,\n buffer: Vec,\n}\n\nimpl StereoMappedSource\nwhere\n S: AudioSource,\n{\n pub fn new(source: S, output_channels: usize) -> Self {\n const BUFFER_SIZE: usize = 16 * 1024;\n\n let input_channels = source.channel_count();\n Self {\n source,\n input_channels,\n output_channels,\n buffer: vec![0.0; BUFFER_SIZE],\n }\n }\n}\n\nimpl AudioSource for StereoMappedSource\nwhere\n S: AudioSource,\n{\n fn write(&mut self, output: &mut [f32]) -> usize {\n let input_max = (output.len() / self.output_channels) * self.input_channels;\n let buffer_max = input_max.min(self.buffer.len());\n let written = self.source.write(&mut self.buffer[..buffer_max]);\n let input = &self.buffer[..written];\n let input_frames = input.chunks_exact(self.input_channels);\n let output_frames = output.chunks_exact_mut(self.output_channels);\n for (i, o) in input_frames.zip(output_frames) {\n o[0] = i[0];\n o[1] = i[1];\n // Assume the rest is is implicitly silence.\n }\n output.len()\n }\n\n fn channel_count(&self) -> usize {\n self.output_channels\n }\n\n fn sample_rate(&self) -> u32 {\n self.source.sample_rate()\n }\n}\n\npub struct ResampledSource {\n source: S,\n resampler: AudioResampler,\n inp: Buf,\n out: Buf,\n}\n\nimpl ResampledSource {\n pub fn new(source: S, output_sample_rate: u32, quality: ResamplingQuality) -> Self\n where\n S: AudioSource,\n {\n const BUFFER_SIZE: usize = 1024;\n\n let spec = ResamplingSpec {\n channels: source.channel_count(),\n input_rate: source.sample_rate(),\n output_rate: output_sample_rate,\n };\n let inp_buf = vec![0.0; BUFFER_SIZE];\n let out_buf = vec![0.0; spec.output_size(BUFFER_SIZE)];\n Self {\n resampler: AudioResampler::new(quality, spec).unwrap(),\n source,\n inp: Buf {\n buf: inp_buf,\n start: 0,\n end: 0,\n },\n out: Buf {\n buf: out_buf,\n start: 0,\n end: 0,\n },\n }\n }\n}\n\nimpl AudioSource for ResampledSource\nwhere\n S: AudioSource,\n{\n fn write(&mut self, output: &mut [f32]) -> usize {\n let mut total = 0;\n\n while total < output.len() {\n if self.out.is_empty() {\n if self.inp.is_empty() {\n let n = self.source.write(&mut self.inp.buf);\n self.inp.buf[n..].iter_mut().for_each(|s| *s = 0.0);\n self.inp.start = 0;\n self.inp.end = self.inp.buf.len();\n }\n let (inp_consumed, out_written) = self\n .resampler\n .process(&self.inp.buf[self.inp.start..], &mut self.out.buf)\n .unwrap();\n self.inp.start += inp_consumed;\n self.out.start = 0;\n self.out.end = out_written;\n }\n let source = self.out.get();\n let target = &mut output[total..];\n let to_write = self.out.len().min(target.len());\n target[..to_write].copy_from_slice(&source[..to_write]);\n total += to_write;\n self.out.start += to_write;\n }\n\n total\n }\n\n fn channel_count(&self) -> usize {\n self.resampler.spec.channels\n }\n\n fn sample_rate(&self) -> u32 {\n self.resampler.spec.output_rate\n }\n}\n\nstruct Buf {\n buf: Vec,\n start: usize,\n end: usize,\n}\n\nimpl Buf {\n fn get(&self) -> &[f32] {\n &self.buf[self.start..self.end]\n }\n\n fn len(&self) -> usize {\n self.end - self.start\n }\n\n fn is_empty(&self) -> bool {\n self.start >= self.end\n }\n}\n" }, { "path": "psst-core/src/cache.rs", "content": "use std::{\n fs, io,\n path::{Path, PathBuf},\n sync::Arc,\n};\n\nuse crate::{\n audio::decrypt::AudioKey,\n error::Error,\n item_id::{FileId, ItemId},\n};\n\nuse librespot_protocol::metadata::{Episode, Track};\nuse protobuf::Message;\n\npub type CacheHandle = Arc;\n\n#[derive(Debug)]\npub struct Cache {\n base: PathBuf,\n}\n\nfn create_cache_dirs(base: &Path) -> io::Result<()> {\n mkdir_if_not_exists(base)?;\n mkdir_if_not_exists(&base.join(\"track\"))?;\n mkdir_if_not_exists(&base.join(\"episode\"))?;\n mkdir_if_not_exists(&base.join(\"audio\"))?;\n mkdir_if_not_exists(&base.join(\"key\"))?;\n Ok(())\n}\n\nimpl Cache {\n pub fn new(base: PathBuf) -> Result {\n log::info!(\"using cache: {base:?}\");\n\n // Create the cache structure.\n create_cache_dirs(&base)?;\n\n let cache = Self { base };\n Ok(Arc::new(cache))\n }\n\n pub fn clear(&self) -> io::Result<()> {\n log::info!(\"clearing cache: {:?}\", self.base);\n\n for entry in fs::read_dir(&self.base)? {\n let entry = entry?;\n let path = entry.path();\n if path.is_dir() {\n fs::remove_dir_all(path)?;\n } else {\n fs::remove_file(path)?;\n }\n }\n\n // Re-create the essential directory structure.\n create_cache_dirs(&self.base)\n }\n}\n\n// Cache of `Track` protobuf structures.\nimpl Cache {\n pub fn get_track(&self, item_id: ItemId) -> Option {\n let buf = fs::read(self.track_path(item_id)).ok()?;\n Track::parse_from_bytes(&buf).ok()\n }\n\n pub fn save_track(&self, item_id: ItemId, track: &Track) -> Result<(), Error> {\n log::debug!(\"saving track to cache: {item_id:?}\");\n fs::write(self.track_path(item_id), track.write_to_bytes()?)?;\n Ok(())\n }\n\n fn track_path(&self, item_id: ItemId) -> PathBuf {\n self.base.join(\"track\").join(item_id.to_base62())\n }\n}\n\n// Cache of `Episode` protobuf structures.\nimpl Cache {\n pub fn get_episode(&self, item_id: ItemId) -> Option {\n let buf = fs::read(self.episode_path(item_id)).ok()?;\n Episode::parse_from_bytes(&buf).ok()\n }\n\n pub fn save_episode(&self, item_id: ItemId, episode: &Episode) -> Result<(), Error> {\n log::debug!(\"saving episode to cache: {item_id:?}\");\n fs::write(self.episode_path(item_id), episode.write_to_bytes()?)?;\n Ok(())\n }\n\n fn episode_path(&self, item_id: ItemId) -> PathBuf {\n self.base.join(\"episode\").join(item_id.to_base62())\n }\n}\n\n// Cache of `AudioKey`s.\nimpl Cache {\n pub fn get_audio_key(&self, item_id: ItemId, file_id: FileId) -> Option {\n let buf = fs::read(self.audio_key_path(item_id, file_id)).ok()?;\n AudioKey::from_raw(&buf)\n }\n\n pub fn save_audio_key(\n &self,\n item_id: ItemId,\n file_id: FileId,\n key: &AudioKey,\n ) -> Result<(), Error> {\n log::debug!(\"saving audio key to cache: {item_id:?}:{file_id:?}\");\n fs::write(self.audio_key_path(item_id, file_id), key.0)?;\n Ok(())\n }\n\n fn audio_key_path(&self, item_id: ItemId, file_id: FileId) -> PathBuf {\n let mut key_id = String::new();\n key_id += &item_id.to_base62()[..16];\n key_id += &file_id.to_base16()[..16];\n self.base.join(\"key\").join(key_id)\n }\n}\n\n// Cache of encrypted audio file content.\nimpl Cache {\n pub fn audio_file_path(&self, file_id: FileId) -> PathBuf {\n self.base.join(\"audio\").join(file_id.to_base16())\n }\n\n pub fn save_audio_file(&self, file_id: FileId, from_path: PathBuf) -> Result<(), Error> {\n log::debug!(\"saving audio file to cache: {file_id:?}\");\n fs::copy(from_path, self.audio_file_path(file_id))?;\n Ok(())\n }\n}\n\n// Cache of user country code.\nimpl Cache {\n pub fn get_country_code(&self) -> Option {\n fs::read_to_string(self.country_code_path()).ok()\n }\n\n pub fn save_country_code(&self, country_code: &str) -> Result<(), Error> {\n fs::write(self.country_code_path(), country_code)?;\n Ok(())\n }\n\n fn country_code_path(&self) -> PathBuf {\n self.base.join(\"country_code\")\n }\n}\n\npub fn mkdir_if_not_exists(path: &Path) -> io::Result<()> {\n fs::create_dir(path).or_else(|err| {\n if err.kind() == io::ErrorKind::AlreadyExists {\n Ok(())\n } else {\n Err(err)\n }\n })\n}\n" }, { "path": "psst-core/src/cdn.rs", "content": "use std::{\n io::Read,\n sync::Arc,\n time::{Duration, Instant},\n};\n\nuse serde::Deserialize;\n\nuse crate::{\n error::Error,\n item_id::FileId,\n session::{SessionService},\n util::default_ureq_agent_builder,\n};\nuse crate::session::login5::Login5;\n\npub type CdnHandle = Arc;\n\npub struct Cdn {\n session: SessionService,\n agent: ureq::Agent,\n login5: Login5,\n}\n\nimpl Cdn {\n pub fn new(session: SessionService, proxy_url: Option<&str>) -> Result {\n let agent = default_ureq_agent_builder(proxy_url).build();\n Ok(Arc::new(Self {\n session,\n agent: agent.into(),\n login5: Login5::new(None, proxy_url),\n }))\n }\n\n pub fn resolve_audio_file_url(&self, id: FileId) -> Result {\n let locations_uri = format!(\n \"https://api.spotify.com/v1/storage-resolve/files/audio/interactive/{}\",\n id.to_base16()\n );\n let access_token = self.login5.get_access_token(&self.session)?;\n let response = self\n .agent\n .get(&locations_uri)\n .query(\"version\", \"10000000\")\n .query(\"product\", \"9\")\n .query(\"platform\", \"39\")\n .query(\"alt\", \"json\")\n .header(\"Authorization\", &format!(\"Bearer {}\", access_token.access_token))\n .call()?;\n\n #[derive(Deserialize)]\n struct AudioFileLocations {\n cdnurl: Vec,\n }\n\n // Deserialize the response and pick a file URL from the returned CDN list.\n let locations: AudioFileLocations = response.into_body().read_json()?;\n let file_uri = locations\n .cdnurl\n .into_iter()\n // TODO:\n // Now, we always pick the first URL in the list, figure out a better strategy.\n // Choosing by random seems wrong.\n .next()\n // TODO: Avoid panicking here.\n .expect(\"No file URI found\");\n\n let uri = CdnUrl::new(file_uri);\n Ok(uri)\n }\n\n pub fn fetch_file_range(\n &self,\n uri: &str,\n offset: u64,\n length: u64,\n ) -> Result<(u64, impl Read), Error> {\n let response = self\n .agent\n .get(uri)\n .header(\"Range\", &range_header(offset, length))\n .call()?;\n let total_length = parse_total_content_length(&response);\n let data_reader = response.into_body().into_reader();\n Ok((total_length, data_reader))\n }\n}\n\n#[derive(Clone)]\npub struct CdnUrl {\n pub url: String,\n pub expires: Instant,\n}\n\nimpl CdnUrl {\n // In case we fail to parse the expiration time from URL, this default is used.\n const DEFAULT_EXPIRATION: Duration = Duration::from_secs(60 * 30);\n\n // Consider URL expired even before the official expiration time.\n const EXPIRATION_TIME_THRESHOLD: Duration = Duration::from_secs(5);\n\n fn new(url: String) -> Self {\n let expires_in = parse_expiration(&url).unwrap_or_else(|| {\n log::warn!(\"failed to parse expiration time from URL {:?}\", &url);\n Self::DEFAULT_EXPIRATION\n });\n let expires = Instant::now() + expires_in;\n Self { url, expires }\n }\n\n pub fn is_expired(&self) -> bool {\n self.expires.saturating_duration_since(Instant::now()) < Self::EXPIRATION_TIME_THRESHOLD\n }\n}\n\nimpl From for Error {\n fn from(err: ureq::Error) -> Self {\n Error::AudioFetchingError(Box::new(err))\n }\n}\n\n/// Constructs a Range header value for given offset and length.\nfn range_header(offfset: u64, length: u64) -> String {\n let last_byte = offfset + length - 1; // Offset of the last byte of the range is inclusive.\n format!(\"bytes={offfset}-{last_byte}\")\n}\n\n/// Parses a total content length from a Content-Range response header.\n///\n/// For example, returns 146515 for a response with header\n/// \"Content-Range: bytes 0-1023/146515\".\nfn parse_total_content_length(response: &ureq::http::response::Response) -> u64 {\n response\n .headers()\n .get(\"Content-Range\")\n .expect(\"Content-Range header not found\")\n .to_str()\n .expect(\"Failed to parse Content-Range Header\")\n .split('/')\n .next_back()\n .expect(\"Failed to parse Content-Range Header\")\n .parse()\n .expect(\"Failed to parse Content-Range Header\")\n}\n\n/// Parses an expiration of an audio file URL.\nfn parse_expiration(url: &str) -> Option {\n let token_exp = url.split(\"__token__=exp=\").nth(1);\n let expires_millis = if let Some(token_exp) = token_exp {\n // Parse from the expiration token param\n token_exp.split('~').next()?\n } else if let Some(verify_exp) = url.split(\"verify=\").nth(1) {\n // Parse from verify parameter (new spotifycdn.com format)\n verify_exp.split('-').next()?\n } else {\n // Parse from the first param\n let first_param = url.split('?').nth(1)?;\n first_param.split('_').next()?\n };\n let expires_millis = expires_millis.parse().ok()?;\n let expires = Duration::from_millis(expires_millis);\n Some(expires)\n}\n" }, { "path": "psst-core/src/connection/diffie_hellman.rs", "content": "use num_bigint::{BigUint, ToBigUint};\nuse rand::Rng;\n\npub struct DHLocalKeys {\n private_key: BigUint,\n public_key: BigUint,\n}\n\nimpl DHLocalKeys {\n pub fn random() -> DHLocalKeys {\n let private_key = rand::rng().random::().to_biguint().unwrap();\n let public_key = dh_generator().modpow(&private_key, &dh_prime());\n DHLocalKeys {\n private_key,\n public_key,\n }\n }\n\n pub fn public_key(&self) -> Vec {\n self.public_key.to_bytes_be()\n }\n\n pub fn shared_secret(&self, remote_key: &[u8]) -> Vec {\n let remote_key = BigUint::from_bytes_be(remote_key);\n let shared_key = remote_key.modpow(&self.private_key, &dh_prime());\n shared_key.to_bytes_be()\n }\n}\n\nfn dh_generator() -> BigUint {\n BigUint::from(0x2_u64)\n}\n\nfn dh_prime() -> BigUint {\n BigUint::from_bytes_be(&[\n 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2, 0x21, 0x68, 0xc2,\n 0x34, 0xc4, 0xc6, 0x62, 0x8b, 0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67,\n 0xcc, 0x74, 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22, 0x51, 0x4a, 0x08, 0x79, 0x8e,\n 0x34, 0x04, 0xdd, 0xef, 0x95, 0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d,\n 0xf2, 0x5f, 0x14, 0x37, 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51, 0xc2, 0x45, 0xe4, 0x85, 0xb5,\n 0x76, 0x62, 0x5e, 0x7e, 0xc6, 0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x3a, 0x36, 0x20, 0xff, 0xff,\n 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n ])\n}\n" }, { "path": "psst-core/src/connection/mod.rs", "content": "pub mod diffie_hellman;\npub mod shannon_codec;\n\nuse std::{\n convert::TryInto,\n io,\n io::{Read, Write},\n net::{TcpStream, ToSocketAddrs},\n};\n\nuse byteorder::{ReadBytesExt, BE};\nuse hmac::{Hmac, Mac};\nuse serde::{Deserialize, Serialize};\nuse sha1::Sha1;\nuse socks::Socks5Stream;\nuse url::Url;\n\nuse crate::{\n connection::{\n diffie_hellman::DHLocalKeys,\n shannon_codec::{ShannonDecoder, ShannonEncoder, ShannonMsg},\n },\n error::Error,\n util::{default_ureq_agent_builder, NET_CONNECT_TIMEOUT, NET_IO_TIMEOUT},\n};\n\nuse librespot_protocol::authentication::AuthenticationType;\nuse protobuf::{Enum, Message, MessageField, SpecialFields};\n\n// Device ID used for authentication message.\nconst DEVICE_ID: &str = \"Psst\";\n\n// URI of access-point resolve endpoint.\nconst AP_RESOLVE_ENDPOINT: &str = \"http://apresolve.spotify.com\";\n\n// Access-point used in case the resolving fails.\nconst AP_FALLBACK: &str = \"ap.spotify.com:443\";\n\n#[derive(Clone, Debug, Serialize, Deserialize)]\n#[serde(from = \"SerializedCredentials\")]\n#[serde(into = \"SerializedCredentials\")]\npub struct Credentials {\n pub username: Option,\n pub auth_data: Vec,\n pub auth_type: AuthenticationType,\n}\n\nimpl Credentials {\n pub fn from_username_and_password(username: String, password: String) -> Self {\n Self {\n username: Some(username),\n auth_type: AuthenticationType::AUTHENTICATION_USER_PASS,\n auth_data: password.into_bytes(),\n }\n }\n\n pub fn from_access_token(token: String) -> Self {\n Self {\n username: None,\n auth_type: AuthenticationType::AUTHENTICATION_SPOTIFY_TOKEN,\n auth_data: token.into_bytes(),\n }\n }\n}\n\n#[derive(Serialize, Deserialize)]\nstruct SerializedCredentials {\n username: String,\n auth_data: String,\n auth_type: i32,\n}\n\nimpl From for Credentials {\n fn from(value: SerializedCredentials) -> Self {\n Self {\n username: Some(value.username),\n auth_data: value.auth_data.into_bytes(),\n auth_type: AuthenticationType::from_i32(value.auth_type).unwrap_or_default(),\n }\n }\n}\n\nimpl From for SerializedCredentials {\n fn from(value: Credentials) -> Self {\n Self {\n username: value.username.unwrap_or_default(),\n auth_data: String::from_utf8(value.auth_data)\n .expect(\"Invalid UTF-8 in serialized credentials\"),\n auth_type: value.auth_type as _,\n }\n }\n}\n\npub struct Transport {\n pub stream: TcpStream,\n pub encoder: ShannonEncoder,\n pub decoder: ShannonDecoder,\n}\n\nimpl Transport {\n pub fn resolve_ap_with_fallback(proxy_url: Option<&str>) -> Vec {\n match Self::resolve_ap(proxy_url) {\n Ok(ap_list) => {\n log::info!(\"successfully resolved {} access points\", ap_list.len());\n ap_list\n }\n Err(err) => {\n log::error!(\"error while resolving APs, using fallback: {err:?}\");\n vec![AP_FALLBACK.into()]\n }\n }\n }\n\n pub fn resolve_ap(proxy_url: Option<&str>) -> Result, Error> {\n #[derive(Clone, Debug, Deserialize)]\n struct APResolveData {\n ap_list: Vec,\n }\n\n let agent: ureq::Agent = default_ureq_agent_builder(proxy_url).build().into();\n log::info!(\"requesting AP list from {AP_RESOLVE_ENDPOINT}\");\n let data: APResolveData = agent\n .get(AP_RESOLVE_ENDPOINT)\n .call()?\n .into_body()\n .read_json()?;\n if data.ap_list.is_empty() {\n log::warn!(\"received empty AP list from server\");\n Err(Error::UnexpectedResponse)\n } else {\n log::info!(\"received {} APs from server\", data.ap_list.len());\n Ok(data.ap_list)\n }\n }\n\n pub fn connect(ap_list: &[String], proxy_url: Option<&str>) -> Result {\n log::info!(\n \"attempting to connect using {} access points\",\n ap_list.len()\n );\n for (index, ap) in ap_list.iter().enumerate() {\n log::info!(\"trying AP {} of {}: {}\", index + 1, ap_list.len(), ap);\n let stream = if let Some(url) = proxy_url {\n match Self::stream_through_proxy(ap, url) {\n Ok(s) => s,\n Err(e) => {\n log::warn!(\"failed to connect to AP {ap} through proxy: {e:?}\");\n continue;\n }\n }\n } else {\n match Self::stream_without_proxy(ap) {\n Ok(s) => s,\n Err(e) => {\n log::warn!(\"failed to connect to AP {ap} without proxy: {e:?}\");\n continue;\n }\n }\n };\n if let Err(err) = stream.set_write_timeout(Some(NET_IO_TIMEOUT)) {\n log::warn!(\"failed to set TCP write timeout: {err:?}\");\n }\n log::info!(\"successfully connected to AP: {ap}\");\n return Self::exchange_keys(stream);\n }\n log::error!(\"failed to connect to any access point\");\n Err(Error::ConnectionFailed)\n }\n\n fn stream_without_proxy(ap: &str) -> Result {\n let mut last_err = None;\n for addr in ap.to_socket_addrs()? {\n match TcpStream::connect_timeout(&addr, NET_CONNECT_TIMEOUT) {\n Ok(stream) => {\n return Ok(stream);\n }\n Err(err) => {\n last_err.replace(err);\n }\n }\n }\n Err(last_err.unwrap_or_else(|| {\n io::Error::new(\n io::ErrorKind::InvalidInput,\n \"could not resolve to any addresses\",\n )\n }))\n }\n\n fn stream_through_proxy(ap: &str, url: &str) -> Result {\n match Url::parse(url) {\n Ok(url) if url.scheme() == \"socks\" || url.scheme() == \"socks5\" => {\n // Currently we only support SOCKS5 proxies.\n Self::stream_through_socks5_proxy(ap, &url)\n }\n _ => {\n // Proxy URL failed to parse or has unsupported scheme.\n Err(Error::ProxyUrlInvalid)\n }\n }\n }\n\n fn stream_through_socks5_proxy(ap: &str, url: &Url) -> Result {\n let addrs = url.socket_addrs(|| None)?;\n let username = url.username();\n let password = url.password().unwrap_or(\"\");\n // TODO: `socks` crate does not support connection timeouts.\n let proxy = if username.is_empty() {\n Socks5Stream::connect(&addrs[..], ap)?\n } else {\n Socks5Stream::connect_with_password(&addrs[..], ap, username, password)?\n };\n Ok(proxy.into_inner())\n }\n\n pub fn exchange_keys(mut stream: TcpStream) -> Result {\n use librespot_protocol::keyexchange::APResponseMessage;\n\n let local_keys = DHLocalKeys::random();\n\n // Start by sending the hello message with our public key and nonce.\n log::trace!(\"sending client hello\");\n let client_nonce: [u8; 16] = rand::random();\n let hello = client_hello(local_keys.public_key(), client_nonce.into());\n let hello_packet = make_packet(&[0, 4], &hello);\n stream.write_all(&hello_packet)?;\n log::trace!(\"sent client hello\");\n\n // Wait for the response packet with the remote public key. Note that we are\n // keeping both the hello packet and the response packet for later (they get\n // hashed together with the shared secret to make a key pair).\n log::trace!(\"waiting for AP response\");\n let apresp_packet = read_packet(&mut stream)?;\n let apresp = APResponseMessage::parse_from_bytes(&apresp_packet[4..])?;\n log::trace!(\"received AP response\");\n\n // Compute the challenge response and the sending/receiving keys.\n let remote_key = apresp\n .challenge\n .login_crypto_challenge\n .diffie_hellman\n .gs\n .as_ref()\n .expect(\"Missing data\");\n\n let (challenge, send_key, recv_key) = compute_keys(\n &local_keys.shared_secret(remote_key),\n &hello_packet,\n &apresp_packet,\n );\n\n // Respond with the computed HMAC and finish the handshake.\n log::trace!(\"sending client response\");\n let response = client_response_plaintext(challenge);\n let response_packet = make_packet(&[], &response);\n stream.write_all(&response_packet)?;\n log::trace!(\"sent client response\");\n\n // Use the derived keys to make a codec, wrapping the TCP stream.\n let encoder = ShannonEncoder::new(stream.try_clone()?, &send_key);\n let decoder = ShannonDecoder::new(stream.try_clone()?, &recv_key);\n\n Ok(Self {\n stream,\n encoder,\n decoder,\n })\n }\n\n pub fn authenticate(&mut self, credentials: Credentials) -> Result {\n use librespot_protocol::{authentication::APWelcome, keyexchange::APLoginFailed};\n\n // Send a login request with the client credentials.\n let request = client_response_encrypted(credentials);\n self.encoder.encode(request)?;\n\n // Expect an immediate response with the authentication result.\n let response = self.decoder.decode()?;\n\n match response.cmd {\n ShannonMsg::AP_WELCOME => {\n let welcome_data =\n APWelcome::parse_from_bytes(&response.payload).expect(\"Missing data\");\n\n Ok(Credentials {\n username: Some(welcome_data.canonical_username().to_string()),\n auth_data: welcome_data.reusable_auth_credentials().to_vec(),\n auth_type: welcome_data.reusable_auth_credentials_type(),\n })\n }\n ShannonMsg::AUTH_FAILURE => {\n let error_data =\n APLoginFailed::parse_from_bytes(&response.payload).expect(\"Missing data\");\n Err(Error::AuthFailed {\n code: error_data.error_code() as _,\n })\n }\n _ => {\n unreachable!(\"unexpected message\");\n }\n }\n }\n}\n\nfn read_packet(stream: &mut TcpStream) -> io::Result> {\n let size = stream.read_u32::()?;\n let mut buf = vec![0_u8; size as usize];\n let (size_buf, data_buf) = buf.split_at_mut(4);\n size_buf.copy_from_slice(&size.to_be_bytes());\n stream.read_exact(data_buf)?;\n Ok(buf)\n}\n\nfn make_packet(prefix: &[u8], data: &[u8]) -> Vec {\n let size = prefix.len() + 4 + data.len();\n let mut buf = Vec::with_capacity(size);\n let size_u32: u32 = size.try_into().unwrap();\n buf.extend(prefix);\n buf.extend(size_u32.to_be_bytes());\n buf.extend(data);\n buf\n}\n\nfn client_hello(public_key: Vec, nonce: Vec) -> Vec {\n use librespot_protocol::keyexchange::*;\n\n let hello = ClientHello {\n build_info: MessageField::some(BuildInfo {\n platform: Some(Platform::PLATFORM_LINUX_X86.into()),\n product: Some(Product::PRODUCT_PARTNER.into()),\n product_flags: vec![],\n version: Some(109_800_078),\n special_fields: SpecialFields::new(),\n }),\n cryptosuites_supported: vec![Cryptosuite::CRYPTO_SUITE_SHANNON.into()],\n fingerprints_supported: vec![],\n powschemes_supported: vec![],\n login_crypto_hello: MessageField::some(LoginCryptoHelloUnion {\n diffie_hellman: MessageField::some(LoginCryptoDiffieHellmanHello {\n gc: Some(public_key),\n server_keys_known: Some(1),\n special_fields: SpecialFields::new(),\n }),\n special_fields: SpecialFields::new(),\n }),\n client_nonce: Some(nonce),\n padding: Some(vec![0x1e]),\n feature_set: None.into(),\n special_fields: SpecialFields::new(),\n };\n\n hello\n .write_to_bytes()\n .expect(\"Failed to serialize client hello\")\n}\n\nfn client_response_plaintext(challenge: Vec) -> Vec {\n use librespot_protocol::keyexchange::*;\n\n let response = ClientResponsePlaintext {\n login_crypto_response: MessageField::some(LoginCryptoResponseUnion {\n diffie_hellman: MessageField::some(LoginCryptoDiffieHellmanResponse {\n hmac: Some(challenge),\n special_fields: SpecialFields::new(),\n }),\n special_fields: SpecialFields::new(),\n }),\n pow_response: MessageField::some(PoWResponseUnion::default()),\n crypto_response: MessageField::some(CryptoResponseUnion::default()),\n special_fields: SpecialFields::new(),\n };\n\n response\n .write_to_bytes()\n .expect(\"Failed to serialize client response\")\n}\n\nfn compute_keys(\n shared_secret: &[u8],\n hello_packet: &[u8],\n apresp_packet: &[u8],\n) -> (Vec, Vec, Vec) {\n let mut data = Vec::with_capacity(5 * 20);\n for i in 1..6 {\n let mut mac: Hmac =\n Hmac::new_from_slice(shared_secret).expect(\"HMAC can take key of any size\");\n mac.update(hello_packet);\n mac.update(apresp_packet);\n mac.update(&[i]);\n data.extend(mac.finalize().into_bytes());\n }\n let mut mac: Hmac =\n Hmac::new_from_slice(&data[..20]).expect(\"HMAC can take key of any size\");\n mac.update(hello_packet);\n mac.update(apresp_packet);\n let digest = mac.finalize().into_bytes();\n\n (\n (*digest).to_vec(),\n data[20..52].to_vec(),\n data[52..84].to_vec(),\n )\n}\n\nfn client_response_encrypted(credentials: Credentials) -> ShannonMsg {\n use librespot_protocol::authentication::{\n ClientResponseEncrypted, LoginCredentials, SystemInfo, Os, CpuFamily\n };\n\n let response = ClientResponseEncrypted {\n login_credentials: MessageField::some(LoginCredentials {\n username: credentials.username,\n auth_data: Some(credentials.auth_data),\n typ: Some(credentials.auth_type.into()),\n special_fields: SpecialFields::new(),\n }),\n system_info: MessageField::some(SystemInfo {\n device_id: Some(DEVICE_ID.to_string()),\n system_information_string: Some(\"librespot_but_actually_psst\".to_string()),\n os: Some(Os::default().into()),\n cpu_family: Some(CpuFamily::default().into()),\n ..SystemInfo::default()\n }),\n ..ClientResponseEncrypted::default()\n };\n\n let buf = response.write_to_bytes().expect(\"Failed to serialize\");\n ShannonMsg::new(ShannonMsg::LOGIN, buf)\n}\n" }, { "path": "psst-core/src/connection/shannon_codec.rs", "content": "use std::{convert::TryInto, io};\n\nuse shannon::Shannon;\n\n#[derive(Debug)]\npub struct ShannonMsg {\n pub cmd: u8,\n pub payload: Vec,\n}\n\nimpl ShannonMsg {\n pub const SECRET_BLOCK: u8 = 0x02;\n pub const PING: u8 = 0x04;\n pub const STREAM_CHUNK: u8 = 0x08;\n pub const STREAM_CHUNK_RES: u8 = 0x09;\n pub const CHANNEL_ERROR: u8 = 0x0a;\n pub const CHANNEL_ABORT: u8 = 0x0b;\n pub const REQUEST_KEY: u8 = 0x0c;\n pub const AES_KEY: u8 = 0x0d;\n pub const AES_KEY_ERROR: u8 = 0x0e;\n pub const IMAGE: u8 = 0x19;\n pub const COUNTRY_CODE: u8 = 0x1b;\n pub const PONG: u8 = 0x49;\n pub const PONG_ACK: u8 = 0x4a;\n pub const PAUSE: u8 = 0x4b;\n pub const PRODUCT_INFO: u8 = 0x50;\n pub const LEGACY_WELCOME: u8 = 0x69;\n pub const LICENSE_VERSION: u8 = 0x76;\n pub const LOGIN: u8 = 0xab;\n pub const AP_WELCOME: u8 = 0xac;\n pub const AUTH_FAILURE: u8 = 0xad;\n pub const MERCURY_REQ: u8 = 0xb2;\n pub const MERCURY_SUB: u8 = 0xb3;\n pub const MERCURY_UNSUB: u8 = 0xb4;\n pub const MERCURY_PUB: u8 = 0xb5;\n\n pub fn new(cmd: u8, payload: impl Into>) -> Self {\n Self {\n cmd,\n payload: payload.into(),\n }\n }\n}\n\nconst MAC_SIZE: usize = 4;\nconst HEADER_SIZE: usize = 3;\n\npub struct ShannonEncoder {\n inner: T,\n nonce: u32,\n cipher: Shannon,\n}\n\nimpl ShannonEncoder\nwhere\n T: io::Write,\n{\n pub fn new(inner: T, send_key: &[u8]) -> Self {\n Self {\n inner,\n nonce: 0,\n cipher: Shannon::new(send_key),\n }\n }\n\n pub fn encode(&mut self, item: ShannonMsg) -> io::Result<()> {\n // Buffer up the whole message.\n let mut buf = Vec::with_capacity(HEADER_SIZE + item.payload.len() + MAC_SIZE);\n let len_u16: u16 = item.payload.len().try_into().unwrap();\n buf.push(item.cmd);\n buf.extend(len_u16.to_be_bytes());\n buf.extend(item.payload);\n\n // Seed the cipher, rotate the nonce, and encrypt the header and payload.\n self.cipher.nonce_u32(self.nonce);\n self.nonce += 1;\n self.cipher.encrypt(&mut buf);\n\n // Compute the MAC and append it.\n let mut mac = [0_u8; MAC_SIZE];\n self.cipher.finish(&mut mac);\n buf.extend(mac);\n\n self.inner.write_all(&buf)\n }\n\n pub fn as_inner_mut(&mut self) -> &mut T {\n &mut self.inner\n }\n}\n\npub struct ShannonDecoder {\n inner: T,\n nonce: u32,\n cipher: Shannon,\n}\n\nimpl ShannonDecoder\nwhere\n T: io::Read,\n{\n pub fn new(inner: T, recv_key: &[u8]) -> Self {\n Self {\n inner,\n nonce: 0,\n cipher: Shannon::new(recv_key),\n }\n }\n\n pub fn decode(&mut self) -> io::Result {\n // Seed the cipher and rotate the nonce.\n self.cipher.nonce_u32(self.nonce);\n self.nonce += 1;\n\n // Read the whole header. Reading and decrypting byte by byte is not really\n // reliable, because of a bug in `shannon` crate.\n let mut header = [0_u8; HEADER_SIZE];\n self.inner.read_exact(&mut header)?;\n self.cipher.decrypt(&mut header);\n\n // Parse the header fields.\n let cmd = header[0];\n let size = u16::from_be_bytes([header[1], header[2]]) as usize;\n\n // Read and decrypt the payload.\n let mut payload = vec![0_u8; size];\n self.inner.read_exact(&mut payload)?;\n self.cipher.decrypt(&mut payload);\n\n // Read and check the MAC.\n let mut mac = [0_u8; MAC_SIZE];\n self.inner.read_exact(&mut mac)?;\n self.cipher.check_mac(&mac)?;\n\n Ok(ShannonMsg::new(cmd, payload))\n }\n\n pub fn as_inner(&self) -> &T {\n &self.inner\n }\n}\n" }, { "path": "psst-core/src/error.rs", "content": "use std::sync::mpsc::RecvTimeoutError;\nuse std::{error, fmt, io};\n\n#[derive(Debug)]\npub enum Error {\n SessionDisconnected,\n UnexpectedResponse,\n MediaFileNotFound,\n ProxyUrlInvalid,\n AuthFailed { code: i32 },\n ConnectionFailed,\n JsonError(Box),\n InvalidStateError(Box),\n UnimplementedError(Box),\n AudioFetchingError(Box),\n AudioDecodingError(Box),\n AudioOutputError(Box),\n AudioProbeError(Box),\n ScrobblerError(Box),\n ResamplingError(i32),\n ConfigError(String),\n IoError(io::Error),\n SendError,\n RecvTimeoutError(RecvTimeoutError),\n JoinError,\n OAuthError(String),\n}\n\nimpl error::Error for Error {}\n\nimpl fmt::Display for Error {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n Self::SessionDisconnected => write!(f, \"Session disconnected\"),\n Self::UnexpectedResponse => write!(f, \"Unknown server response\"),\n Self::MediaFileNotFound => write!(f, \"Audio file not found\"),\n Self::ProxyUrlInvalid => write!(f, \"Invalid proxy URL\"),\n Self::AuthFailed { code } => match code {\n 0 => write!(f, \"Authentication failed: protocol error\"),\n 2 => write!(f, \"Authentication failed: try another AP\"),\n 5 => write!(f, \"Authentication failed: bad connection id\"),\n 9 => write!(f, \"Authentication failed: travel restriction\"),\n 11 => write!(f, \"Authentication failed: premium account required\"),\n 12 => write!(f, \"Authentication failed: bad credentials\"),\n 13 => write!(f, \"Authentication failed: could not validate credentials\"),\n 14 => write!(f, \"Authentication failed: account exists\"),\n 15 => write!(f, \"Authentication failed: extra verification required\"),\n 16 => write!(f, \"Authentication failed: invalid app key\"),\n 17 => write!(f, \"Authentication failed: application banned\"),\n _ => write!(f, \"Authentication failed with error code {code}\"),\n },\n Self::ConnectionFailed => write!(f, \"Failed to connect to any access point\"),\n Self::ResamplingError(code) => {\n write!(f, \"Resampling failed with error code {code}\")\n }\n Self::ConfigError(msg) => write!(f, \"Configuration error: {msg}\"),\n Self::JsonError(err)\n | Self::AudioFetchingError(err)\n | Self::AudioDecodingError(err)\n | Self::AudioOutputError(err)\n | Self::ScrobblerError(err)\n | Self::AudioProbeError(err) => err.fmt(f),\n Self::InvalidStateError(err)\n | Self::UnimplementedError(err) => err.fmt(f),\n Self::IoError(err) => err.fmt(f),\n Self::SendError => write!(f, \"Failed to send into a channel\"),\n Self::RecvTimeoutError(err) => write!(f, \"Channel receive timeout: {err}\"),\n Self::JoinError => write!(f, \"Failed to join thread\"),\n Self::OAuthError(msg) => write!(f, \"OAuth error: {msg}\"),\n }\n }\n}\n\nimpl From for Error {\n fn from(err: io::Error) -> Error {\n Error::IoError(err)\n }\n}\n\nimpl From> for Error {\n fn from(_: crossbeam_channel::SendError) -> Self {\n Error::SendError\n }\n}\n\nimpl From for Error {\n fn from(err: RecvTimeoutError) -> Self {\n Error::RecvTimeoutError(err)\n }\n}\n\nimpl From for Error {\n fn from(err: protobuf::Error) -> Self { Error::InvalidStateError(err.into()) }\n}" }, { "path": "psst-core/src/item_id.rs", "content": "use std::{\n collections::HashMap,\n convert::TryInto,\n fmt,\n ops::Deref,\n path::PathBuf,\n sync::{LazyLock, Mutex},\n};\n\nstatic LOCAL_REGISTRY: LazyLock> =\n LazyLock::new(|| Mutex::new(LocalItemRegistry::new()));\n\n// LocalItemRegistry allows generating IDs for local music files, so they can be\n// treated similarly to files hosted on Spotify's remote servers. IDs are\n// easier to pass around since they implement `Copy`, as opposed to passing\n// around a `PathBuf` or `File` pointing to the file.\n//\n// The registry stores two complementary maps for bi-directional lookup. This\n// allows for quick registration of new tracks and quick lookup of existing\n// tracks by ID, at the cost of increased memory usage. The ID-to-path lookup\n// should be prioritized, as that is required to begin playback. Path-to-ID\n// lookup is helpful to avoid registering the same path under multiple IDs,\n// but is okay to be a bit slower since it's only done once per track when\n// (when loading the list of local files from Spotify's config).\npub struct LocalItemRegistry {\n next_id: u128,\n path_to_id: HashMap,\n id_to_path: HashMap,\n}\n\nimpl LocalItemRegistry {\n fn new() -> Self {\n Self {\n next_id: 1,\n path_to_id: HashMap::new(),\n id_to_path: HashMap::new(),\n }\n }\n\n pub fn get_or_insert(path: PathBuf) -> u128 {\n let mut registry = LOCAL_REGISTRY.lock().unwrap();\n registry.path_to_id.get(&path).copied().unwrap_or_else(|| {\n let id = registry.next_id;\n registry.next_id += 1;\n registry.id_to_path.insert(id, path.clone());\n id\n })\n }\n\n pub fn get(id: u128) -> Option {\n let registry = LOCAL_REGISTRY.lock().unwrap();\n registry.id_to_path.get(&id).cloned()\n }\n}\n\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]\npub enum ItemIdType {\n Track,\n Podcast,\n LocalFile,\n Unknown,\n}\n\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]\npub struct ItemId {\n pub id: u128,\n pub id_type: ItemIdType,\n}\n\nconst BASE62_DIGITS: &[u8] = b\"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\";\nconst BASE16_DIGITS: &[u8] = b\"0123456789abcdef\";\n\nimpl ItemId {\n pub const INVALID: Self = Self::new(0u128, ItemIdType::Unknown);\n\n pub const fn new(id: u128, id_type: ItemIdType) -> Self {\n Self { id, id_type }\n }\n\n pub fn from_base16(id: &str, id_type: ItemIdType) -> Option {\n let mut n = 0_u128;\n for c in id.as_bytes() {\n let d = BASE16_DIGITS.iter().position(|e| e == c)? as u128;\n n *= 16;\n n += d;\n }\n Some(Self::new(n, id_type))\n }\n\n pub fn from_base62(id: &str, id_type: ItemIdType) -> Option {\n let mut n = 0_u128;\n for c in id.as_bytes() {\n let d = BASE62_DIGITS.iter().position(|e| e == c)? as u128;\n n *= 62;\n n += d;\n }\n Some(Self::new(n, id_type))\n }\n\n pub fn from_raw(data: &[u8], id_type: ItemIdType) -> Option {\n let n = u128::from_be_bytes(data.try_into().ok()?);\n Some(Self::new(n, id_type))\n }\n\n pub fn from_uri(uri: &str) -> Option {\n let gid = uri.split(':').next_back()?;\n if uri.contains(\":episode:\") {\n Self::from_base62(gid, ItemIdType::Podcast)\n } else if uri.contains(\":track:\") {\n Self::from_base62(gid, ItemIdType::Track)\n } else {\n Self::from_base62(gid, ItemIdType::Unknown)\n }\n }\n\n /// Converts an ID to an URI as described in: https://developer.spotify.com/documentation/web-api/#spotify-uris-and-ids\n pub fn to_uri(&self) -> Option {\n let b64 = self.to_base62();\n match self.id_type {\n ItemIdType::Track => Some(format!(\"spotify:track:{b64}\")),\n ItemIdType::Podcast => Some(format!(\"spotify:podcast:{b64}\")),\n // TODO: support adding local files to playlists\n ItemIdType::LocalFile => None,\n ItemIdType::Unknown => None,\n }\n }\n\n pub fn to_base16(&self) -> String {\n format!(\"{:032x}\", self.id)\n }\n\n pub fn to_base62(&self) -> String {\n let mut n = self.id;\n let mut data = [0_u8; 22];\n for i in 0..22 {\n data[21 - i] = BASE62_DIGITS[(n % 62) as usize];\n n /= 62;\n }\n std::str::from_utf8(&data).unwrap().to_string()\n }\n\n pub fn to_raw(&self) -> [u8; 16] {\n self.id.to_be_bytes()\n }\n\n pub fn from_local(path: PathBuf) -> Self {\n Self::new(\n LocalItemRegistry::get_or_insert(path),\n ItemIdType::LocalFile,\n )\n }\n\n pub fn to_local(&self) -> PathBuf {\n match self.id_type {\n // local items should only be constructed with `from_local`\n ItemIdType::LocalFile => LocalItemRegistry::get(self.id).expect(\"valid item ID\"),\n _ => panic!(\"expected local file\"),\n }\n }\n}\n\nimpl Default for ItemId {\n fn default() -> Self {\n Self::INVALID\n }\n}\n\nimpl From for String {\n fn from(id: ItemId) -> Self {\n id.to_base62()\n }\n}\n\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]\npub struct FileId(pub [u8; 20]);\n\nimpl FileId {\n pub fn from_raw(data: &[u8]) -> Option {\n Some(FileId(data.try_into().ok()?))\n }\n\n pub fn to_base16(&self) -> String {\n self.0\n .iter()\n .map(|b| format!(\"{b:02x}\"))\n .collect::>()\n .concat()\n }\n}\n\nimpl Deref for FileId {\n type Target = [u8];\n\n fn deref(&self) -> &Self::Target {\n &self.0\n }\n}\n\nimpl fmt::Debug for FileId {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n f.debug_tuple(\"FileId\").field(&self.to_base16()).finish()\n }\n}\n\nimpl fmt::Display for FileId {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n f.write_str(&self.to_base16())\n }\n}\n" }, { "path": "psst-core/src/lastfm.rs", "content": "use crate::error::Error;\nuse crate::oauth::listen_for_callback_parameter;\nuse rustfm_scrobble::{responses::SessionResponse, Scrobble, Scrobbler, ScrobblerError};\nuse std::{net::SocketAddr, time::Duration};\nuse url::Url;\n\npub struct LastFmClient;\n\nimpl LastFmClient {\n /// Report a track as \"now playing\" to Last.fm using an existing Scrobbler instance.\n pub fn now_playing_song(\n scrobbler: &Scrobbler, // Requires an authenticated Scrobbler\n artist: &str,\n title: &str,\n album: Option<&str>,\n ) -> Result<(), Error> {\n let song = Scrobble::new(artist, title, album.unwrap_or(\"\"));\n scrobbler\n .now_playing(&song)\n .map(|_| ())\n .map_err(Error::from)\n }\n\n /// Scrobble a finished track to Last.fm using an existing Scrobbler instance.\n pub fn scrobble_song(\n scrobbler: &Scrobbler, // Requires an authenticated Scrobbler\n artist: &str,\n title: &str,\n album: Option<&str>,\n ) -> Result<(), Error> {\n let song = Scrobble::new(artist, title, album.unwrap_or(\"\"));\n scrobbler.scrobble(&song).map(|_| ()).map_err(Error::from)\n }\n\n /// Creates an authenticated Last.fm Scrobbler instance with provided credentials.\n /// Note: This assumes the session_key is valid. Validity is checked on first API call.\n pub fn create_scrobbler(\n api_key: Option<&str>,\n api_secret: Option<&str>,\n session_key: Option<&str>,\n ) -> Result {\n let (Some(api_key), Some(api_secret), Some(session_key)) =\n (api_key, api_secret, session_key)\n else {\n log::warn!(\"missing Last.fm API key, secret, or session key for scrobbler creation.\");\n return Err(Error::ConfigError(\n \"Missing Last.fm API key, secret, or session key.\".to_string(),\n ));\n };\n\n let mut scrobbler = Scrobbler::new(api_key, api_secret);\n // Associate the session key with the scrobbler instance.\n scrobbler.authenticate_with_session_key(session_key);\n log::info!(\"scrobbler instance created with session key (validity checked on first use).\");\n Ok(scrobbler)\n }\n}\n\nimpl From for Error {\n fn from(value: ScrobblerError) -> Self {\n Self::ScrobblerError(Box::new(value))\n }\n}\n\n/// Generate a Last.fm authentication URL\npub fn generate_lastfm_auth_url(\n api_key: &str,\n callback_url: &str,\n) -> Result {\n let base = \"http://www.last.fm/api/auth/\";\n let url = Url::parse_with_params(base, &[(\"api_key\", api_key), (\"cb\", callback_url)])?;\n Ok(url.to_string())\n}\n\n/// Exchange a token for a Last.fm session key\npub fn exchange_token_for_session(\n api_key: &str,\n api_secret: &str,\n token: &str,\n) -> Result {\n let mut scrobbler = Scrobbler::new(api_key, api_secret);\n scrobbler\n .authenticate_with_token(token) // Uses auth.getSession API call internally\n .map(|response: SessionResponse| response.key) // Extract the session key string\n .map_err(Error::from) // Map ScrobblerError to crate::error::Error\n}\n\n/// Listen for a Last.fm token from the callback\npub fn get_lastfm_token_listener(\n socket_address: SocketAddr,\n timeout: Duration,\n) -> Result {\n // Use the shared listener function, specifying \"token\" as the parameter\n listen_for_callback_parameter(socket_address, timeout, \"token\")\n}\n" }, { "path": "psst-core/src/lib.rs", "content": "#![allow(clippy::new_without_default)]\n\nuse git_version::git_version;\n\npub const GIT_VERSION: &str = git_version!();\npub const BUILD_TIME: &str = include!(concat!(env!(\"OUT_DIR\"), \"/build-time.txt\"));\npub const REMOTE_URL: &str = include!(concat!(env!(\"OUT_DIR\"), \"/remote-url.txt\"));\n\npub mod actor;\npub mod audio;\npub mod cache;\npub mod cdn;\npub mod connection;\npub mod error;\npub mod item_id;\npub mod lastfm;\npub mod metadata;\npub mod oauth;\npub mod player;\npub mod session;\npub mod system_info;\npub mod util;\n" }, { "path": "psst-core/src/metadata.rs", "content": "use std::time::Duration;\n\nuse crate::{\n error::Error,\n item_id::{FileId, ItemId, ItemIdType},\n player::file::{AudioFormat, MediaFile, MediaPath},\n session::SessionService,\n};\n\nuse librespot_protocol::metadata::restriction::Country_restriction;\nuse librespot_protocol::metadata::{AudioFile, Episode, Restriction, Track};\n\npub trait Fetch: protobuf::Message {\n fn uri(id: ItemId) -> String;\n fn fetch(session: &SessionService, id: ItemId) -> Result {\n session.connected()?.get_mercury_protobuf(Self::uri(id))\n }\n}\n\nimpl Fetch for Track {\n fn uri(id: ItemId) -> String {\n format!(\"hm://metadata/3/track/{}\", id.to_base16())\n }\n}\n\nimpl Fetch for Episode {\n fn uri(id: ItemId) -> String {\n format!(\"hm://metadata/3/episode/{}\", id.to_base16())\n }\n}\n\npub trait ToMediaPath {\n fn is_restricted_in_region(&self, country: &str) -> bool;\n fn find_allowed_alternative(&self, country: &str) -> Option;\n fn to_media_path(&self, preferred_bitrate: usize) -> Option;\n}\n\nimpl ToMediaPath for Track {\n fn is_restricted_in_region(&self, country: &str) -> bool {\n self.restriction\n .iter()\n .any(|rest| is_restricted_in_region(rest, country))\n }\n\n fn find_allowed_alternative(&self, country: &str) -> Option {\n let alt_track = self\n .alternative\n .iter()\n .find(|alt_track| !alt_track.is_restricted_in_region(country))?;\n ItemId::from_raw(alt_track.gid.as_ref()?, ItemIdType::Track)\n }\n\n fn to_media_path(&self, preferred_bitrate: usize) -> Option {\n let file = select_preferred_file(&self.file, preferred_bitrate)?;\n Some(MediaPath {\n item_id: ItemId::from_raw(self.gid.as_ref()?, ItemIdType::Track)?,\n file_id: FileId::from_raw(file.file_id.as_ref()?)?,\n file_format: AudioFormat::from_protocol(file.format()),\n duration: Duration::from_millis(self.duration? as u64),\n })\n }\n}\n\nimpl ToMediaPath for Episode {\n fn is_restricted_in_region(&self, country: &str) -> bool {\n self.restriction\n .iter()\n .any(|rest| is_restricted_in_region(rest, country))\n }\n\n fn find_allowed_alternative(&self, _country: &str) -> Option {\n None\n }\n\n fn to_media_path(&self, preferred_bitrate: usize) -> Option {\n let file = select_preferred_file(&self.audio, preferred_bitrate)?;\n Some(MediaPath {\n item_id: ItemId::from_raw(self.gid.as_ref()?, ItemIdType::Podcast)?,\n file_id: FileId::from_raw(file.file_id.as_ref()?)?,\n file_format: AudioFormat::from_protocol(file.format()),\n duration: Duration::from_millis(self.duration? as u64),\n })\n }\n}\n\nfn select_preferred_file(files: &[AudioFile], preferred_bitrate: usize) -> Option<&AudioFile> {\n MediaFile::supported_audio_formats_for_bitrate(preferred_bitrate)\n .iter()\n .find_map(|&preferred_format| {\n files\n .iter()\n .find(|file| file.format == Some(preferred_format.into()))\n })\n}\n\nfn is_restricted_in_region(restriction: &Restriction, country: &str) -> bool {\n if let Some(list) = &restriction.country_restriction {\n return match list {\n Country_restriction::CountriesAllowed(allowed) => {\n !is_country_in_list(allowed.as_bytes(), country.as_bytes())\n }\n Country_restriction::CountriesForbidden(forbidden) => {\n is_country_in_list(forbidden.as_bytes(), country.as_bytes())\n }\n _ => false,\n };\n }\n false\n}\n\nfn is_country_in_list(countries: &[u8], country: &[u8]) -> bool {\n countries.chunks(2).any(|code| code == country)\n}\n" }, { "path": "psst-core/src/oauth.rs", "content": "use crate::error::Error;\nuse oauth2::{\n basic::BasicClient, reqwest::http_client, AuthUrl, AuthorizationCode, ClientId, CsrfToken,\n PkceCodeChallenge, PkceCodeVerifier, RedirectUrl, Scope, TokenResponse, TokenUrl,\n};\nuse std::{\n io::{BufRead, BufReader, Write},\n net::TcpStream,\n net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener},\n sync::mpsc,\n time::Duration,\n};\nuse url::Url;\n\npub fn listen_for_callback_parameter(\n socket_address: SocketAddr,\n timeout: Duration,\n parameter_name: &'static str,\n) -> Result {\n log::info!(\n \"starting callback listener for '{parameter_name}' on {socket_address:?}\",\n );\n\n // Create a simpler, linear flow\n // 1. Bind the listener\n let listener = match TcpListener::bind(socket_address) {\n Ok(l) => {\n log::info!(\"listener bound successfully\");\n l\n }\n Err(e) => {\n log::error!(\"Failed to bind listener: {e}\");\n return Err(Error::IoError(e));\n }\n };\n\n // 2. Set up the channel for communication\n let (tx, rx) = mpsc::channel::>();\n\n // 3. Spawn the thread\n let handle = std::thread::spawn(move || {\n if let Ok((mut stream, _)) = listener.accept() {\n handle_callback_connection(&mut stream, &tx, parameter_name);\n } else {\n log::error!(\"Failed to accept connection on callback listener\");\n let _ = tx.send(Err(Error::IoError(std::io::Error::other(\n \"Failed to accept connection\",\n ))));\n }\n });\n\n // 4. Wait for the result with timeout\n let result = match rx.recv_timeout(timeout) {\n Ok(r) => r,\n Err(e) => {\n log::error!(\"Timed out or channel error: {e}\");\n return Err(Error::from(e));\n }\n };\n\n // 5. Wait for thread completion\n if handle.join().is_err() {\n log::warn!(\"thread join failed, but continuing with result\");\n }\n\n // 6. Return the result\n result\n}\n\n/// Handles an incoming TCP connection for a generic OAuth callback.\nfn handle_callback_connection(\n stream: &mut TcpStream,\n tx: &mpsc::Sender>,\n parameter_name: &'static str,\n) {\n let mut reader = BufReader::new(&mut *stream);\n let mut request_line = String::new();\n\n if reader.read_line(&mut request_line).is_ok() {\n match extract_parameter_from_request(&request_line, parameter_name) {\n Some(value) => {\n log::info!(\"received callback parameter '{parameter_name}'.\");\n send_success_response(stream);\n let _ = tx.send(Ok(value));\n }\n None => {\n let err_msg = format!(\n \"Failed to extract parameter '{parameter_name}' from request: {request_line}\",\n );\n log::error!(\"{err_msg}\");\n let _ = tx.send(Err(Error::OAuthError(err_msg)));\n }\n }\n } else {\n log::error!(\"Failed to read request line from callback.\");\n let _ = tx.send(Err(Error::IoError(std::io::Error::other(\n \"Failed to read request line\",\n ))));\n }\n}\n\n/// Extracts a specified query parameter from an HTTP request line.\nfn extract_parameter_from_request(request_line: &str, parameter_name: &str) -> Option {\n request_line\n .split_whitespace()\n .nth(1)\n .and_then(|path| Url::parse(&format!(\"http://localhost{path}\")).ok())\n .and_then(|url| {\n url.query_pairs()\n .find(|(key, _)| key == parameter_name)\n .map(|(_, value)| value.into_owned())\n })\n}\n\npub fn get_authcode_listener(\n socket_address: SocketAddr,\n timeout: Duration,\n) -> Result {\n listen_for_callback_parameter(socket_address, timeout, \"code\").map(AuthorizationCode::new)\n}\n\npub fn send_success_response(stream: &mut TcpStream) {\n let response = \"HTTP/1.1 200 OK\\r\\n\\r\\n\\\n \\\n \\\n \\\n \\\n \\\n
Successfully authenticated! You can close this window now.
\\\n \\\n \";\n let _ = stream.write_all(response.as_bytes());\n}\n\nfn create_spotify_oauth_client(redirect_port: u16) -> BasicClient {\n let redirect_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), redirect_port);\n let redirect_uri = format!(\"http://{redirect_address}/login\");\n\n BasicClient::new(\n ClientId::new(crate::session::access_token::CLIENT_ID.to_string()),\n None,\n AuthUrl::new(\"https://accounts.spotify.com/authorize\".to_string()).unwrap(),\n Some(TokenUrl::new(\"https://accounts.spotify.com/api/token\".to_string()).unwrap()),\n )\n .set_redirect_uri(RedirectUrl::new(redirect_uri).expect(\"Invalid redirect URL\"))\n}\n\npub fn generate_auth_url(redirect_port: u16) -> (String, PkceCodeVerifier) {\n let client = create_spotify_oauth_client(redirect_port);\n let (pkce_challenge, pkce_verifier) = PkceCodeChallenge::new_random_sha256();\n\n let (auth_url, _) = client\n .authorize_url(CsrfToken::new_random)\n .add_scopes(get_scopes())\n .set_pkce_challenge(pkce_challenge)\n .url();\n\n (auth_url.to_string(), pkce_verifier)\n}\n\npub fn exchange_code_for_token(\n redirect_port: u16,\n code: AuthorizationCode,\n pkce_verifier: PkceCodeVerifier,\n) -> String {\n let client = create_spotify_oauth_client(redirect_port);\n\n let token_response = client\n .exchange_code(code)\n .set_pkce_verifier(pkce_verifier)\n .request(http_client)\n .expect(\"Failed to exchange code for token\");\n\n token_response.access_token().secret().to_string()\n}\n\nfn get_scopes() -> Vec {\n crate::session::access_token::ACCESS_SCOPES\n .split(',')\n .map(|s| Scope::new(s.trim().to_string()))\n .collect()\n}\n" }, { "path": "psst-core/src/player/file.rs", "content": "use std::{\n fs, io,\n io::{Seek, SeekFrom},\n path::PathBuf,\n sync::Arc,\n thread,\n thread::JoinHandle,\n time::Duration,\n};\n\nuse symphonia::core::codecs::CodecType;\n\nuse crate::{\n audio::{\n decode::{AudioCodecFormat, AudioDecoder},\n decrypt::{AudioDecrypt, AudioKey},\n normalize::NormalizationData,\n },\n cache::CacheHandle,\n cdn::{CdnHandle, CdnUrl},\n error::Error,\n item_id::{FileId, ItemId},\n util::OffsetFile,\n};\n\nuse librespot_protocol::metadata::audio_file::Format;\n\nuse super::storage::{StreamRequest, StreamStorage, StreamWriter};\n\n#[derive(Debug, Clone, Copy)]\npub struct MediaPath {\n pub item_id: ItemId,\n pub file_id: FileId,\n pub file_format: AudioFormat,\n pub duration: Duration,\n}\n\n// possibly should be combined with AudioCodecFormat?\n#[derive(Debug, Clone, Copy)]\npub enum AudioFormat {\n Mp3,\n OggVorbis,\n Unsupported,\n}\n\nimpl AudioFormat {\n pub fn from_protocol(format: Format) -> Self {\n use Format::*;\n match format {\n MP3_256 | MP3_320 | MP3_160 | MP3_96 | MP3_160_ENC => Self::Mp3,\n OGG_VORBIS_96 | OGG_VORBIS_160 | OGG_VORBIS_320 => Self::OggVorbis,\n _ => Self::Unsupported,\n }\n }\n\n pub fn from_codec(codec: CodecType) -> Self {\n use symphonia::core::codecs::*;\n if codec == CODEC_TYPE_MP3 {\n Self::Mp3\n } else if codec == CODEC_TYPE_VORBIS {\n Self::OggVorbis\n } else {\n Self::Unsupported\n }\n }\n}\n\npub enum MediaFile {\n Streamed {\n streamed_file: Arc,\n servicing_handle: JoinHandle<()>,\n },\n Cached {\n cached_file: CachedFile,\n },\n Local {\n path: MediaPath,\n },\n}\n\nimpl MediaFile {\n pub fn supported_audio_formats_for_bitrate(bitrate: usize) -> &'static [Format] {\n match bitrate {\n 96 => &[\n Format::OGG_VORBIS_96,\n Format::MP3_96,\n Format::OGG_VORBIS_160,\n Format::MP3_160,\n Format::MP3_160_ENC,\n Format::MP3_256,\n Format::OGG_VORBIS_320,\n Format::MP3_320,\n ],\n 160 => &[\n Format::OGG_VORBIS_160,\n Format::MP3_160,\n Format::MP3_160_ENC,\n Format::MP3_256,\n Format::OGG_VORBIS_320,\n Format::MP3_320,\n Format::OGG_VORBIS_96,\n Format::MP3_96,\n ],\n 320 => &[\n Format::OGG_VORBIS_320,\n Format::MP3_320,\n Format::MP3_256,\n Format::OGG_VORBIS_160,\n Format::MP3_160,\n Format::MP3_160_ENC,\n Format::OGG_VORBIS_96,\n Format::MP3_96,\n ],\n _ => unreachable!(),\n }\n }\n\n pub fn open(path: MediaPath, cdn: CdnHandle, cache: CacheHandle) -> Result {\n let cached_path = cache.audio_file_path(path.file_id);\n if cached_path.exists() {\n let cached_file = CachedFile::open(path, cached_path)?;\n Ok(Self::Cached { cached_file })\n } else {\n let streamed_file = Arc::new(StreamedFile::open(path, cdn, cache)?);\n let servicing_handle = thread::spawn({\n let streamed_file = Arc::clone(&streamed_file);\n move || {\n streamed_file\n .service_streaming()\n .expect(\"Streaming thread failed\");\n }\n });\n Ok(Self::Streamed {\n streamed_file,\n servicing_handle,\n })\n }\n }\n\n pub fn local(path: MediaPath) -> Self {\n Self::Local { path }\n }\n\n pub fn path(&self) -> MediaPath {\n match self {\n Self::Streamed { streamed_file, .. } => streamed_file.path,\n Self::Cached { cached_file, .. } => cached_file.path,\n Self::Local { path } => *path,\n }\n }\n\n pub fn storage(&self) -> Option<&StreamStorage> {\n match self {\n Self::Streamed { streamed_file, .. } => Some(&streamed_file.storage),\n Self::Cached { cached_file, .. } => Some(&cached_file.storage),\n Self::Local { .. } => None,\n }\n }\n\n pub fn remote_audio_source(\n &self,\n key: AudioKey,\n ) -> Result<(AudioDecoder, NormalizationData), Error> {\n let reader = self\n .storage()\n .expect(\"storage always set for remote files\")\n .reader()?;\n let mut decrypted = AudioDecrypt::new(key, reader);\n let normalization = NormalizationData::parse(&mut decrypted)?;\n let encoded = OffsetFile::new(decrypted, self.header_length())?;\n let decoded = AudioDecoder::new(encoded, self.codec_format())?;\n Ok((decoded, normalization))\n }\n\n pub fn local_audio_source(&self) -> Result<(AudioDecoder, NormalizationData), Error> {\n let mut reader = fs::File::open(self.path().item_id.to_local())?;\n let normalization = NormalizationData::parse(&mut reader)?;\n let encoded = OffsetFile::new(reader, self.header_length())?;\n let decoded = AudioDecoder::new(encoded, self.codec_format())?;\n Ok((decoded, normalization))\n }\n\n fn header_length(&self) -> u64 {\n match self.path().file_format {\n AudioFormat::OggVorbis => 167,\n _ => 0,\n }\n }\n\n fn codec_format(&self) -> AudioCodecFormat {\n match self.path().file_format {\n AudioFormat::OggVorbis => AudioCodecFormat::OggVorbis,\n AudioFormat::Mp3 => AudioCodecFormat::Mp3,\n AudioFormat::Unsupported => unreachable!(\"unsupported codec\"),\n }\n }\n}\n\npub struct StreamedFile {\n path: MediaPath,\n storage: StreamStorage,\n url: CdnUrl,\n cdn: CdnHandle,\n cache: CacheHandle,\n}\n\nimpl StreamedFile {\n fn open(path: MediaPath, cdn: CdnHandle, cache: CacheHandle) -> Result {\n // First, we need to resolve URL of the file contents.\n let url = cdn.resolve_audio_file_url(path.file_id)?;\n log::debug!(\"resolved file URL: {:?}\", url.url);\n\n // How many bytes we request in the first chunk.\n const INITIAL_REQUEST_LENGTH: u64 = 1024 * 6;\n\n // Send the initial request, that gives us the total file length and the\n // beginning of the contents. Use the total length for creating the backing\n // data storage.\n let (total_length, mut initial_data) =\n cdn.fetch_file_range(&url.url, 0, INITIAL_REQUEST_LENGTH)?;\n let storage = StreamStorage::new(total_length)?;\n\n // Pipe the initial data from the request body into storage.\n io::copy(&mut initial_data, &mut storage.writer()?)?;\n\n Ok(StreamedFile {\n path,\n storage,\n url,\n cdn,\n cache,\n })\n }\n\n fn service_streaming(&self) -> Result<(), Error> {\n let mut last_url = self.url.clone();\n let mut fresh_url = || -> Result {\n if last_url.is_expired() {\n last_url = self.cdn.resolve_audio_file_url(self.path.file_id)?;\n }\n Ok(last_url.clone())\n };\n let mut download_range = |offset, length| -> Result<(), Error> {\n let thread_name = format!(\n \"cdn-{}-{}..{}\",\n self.path.file_id.to_base16(),\n offset,\n offset + length\n );\n // TODO: We spawn threads here without any accounting. Seems wrong.\n thread::Builder::new().name(thread_name).spawn({\n let url = fresh_url()?.url;\n let cdn = self.cdn.clone();\n let cache = self.cache.clone();\n let mut writer = self.storage.writer()?;\n let file_path = self.storage.path().to_path_buf();\n let file_id = self.path.file_id;\n move || {\n match load_range(&mut writer, &cdn, &url, offset, length) {\n Ok(_) => {\n // If the file is completely downloaded, copy it to cache.\n if writer.is_complete() && !cache.audio_file_path(file_id).exists() {\n // TODO: We should do this atomically.\n if let Err(err) = cache.save_audio_file(file_id, file_path) {\n log::warn!(\"failed to save audio file to cache: {err:?}\");\n }\n }\n }\n Err(err) => {\n log::error!(\"failed to download: {err}\");\n // Range failed to download, remove it from the requested set.\n writer.mark_as_not_requested(offset, length);\n }\n }\n }\n })?;\n\n Ok(())\n };\n\n while let Ok(req) = self.storage.receiver().recv() {\n match req {\n StreamRequest::Preload { offset, length } => {\n if let Err(err) = download_range(offset, length) {\n log::error!(\"failed to request audio range: {err:?}\");\n }\n }\n StreamRequest::Blocked { offset } => {\n log::info!(\"blocked at {offset}\");\n }\n }\n }\n Ok(())\n }\n}\n\npub struct CachedFile {\n path: MediaPath,\n storage: StreamStorage,\n}\n\nimpl CachedFile {\n fn open(path: MediaPath, file_path: PathBuf) -> Result {\n Ok(Self {\n path,\n storage: StreamStorage::from_complete_file(file_path)?,\n })\n }\n}\n\nfn load_range(\n writer: &mut StreamWriter,\n cdn: &CdnHandle,\n url: &str,\n offset: u64,\n length: u64,\n) -> Result<(), Error> {\n log::trace!(\"downloading {}..{}\", offset, offset + length);\n\n // Download range of data from the CDN. Block until we a have reader of the\n // request body.\n let (_total_length, mut reader) = cdn.fetch_file_range(url, offset, length)?;\n\n // Pipe it into storage. Blocks until fully written, but readers sleeping on\n // this file should be notified as soon as their offset is covered.\n writer.seek(SeekFrom::Start(offset))?;\n io::copy(&mut reader, writer)?;\n\n Ok(())\n}\n" }, { "path": "psst-core/src/player/item.rs", "content": "use std::time::Duration;\n\nuse crate::{\n audio::{\n decode::AudioDecoder, decrypt::AudioKey, normalize::NormalizationLevel, probe::TrackProbe,\n },\n cache::CacheHandle,\n cdn::CdnHandle,\n error::Error,\n item_id::{ItemId, ItemIdType, LocalItemRegistry},\n metadata::{Fetch, ToMediaPath},\n session::SessionService,\n};\n\nuse librespot_protocol::metadata::{Episode, Track};\n\nuse super::{\n file::{AudioFormat, MediaFile, MediaPath},\n PlaybackConfig,\n};\n\npub struct LoadedPlaybackItem {\n pub file: MediaFile,\n pub source: AudioDecoder,\n pub norm_factor: f32,\n}\n\n#[derive(Debug, Clone, Copy, Eq, PartialEq)]\npub struct PlaybackItem {\n pub item_id: ItemId,\n pub norm_level: NormalizationLevel,\n}\n\nimpl PlaybackItem {\n pub fn load(\n &self,\n session: &SessionService,\n cdn: CdnHandle,\n cache: CacheHandle,\n config: &PlaybackConfig,\n ) -> Result {\n let path = load_media_path(self.item_id, session, &cache, config)?;\n let (file, source, norm_data) = match self.item_id.id_type {\n ItemIdType::LocalFile => {\n let file = MediaFile::local(path);\n let (source, norm_data) = file.local_audio_source()?;\n (file, source, norm_data)\n }\n _ => {\n let key = load_audio_key(&path, session, &cache)?;\n let file = MediaFile::open(path, cdn, cache)?;\n let (source, norm_data) = file.remote_audio_source(key)?;\n (file, source, norm_data)\n }\n };\n let norm_factor = norm_data.factor_for_level(self.norm_level, config.pregain);\n Ok(LoadedPlaybackItem {\n file,\n source,\n norm_factor,\n })\n }\n}\n\nfn load_media_path(\n item_id: ItemId,\n session: &SessionService,\n cache: &CacheHandle,\n config: &PlaybackConfig,\n) -> Result {\n match item_id.id_type {\n ItemIdType::Track => {\n load_media_path_from_track_or_alternative(item_id, session, cache, config)\n }\n ItemIdType::Podcast => load_media_path_from_episode(item_id, session, cache, config),\n ItemIdType::LocalFile => load_media_path_from_local(item_id),\n ItemIdType::Unknown => unimplemented!(),\n }\n}\n\nfn load_media_path_from_track_or_alternative(\n item_id: ItemId,\n session: &SessionService,\n cache: &CacheHandle,\n config: &PlaybackConfig,\n) -> Result {\n let track = load_track(item_id, session, cache)?;\n let country = get_country_code(session, cache);\n let path = match country {\n Some(user_country) if track.is_restricted_in_region(&user_country) => {\n // The track is regionally restricted and is unavailable. Let's try to find an\n // alternative track.\n let alt_id = track\n .find_allowed_alternative(&user_country)\n .ok_or(Error::MediaFileNotFound)?;\n let alt_track = load_track(alt_id, session, cache)?;\n let alt_path = alt_track\n .to_media_path(config.bitrate)\n .ok_or(Error::MediaFileNotFound)?;\n // We've found an alternative track with a fitting audio file. Let's cheat a\n // little and pretend we've obtained it from the requested track.\n // TODO: We should be honest and display the real track information.\n MediaPath {\n item_id,\n ..alt_path\n }\n }\n _ => {\n // Either we do not have a country code loaded or the track is available, return\n // it.\n track\n .to_media_path(config.bitrate)\n .ok_or(Error::MediaFileNotFound)?\n }\n };\n Ok(path)\n}\n\nfn load_media_path_from_episode(\n item_id: ItemId,\n session: &SessionService,\n cache: &CacheHandle,\n config: &PlaybackConfig,\n) -> Result {\n let episode = load_episode(item_id, session, cache)?;\n let country = get_country_code(session, cache);\n let path = match country {\n Some(user_country) if episode.is_restricted_in_region(&user_country) => {\n // Episode is restricted, and doesn't have any alternatives.\n return Err(Error::MediaFileNotFound);\n }\n _ => episode\n .to_media_path(config.bitrate)\n .ok_or(Error::MediaFileNotFound)?,\n };\n Ok(path)\n}\n\nfn load_media_path_from_local(item_id: ItemId) -> Result {\n let path = LocalItemRegistry::get(item_id.id).expect(\"valid local item ID\");\n let probe = TrackProbe::new(&path)?;\n Ok(MediaPath {\n item_id,\n file_id: Default::default(),\n file_format: AudioFormat::from_codec(probe.codec),\n // It's possible (though unlikely) that we're unable to determine the track\n // duration from the codec params; in that case, default to 0 and let it\n // be calculated at runtime as we play the track.\n duration: probe.duration.unwrap_or(Duration::from_millis(0)),\n })\n}\n\nfn get_country_code(session: &SessionService, cache: &CacheHandle) -> Option {\n if let Some(cached_country_code) = cache.get_country_code() {\n Some(cached_country_code)\n } else {\n let country_code = session.connected().ok()?.get_country_code()?;\n if let Err(err) = cache.save_country_code(&country_code) {\n log::warn!(\"failed to save country code to cache: {err:?}\");\n }\n Some(country_code)\n }\n}\n\nfn load_track(\n item_id: ItemId,\n session: &SessionService,\n cache: &CacheHandle,\n) -> Result {\n if let Some(cached_track) = cache.get_track(item_id) {\n Ok(cached_track)\n } else {\n let track = Track::fetch(session, item_id)?;\n if let Err(err) = cache.save_track(item_id, &track) {\n log::warn!(\"failed to save track to cache: {err:?}\");\n }\n Ok(track)\n }\n}\n\nfn load_episode(\n item_id: ItemId,\n session: &SessionService,\n cache: &CacheHandle,\n) -> Result {\n if let Some(cached_episode) = cache.get_episode(item_id) {\n Ok(cached_episode)\n } else {\n let episode = Episode::fetch(session, item_id)?;\n if let Err(err) = cache.save_episode(item_id, &episode) {\n log::warn!(\"failed to save episode to cache: {err:?}\");\n }\n Ok(episode)\n }\n}\n\nfn load_audio_key(\n path: &MediaPath,\n session: &SessionService,\n cache: &CacheHandle,\n) -> Result {\n if let Some(cached_key) = cache.get_audio_key(path.item_id, path.file_id) {\n Ok(cached_key)\n } else {\n let key = session\n .connected()?\n .get_audio_key(path.item_id, path.file_id)?;\n if let Err(err) = cache.save_audio_key(path.item_id, path.file_id, &key) {\n log::warn!(\"failed to save audio key to cache: {err:?}\");\n }\n Ok(key)\n }\n}\n" }, { "path": "psst-core/src/player/mod.rs", "content": "pub mod file;\npub mod item;\npub mod queue;\nmod storage;\nmod worker;\n\nuse std::{mem, thread, thread::JoinHandle, time::Duration};\n\nuse crossbeam_channel::{unbounded, Receiver, Sender};\n\nuse crate::{\n audio::output::{AudioOutput, AudioSink, DefaultAudioOutput, DefaultAudioSink},\n cache::CacheHandle,\n cdn::CdnHandle,\n error::Error,\n session::SessionService,\n};\n\nuse self::{\n file::MediaPath,\n item::{LoadedPlaybackItem, PlaybackItem},\n queue::{Queue, QueueBehavior},\n worker::PlaybackManager,\n};\n\nconst PREVIOUS_TRACK_THRESHOLD: Duration = Duration::from_secs(3);\nconst STOP_AFTER_CONSECUTIVE_LOADING_FAILURES: usize = 3;\n\n#[derive(Clone)]\npub struct PlaybackConfig {\n pub bitrate: usize,\n pub pregain: f32,\n}\n\nimpl Default for PlaybackConfig {\n fn default() -> Self {\n Self {\n bitrate: 320,\n pregain: 3.0,\n }\n }\n}\n\npub struct Player {\n state: PlayerState,\n preload: PreloadState,\n session: SessionService,\n cdn: CdnHandle,\n cache: CacheHandle,\n config: PlaybackConfig,\n queue: Queue,\n sender: Sender,\n receiver: Receiver,\n audio_output_sink: DefaultAudioSink,\n playback_mgr: PlaybackManager,\n consecutive_loading_failures: usize,\n}\n\nimpl Player {\n pub fn new(\n session: SessionService,\n cdn: CdnHandle,\n cache: CacheHandle,\n config: PlaybackConfig,\n audio_output: &DefaultAudioOutput,\n ) -> Self {\n let (sender, receiver) = unbounded();\n Self {\n playback_mgr: PlaybackManager::new(audio_output.sink(), sender.clone()),\n session,\n cdn,\n cache,\n config,\n sender,\n receiver,\n audio_output_sink: audio_output.sink(),\n state: PlayerState::Stopped,\n preload: PreloadState::None,\n queue: Queue::new(),\n consecutive_loading_failures: 0,\n }\n }\n\n pub fn sender(&self) -> Sender {\n self.sender.clone()\n }\n\n pub fn receiver(&self) -> Receiver {\n self.receiver.clone()\n }\n\n pub fn handle(&mut self, event: PlayerEvent) {\n match event {\n PlayerEvent::Command(cmd) => self.handle_command(cmd),\n PlayerEvent::Loaded { item, result } => self.handle_loaded(item, result),\n PlayerEvent::Preloaded { item, result } => self.handle_preloaded(item, result),\n PlayerEvent::Position { position, path } => self.handle_position(position, path),\n PlayerEvent::EndOfTrack => self.handle_end_of_track(),\n PlayerEvent::Loading { .. }\n | PlayerEvent::Playing { .. }\n | PlayerEvent::Pausing { .. }\n | PlayerEvent::Resuming { .. }\n | PlayerEvent::Stopped\n | PlayerEvent::Blocked { .. } => {}\n };\n }\n\n fn handle_command(&mut self, cmd: PlayerCommand) {\n match cmd {\n PlayerCommand::LoadQueue { items, position } => self.load_queue(items, position),\n PlayerCommand::LoadAndPlay { item } => self.load_and_play(item),\n PlayerCommand::Preload { item } => self.preload(item),\n PlayerCommand::Pause => self.pause(),\n PlayerCommand::Resume => self.resume(),\n PlayerCommand::PauseOrResume => self.pause_or_resume(),\n PlayerCommand::Previous => self.previous(),\n PlayerCommand::Next => self.next(),\n PlayerCommand::Stop => self.stop(),\n PlayerCommand::Seek { position } => self.seek(position),\n PlayerCommand::Configure { config } => self.configure(config),\n PlayerCommand::SetQueueBehavior { behavior } => self.queue.set_behaviour(behavior),\n PlayerCommand::AddToQueue { item } => self.queue.add(item),\n PlayerCommand::SetVolume { volume } => self.set_volume(volume),\n }\n }\n\n fn handle_loaded(&mut self, item: PlaybackItem, result: Result) {\n match self.state {\n PlayerState::Loading {\n item: requested_item,\n ..\n } if item == requested_item => match result {\n Ok(loaded_item) => {\n self.consecutive_loading_failures = 0;\n self.play_loaded(loaded_item);\n }\n Err(err) => {\n self.consecutive_loading_failures += 1;\n if self.consecutive_loading_failures < STOP_AFTER_CONSECUTIVE_LOADING_FAILURES {\n log::error!(\"skipping, error while loading: {err}\");\n self.next();\n } else {\n log::error!(\"stopping, error while loading: {err}\");\n self.stop();\n }\n }\n },\n _ => {\n log::info!(\"stale load result received, ignoring\");\n }\n }\n }\n\n fn handle_preloaded(&mut self, item: PlaybackItem, result: Result) {\n match self.preload {\n PreloadState::Preloading {\n item: requested_item,\n ..\n } if item == requested_item => match result {\n Ok(loaded_item) => {\n log::info!(\"preloaded audio file\");\n self.preload = PreloadState::Preloaded { item, loaded_item };\n }\n Err(err) => {\n log::error!(\"failed to preload audio file, error while opening: {err}\");\n self.preload = PreloadState::None;\n }\n },\n _ => {\n log::info!(\"stale preload result received, ignoring\");\n\n // We are not preloading this item, but because we sometimes extract the\n // preloading thread and use it for loading, let's check if the item is not\n // being loaded now.\n self.handle_loaded(item, result);\n }\n }\n }\n\n fn handle_position(&mut self, new_position: Duration, path: MediaPath) {\n match &mut self.state {\n PlayerState::Playing { position, .. } | PlayerState::Paused { position, .. } => {\n *position = new_position;\n }\n _ => {\n log::warn!(\"received unexpected position report\");\n }\n }\n const PRELOAD_BEFORE_END_OF_TRACK: Duration = Duration::from_secs(30);\n let time_until_end_of_track = path.duration.checked_sub(new_position).unwrap_or_default();\n if time_until_end_of_track <= PRELOAD_BEFORE_END_OF_TRACK {\n if let Some(&item_to_preload) = self.queue.get_following() {\n self.preload(item_to_preload);\n }\n }\n }\n\n fn handle_end_of_track(&mut self) {\n self.queue.skip_to_following();\n if let Some(&item) = self.queue.get_current() {\n self.load_and_play(item);\n } else {\n self.stop();\n }\n }\n\n fn load_queue(&mut self, items: Vec, position: usize) {\n self.queue.fill(items, position);\n if let Some(&item) = self.queue.get_current() {\n self.load_and_play(item);\n } else {\n self.stop();\n }\n }\n\n fn load_and_play(&mut self, item: PlaybackItem) {\n // Make sure to stop the sink, so any current audio source is cleared and the\n // playback stopped.\n self.audio_output_sink.stop();\n\n // Check if the item is already in the preloader state.\n let loading_handle = match mem::replace(&mut self.preload, PreloadState::None) {\n PreloadState::Preloaded {\n item: preloaded_item,\n loaded_item,\n } if preloaded_item == item => {\n // This item is already loaded in the preloader state.\n self.play_loaded(loaded_item);\n return;\n }\n\n PreloadState::Preloading {\n item: preloaded_item,\n loading_handle,\n } if preloaded_item == item => {\n // This item is being preloaded. Take it out of the preloader state.\n loading_handle\n }\n\n preloading_other_file_or_none => {\n self.preload = preloading_other_file_or_none;\n // Item is not preloaded yet, load it in a background thread.\n thread::spawn({\n let sender = self.sender.clone();\n let session = self.session.clone();\n let cdn = self.cdn.clone();\n let cache = self.cache.clone();\n let config = self.config.clone();\n move || {\n let result = item.load(&session, cdn, cache, &config);\n sender.send(PlayerEvent::Loaded { item, result }).unwrap();\n }\n })\n }\n };\n\n self.sender.send(PlayerEvent::Loading { item }).unwrap();\n self.state = PlayerState::Loading {\n item,\n _loading_handle: loading_handle,\n };\n }\n\n fn preload(&mut self, item: PlaybackItem) {\n if self.is_in_preload(item) {\n return;\n }\n let loading_handle = thread::spawn({\n let sender = self.sender.clone();\n let session = self.session.clone();\n let cdn = self.cdn.clone();\n let cache = self.cache.clone();\n let config = self.config.clone();\n move || {\n let result = item.load(&session, cdn, cache, &config);\n sender\n .send(PlayerEvent::Preloaded { item, result })\n .unwrap();\n }\n });\n self.preload = PreloadState::Preloading {\n item,\n loading_handle,\n };\n }\n\n fn set_volume(&mut self, volume: f64) {\n self.audio_output_sink.set_volume(volume as f32);\n }\n\n fn play_loaded(&mut self, loaded_item: LoadedPlaybackItem) {\n log::info!(\"starting playback\");\n let path = loaded_item.file.path();\n let position = Duration::default();\n self.playback_mgr.play(loaded_item);\n self.state = PlayerState::Playing { path, position };\n self.sender\n .send(PlayerEvent::Playing { path, position })\n .unwrap();\n }\n\n fn pause(&mut self) {\n match mem::replace(&mut self.state, PlayerState::Invalid) {\n PlayerState::Playing { path, position } | PlayerState::Paused { path, position } => {\n log::info!(\"pausing playback\");\n self.audio_output_sink.pause();\n self.sender\n .send(PlayerEvent::Pausing { path, position })\n .unwrap();\n self.state = PlayerState::Paused { path, position };\n }\n _ => {\n log::warn!(\"invalid state transition\");\n }\n }\n }\n\n fn resume(&mut self) {\n match mem::replace(&mut self.state, PlayerState::Invalid) {\n PlayerState::Playing { path, position } | PlayerState::Paused { path, position } => {\n log::info!(\"resuming playback\");\n self.audio_output_sink.resume();\n self.sender\n .send(PlayerEvent::Resuming { path, position })\n .unwrap();\n self.state = PlayerState::Playing { path, position };\n }\n _ => {\n log::warn!(\"invalid state transition\");\n }\n }\n }\n\n fn pause_or_resume(&mut self) {\n match &self.state {\n PlayerState::Playing { .. } => self.pause(),\n PlayerState::Paused { .. } => self.resume(),\n _ => {\n // Do nothing.\n }\n }\n }\n\n fn previous(&mut self) {\n if self.is_near_playback_start() {\n self.queue.skip_to_previous();\n if let Some(&item) = self.queue.get_current() {\n self.load_and_play(item);\n } else {\n self.stop();\n }\n } else {\n self.seek(Duration::default());\n }\n }\n\n fn next(&mut self) {\n self.queue.skip_to_next();\n if let Some(&item) = self.queue.get_current() {\n self.load_and_play(item);\n } else {\n self.stop();\n }\n }\n\n fn stop(&mut self) {\n self.sender.send(PlayerEvent::Stopped).unwrap();\n self.audio_output_sink.stop();\n self.state = PlayerState::Stopped;\n self.queue.clear();\n self.consecutive_loading_failures = 0;\n }\n\n fn seek(&mut self, position: Duration) {\n self.playback_mgr.seek(position);\n }\n\n fn configure(&mut self, config: PlaybackConfig) {\n self.config = config;\n }\n\n fn is_near_playback_start(&self) -> bool {\n match self.state {\n PlayerState::Playing { position, .. } | PlayerState::Paused { position, .. } => {\n position < PREVIOUS_TRACK_THRESHOLD\n }\n _ => false,\n }\n }\n\n fn is_in_preload(&self, item: PlaybackItem) -> bool {\n match self.preload {\n PreloadState::Preloading { item: p_item, .. }\n | PreloadState::Preloaded { item: p_item, .. } => p_item == item,\n _ => false,\n }\n }\n}\n\npub enum PlayerCommand {\n LoadQueue {\n items: Vec,\n position: usize,\n },\n LoadAndPlay {\n item: PlaybackItem,\n },\n Preload {\n item: PlaybackItem,\n },\n Pause,\n Resume,\n PauseOrResume,\n Previous,\n Next,\n Stop,\n Seek {\n position: Duration,\n },\n Configure {\n config: PlaybackConfig,\n },\n SetQueueBehavior {\n behavior: QueueBehavior,\n },\n AddToQueue {\n item: PlaybackItem,\n },\n /// Change playback volume to a value in 0.0..=1.0 range.\n SetVolume {\n volume: f64,\n },\n}\n\npub enum PlayerEvent {\n Command(PlayerCommand),\n /// Track has started loading. `Loaded` follows.\n Loading {\n item: PlaybackItem,\n },\n /// Track loading either succeeded or failed. `Playing` follows in case of\n /// success.\n Loaded {\n item: PlaybackItem,\n result: Result,\n },\n /// Next item in queue has been either successfully preloaded or failed to\n /// preload.\n Preloaded {\n item: PlaybackItem,\n result: Result,\n },\n /// Player has started playing new track. `Position` events will follow.\n Playing {\n path: MediaPath,\n position: Duration,\n },\n /// Player is in a paused state. `Resuming` might follow.\n Pausing {\n path: MediaPath,\n position: Duration,\n },\n /// Player is resuming playback of a track. `Position` events will follow.\n Resuming {\n path: MediaPath,\n position: Duration,\n },\n /// Position of the playback head has changed.\n Position {\n path: MediaPath,\n position: Duration,\n },\n /// Player would like to continue playing, but is blocked, waiting for I/O.\n Blocked {\n path: MediaPath,\n position: Duration,\n },\n /// Player has finished playing a track. `Loading` or `Playing` might\n /// follow if the queue is not empty, `Stopped` will follow if it is.\n EndOfTrack,\n /// The queue is empty.\n Stopped,\n}\n\nenum PlayerState {\n Loading {\n item: PlaybackItem,\n _loading_handle: JoinHandle<()>,\n },\n Playing {\n path: MediaPath,\n position: Duration,\n },\n Paused {\n path: MediaPath,\n position: Duration,\n },\n Stopped,\n Invalid,\n}\n\nenum PreloadState {\n Preloading {\n item: PlaybackItem,\n loading_handle: JoinHandle<()>,\n },\n Preloaded {\n item: PlaybackItem,\n loaded_item: LoadedPlaybackItem,\n },\n None,\n}\n" }, { "path": "psst-core/src/player/queue.rs", "content": "use rand::prelude::SliceRandom;\n\nuse super::PlaybackItem;\n\n#[derive(Default, Debug)]\npub enum QueueBehavior {\n #[default]\n Sequential,\n Random,\n LoopTrack,\n LoopAll,\n}\n\npub struct Queue {\n items: Vec,\n user_items: Vec,\n position: usize,\n user_items_position: usize,\n positions: Vec,\n behavior: QueueBehavior,\n}\n\nimpl Queue {\n pub fn new() -> Self {\n Self {\n items: Vec::new(),\n user_items: Vec::new(),\n position: 0,\n user_items_position: 0,\n positions: Vec::new(),\n behavior: QueueBehavior::default(),\n }\n }\n\n pub fn clear(&mut self) {\n self.items.clear();\n self.positions.clear();\n self.position = 0;\n }\n\n pub fn fill(&mut self, items: Vec, position: usize) {\n self.positions.clear();\n self.items = items;\n self.position = position;\n self.compute_positions();\n }\n\n pub fn add(&mut self, item: PlaybackItem) {\n self.user_items.push(item);\n }\n\n fn handle_added_queue(&mut self) {\n if self.user_items.len() > self.user_items_position {\n self.items.insert(\n self.positions.len(),\n self.user_items[self.user_items_position],\n );\n self.positions\n .insert(self.position + 1, self.positions.len());\n self.user_items_position += 1;\n }\n }\n\n pub fn set_behaviour(&mut self, behavior: QueueBehavior) {\n self.behavior = behavior;\n self.compute_positions();\n }\n\n fn compute_positions(&mut self) {\n // In the case of switching away from shuffle, the position should be set back to\n // where it appears in the actual playlist order.\n let playlist_position = if self.positions.len() > 1 {\n self.positions[self.position]\n } else {\n self.position\n };\n // Start with an ordered 1:1 mapping.\n self.positions = (0..self.items.len()).collect();\n\n if let QueueBehavior::Random = self.behavior {\n // Swap the current position with the first item, so we will start from the\n // beginning, with the full queue ahead of us. Then shuffle the rest of the\n // items and set the position to 0.\n if self.positions.len() > 1 {\n self.positions.swap(0, self.position);\n self.positions[1..].shuffle(&mut rand::rng());\n }\n self.position = 0;\n } else {\n self.position = playlist_position;\n }\n }\n\n pub fn skip_to_previous(&mut self) {\n self.position = self.previous_position();\n }\n\n pub fn skip_to_next(&mut self) {\n self.handle_added_queue();\n self.position = self.next_position();\n }\n\n pub fn skip_to_following(&mut self) {\n self.handle_added_queue();\n self.position = self.following_position();\n }\n\n pub fn get_current(&self) -> Option<&PlaybackItem> {\n let position = self.positions.get(self.position).copied()?;\n self.items.get(position)\n }\n\n pub fn get_following(&self) -> Option<&PlaybackItem> {\n if let Some(position) = self.positions.get(self.position).copied() {\n if let Some(item) = self.items.get(position) {\n return Some(item);\n }\n } else {\n return self.user_items.first();\n }\n None\n }\n\n fn previous_position(&self) -> usize {\n match self.behavior {\n QueueBehavior::Sequential\n | QueueBehavior::Random\n | QueueBehavior::LoopTrack\n | QueueBehavior::LoopAll => self.position.saturating_sub(1),\n }\n }\n\n fn next_position(&self) -> usize {\n match self.behavior {\n QueueBehavior::Sequential | QueueBehavior::Random | QueueBehavior::LoopTrack => {\n self.position + 1\n }\n QueueBehavior::LoopAll => (self.position + 1) % self.items.len(),\n }\n }\n\n fn following_position(&self) -> usize {\n match self.behavior {\n QueueBehavior::Sequential | QueueBehavior::Random => self.position + 1,\n QueueBehavior::LoopTrack => self.position,\n QueueBehavior::LoopAll => (self.position + 1) % self.items.len(),\n }\n }\n}\n" }, { "path": "psst-core/src/player/storage.rs", "content": "use std::{\n fs::File,\n io,\n io::{Read, Seek, SeekFrom, Write},\n ops::Range,\n path::{Path, PathBuf},\n sync::Arc,\n};\n\nuse crossbeam_channel::{unbounded, Receiver, Sender};\nuse parking_lot::{Condvar, Mutex};\nuse rangemap::RangeSet;\nuse tempfile::NamedTempFile;\n\npub enum StreamRequest {\n Preload { offset: u64, length: u64 },\n Blocked { offset: u64 },\n}\n\npub struct StreamStorage {\n file: StreamFile,\n data_map: Arc,\n req_receiver: Receiver,\n req_sender: Sender,\n}\n\npub struct StreamReader {\n reader: File,\n data_map: Arc,\n req_sender: Sender,\n}\n\npub struct StreamWriter {\n writer: File,\n data_map: Arc,\n}\n\nimpl StreamStorage {\n pub fn new(total_size: u64) -> io::Result {\n // Use a temporary file for the backing storage, stretched to the full size, so\n // we can seek freely.\n let tmp_file = NamedTempFile::new()?;\n tmp_file.as_file().set_len(total_size)?;\n\n // Create a channel for requesting downloads of data.\n let (data_req_sender, data_req_receiver) = unbounded();\n\n Ok(StreamStorage {\n file: StreamFile::Temporary(tmp_file),\n req_receiver: data_req_receiver,\n req_sender: data_req_sender,\n data_map: Arc::new(StreamDataMap {\n total_size,\n downloaded: Mutex::new(RangeSet::new()),\n requested: Mutex::new(RangeSet::new()),\n condvar: Condvar::new(),\n }),\n })\n }\n\n pub fn from_complete_file(path: PathBuf) -> io::Result {\n // Query for the total file size.\n let total_size = path.metadata()?.len();\n\n // Create the data channel even though it will not be used, as the file should\n // be complete. We could also turn these into `Option`s.\n let (data_req_sender, data_req_receiver) = unbounded();\n\n // Because the file is complete, let's mark the full range of data as\n // downloaded. We mark it as requested as well, because the downloaded set is\n // always ⊆ the requested set.\n let mut downloaded_set = RangeSet::new();\n downloaded_set.insert(0..total_size);\n let requested_set = downloaded_set.clone();\n\n Ok(StreamStorage {\n file: StreamFile::Persisted(path),\n req_receiver: data_req_receiver,\n req_sender: data_req_sender,\n data_map: Arc::new(StreamDataMap {\n total_size,\n downloaded: Mutex::new(downloaded_set),\n requested: Mutex::new(requested_set),\n condvar: Condvar::new(),\n }),\n })\n }\n\n pub fn reader(&self) -> io::Result {\n Ok(StreamReader {\n reader: self.file.reopen()?, // Re-opened files have a starting seek position.\n data_map: self.data_map.clone(),\n req_sender: self.req_sender.clone(),\n })\n }\n\n pub fn writer(&self) -> io::Result {\n Ok(StreamWriter {\n writer: self.file.reopen()?, // Re-opened files have a starting seek position.\n data_map: self.data_map.clone(),\n })\n }\n\n pub fn receiver(&self) -> &Receiver {\n &self.req_receiver\n }\n\n pub fn path(&self) -> &Path {\n self.file.path()\n }\n}\n\nenum StreamFile {\n Temporary(NamedTempFile),\n Persisted(PathBuf),\n}\n\nimpl StreamFile {\n fn reopen(&self) -> io::Result {\n match self {\n StreamFile::Temporary(tmp_file) => tmp_file.reopen(),\n StreamFile::Persisted(path) => File::open(path),\n }\n }\n\n fn path(&self) -> &Path {\n match self {\n StreamFile::Temporary(tmp_file) => tmp_file.path(),\n StreamFile::Persisted(path) => path,\n }\n }\n}\n\nimpl StreamWriter {\n pub fn is_complete(&self) -> bool {\n self.data_map.is_complete()\n }\n\n pub fn mark_as_not_requested(&self, offset: u64, length: u64) {\n self.data_map.mark_as_not_requested(offset, length);\n }\n}\n\nimpl Write for StreamWriter {\n fn write(&mut self, buf: &[u8]) -> io::Result {\n let position = self.writer.stream_position()?;\n let written = self.writer.write(buf)?;\n self.data_map.mark_as_downloaded(position, written as u64);\n Ok(written)\n }\n\n fn flush(&mut self) -> io::Result<()> {\n self.writer.flush()\n }\n}\n\nimpl Seek for StreamWriter {\n fn seek(&mut self, pos: SeekFrom) -> io::Result {\n self.writer.seek(pos)\n }\n}\n\nconst MINIMUM_READ_LENGTH: u64 = 1024 * 64;\nconst PREFETCH_READ_LENGTH: u64 = 1024 * 256;\n\nimpl Read for StreamReader {\n fn read(&mut self, buf: &mut [u8]) -> io::Result {\n let position = self.reader.stream_position()?;\n let remaining_len = self.data_map.remaining(position);\n if remaining_len == 0 {\n return Ok(0); // We're at the end of the file.\n }\n let needed_len = remaining_len.min(buf.len() as u64);\n\n // Make sure that at least `PREFETCH_READ_LENGTH` bytes in front of the reading\n // head is requested.\n let prefetch_len = needed_len.max(PREFETCH_READ_LENGTH).min(remaining_len);\n for (pos, len) in self.data_map.not_yet_requested(position, prefetch_len) {\n let req_len = len.max(MINIMUM_READ_LENGTH);\n self.data_map.mark_as_requested(pos, req_len);\n self.req_sender\n .send(StreamRequest::Preload {\n offset: pos,\n length: req_len,\n })\n .expect(\"Data request channel was closed\");\n }\n\n // Block and wait until at least a part of the range is available, and read it.\n let ready_to_read_len = self.data_map.wait_for(position, |offset| {\n // Notify the servicing thread we are blocked, so it can possibly prioritize the\n // blocked offset.\n self.req_sender\n .send(StreamRequest::Blocked { offset })\n .expect(\"Data request channel was closed\");\n });\n assert!(ready_to_read_len > 0);\n self.reader\n .read(&mut buf[..ready_to_read_len.min(needed_len) as usize])\n }\n}\n\nimpl Seek for StreamReader {\n fn seek(&mut self, pos: SeekFrom) -> io::Result {\n self.reader.seek(pos)\n }\n}\n\n#[derive(Debug)]\nstruct StreamDataMap {\n total_size: u64,\n // Contains ranges of data requested from the server. Downloaded ranges are not removed from\n // this set.\n requested: Mutex>,\n // Contains ranges of data sure to be present in the backing storage. Always a subset of the\n // requested ranges.\n downloaded: Mutex>,\n condvar: Condvar,\n}\n\nimpl StreamDataMap {\n /// Return the number of bytes from offset until the end of the file.\n fn remaining(&self, offset: u64) -> u64 {\n self.total_size.saturating_sub(offset)\n }\n\n /// Return a vector of sub-ranges of `offset..offset+length` that have not\n /// yet been requested from the backend.\n fn not_yet_requested(&self, offset: u64, length: u64) -> Vec<(u64, u64)> {\n self.requested\n .lock()\n .gaps(&(offset..offset + length))\n .map(|r| range_to_offset_and_length(&r))\n .collect()\n }\n\n /// Mark given range as requested from the backend, so we can avoid\n /// requesting it more than once.\n fn mark_as_requested(&self, offset: u64, length: u64) {\n self.requested.lock().insert(offset..offset + length);\n }\n\n /// Remove range previously marked as requested.\n fn mark_as_not_requested(&self, offset: u64, length: u64) {\n self.requested.lock().remove(offset..offset + length);\n }\n\n /// Mark the range as downloaded and notify the `self.condvar`, so tasks\n /// currently blocked in `self.wait_for` are woken up.\n fn mark_as_downloaded(&self, offset: u64, length: u64) {\n self.downloaded.lock().insert(offset..offset + length);\n self.condvar.notify_all();\n }\n\n /// Block, waiting until at least some data at given offset is downloaded.\n /// Returns length that is available. See `self.mark_as_downloaded`.\n fn wait_for(&self, offset: u64, blocking_callback: impl Fn(u64)) -> u64 {\n let mut downloaded = self.downloaded.lock();\n let mut called_callback = false;\n loop {\n if let Some(range) = downloaded.get(&offset) {\n let (over_ofs, over_len) = range_to_offset_and_length(range);\n let offset_from_overlapping = offset - over_ofs;\n let available_len = over_len - offset_from_overlapping;\n // There is `available_len` bytes of data downloaded, stop waiting.\n break available_len;\n } else {\n // Call the blocking callback, but only the first time we are waiting.\n if !called_callback {\n called_callback = true;\n blocking_callback(offset);\n }\n // There are no overlaps, wait.\n self.condvar.wait(&mut downloaded);\n }\n }\n }\n\n // Returns true if data is completely downloaded.\n fn is_complete(&self) -> bool {\n self.downloaded\n .lock()\n .gaps(&(0..self.total_size))\n .next()\n .is_none()\n }\n}\n\nfn range_to_offset_and_length(range: &Range) -> (u64, u64) {\n (range.start, range.end - range.start)\n}\n" }, { "path": "psst-core/src/player/worker.rs", "content": "use std::{\n ops::Range,\n sync::{\n atomic::{AtomicU64, Ordering},\n Arc,\n },\n time::Duration,\n};\n\nuse crossbeam_channel::Sender;\nuse rb::{Consumer, Producer, RbConsumer, RbProducer, SpscRb, RB};\nuse symphonia::core::{\n audio::{SampleBuffer, SignalSpec},\n units::TimeBase,\n};\n\nuse crate::{\n actor::{Act, Actor, ActorHandle},\n audio::{\n decode::AudioDecoder,\n output::{AudioSink, DefaultAudioSink},\n resample::ResamplingQuality,\n source::{AudioSource, ResampledSource, StereoMappedSource},\n },\n error::Error,\n};\n\nuse super::{\n file::{MediaFile, MediaPath},\n LoadedPlaybackItem, PlayerEvent,\n};\n\npub struct PlaybackManager {\n sink: DefaultAudioSink,\n event_send: Sender,\n current: Option<(MediaPath, Sender)>,\n}\n\nimpl PlaybackManager {\n pub fn new(sink: DefaultAudioSink, event_send: Sender) -> Self {\n Self {\n sink,\n event_send,\n current: None,\n }\n }\n\n pub fn play(&mut self, loaded: LoadedPlaybackItem) {\n let path = loaded.file.path();\n let source = DecoderSource::new(\n loaded.file,\n loaded.source,\n loaded.norm_factor,\n self.event_send.clone(),\n );\n self.current = Some((path, source.actor.sender()));\n if source.sample_rate() == self.sink.sample_rate()\n && source.channel_count() == self.sink.channel_count()\n {\n // We can start playing the source right away.\n self.sink.play(source);\n } else {\n // Some output streams have different sample rate than the source, so we need to\n // resample before pushing to the sink.\n let source = ResampledSource::new(\n source,\n self.sink.sample_rate(),\n ResamplingQuality::SincMediumQuality,\n );\n // Source output streams also have a different channel count. Map the stereo\n // channels and silence the others.\n let source = StereoMappedSource::new(source, self.sink.channel_count());\n self.sink.play(source);\n }\n self.sink.resume();\n }\n\n pub fn seek(&self, position: Duration) {\n if let Some((path, worker)) = &self.current {\n let _ = worker.send(Msg::Seek(position));\n\n // Because the position events are sent in the `DecoderSource`, doing this here\n // is slightly hacky. The alternative would be propagating `event_send` into the\n // worker.\n let _ = self.event_send.send(PlayerEvent::Position {\n path: path.to_owned(),\n position,\n });\n }\n }\n}\n\npub struct DecoderSource {\n file: MediaFile,\n actor: ActorHandle,\n consumer: Consumer,\n event_send: Sender,\n total_samples: Arc,\n position: Arc,\n precision: u64,\n reported: u64,\n end_of_track: bool,\n norm_factor: f32,\n signal_spec: SignalSpec,\n time_base: TimeBase,\n}\n\nimpl DecoderSource {\n pub fn new(\n file: MediaFile,\n decoder: AudioDecoder,\n norm_factor: f32,\n event_send: Sender,\n ) -> Self {\n const REPORT_PRECISION: Duration = Duration::from_millis(900);\n\n // Gather the source signal parameters and compute how often we should report\n // the play-head position.\n let signal_spec = decoder.signal_spec();\n let time_base = decoder.codec_params().time_base.unwrap();\n let precision = (signal_spec.rate as f64\n * signal_spec.channels.count() as f64\n * REPORT_PRECISION.as_secs_f64()) as u64;\n\n // Create a ring-buffer for the decoded samples. Worker thread is producing,\n // we are consuming in the `AudioSource` impl.\n let buffer = Worker::default_buffer();\n let consumer = buffer.consumer();\n\n // We keep track of the current play-head position by sharing an atomic sample\n // counter with the decoding worker. Worker is setting this on seek, we are\n // incrementing on reading from the ring-buffer.\n let position = Arc::new(AtomicU64::new(0));\n\n // Because the `n_frames` count that Symphonia gives us can be a bit unreliable,\n // we track the total number of samples in this stream in this atomic, set when\n // the underlying decoder returns EOF.\n let total_samples = Arc::new(AtomicU64::new(u64::MAX));\n\n // Spawn the worker and kick-start the decoding. The buffer will start filling\n // now.\n let actor = Worker::spawn_with_default_cap(\"audio_decoding\", {\n let position = Arc::clone(&position);\n let total_samples = Arc::clone(&total_samples);\n move |this| Worker::new(this, decoder, buffer, position, total_samples)\n });\n let _ = actor.send(Msg::Read);\n\n Self {\n file,\n actor,\n consumer,\n event_send,\n norm_factor,\n signal_spec,\n time_base,\n total_samples,\n end_of_track: false,\n position,\n precision,\n reported: u64::MAX, // Something sufficiently distinct from any position.\n }\n }\n\n fn written_samples(&self, position: u64) -> u64 {\n self.position.fetch_add(position, Ordering::Relaxed) + position\n }\n\n fn should_report(&self, pos: u64) -> bool {\n self.reported > pos || pos - self.reported >= self.precision\n }\n\n fn samples_to_duration(&self, samples: u64) -> Duration {\n let frames = samples / self.signal_spec.channels.count() as u64;\n let time = self.time_base.calc_time(frames);\n Duration::from_secs(time.seconds) + Duration::from_secs_f64(time.frac)\n }\n}\n\nimpl AudioSource for DecoderSource {\n fn write(&mut self, output: &mut [f32]) -> usize {\n if self.end_of_track {\n return 0;\n }\n let written = self.consumer.read(output).unwrap_or(0);\n\n // Apply the normalization factor.\n output[..written]\n .iter_mut()\n .for_each(|s| *s *= self.norm_factor);\n\n let position = self.written_samples(written as u64);\n if self.should_report(position) {\n // Send a position report, so the upper layers can visualize the playback\n // progress and preload the next track. We cannot block here, so if the channel\n // is full, we just try the next time instead of waiting.\n if self\n .event_send\n .try_send(PlayerEvent::Position {\n path: self.file.path(),\n position: self.samples_to_duration(position),\n })\n .is_ok()\n {\n self.reported = position;\n }\n }\n\n let total_samples = self.total_samples.load(Ordering::Relaxed);\n if position >= total_samples {\n // After reading the total number of samples, we stop. Signal to the upper layer\n // this track is over and short-circuit all further reads from this source.\n if self.event_send.try_send(PlayerEvent::EndOfTrack).is_ok() {\n self.end_of_track = true;\n }\n }\n\n written\n }\n\n fn channel_count(&self) -> usize {\n self.signal_spec.channels.count()\n }\n\n fn sample_rate(&self) -> u32 {\n self.signal_spec.rate\n }\n}\n\nimpl Drop for DecoderSource {\n fn drop(&mut self) {\n let _ = self.actor.send(Msg::Stop);\n }\n}\n\nenum Msg {\n Seek(Duration),\n Read,\n Stop,\n}\n\nstruct Worker {\n /// Sending part of our own actor channel.\n this: Sender,\n /// Decoder we are reading packets/samples from.\n input: AudioDecoder,\n /// Audio properties of the decoded signal.\n input_spec: SignalSpec,\n /// Sample buffer containing samples read in the last packet.\n input_packet: SampleBuffer,\n /// Ring-buffer for the output signal.\n output: SpscRb,\n /// Producing part of the output ring-buffer.\n output_producer: Producer,\n /// Shared atomic position. We update this on seek only.\n position: Arc,\n /// Shared atomic for total number of samples. We set this on EOF.\n total_samples: Arc,\n /// Range of samples in `resampled` that are awaiting flush into `output`.\n samples_to_write: Range,\n /// Number of samples written into the output channel.\n samples_written: u64,\n /// Are we in the middle of automatic read loop?\n is_reading: bool,\n}\n\nimpl Worker {\n fn default_buffer() -> SpscRb {\n const DEFAULT_BUFFER_SIZE: usize = 128 * 1024;\n\n SpscRb::new(DEFAULT_BUFFER_SIZE)\n }\n\n fn new(\n this: Sender,\n input: AudioDecoder,\n output: SpscRb,\n position: Arc,\n total_samples: Arc,\n ) -> Self {\n const DEFAULT_MAX_FRAMES: u64 = 8 * 1024;\n\n let max_input_frames = input\n .codec_params()\n .max_frames_per_packet\n .unwrap_or(DEFAULT_MAX_FRAMES);\n\n // Promote the worker thread to audio priority to prevent buffer under-runs on\n // high CPU usage.\n if let Err(err) =\n audio_thread_priority::promote_current_thread_to_real_time(0, input.signal_spec().rate)\n {\n log::warn!(\"failed to promote thread to audio priority: {err}\");\n }\n\n Self {\n output_producer: output.producer(),\n input_packet: SampleBuffer::new(max_input_frames, input.signal_spec()),\n input_spec: input.signal_spec(),\n input,\n this,\n output,\n position,\n total_samples,\n samples_written: 0,\n samples_to_write: 0..0, // Arbitrary empty range.\n is_reading: false,\n }\n }\n}\n\nimpl Actor for Worker {\n type Message = Msg;\n type Error = Error;\n\n fn handle(&mut self, msg: Msg) -> Result, Self::Error> {\n match msg {\n Msg::Seek(time) => self.on_seek(time),\n Msg::Read => self.on_read(),\n Msg::Stop => Ok(Act::Shutdown),\n }\n }\n}\n\nimpl Worker {\n fn on_seek(&mut self, time: Duration) -> Result, Error> {\n match self.input.seek(time) {\n Ok(timestamp) => {\n if self.is_reading {\n self.samples_to_write = 0..0;\n } else {\n self.this.send(Msg::Read)?;\n }\n let position = timestamp * self.input_spec.channels.count() as u64;\n self.samples_written = position;\n self.position.store(position, Ordering::Relaxed);\n self.output.clear();\n }\n Err(err) => {\n log::error!(\"failed to seek: {err}\");\n }\n }\n Ok(Act::Continue)\n }\n\n fn on_read(&mut self) -> Result, Error> {\n if !self.samples_to_write.is_empty() {\n let writable = &self.input_packet.samples()[self.samples_to_write.clone()];\n if let Ok(written) = self.output_producer.write(writable) {\n self.samples_written += written as u64;\n self.samples_to_write.start += written;\n self.is_reading = true;\n self.this.send(Msg::Read)?;\n Ok(Act::Continue)\n } else {\n // Buffer is full. Wait a bit a try again. We also have to indicate that the\n // read loop is not running at the moment (if we receive a `Seek` while waiting,\n // we need it to explicitly kickstart reading again).\n self.is_reading = false;\n Ok(Act::WaitOr {\n timeout: Duration::from_millis(500),\n timeout_msg: Msg::Read,\n })\n }\n } else {\n match self.input.read_packet(&mut self.input_packet) {\n Some(_) => {\n self.samples_to_write = 0..self.input_packet.samples().len();\n self.is_reading = true;\n self.this.send(Msg::Read)?;\n }\n None => {\n self.is_reading = false;\n self.total_samples\n .store(self.samples_written, Ordering::Relaxed);\n }\n }\n Ok(Act::Continue)\n }\n }\n}\n" }, { "path": "psst-core/src/session/access_token.rs", "content": "use std::time::{Duration, Instant};\n\nuse parking_lot::Mutex;\nuse serde::Deserialize;\n\nuse crate::error::Error;\n\nuse super::SessionService;\n\n// Client ID of the official Web Spotify front-end.\npub const CLIENT_ID: &str = \"65b708073fc0480ea92a077233ca87bd\";\n\n// All scopes we could possibly require.\npub const ACCESS_SCOPES: &str = \"streaming,user-read-email,user-read-private,playlist-read-private,playlist-read-collaborative,playlist-modify-public,playlist-modify-private,user-follow-modify,user-follow-read,user-library-read,user-library-modify,user-top-read,user-read-recently-played\";\n\n// Consider token expired even before the official expiration time. Spotify\n// seems to be reporting excessive token TTLs so let's cut it down by 30\n// minutes.\nconst EXPIRATION_TIME_THRESHOLD: Duration = Duration::from_secs(60 * 30);\n\n#[derive(Clone)]\npub struct AccessToken {\n pub token: String,\n pub expires: Instant,\n}\n\nimpl AccessToken {\n fn expired() -> Self {\n Self {\n token: String::new(),\n expires: Instant::now(),\n }\n }\n\n pub fn request(session: &SessionService) -> Result {\n #[derive(Deserialize)]\n struct MercuryAccessToken {\n #[serde(rename = \"expiresIn\")]\n expires_in: u64,\n #[serde(rename = \"accessToken\")]\n access_token: String,\n }\n\n let token: MercuryAccessToken = session.connected()?.get_mercury_json(format!(\n \"hm://keymaster/token/authenticated?client_id={CLIENT_ID}&scope={ACCESS_SCOPES}\",\n ))?;\n\n Ok(Self {\n token: token.access_token,\n expires: Instant::now() + Duration::from_secs(token.expires_in),\n })\n }\n\n fn is_expired(&self) -> bool {\n self.expires.saturating_duration_since(Instant::now()) < EXPIRATION_TIME_THRESHOLD\n }\n}\n\npub struct TokenProvider {\n token: Mutex,\n}\n\nimpl TokenProvider {\n pub fn new() -> Self {\n Self {\n token: Mutex::new(AccessToken::expired()),\n }\n }\n\n pub fn get(&self, session: &SessionService) -> Result {\n let mut token = self.token.lock();\n if token.is_expired() {\n log::info!(\"access token expired, requesting\");\n *token = AccessToken::request(session)?;\n }\n Ok(token.clone())\n }\n}\n" }, { "path": "psst-core/src/session/audio_key.rs", "content": "use std::{\n collections::HashMap,\n io::{Cursor, Read},\n};\n\nuse byteorder::{ReadBytesExt, BE};\nuse crossbeam_channel::Sender;\n\nuse crate::{\n audio::decrypt::AudioKey,\n connection::shannon_codec::ShannonMsg,\n error::Error,\n item_id::{FileId, ItemId},\n util::Sequence,\n};\n\npub struct AudioKeyDispatcher {\n sequence: Sequence,\n pending: HashMap>>,\n}\n\nimpl AudioKeyDispatcher {\n pub fn new() -> Self {\n Self {\n sequence: Sequence::new(0),\n pending: HashMap::new(),\n }\n }\n\n pub fn enqueue_request(\n &mut self,\n track: ItemId,\n file: FileId,\n callback: Sender>,\n ) -> ShannonMsg {\n let seq = self.sequence.advance();\n self.pending.insert(seq, callback);\n Self::make_key_request(seq, track, file)\n }\n\n fn make_key_request(seq: u32, track: ItemId, file: FileId) -> ShannonMsg {\n let mut buf = Vec::new();\n buf.extend(file.0);\n buf.extend(track.to_raw());\n buf.extend(seq.to_be_bytes());\n buf.extend(0_u16.to_be_bytes());\n ShannonMsg::new(ShannonMsg::REQUEST_KEY, buf)\n }\n\n pub fn handle_aes_key(&mut self, msg: ShannonMsg) {\n let mut payload = Cursor::new(msg.payload);\n let seq = payload.read_u32::().unwrap();\n\n if let Some(tx) = self.pending.remove(&seq) {\n let mut key = [0_u8; 16];\n payload.read_exact(&mut key).unwrap();\n\n if tx.send(Ok(AudioKey(key))).is_err() {\n log::warn!(\"missing receiver for audio key, seq: {seq}\");\n }\n } else {\n log::warn!(\"received unexpected audio key msg, seq: {seq}\");\n }\n }\n\n pub fn handle_aes_key_error(&mut self, msg: ShannonMsg) {\n let mut payload = Cursor::new(msg.payload);\n let seq = payload.read_u32::().unwrap();\n\n if let Some(tx) = self.pending.remove(&seq) {\n log::error!(\"audio key error\");\n if tx.send(Err(Error::UnexpectedResponse)).is_err() {\n log::warn!(\"missing receiver for audio key error, seq: {seq}\");\n }\n } else {\n log::warn!(\"received unknown audio key, seq: {seq}\");\n }\n }\n}\n" }, { "path": "psst-core/src/session/client_token.rs", "content": "// Ported from librespot\n\nuse crate::error::Error;\nuse crate::session::token::{Token};\nuse crate::util::{default_ureq_agent_builder, solve_hash_cash};\nuse data_encoding::HEXUPPER_PERMISSIVE;\nuse librespot_protocol::clienttoken_http::{\n ChallengeAnswer, ChallengeType, ClientTokenRequest, ClientTokenRequestType,\n ClientTokenResponse, ClientTokenResponseType,\n};\nuse parking_lot::Mutex;\nuse protobuf::{Enum, Message};\nuse std::time::{Duration, Instant};\nuse crate::system_info::{CLIENT_ID, DEVICE_ID, OS, SPOTIFY_SEMANTIC_VERSION};\n\npub struct ClientTokenProvider {\n token: Mutex>,\n agent: ureq::Agent,\n}\n\nimpl ClientTokenProvider {\n pub fn new(proxy_url: Option<&str>) -> Self {\n Self {\n token: Mutex::new(None),\n agent: default_ureq_agent_builder(proxy_url).build().into(),\n }\n }\n\n fn request(&self, message: &M) -> Result, Error> {\n let body = message.write_to_bytes()?;\n\n let mut response = self\n .agent\n .post(\"https://clienttoken.spotify.com/v1/clienttoken\")\n .header(\"Accept\", \"application/x-protobuf\")\n .send(body)?;\n\n let vec = response.body_mut().read_to_vec();\n Ok(vec?)\n }\n\n fn request_new_token(&self) -> Result {\n log::debug!(\"Requesting new token...\");\n\n let mut request = ClientTokenRequest::new();\n request.request_type = ClientTokenRequestType::REQUEST_CLIENT_DATA_REQUEST.into();\n\n let client_data = request.mut_client_data();\n\n client_data.client_version = SPOTIFY_SEMANTIC_VERSION.into();\n client_data.client_id = CLIENT_ID.into();\n\n let connectivity_data = client_data.mut_connectivity_sdk_data();\n connectivity_data.device_id = DEVICE_ID.to_string();\n\n let platform_data = connectivity_data\n .platform_specific_data\n .mut_or_insert_default();\n\n let os_version = sysinfo::System::os_version().unwrap_or(\"0\".into());\n let kernel_version = sysinfo::System::kernel_version().unwrap_or_else(|| String::from(\"0\"));\n\n match OS {\n \"windows\" => {\n let os_version = os_version.parse::().unwrap_or(10.) as i32;\n let kernel_version = kernel_version.parse::().unwrap_or(21370);\n\n let (pe, image_file) = match std::env::consts::ARCH {\n \"arm\" => (448, 452),\n \"aarch64\" => (43620, 452),\n \"x86_64\" => (34404, 34404),\n _ => (332, 332), // x86\n };\n\n let windows_data = platform_data.mut_desktop_windows();\n windows_data.os_version = os_version;\n windows_data.os_build = kernel_version;\n windows_data.platform_id = 2;\n windows_data.unknown_value_6 = 9;\n windows_data.image_file_machine = image_file;\n windows_data.pe_machine = pe;\n windows_data.unknown_value_10 = true;\n }\n \"ios\" => {\n let ios_data = platform_data.mut_ios();\n ios_data.user_interface_idiom = 0;\n ios_data.target_iphone_simulator = false;\n ios_data.hw_machine = \"iPhone14,5\".to_string();\n ios_data.system_version = os_version;\n }\n \"android\" => {\n let android_data = platform_data.mut_android();\n android_data.android_version = os_version;\n android_data.api_version = 31;\n \"Pixel\".clone_into(&mut android_data.device_name);\n \"GF5KQ\".clone_into(&mut android_data.model_str);\n \"Google\".clone_into(&mut android_data.vendor);\n }\n \"macos\" => {\n let macos_data = platform_data.mut_desktop_macos();\n macos_data.system_version = os_version;\n macos_data.hw_model = \"iMac21,1\".to_string();\n macos_data.compiled_cpu_type = std::env::consts::ARCH.to_string();\n }\n _ => {\n let linux_data = platform_data.mut_desktop_linux();\n linux_data.system_name = \"Linux\".to_string();\n linux_data.system_release = kernel_version;\n linux_data.system_version = os_version;\n linux_data.hardware = std::env::consts::ARCH.to_string();\n }\n }\n\n let mut response = self.request(&request)?;\n let mut count = 0;\n const MAX_TRIES: u8 = 3;\n\n let token_response = loop {\n count += 1;\n\n let message = ClientTokenResponse::parse_from_bytes(&response)?;\n\n match ClientTokenResponseType::from_i32(message.response_type.value()) {\n // depending on the platform, you're either given a token immediately\n // or are presented a hash cash challenge to solve first\n Some(ClientTokenResponseType::RESPONSE_GRANTED_TOKEN_RESPONSE) => {\n log::debug!(\"Received a granted token\");\n break message;\n }\n Some(ClientTokenResponseType::RESPONSE_CHALLENGES_RESPONSE) => {\n log::debug!(\"Received a hash cash challenge, solving...\");\n\n let challenges = message.challenges().clone();\n let state = challenges.state;\n if let Some(challenge) = challenges.challenges.first() {\n let hash_cash_challenge = challenge.evaluate_hashcash_parameters();\n\n let ctx = vec![];\n let prefix = HEXUPPER_PERMISSIVE\n .decode(hash_cash_challenge.prefix.as_bytes())\n .map_err(|e| {\n Error::InvalidStateError(\n format!(\"Unable to decode hash cash challenge: {e}\").into(),\n )\n })?;\n let length = hash_cash_challenge.length;\n\n let mut suffix = [0u8; 0x10];\n let answer = solve_hash_cash(&ctx, &prefix, length, &mut suffix);\n\n match answer {\n Ok(_) => {\n // the suffix must be in uppercase\n let suffix = HEXUPPER_PERMISSIVE.encode(&suffix);\n\n let mut answer_message = ClientTokenRequest::new();\n answer_message.request_type =\n ClientTokenRequestType::REQUEST_CHALLENGE_ANSWERS_REQUEST\n .into();\n\n let challenge_answers = answer_message.mut_challenge_answers();\n\n let mut challenge_answer = ChallengeAnswer::new();\n challenge_answer.mut_hash_cash().suffix = suffix;\n challenge_answer.ChallengeType =\n ChallengeType::CHALLENGE_HASH_CASH.into();\n\n challenge_answers.state = state.to_string();\n challenge_answers.answers.push(challenge_answer);\n\n log::trace!(\"Answering hash cash challenge\");\n match self.request(&answer_message) {\n Ok(token) => {\n response = token;\n continue;\n }\n Err(e) => {\n log::trace!(\"Answer not accepted {count}/{MAX_TRIES}: {e}\");\n }\n }\n }\n Err(e) => log::trace!(\n \"Unable to solve hash cash challenge {count}/{MAX_TRIES}: {e}\"\n ),\n }\n\n if count < MAX_TRIES {\n response = self.request(&request)?;\n } else {\n return Err(Error::InvalidStateError(\n format!(\"Unable to solve any of {MAX_TRIES} hash cash challenges\")\n .into(),\n ));\n }\n } else {\n return Err(Error::InvalidStateError(\"No challenges found\".into()));\n }\n }\n\n Some(unknown) => {\n return Err(Error::UnimplementedError(\n format!(\"Unknown client token response type: {unknown:?}\").into(),\n ));\n }\n None => {\n return Err(Error::InvalidStateError(\n \"No client token response type\".into(),\n ))\n }\n }\n };\n\n let granted_token = token_response.granted_token();\n let access_token = granted_token.token.to_owned();\n\n Ok(Token {\n access_token: access_token.clone(),\n expires_in: Duration::from_secs(\n granted_token\n .refresh_after_seconds\n .try_into()\n .unwrap_or(7200),\n ),\n token_type: \"client-token\".to_string(),\n scopes: granted_token\n .domains\n .iter()\n .map(|d| d.domain.clone())\n .collect(),\n timestamp: Instant::now(),\n })\n }\n\n pub fn get(&self) -> Result {\n // Check for cached token availability, else retrieve fresh token\n let mut cur_token = self.token.lock();\n\n if let Some(token) = &*cur_token {\n if !token.is_expired() {\n return Ok(token.access_token.clone());\n }\n\n *cur_token = None;\n log::debug!(\"Client token expired\");\n }\n\n let new_token = self.request_new_token()?;\n\n *cur_token = Some(new_token.clone());\n Ok(new_token.access_token)\n }\n}\n" }, { "path": "psst-core/src/session/login5.rs", "content": "// Ported from librespot\n\nuse crate::error::Error;\nuse crate::session::client_token::ClientTokenProvider;\nuse crate::session::token::Token;\nuse crate::session::SessionService;\nuse crate::system_info::{CLIENT_ID, DEVICE_ID};\nuse crate::util::{default_ureq_agent_builder, solve_hash_cash};\nuse librespot_protocol::login5::login_response::Response;\nuse librespot_protocol::{\n client_info::ClientInfo,\n credentials::StoredCredential,\n hashcash::HashcashSolution,\n login5::{\n login_request::Login_method, ChallengeSolution, LoginError, LoginRequest, LoginResponse,\n },\n};\nuse parking_lot::Mutex;\nuse protobuf::well_known_types::duration::Duration as ProtoDuration;\nuse protobuf::{Message, MessageField};\nuse std::fmt::Formatter;\nuse std::time::{Duration, Instant};\nuse std::{error, fmt, thread};\n\nconst MAX_LOGIN_TRIES: u8 = 3;\nconst LOGIN_TIMEOUT: Duration = Duration::from_secs(3);\n\n#[derive(Debug)]\npub enum ChallengeError {\n Unsupported,\n NoneFound,\n}\n\n#[derive(Debug)]\nenum Login5Error {\n /// The server denied the request with a specific error code.\n RequestDenied(LoginError),\n /// The server issued a challenge that we could not solve.\n Challenge(ChallengeError),\n /// The operation could not be performed due to invalid local state.\n InvalidState(String),\n /// The login attempt failed after multiple retries.\n RetriesExceeded(u8),\n /// The server's response was malformed or missing expected fields.\n MalformedResponse,\n}\n\nimpl error::Error for Login5Error {}\n\nimpl fmt::Display for Login5Error {\n fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\n match self {\n Login5Error::RequestDenied(e) => write!(f, \"Login request was denied: {:?}\", e),\n Login5Error::Challenge(c) => match c {\n ChallengeError::Unsupported => write!(f, \"Login5 code challenge is not supported\"),\n ChallengeError::NoneFound => write!(f, \"No challenges found in response\"),\n },\n Login5Error::InvalidState(s) => write!(f, \"Invalid state: {}\", s),\n Login5Error::RetriesExceeded(n) => {\n write!(f, \"Couldn't successfully authenticate after {} times\", n)\n }\n Login5Error::MalformedResponse => write!(f, \"Missing response from login server\"),\n }\n }\n}\n\nimpl From for Error {\n fn from(err: Login5Error) -> Self {\n match err {\n Login5Error::RequestDenied(_)\n | Login5Error::InvalidState(_)\n | Login5Error::RetriesExceeded(_)\n | Login5Error::MalformedResponse => Error::InvalidStateError(err.into()),\n Login5Error::Challenge(_) => Error::UnimplementedError(err.into()),\n }\n }\n}\n\npub struct Login5 {\n auth_token: Mutex>,\n client_token_provider: ClientTokenProvider,\n agent: ureq::Agent,\n}\n\nimpl Login5 {\n /// Login5 instances can be used to cache and retrieve access tokens from stored credentials.\n ///\n /// # Arguments\n ///\n /// * `client_token_provider`: Can be optionally injected to control which client-id is\n /// used for it.\n ///\n /// returns: Login5\n pub fn new(\n client_token_provider: Option,\n proxy_url: Option<&str>,\n ) -> Self {\n Self {\n auth_token: Mutex::new(None),\n client_token_provider: client_token_provider\n .unwrap_or_else(|| ClientTokenProvider::new(proxy_url)),\n agent: default_ureq_agent_builder(proxy_url).build().into(),\n }\n }\n\n fn request(&self, message: &LoginRequest) -> Result, Error> {\n let client_token: String = self.client_token_provider.get()?;\n let body = message.write_to_bytes()?;\n\n let mut response = self\n .agent\n .post(\"https://login5.spotify.com/v3/login\")\n .header(\"Accept\", \"application/x-protobuf\")\n .header(\"client-token\", &client_token)\n .send(body)?;\n\n let vec = response.body_mut().read_to_vec()?;\n Ok(vec)\n }\n\n fn request_new_token(&self, login: Login_method) -> Result {\n let mut login_request = LoginRequest {\n client_info: MessageField::some(ClientInfo {\n client_id: String::from(CLIENT_ID),\n device_id: String::from(DEVICE_ID),\n special_fields: Default::default(),\n }),\n login_method: Some(login),\n ..Default::default()\n };\n\n let mut response = self.request(&login_request)?;\n let mut count = 0;\n\n loop {\n count += 1;\n\n let mut message = LoginResponse::parse_from_bytes(&response)?;\n match message.response.take() {\n Some(Response::Ok(ok)) => {\n let expiry_secs = ok.access_token_expires_in.try_into().unwrap_or(3600);\n return Ok(Token {\n access_token: ok.access_token,\n expires_in: Duration::from_secs(expiry_secs),\n token_type: \"Bearer\".to_string(),\n scopes: vec![],\n timestamp: Instant::now(),\n });\n }\n Some(Response::Error(err)) => match err.enum_value() {\n Ok(LoginError::TIMEOUT) | Ok(LoginError::TOO_MANY_ATTEMPTS) => {\n log::debug!(\"Too many login5 requests... timeout!\");\n thread::sleep(LOGIN_TIMEOUT)\n }\n Ok(other) => {\n log::debug!(\"Login5 request failed!\");\n return Err(Login5Error::RequestDenied(other).into());\n }\n Err(other) => {\n log::warn!(\"Unknown login error: {}\", other);\n }\n },\n Some(Response::Challenges(_)) => {\n // handles the challenges, and updates the login context with the response\n Self::handle_challenges(&mut login_request, message)?;\n }\n None => {\n return Err(Login5Error::MalformedResponse.into());\n }\n _ => {\n log::warn!(\"Unhandled login response\");\n }\n }\n\n if count < MAX_LOGIN_TRIES {\n response = self.request(&login_request)?;\n } else {\n return Err(Login5Error::RetriesExceeded(MAX_LOGIN_TRIES).into());\n }\n }\n }\n\n fn handle_challenges(\n login_request: &mut LoginRequest,\n message: LoginResponse,\n ) -> Result<(), Error> {\n let challenges = message.challenges();\n log::debug!(\n \"Received {} challenges, solving...\",\n challenges.challenges.len()\n );\n\n if challenges.challenges.is_empty() {\n return Err(Login5Error::Challenge(ChallengeError::NoneFound).into());\n }\n\n for challenge in &challenges.challenges {\n if challenge.has_code() || !challenge.has_hashcash() {\n // We only solve hashcash challenges.\n return Err(Login5Error::Challenge(ChallengeError::Unsupported).into());\n }\n\n let hash_cash_challenge = challenge.hashcash();\n\n let mut suffix = [0u8; 0x10];\n let duration = solve_hash_cash(\n &message.login_context,\n &hash_cash_challenge.prefix,\n hash_cash_challenge.length,\n &mut suffix,\n )?;\n let (seconds, nanos) = (duration.as_secs() as i64, duration.subsec_nanos() as i32);\n log::debug!(\"Solving hashcash took {seconds}s {nanos}ns\");\n\n let mut solution = ChallengeSolution::new();\n solution.set_hashcash(HashcashSolution {\n suffix: Vec::from(suffix),\n duration: MessageField::some(ProtoDuration {\n seconds,\n nanos,\n ..Default::default()\n }),\n ..Default::default()\n });\n\n login_request\n .challenge_solutions\n .mut_or_insert_default()\n .solutions\n .push(solution);\n }\n\n login_request.login_context = message.login_context;\n\n Ok(())\n }\n\n /// Retrieve an `access_token` via Login5. The token is either requested first (slow), or\n /// retrieved from local cache (fast).\n ///\n /// This request will only work if the session already has valid credentials available.\n /// The client-id of the credentials have to match the client-id used to retrieve\n /// the client token (see also `Login5::new(...)`). For example, if you previously generated\n /// stored credentials with an android client-id, they won't work within login5 using a desktop\n /// client-id.\n pub fn get_access_token(&self, session: &SessionService) -> Result {\n let mut cur_token = self.auth_token.lock();\n\n let login_creds = session.config.lock().as_ref().unwrap().login_creds.clone();\n let auth_data = login_creds.auth_data.clone();\n if auth_data.is_empty() {\n return Err(Login5Error::InvalidState(\n \"Tried to acquire access token without stored credentials\".to_string(),\n )\n .into());\n }\n\n if let Some(auth_token) = &*cur_token {\n if !auth_token.is_expired() {\n return Ok(auth_token.clone());\n }\n\n *cur_token = None;\n log::debug!(\"Auth token expired\");\n }\n\n log::debug!(\"Requesting new auth token\");\n\n // Conversion from psst protocol structs to librespot protocol structs\n let method = Login_method::StoredCredential(StoredCredential {\n username: login_creds.username.clone().unwrap(),\n data: auth_data,\n ..Default::default()\n });\n\n let new_token = self.request_new_token(method)?;\n\n log::debug!(\"Successfully requested new auth token\");\n\n *cur_token = Some(new_token.clone());\n Ok(new_token)\n }\n}\n" }, { "path": "psst-core/src/session/mercury.rs", "content": "use std::{\n collections::HashMap,\n io::{Cursor, Read},\n};\n\nuse byteorder::{ReadBytesExt, BE};\nuse crossbeam_channel::Sender;\n\nuse crate::{connection::shannon_codec::ShannonMsg, util::Sequence};\n\nuse librespot_protocol::mercury::Header;\nuse protobuf::Message;\n\npub struct MercuryDispatcher {\n sequence: Sequence,\n pending: HashMap,\n}\n\nimpl MercuryDispatcher {\n pub fn new() -> Self {\n Self {\n sequence: Sequence::new(0),\n pending: HashMap::new(),\n }\n }\n\n pub fn enqueue_request(\n &mut self,\n req: MercuryRequest,\n callback: Sender,\n ) -> ShannonMsg {\n let seq = self.sequence.advance();\n self.pending.insert(\n seq,\n Pending {\n callback,\n messages: Vec::new(),\n },\n );\n ShannonMsg::new(ShannonMsg::MERCURY_REQ, req.encode_to_mercury_message(seq))\n }\n\n pub fn handle_mercury_req(&mut self, shannon_msg: ShannonMsg) {\n let msg = Msg::decode(shannon_msg.payload);\n let msg_flags = msg.flags;\n let msg_seq = msg.seq;\n if let Some(mut pending) = self.pending.remove(&msg_seq) {\n pending.messages.push(msg);\n if msg_flags == Msg::FINAL {\n // This is the final message. Aggregate all pending parts and process further.\n let parts = Msg::aggregate(pending.messages);\n let response = MercuryResponse::decode_from_parts(parts);\n // Send the response. If the response channel is closed, ignore it.\n let _ = pending.callback.send(response);\n } else {\n // This is not the final message of this sequence, but it back as pending.\n self.pending.insert(msg_seq, pending);\n }\n } else {\n log::warn!(\"received unexpected mercury msg, seq: {msg_seq}\");\n }\n }\n}\n\n#[derive(Debug)]\npub struct MercuryRequest {\n pub uri: String,\n pub method: String,\n pub payload: Vec>,\n}\n\nimpl MercuryRequest {\n pub fn get(uri: String) -> Self {\n Self {\n uri,\n method: \"GET\".to_string(),\n payload: Vec::new(),\n }\n }\n\n pub fn send(uri: String, data: Vec) -> Self {\n Self {\n uri,\n method: \"SEND\".to_string(),\n payload: vec![data],\n }\n }\n\n fn encode_to_mercury_message(self, seq: u64) -> Vec {\n let parts = self.encode_to_parts();\n let msg = Msg::new(seq, Msg::FINAL, parts);\n msg.encode()\n }\n\n fn encode_to_parts(self) -> Vec> {\n let header = Header {\n uri: Some(self.uri),\n method: Some(self.method),\n ..Header::default()\n };\n let header_part = header\n .write_to_bytes()\n .expect(\"Failed to serialize message header\");\n\n let mut parts = self.payload;\n parts.insert(0, header_part);\n parts\n }\n}\n\n#[derive(Debug, Clone)]\npub struct MercuryResponse {\n pub uri: String,\n pub status_code: i32,\n pub payload: Vec>,\n}\n\nimpl MercuryResponse {\n fn decode_from_parts(mut parts: Vec>) -> Self {\n let header_part = parts.remove(0);\n let header = Header::parse_from_bytes(&header_part)\n .expect(\"Failed to deserialize message header\");\n\n Self {\n uri: header.uri.unwrap(),\n status_code: header.status_code.unwrap(),\n payload: parts,\n }\n }\n}\n\n#[derive(Debug)]\nstruct Pending {\n messages: Vec,\n callback: Sender,\n}\n\n#[derive(Debug, Default)]\nstruct Msg {\n seq: u64,\n flags: u8,\n count: u16,\n parts: Vec>,\n}\n\nimpl Msg {\n const FINAL: u8 = 0x01;\n const PARTIAL: u8 = 0x02;\n\n fn new(seq: u64, flags: u8, parts: Vec>) -> Self {\n let count = parts.len() as u16;\n Self {\n seq,\n flags,\n count,\n parts,\n }\n }\n\n fn decode(buf: Vec) -> Self {\n let mut buf = Cursor::new(buf);\n let seq_len = buf.read_u16::().unwrap();\n let seq = buf.read_uint::(seq_len.into()).unwrap();\n let flags = buf.read_u8().unwrap();\n let count = buf.read_u16::().unwrap();\n let mut parts = Vec::with_capacity(count.into());\n for _ in 0..count {\n let part_len = buf.read_u16::().unwrap();\n let mut part = vec![0_u8; part_len.into()];\n buf.read_exact(&mut part).unwrap();\n parts.push(part);\n }\n Self {\n seq,\n flags,\n count,\n parts,\n }\n }\n\n fn encode(&self) -> Vec {\n let mut buf = Vec::new();\n buf.extend(8_u16.to_be_bytes()); // Sequence length.\n buf.extend(self.seq.to_be_bytes());\n buf.push(self.flags);\n buf.extend(self.count.to_be_bytes());\n for part in &self.parts {\n let len = part.len() as u16;\n buf.extend(len.to_be_bytes());\n buf.extend(part);\n }\n buf\n }\n\n fn aggregate(msgs: impl IntoIterator) -> Vec> {\n let mut results = Vec::new();\n let mut partial: Option> = None;\n\n for msg in msgs {\n for (i, mut part) in msg.parts.into_iter().enumerate() {\n // If we have a partial data left from the last message, append to it.\n if let Some(mut partial) = partial.take() {\n partial.extend(part);\n part = partial;\n }\n\n // Save the last part of partial messages for later.\n let is_last_part = i as u16 == msg.count - 1;\n if msg.flags == Self::PARTIAL && is_last_part {\n partial = Some(part);\n } else {\n results.push(part);\n }\n }\n }\n\n results\n }\n}" }, { "path": "psst-core/src/session/mod.rs", "content": "pub mod access_token;\npub mod audio_key;\npub mod mercury;\npub mod login5;\npub mod client_token;\npub mod token;\n\nuse std::{\n io,\n net::{Shutdown, TcpStream},\n sync::{\n atomic::{AtomicBool, Ordering},\n Arc,\n },\n thread::{self, JoinHandle},\n};\n\nuse crossbeam_channel::{unbounded, Receiver, Sender};\nuse parking_lot::Mutex;\nuse serde::de::DeserializeOwned;\n\nuse crate::{\n audio::decrypt::AudioKey,\n connection::{\n shannon_codec::{ShannonDecoder, ShannonEncoder, ShannonMsg},\n Credentials, Transport,\n },\n error::Error,\n item_id::{FileId, ItemId},\n};\n\nuse self::{\n audio_key::AudioKeyDispatcher,\n mercury::{MercuryDispatcher, MercuryRequest, MercuryResponse},\n};\n\n/// Configuration values needed to open the session connection.\n#[derive(Clone)]\npub struct SessionConfig {\n pub login_creds: Credentials,\n pub proxy_url: Option,\n}\n\n/// Cheap to clone, shareable service handle that holds the active session\n/// worker. Session connection is lazily opened in `connected()`, using config\n/// values set in `update_config()`. In case the session dies or is explicitly\n/// shut down, worker is disposed of, and a new session is opened on the next\n/// request.\n#[derive(Clone)]\npub struct SessionService {\n connected: Arc>>,\n config: Arc>>,\n}\n\nimpl SessionService {\n /// Create a new session service without any configuration. To open a\n /// session, a config needs to be set up first using `update_config`.\n pub fn empty() -> Self {\n Self {\n connected: Arc::default(),\n config: Arc::default(),\n }\n }\n\n /// Create a new session service with pre-set configuration.\n pub fn with_config(config: SessionConfig) -> Self {\n Self {\n connected: Arc::default(),\n config: Arc::new(Mutex::new(Some(config))),\n }\n }\n\n /// Replace the active session config. If a session is already connected,\n /// shut it down and wait until it's terminated.\n pub fn update_config(&self, config: SessionConfig) {\n self.config.lock().replace(config);\n self.shutdown();\n }\n\n /// Returns true if a session worker is actively servicing the connected\n /// session. We return false here after any case of I/O errors or an\n /// explicit session shutdown.\n pub fn is_connected(&self) -> bool {\n matches!(self.connected.lock().as_ref(), Some(worker) if !worker.has_terminated())\n }\n\n /// Return a handle for the connected session. In case no connection is\n /// open, *synchronously* connect, start the worker and keep it as active.\n /// Although a lock is held for the whole duration of connection setup,\n /// `SessionConnection::open` has an internal timeout, and should give up in\n /// a timely manner.\n pub fn connected(&self) -> Result {\n let mut connected = self.connected.lock();\n let is_connected_and_not_terminated =\n matches!(connected.as_ref(), Some(worker) if !worker.has_terminated());\n if !is_connected_and_not_terminated {\n let connection = SessionConnection::open(\n self.config\n .lock()\n .as_ref()\n .ok_or(Error::SessionDisconnected)?\n .clone(),\n )?;\n let worker = SessionWorker::run(connection.transport);\n connected.replace(worker);\n }\n connected\n .as_ref()\n .map(SessionWorker::handle)\n .ok_or(Error::SessionDisconnected)\n }\n\n /// Signal a shutdown to the active worker and wait until it terminates.\n pub fn shutdown(&self) {\n if let Some(worker) = self.connected.lock().take() {\n worker.handle().request_shutdown();\n worker.join();\n }\n }\n}\n\n/// Successful connection through the Spotify Shannon-encrypted TCP channel.\npub struct SessionConnection {\n /// Credentials re-usable in the next authentication (i.e. username and\n /// password are not required anymore).\n pub credentials: Credentials,\n /// I/O codec for the Shannon messages.\n pub transport: Transport,\n}\n\nimpl SessionConnection {\n /// Synchronously connect to the Spotify servers and authenticate with\n /// credentials provided in `config`.\n pub fn open(config: SessionConfig) -> Result {\n // Connect to the server and exchange keys.\n let proxy_url = config.proxy_url.as_deref();\n let ap_list = Transport::resolve_ap_with_fallback(proxy_url);\n let mut transport = Transport::connect(&ap_list, proxy_url)?;\n let credentials = transport.authenticate(config.login_creds)?;\n Ok(Self {\n credentials,\n transport,\n })\n }\n}\n\npub struct SessionWorker {\n sender: Sender,\n decoding_thread: JoinHandle<()>,\n encoding_thread: JoinHandle<()>,\n dispatching_thread: JoinHandle<()>,\n terminated: Arc,\n}\n\nimpl SessionWorker {\n pub fn run(transport: Transport) -> Self {\n let (disp_send, disp_recv) = unbounded();\n let (msg_send, msg_recv) = unbounded();\n let terminated = Arc::new(AtomicBool::new(false));\n Self {\n decoding_thread: {\n let decoder = transport.decoder;\n let disp_send = disp_send.clone();\n thread::spawn(move || decode_shannon_messages(decoder, disp_send))\n },\n encoding_thread: {\n let encoder = transport.encoder;\n let disp_send = disp_send.clone();\n thread::spawn(move || encode_shannon_messages(encoder, msg_recv, disp_send))\n },\n dispatching_thread: {\n let stream = transport.stream;\n let terminated = terminated.clone();\n thread::spawn(move || {\n dispatch_messages(disp_recv, msg_send, stream);\n terminated.store(true, Ordering::SeqCst);\n })\n },\n sender: disp_send,\n terminated,\n }\n }\n\n pub fn handle(&self) -> SessionHandle {\n SessionHandle {\n sender: self.sender.clone(),\n }\n }\n\n pub fn join(self) {\n if let Err(err) = self.dispatching_thread.join() {\n log::error!(\"session dispatching thread panicked: {err:?}\");\n }\n if let Err(err) = self.encoding_thread.join() {\n log::error!(\"session encoding thread panicked: {err:?}\");\n }\n if let Err(err) = self.decoding_thread.join() {\n log::error!(\"session decoding thread panicked: {err:?}\");\n }\n }\n\n pub fn has_terminated(&self) -> bool {\n self.terminated.load(Ordering::SeqCst)\n }\n}\n\n#[derive(Clone)]\npub struct SessionHandle {\n sender: Sender,\n}\n\nimpl SessionHandle {\n pub fn get_mercury_protobuf(&self, uri: String) -> Result\n where\n T: protobuf::Message,\n {\n let payload = self.get_mercury_bytes(uri)?;\n let message = T::parse_from_bytes(&payload)?;\n Ok(message)\n }\n\n pub fn get_mercury_json(&self, uri: String) -> Result\n where\n T: DeserializeOwned,\n {\n let payload = self.get_mercury_bytes(uri)?;\n let message = serde_json::from_slice(&payload)?;\n Ok(message)\n }\n\n pub fn get_mercury_bytes(&self, uri: String) -> Result, Error> {\n let (callback, receiver) = unbounded();\n let request = MercuryRequest::get(uri);\n self.sender\n .send(DispatchCmd::MercuryReq { callback, request })\n .ok()\n .ok_or(Error::SessionDisconnected)?;\n let response = receiver.recv().ok().ok_or(Error::SessionDisconnected)?;\n let first_part = response\n .payload\n .into_iter()\n .next()\n .ok_or(Error::UnexpectedResponse)?;\n Ok(first_part)\n }\n\n pub fn get_audio_key(&self, track: ItemId, file: FileId) -> Result {\n let (callback, receiver) = unbounded();\n self.sender\n .send(DispatchCmd::AudioKeyReq {\n callback,\n track,\n file,\n })\n .ok()\n .ok_or(Error::SessionDisconnected)?;\n receiver.recv().ok().ok_or(Error::SessionDisconnected)?\n }\n\n pub fn get_country_code(&self) -> Option {\n let (callback, receiver) = unbounded();\n self.sender\n .send(DispatchCmd::CountryCodeReq { callback })\n .ok()?;\n receiver.recv().ok()?\n }\n\n pub fn request_shutdown(&self) {\n let _ = self.sender.send(DispatchCmd::Shutdown);\n }\n}\n\n/// Read Shannon messages from the TCP stream one by one and send them to\n/// dispatcher for further processing. In case the decoding fails with an error\n/// (this happens also in case we explicitly shutdown the connection), report\n/// the error to the dispatcher and quit. If the dispatcher has already dropped\n/// its receiving part, quit silently as well.\nfn decode_shannon_messages(mut decoder: ShannonDecoder, dispatch: Sender) {\n loop {\n match decoder.decode() {\n Ok(msg) => {\n if dispatch.send(DispatchCmd::DecodedMsg(msg)).is_err() {\n break;\n }\n }\n Err(err) => {\n let _ = dispatch.send(DispatchCmd::DecoderError(err));\n break;\n }\n };\n }\n}\n\n/// Receive Shannon messages from `messages` and encode them into the TCP stream\n/// through `encoder`. In case the encoding fails with an error (this happens\n/// also in case we explicitly shutdown the connection), report the error to the\n/// dispatcher and quit. If the dispatcher has already dropped the\n/// corresponding sender of `messages`, quit as well.\nfn encode_shannon_messages(\n mut encoder: ShannonEncoder,\n messages: Receiver,\n dispatch: Sender,\n) {\n for msg in messages {\n match encoder.encode(msg) {\n Ok(_) => {\n // Message encoded, continue.\n }\n Err(err) => {\n let _ = dispatch.send(DispatchCmd::EncoderError(err));\n break;\n }\n }\n }\n}\n\nenum DispatchCmd {\n MercuryReq {\n request: MercuryRequest,\n callback: Sender,\n },\n AudioKeyReq {\n track: ItemId,\n file: FileId,\n callback: Sender>,\n },\n CountryCodeReq {\n callback: Sender>,\n },\n DecodedMsg(ShannonMsg),\n DecoderError(io::Error),\n EncoderError(io::Error),\n Shutdown,\n}\n\nfn dispatch_messages(\n dispatch: Receiver,\n messages: Sender,\n stream: TcpStream,\n) {\n let mut mercury = MercuryDispatcher::new();\n let mut audio_key = AudioKeyDispatcher::new();\n let mut country_code = None;\n\n for disp in dispatch {\n match disp {\n DispatchCmd::MercuryReq { request, callback } => {\n let msg = mercury.enqueue_request(request, callback);\n let _ = messages.send(msg);\n }\n DispatchCmd::AudioKeyReq {\n track,\n file,\n callback,\n } => {\n let msg = audio_key.enqueue_request(track, file, callback);\n let _ = messages.send(msg);\n }\n DispatchCmd::CountryCodeReq { callback } => {\n let _ = callback.send(country_code.clone());\n }\n DispatchCmd::DecodedMsg(msg) if msg.cmd == ShannonMsg::PING => {\n let _ = messages.send(pong_message());\n }\n DispatchCmd::DecodedMsg(msg) if msg.cmd == ShannonMsg::COUNTRY_CODE => {\n country_code.replace(parse_country_code(msg).unwrap());\n }\n DispatchCmd::DecodedMsg(msg) if msg.cmd == ShannonMsg::AES_KEY => {\n audio_key.handle_aes_key(msg)\n }\n DispatchCmd::DecodedMsg(msg) if msg.cmd == ShannonMsg::AES_KEY_ERROR => {\n audio_key.handle_aes_key_error(msg)\n }\n DispatchCmd::DecodedMsg(msg) if msg.cmd == ShannonMsg::MERCURY_REQ => {\n mercury.handle_mercury_req(msg)\n }\n DispatchCmd::DecodedMsg(msg) => {\n log::debug!(\"ignored message: {:?}\", msg.cmd);\n }\n DispatchCmd::DecoderError(err) => {\n log::error!(\"connection error: {err:?}\");\n let _ = stream.shutdown(Shutdown::Write);\n break;\n }\n DispatchCmd::EncoderError(err) => {\n log::error!(\"connection error: {err:?}\");\n let _ = stream.shutdown(Shutdown::Read);\n break;\n }\n DispatchCmd::Shutdown => {\n log::info!(\"connection shutdown\");\n let _ = stream.shutdown(Shutdown::Both);\n break;\n }\n }\n }\n}\n\nfn pong_message() -> ShannonMsg {\n ShannonMsg::new(ShannonMsg::PONG, vec![0, 0, 0, 0])\n}\n\nfn parse_country_code(msg: ShannonMsg) -> Result {\n String::from_utf8(msg.payload)\n .ok()\n .ok_or(Error::UnexpectedResponse)\n}\n\nimpl From for Error {\n fn from(error: serde_json::Error) -> Self {\n Error::JsonError(Box::new(error))\n }\n}\n" }, { "path": "psst-core/src/session/token.rs", "content": "// Ported from librespot\n\nuse std::time::{Duration, Instant};\n\nconst EXPIRY_THRESHOLD: Duration = Duration::from_secs(10);\n\n#[derive(Clone, Debug)]\npub struct Token {\n pub access_token: String,\n pub expires_in: Duration,\n pub token_type: String,\n pub scopes: Vec,\n pub timestamp: Instant,\n}\n\nimpl Token {\n pub fn is_expired(&self) -> bool {\n self.timestamp + (self.expires_in.saturating_sub(EXPIRY_THRESHOLD)) < Instant::now()\n }\n}" }, { "path": "psst-core/src/system_info.rs", "content": "/// Operating System as given by the Rust standard library\npub const OS: &str = std::env::consts::OS;\n\n/// Device ID used for authentication procedures.\n/// librespot opts for UUIDv4s instead\npub const DEVICE_ID: &str = \"Psst\";\n\n/// Client ID for desktop keymaster client\npub const CLIENT_ID: &str = \"65b708073fc0480ea92a077233ca87bd\";\n\n/// The semantic version of the Spotify desktop client\npub const SPOTIFY_SEMANTIC_VERSION: &str = \"1.2.52.442\";" }, { "path": "psst-core/src/util.rs", "content": "use crate::error::Error;\nuse byteorder::{BigEndian, ByteOrder};\nuse num_traits::{One, WrappingAdd};\nuse sha1::{Digest, Sha1};\nuse std::time::Instant;\nuse std::{io, io::SeekFrom, mem, time::Duration};\n\npub const NET_CONNECT_TIMEOUT: Duration = Duration::from_millis(8 * 1000);\n\npub const NET_IO_TIMEOUT: Duration = Duration::from_millis(16 * 1000);\n\npub fn default_ureq_agent_builder(\n proxy_url: Option<&str>,\n) -> ureq::config::ConfigBuilder {\n let mut agent = ureq::Agent::config_builder()\n .timeout_global(Some(Duration::from_secs(5)))\n .timeout_connect(Some(NET_CONNECT_TIMEOUT))\n .timeout_recv_response(Some(NET_IO_TIMEOUT))\n .timeout_send_request(Some(NET_IO_TIMEOUT));\n\n if let Some(proxy_url) = proxy_url {\n let proxy = ureq::Proxy::new(proxy_url).ok();\n agent = agent.proxy(proxy);\n }\n\n agent\n}\n\npub fn solve_hash_cash(\n ctx: &[u8],\n prefix: &[u8],\n length: i32,\n dst: &mut [u8],\n) -> Result {\n const TIMEOUT: Duration = Duration::from_secs(5);\n // SHA-1 produces a 20-byte hash, we check the trailing 8 bytes.\n const OFFSET_LEN: usize = 8;\n const CHECK_OFFSET: usize = 20 - OFFSET_LEN;\n\n let now = Instant::now();\n let initial_digest = Sha1::digest(ctx);\n let target = BigEndian::read_i64(&initial_digest[CHECK_OFFSET..]);\n\n let mut suffix = [0u8; 16];\n let mut counter = 0i64;\n\n while now.elapsed() < TIMEOUT {\n suffix[..OFFSET_LEN].copy_from_slice(&target.wrapping_add(counter).to_be_bytes());\n suffix[OFFSET_LEN..].copy_from_slice(&counter.to_be_bytes());\n\n let final_digest = Sha1::new()\n .chain_update(prefix)\n .chain_update(suffix)\n .finalize();\n\n if BigEndian::read_i64(&final_digest[CHECK_OFFSET..]).trailing_zeros() >= (length as u32) {\n dst.copy_from_slice(&suffix);\n return Ok(now.elapsed());\n }\n\n counter += 1;\n }\n\n Err(Error::InvalidStateError(\n format!(\"{TIMEOUT:?} expired\").into(),\n ))\n}\n\n#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]\npub struct Sequence(T);\n\nimpl Sequence {\n pub fn new(value: T) -> Self {\n Sequence(value)\n }\n\n pub fn advance(&mut self) -> T {\n let next = self.0.wrapping_add(&T::one());\n mem::replace(&mut self.0, next)\n }\n}\n\npub struct OffsetFile {\n stream: T,\n offset: u64,\n}\n\nimpl OffsetFile {\n pub fn new(mut stream: T, offset: u64) -> io::Result> {\n stream.seek(SeekFrom::Start(offset))?;\n Ok(OffsetFile { stream, offset })\n }\n}\n\nimpl io::Read for OffsetFile {\n fn read(&mut self, buf: &mut [u8]) -> io::Result {\n self.stream.read(buf)\n }\n}\n\nimpl io::Write for OffsetFile {\n fn write(&mut self, buf: &[u8]) -> io::Result {\n self.stream.write(buf)\n }\n\n fn flush(&mut self) -> io::Result<()> {\n self.stream.flush()\n }\n}\n\nimpl io::Seek for OffsetFile {\n fn seek(&mut self, pos: SeekFrom) -> io::Result {\n let offset_pos = match pos {\n SeekFrom::Start(offset) => SeekFrom::Start(offset + self.offset),\n from_end_or_current => from_end_or_current,\n };\n let new_pos = self.stream.seek(offset_pos)?;\n let offset_new_pos = new_pos.saturating_sub(self.offset);\n Ok(offset_new_pos)\n }\n}\n\npub struct FileWithConstSize {\n stream: T,\n len: u64,\n}\n\nimpl FileWithConstSize {\n pub fn len(&self) -> u64 {\n self.len\n }\n\n pub fn is_empty(&self) -> bool {\n self.len() == 0\n }\n}\n\nimpl FileWithConstSize\nwhere\n T: io::Seek,\n{\n pub fn new(mut stream: T) -> Self {\n stream.seek(SeekFrom::End(0)).unwrap();\n let len = stream.stream_position().unwrap();\n stream.seek(SeekFrom::Start(0)).unwrap();\n Self { stream, len }\n }\n}\n\nimpl io::Read for FileWithConstSize\nwhere\n T: io::Read,\n{\n fn read(&mut self, buf: &mut [u8]) -> io::Result {\n self.stream.read(buf)\n }\n}\n\nimpl io::Seek for FileWithConstSize\nwhere\n T: io::Seek,\n{\n fn seek(&mut self, pos: io::SeekFrom) -> io::Result {\n self.stream.seek(pos)\n }\n}\n" }, { "path": "psst-gui/Cargo.toml", "content": "[package]\nname = \"psst-gui\"\nversion = \"0.1.0\"\nauthors = [\"Jan Pochyla \"]\nedition = \"2021\"\nbuild = \"build.rs\"\ndescription = \"Fast and native Spotify client\"\nrepository = \"https://github.com/jpochyla/psst\"\n\n[features]\ndefault = [\"cpal\"]\ncpal = [\"psst-core/cpal\"]\ncubeb = [\"psst-core/cubeb\"]\n\n[dependencies]\npsst-core = { path = \"../psst-core\" }\n\n# Common\ncrossbeam-channel = { version = \"0.5.15\" }\ndirectories = \"6.0.0\"\nenv_logger = { version = \"0.11.8\" }\nitertools = \"0.14.0\"\nlog = { version = \"0.4.27\" }\nlru = \"0.14.0\"\nparking_lot = { version = \"0.12.3\" }\nplatform-dirs = { version = \"0.3.0\" }\nrand = { version = \"0.9.1\" }\nregex = { version = \"1.11.1\" }\nserde = { version = \"1.0.219\", features = [\"derive\", \"rc\"] }\nserde_json = { version = \"1.0.140\" }\nthreadpool = { version = \"1.8.1\" }\ntime = { version = \"0.3.41\", features = [\"macros\", \"formatting\"] }\ntime-humanize = { version = \"0.1.3\" }\nureq = { version = \"3.0.11\", features = [\"json\", \"socks-proxy\"] }\nurl = { version = \"2.5.4\" }\ninfer = \"0.19.0\"\nurlencoding = { version = \"2.1.3\" }\n\n# GUI\ndruid = { git = \"https://github.com/jpochyla/druid\", branch = \"psst\", features = [\n \"im\",\n \"image\",\n \"jpeg\",\n \"png\",\n \"webp\",\n \"serde\",\n] }\ndruid-enums = { git = \"https://github.com/jpochyla/druid-enums\" }\ndruid-shell = { git = \"https://github.com/jpochyla/druid\", branch = \"psst\", features = [\n \"raw-win-handle\",\n] }\nopen = { version = \"5.3.2\" }\nraw-window-handle = \"0.5.2\" # Must stay compatible with Druid\nsouvlaki = { version = \"0.8.2\", default-features = false, features = [\"use_zbus\"] }\nsanitize_html = \"0.9.0\"\nrustfm-scrobble = \"1.1.1\"\n[target.'cfg(windows)'.build-dependencies]\nwinres = { version = \"0.1.12\" }\nimage = { version = \"0.25.6\" }\n\n[package.metadata.bundle]\nname = \"Psst\"\nidentifier = \"com.jpochyla.psst\"\nicon = [\"assets/logo.icns\"]\nversion = \"0.1.0\"\nosx_minimum_system_version = \"11.0\"\nresources = []\ncopyright = \"Copyright (c) Jan Pochyla 2024. All rights reserved.\"\ncategory = \"Music\"\nshort_description = \"Fast and native Spotify client\"\nlong_description = \"\"\"\nSmall and efficient graphical music player for the Spotify network.\n\"\"\"\n" }, { "path": "psst-gui/build-icons.sh", "content": "#!/bin/bash\nset -euo pipefail\n\n# Check for required tools\ncommand -v rsvg-convert >/dev/null 2>&1 || {\n\techo >&2 \"rsvg-convert is required but not installed. Aborting.\"\n\texit 1\n}\ncommand -v iconutil >/dev/null 2>&1 || {\n\techo >&2 \"iconutil is required but not installed. Aborting.\"\n\texit 1\n}\ncommand -v pngquant >/dev/null 2>&1 || {\n\techo >&2 \"pngquant is required but not installed. Aborting.\"\n\texit 1\n}\ncommand -v optipng >/dev/null 2>&1 || {\n\techo >&2 \"optipng is required but not installed. Aborting.\"\n\texit 1\n}\n\n# Temp folder\nICON_DIR=\"icons\"\nmkdir -p \"$ICON_DIR\"\n\n# Generate PNG icons from SVG\nSIZES=(16 32 64 128 256 512)\nfor size in \"${SIZES[@]}\"; do\n\trsvg-convert -w $size -h $size assets/logo.svg -o \"$ICON_DIR/logo_${size}.png\"\n\n\t# Apply lossy compression with pngquant\n\tpngquant --force --quality=60-80 \"$ICON_DIR/logo_${size}.png\" --output \"$ICON_DIR/logo_${size}.png\"\n\n\t# Further optimize with optipng\n\toptipng -quiet -o5 \"$ICON_DIR/logo_${size}.png\"\n\n\t# For smaller sizes, reduce color depth\n\tif [ $size -le 32 ]; then\n\t\tmagick \"$ICON_DIR/logo_${size}.png\" -colors 256 PNG8:\"$ICON_DIR/logo_${size}.png\"\n\tfi\ndone\n\n# Generate ICNS for macOS\nICONSET_DIR=\"$ICON_DIR/psst.iconset\"\nmkdir -p \"$ICONSET_DIR\"\nfor size in \"${SIZES[@]}\"; do\n\tcp \"$ICON_DIR/logo_${size}.png\" \"$ICONSET_DIR/icon_${size}x${size}.png\"\n\tif [ $size -ne 16 ] && [ $size -ne 32 ]; then\n\t\tcp \"$ICON_DIR/logo_${size}.png\" \"$ICONSET_DIR/icon_$((size / 2))x$((size / 2))@2x.png\"\n\tfi\ndone\n\n# Create ICNS file\niconutil -c icns \"$ICONSET_DIR\" -o assets/logo.icns\n\n# Cleanup\nrm -r \"$ICON_DIR\"\n\necho \"Icon generation complete. ICNS file size: $(du -h assets/logo.icns | cut -f1)\"\n" }, { "path": "psst-gui/build.rs", "content": "fn main() {\n #[cfg(windows)]\n add_windows_icon();\n}\n\n#[cfg(windows)]\nfn add_windows_icon() {\n use image::{\n codecs::ico::{IcoEncoder, IcoFrame},\n ColorType,\n };\n\n let ico_path = \"assets/logo.ico\";\n if std::fs::metadata(ico_path).is_err() {\n let ico_frames = load_images();\n save_ico(&ico_frames, ico_path);\n }\n\n let mut res = winres::WindowsResource::new();\n res.set_icon(ico_path);\n res.compile().expect(\"Could not attach exe icon\");\n\n fn load_images() -> Vec> {\n let sizes = [32, 64, 128, 256];\n sizes\n .iter()\n .map(|s| {\n IcoFrame::as_png(\n image::open(format!(\"assets/logo_{s}.png\"))\n .unwrap()\n .as_bytes(),\n *s,\n *s,\n ColorType::Rgba8.into(),\n )\n .unwrap()\n })\n .collect()\n }\n\n fn save_ico(images: &[IcoFrame<'_>], ico_path: &str) {\n let file = std::fs::File::create(ico_path).unwrap();\n let encoder = IcoEncoder::new(file);\n encoder.encode_images(images).unwrap();\n }\n}\n" }, { "path": "psst-gui/src/cmd.rs", "content": "use crate::data::Track;\nuse druid::{Selector, WidgetId};\nuse psst_core::{item_id::ItemId, player::item::PlaybackItem};\nuse std::sync::Arc;\nuse std::time::Duration;\n\nuse crate::{\n data::{Nav, PlaybackPayload, QueueBehavior, QueueEntry},\n ui::find::Find,\n};\n\n// Widget IDs\npub const WIDGET_SEARCH_INPUT: WidgetId = WidgetId::reserved(1);\n\n// Common\npub const SHOW_MAIN: Selector = Selector::new(\"app.show-main\");\npub const SHOW_ACCOUNT_SETUP: Selector = Selector::new(\"app.show-initial\");\npub const CLOSE_ALL_WINDOWS: Selector = Selector::new(\"app.close-all-windows\");\npub const QUIT_APP_WITH_SAVE: Selector = Selector::new(\"app.quit-with-save\");\npub const SET_FOCUS: Selector = Selector::new(\"app.set-focus\");\npub const COPY: Selector = Selector::new(\"app.copy-to-clipboard\");\npub const GO_TO_URL: Selector = Selector::new(\"app.go-to-url\");\n\n// Find\npub const TOGGLE_FINDER: Selector = Selector::new(\"app.show-finder\");\npub const FIND_IN_PLAYLIST: Selector = Selector::new(\"find-in-playlist\");\npub const FIND_IN_SAVED_TRACKS: Selector = Selector::new(\"find-in-saved-tracks\");\n\n// Session\npub const SESSION_CONNECT: Selector = Selector::new(\"app.session-connect\");\npub const LOG_OUT: Selector = Selector::new(\"app.log-out\");\n\n// Navigation\npub const NAVIGATE: Selector