sharpemu/src/SharpEmu.CLI/SharpEmu.CLI.csproj

<!--
Copyright (C) 2026 SharpEmu Emulator Project
SPDX-License-Identifier: GPL-2.0-or-later
-->

<Project Sdk="Microsoft.NET.Sdk">

  <ItemGroup>
    <ProjectReference Include="..\SharpEmu.Core\SharpEmu.Core.csproj" />
    <ProjectReference Include="..\SharpEmu.Debugger\SharpEmu.Debugger.csproj" />
    <ProjectReference Include="..\SharpEmu.GUI\SharpEmu.GUI.csproj" />
    <ProjectReference Include="..\SharpEmu.Logging\SharpEmu.Logging.csproj" />
  </ItemGroup>

  <PropertyGroup>
    <!-- GUI subsystem so starting without arguments opens the frontend with no
         console window; CLI mode re-attaches to the parent terminal's console. -->
    <OutputType>WinExe</OutputType>
    <AssemblyName>SharpEmu</AssemblyName>
    <!-- osx-x64 is the macOS target: the CPU backend executes guest x86-64
         natively, so on Apple Silicon it runs under Rosetta 2. -->
    <RuntimeIdentifiers>win-x64;linux-x64;osx-x64;osx-arm64</RuntimeIdentifiers>
    <!-- A plain "dotnet publish" with no -r defaults $(RuntimeIdentifier) to
         the host's own RID; see Directory.Build.props, which is where that
         default actually has to live (PublishDir's RID suffix is decided
         there, evaluated before this file, so a default set only here would
         be too late for it). -->
    <SelfContained>true</SelfContained>
    <PublishSingleFile>true</PublishSingleFile>
    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
    <EnableCompressionInSingleFile>true</EnableCompressionInSingleFile>
    <ImplicitUsings>enable</ImplicitUsings>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <!-- Server GC reserves one large heap range per logical processor. On
         high-core-count hosts those ranges can overlap fixed PS5 image bases
         before the guest address space is established. Workstation GC avoids
         that collision and keeps the emulator's required mappings available. -->
    <ServerGarbageCollection>false</ServerGarbageCollection>
    <ConcurrentGarbageCollection>true</ConcurrentGarbageCollection>
    <TieredPGO>true</TieredPGO>
  </PropertyGroup>

  <!-- Background GC's write-watch revisit calls FlushProcessWriteBuffers,
       which on macOS uses thread_get_register_pointer_values; under Rosetta 2
       that Mach call can stall indefinitely on threads executing translated
       guest code, wedging the whole runtime (every allocating thread then
       blocks behind the never-finishing GC). Non-concurrent GC never takes
       that path. Windows and Linux keep concurrent GC. -->
  <PropertyGroup Condition="$([System.String]::Copy('$(RuntimeIdentifier)').StartsWith('osx'))">
    <ConcurrentGarbageCollection>false</ConcurrentGarbageCollection>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
    <GenerateDocumentationFile>false</GenerateDocumentationFile>
    <DebugType>none</DebugType>
    <DebugSymbols>false</DebugSymbols>
  </PropertyGroup>

  <PropertyGroup Condition="'$(RuntimeIdentifier)' == 'win-x64' Or '$(RuntimeIdentifier)' == ''">
    <ApplicationIcon>..\..\assets\images\SharpEmu.ico</ApplicationIcon>
    <Win32Icon>..\..\assets\images\SharpEmu.ico</Win32Icon>
    <ApplicationManifest>app.manifest</ApplicationManifest>
  </PropertyGroup>

  <PropertyGroup>
    <NoWarn>$(NoWarn);1591</NoWarn>
  </PropertyGroup>

  <ItemGroup>
    <Content Include="..\..\LICENSE.txt">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
      <TargetPath>LICENSE.txt</TargetPath>
      <Visible>False</Visible>
    </Content>
    <Content Include="..\SharpEmu.GUI\Languages\*.json" Condition="'$(Configuration)' != 'Release'">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
      <TargetPath>Languages\%(Filename)%(Extension)</TargetPath>
      <Visible>False</Visible>
    </Content>
  </ItemGroup>

  <!-- Native libraries (glfw, FFmpeg) publish into a subfolder next to the
       executable instead of sitting loose beside it, so the publish
       directory stays uncluttered as more native deps get added. The folder
       name is a fixed constant, not derived from the RID/architecture: each
       publish output only ever holds one architecture's binaries anyway, so
       varying the name added a class of bugs (RID resolution timing, host-OS
       vs. target-RID mixups) for no benefit. Runtime code (Program.cs's
       PreloadGlfw, FfmpegNativeBinkFrameSource's RootPath) uses the same
       literal "plugins" folder name. -->
  <PropertyGroup>
    <NativeLibraryFolderName>plugins</NativeLibraryFolderName>
  </PropertyGroup>

  <!-- Keep glfw as a loose file in the native subfolder; every other native
       library is embedded into the single-file bundle. -->
  <Target Name="KeepGlfwOutsideSingleFile" AfterTargets="ComputeResolvedFilesToPublishList">
    <ItemGroup>
      <_GlfwPublishFiles Include="@(ResolvedFileToPublish)"
        Condition="$([System.String]::Copy('%(ResolvedFileToPublish.Filename)').StartsWith('glfw')) Or $([System.String]::Copy('%(ResolvedFileToPublish.Filename)').StartsWith('libglfw'))" />
      <ResolvedFileToPublish Remove="@(_GlfwPublishFiles)" />
      <ResolvedFileToPublish Include="@(_GlfwPublishFiles)">
        <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
        <RelativePath>$(NativeLibraryFolderName)/%(Filename)%(Extension)</RelativePath>
      </ResolvedFileToPublish>
    </ItemGroup>
  </Target>

  <PropertyGroup>
    <FfmpegRuntimeTag>2c92585</FfmpegRuntimeTag>
    <FfmpegRuntimeDir>
      $(BaseIntermediateOutputPath)ffmpeg-runtime/$(FfmpegRuntimeTag)/$(RuntimeIdentifier)</FfmpegRuntimeDir>
    <FfmpegRuntimePackage Condition="'$(RuntimeIdentifier)' == 'win-x64'">ffmpeg-windows-x64.zip</FfmpegRuntimePackage>
    <FfmpegRuntimePackage Condition="'$(RuntimeIdentifier)' == 'linux-x64'">ffmpeg-linux-x64.zip</FfmpegRuntimePackage>
    <FfmpegRuntimePackage Condition="'$(RuntimeIdentifier)' == 'osx-x64'">ffmpeg-macos-x64.zip</FfmpegRuntimePackage>
    <FfmpegRuntimePackage Condition="'$(RuntimeIdentifier)' == 'osx-arm64'">ffmpeg-macos-arm64.zip</FfmpegRuntimePackage>
    <FfmpegRuntimeArchive>$(FfmpegRuntimeDir)/$(FfmpegRuntimePackage)</FfmpegRuntimeArchive>
    <FfmpegRuntimeExtractDir>$(FfmpegRuntimeDir)/extracted</FfmpegRuntimeExtractDir>
  </PropertyGroup>

  <Target Name="FetchFfmpegRuntime"
    BeforeTargets="Publish"
    Condition="'$(RuntimeIdentifier)' != '' And '$(FfmpegRuntimePackage)' != ''">
    <DownloadFile
      SourceUrl="https://github.com/sharpemu/ffmpeg-core/releases/download/$(FfmpegRuntimeTag)/$(FfmpegRuntimePackage)"
      DestinationFolder="$(FfmpegRuntimeDir)"
      Condition="!Exists('$(FfmpegRuntimeArchive)')" />
    <Unzip
      SourceFiles="$(FfmpegRuntimeArchive)"
      DestinationFolder="$(FfmpegRuntimeExtractDir)"
      Condition="!Exists('$(FfmpegRuntimeExtractDir)')" />
  </Target>

  <Target Name="PublishFfmpegRuntime"
    AfterTargets="Publish"
    DependsOnTargets="FetchFfmpegRuntime"
    Condition="'$(RuntimeIdentifier)' != '' And '$(FfmpegRuntimePackage)' != ''">
    <!-- Keyed off the target $(RuntimeIdentifier), not the host OS: publishing
         e.g. linux-x64 from a Windows machine is a supported cross-publish,
         and the extracted archive's own layout (bin/*.dll vs lib/*.so*) only
         depends on which platform's ffmpeg-core package was fetched. -->
    <ItemGroup>
      <_FfmpegRuntimeFiles Condition="$(RuntimeIdentifier.StartsWith('win'))"
        Include="$(FfmpegRuntimeExtractDir)/bin/*.dll" />
      <_FfmpegRuntimeFiles Condition="!$(RuntimeIdentifier.StartsWith('win'))"
        Include="$(FfmpegRuntimeExtractDir)/lib/*.so;$(FfmpegRuntimeExtractDir)/lib/*.so.*;$(FfmpegRuntimeExtractDir)/lib/*.dylib" />
    </ItemGroup>
    <Copy SourceFiles="@(_FfmpegRuntimeFiles)"
      DestinationFolder="$(PublishDir)$(NativeLibraryFolderName)"
      SkipUnchangedFiles="true" />
  </Target>

</Project>