mirror of
https://github.com/focus-creative-games/hybridclr_unity.git
synced 2026-11-19 14:52:41 +08:00
Compare commits
185 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 7e74e59637 | |||
| e48a7beb95 | |||
| 9790036a2f | |||
| ea9196e8c3 | |||
| 6cadd24d10 | |||
| 9b2cbbf1a7 | |||
| ab71cfa6cf | |||
| e61ff2296f | |||
| 635dc7dd1e | |||
| 0762becc28 | |||
| 52f07bc8b3 | |||
| baa70f8eb9 | |||
| 8d0476c2c9 | |||
| f5ca39f3c9 | |||
| 86e6407a35 | |||
| 44057b0107 | |||
| d17a727fac | |||
| d91835ac31 | |||
| 6ecc0a9728 | |||
| fd32708e7f | |||
| a0e0b502c6 | |||
| a93ca3dc27 | |||
| b700ae679c | |||
| 6e635f78bf | |||
| ca7f87b6a7 | |||
| e4def761d6 | |||
| f0be76c0ce | |||
| 4feac30cb2 | |||
| fc3d9dcd7d | |||
| 6a320c556f | |||
| 03083ad8f9 | |||
| c6d53bff82 | |||
| 77d4aec034 | |||
| 4df417e56a | |||
| 213d44bd12 | |||
| c138a58c4d | |||
| fcef6dfe8e | |||
| 478caea644 | |||
| 2534dea381 | |||
| 391cd04cdf | |||
| 01754c8fb4 | |||
| 1934d90f27 | |||
| 814572e1a1 | |||
| d505624c78 | |||
| e36bbb9022 | |||
| 0642726469 | |||
| d86572db37 | |||
| b5944ea834 | |||
| 73654e76d2 | |||
| 1537690bb5 | |||
| 7f158f814a | |||
| ee7af5c592 | |||
| ab41cd0144 | |||
| 59a3c3974a | |||
| c9ff293dfe | |||
| 56486b8a76 | |||
| 8e27e8d41b | |||
| fca130bbfa | |||
| c21dbcc60a | |||
| 7f2fa52f37 | |||
| da46e71534 | |||
| 804418fddb | |||
| 7a0032934b | |||
| b301b44cd3 | |||
| ddc3332958 | |||
| 52f25bdb2a | |||
| 31be818bb6 | |||
| 213a11ff25 | |||
| 585be97be9 | |||
| 361873803f | |||
| 46f308ed5e | |||
| 34406b1c13 | |||
| e5b52922f7 | |||
| e44fa663db | |||
| 903cf9faa2 | |||
| 3fe41a8cba | |||
| 603b0ccb24 | |||
| 9429a4d24d | |||
| ea592ba20c | |||
| 8d1280a1bd | |||
| 528240b52b | |||
| 4768c039d2 | |||
| 10dc749d7a | |||
| 0c5ef00c12 | |||
| 1553582ec1 | |||
| 756b906a21 | |||
| 355e24fbe8 | |||
| 9e4946aa45 | |||
| 8e571d594d | |||
| b8dd2be1e4 | |||
| de7b60695a | |||
| a11ebecf93 | |||
| 019412fa81 | |||
| 84bf6d59db | |||
| 82163d2e50 | |||
| 208372e6af | |||
| dd8d812641 | |||
| c19b34542e | |||
| e30306d7e1 | |||
| 20f34c9b14 | |||
| 45749ffb5c | |||
| b176d63d93 | |||
| 0c99afd58e | |||
| 2458c9a9ba | |||
| 4d0fef095b | |||
| 642d2cd644 | |||
| e54ce36b0e | |||
| ac8b649d50 | |||
| 9ca9cd5aa7 | |||
| 37dafd7b3c | |||
| f58d12c2cb | |||
| d5eaa350c5 | |||
| 1f0053a3c9 | |||
| 15dccc7427 | |||
| 7d287a2293 | |||
| f19ba3eb30 | |||
| 4e172129d8 | |||
| 2414e77fef | |||
| 77517a9814 | |||
| 162f21f6a5 | |||
| bd7c3293bc | |||
| e25be945c7 | |||
| 925921c27c | |||
| 64a6d26fa3 | |||
| c24617d864 | |||
| 59bc259cc8 | |||
| c413cd6143 | |||
| c614cdcf4e | |||
| 08f493ab3e | |||
| 3705ca6e1f | |||
| 34df279943 | |||
| b85ed1aa92 | |||
| faf4a328af | |||
| 53f4f33bf0 | |||
| 48c91f497b | |||
| 9afbe3bd84 | |||
| 2d5f71f6b7 | |||
| 5747458bf2 | |||
| 0b455eb882 | |||
| e086228d90 | |||
| 909e96ca7c | |||
| 75b24345f6 | |||
| 88e20505f8 | |||
| b4b486944c | |||
| 360ba38805 | |||
| e5a6952777 | |||
| 9330cf682c | |||
| 16a7d5d529 | |||
| 303c6c7b35 | |||
| e4cf9e9086 | |||
| b977a85b23 | |||
| 0fcb51a369 | |||
| d61511924d | |||
| aca7dd0a67 | |||
| fc685a99ca | |||
| d431aeb019 | |||
| 63d0aaa6e6 | |||
| d45974c6b4 | |||
| 3de931a3af | |||
| b96d6fc10d | |||
| ef1b78caae | |||
| 47622bf49c | |||
| 846d7103a3 | |||
| 170f13082e | |||
| 60016d7481 | |||
| 97dae7fed2 | |||
| f935127cd3 | |||
| ec5f2ef05e | |||
| 6d0ceaa4f5 | |||
| 95922aec1e | |||
| 3259c11828 | |||
| 74bab1d935 | |||
| fd81edb495 | |||
| 12bafb897f | |||
| a6befb1312 | |||
| a36e3fe72d | |||
| d9776d1793 | |||
| 2697eb5a90 | |||
| 4879bb7f44 | |||
| 24f85780a2 | |||
| 6c679cc3ab | |||
| 20a06f1ec5 | |||
| 5446bd937c | |||
| ae88dd0eec | |||
| a5c006d67c |
Binary file not shown.
Binary file not shown.
@@ -1,24 +1,24 @@
|
||||
{
|
||||
"versions": [
|
||||
{
|
||||
"unity_version":"2019",
|
||||
"hybridclr" : { "branch":"v5.1.0"},
|
||||
"il2cpp_plus": { "branch":"v2019-5.0.0"}
|
||||
"unity_version":"2022.3.x",
|
||||
"hybridclr" : { "tag":"v9.1.0"},
|
||||
"il2cpp_plus": { "tag":"v2022.3.x-9.1.0"}
|
||||
},
|
||||
{
|
||||
"unity_version":"2020",
|
||||
"hybridclr" : { "branch":"v5.1.0"},
|
||||
"il2cpp_plus": { "branch":"v2020-5.0.0"}
|
||||
"unity_version":"2022.3.x-tuanjie",
|
||||
"hybridclr" : { "tag":"v9.1.0"},
|
||||
"il2cpp_plus": { "tag":"v2022.3.x-tuanjie-9.1.0"}
|
||||
},
|
||||
{
|
||||
"unity_version":"2021",
|
||||
"hybridclr" : { "branch":"v5.1.0"},
|
||||
"il2cpp_plus": { "branch":"v2021-5.0.0"}
|
||||
"unity_version":"6000.0.x",
|
||||
"hybridclr" : { "tag":"v9.1.0"},
|
||||
"il2cpp_plus": { "tag":"v6000.0.x-9.1.0"}
|
||||
},
|
||||
{
|
||||
"unity_version":"2022",
|
||||
"hybridclr" : { "branch":"v5.1.0"},
|
||||
"il2cpp_plus": { "branch":"v2022-5.1.0"}
|
||||
"unity_version":"6000.3.x",
|
||||
"hybridclr" : { "tag":"v6000.3.x-9.1.0"},
|
||||
"il2cpp_plus": { "tag":"v6000.3.x-9.1.0"}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
---
|
||||
name: hybridclr-aot-generic
|
||||
description: >-
|
||||
Handle HybridCLR AOT generics: supplementary metadata via LoadMetadataForAOTAssembly, saving stripped AOT dlls per platform, HomologousImageMode, AOTGenericReference, and MissingMethodException for an AOT generic method. Use when an AOT generic fails to instantiate, the user asks about metadata patching, List/Dictionary/async generics, or which supplementary dll to ship.
|
||||
---
|
||||
|
||||
# AOT generics
|
||||
|
||||
Docs: `guide/build/aotgeneric.md` and `start/generic.md` in the HybridCLR documentation.
|
||||
|
||||
Generic types and methods **defined in hot-update assemblies** have no AOT restriction. The restriction is hot-update code using a generic **defined in an AOT assembly** (`List<T>`, `Dictionary<TKey,TValue>`, async state machines, and similar) when that instantiation was not generated in AOT. Typical log:
|
||||
|
||||
```text
|
||||
MissingMethodException: AOT generic method not instantiated in aot module
|
||||
```
|
||||
|
||||
## Default: supplementary metadata
|
||||
|
||||
The community edition uses supplementary metadata. Do not send the user to hand-written RefTypes unless they are chasing one instantiation or optimizing a hot path.
|
||||
|
||||
Patch the **AOT dll that contains the generic method**, not the dll that contains the generic argument. `List<SomeHotUpdateStruct>` needs `mscorlib.dll`, because the missing IL is `List<T>.Add`, not the struct.
|
||||
|
||||
```csharp
|
||||
// Call once before any hot-update code uses that AOT generic. Order among dlls does not matter.
|
||||
LoadImageErrorCode err = HybridCLR.RuntimeApi.LoadMetadataForAOTAssembly(dllBytes, HomologousImageMode.SuperSet);
|
||||
// Do not keep dllBytes. The API copies them.
|
||||
```
|
||||
|
||||
- Call it after player startup, or after hot-update dlls are loaded and before business code runs. The supplementary dlls can ship in the player (for example StreamingAssets) or with a hot update.
|
||||
- Call it on another thread if it stalls.
|
||||
- Loaded metadata uses several times the dll size and is not released. Memory-tight projects use the commercial full generic sharing build (no supplementary dlls), or run `AOTAssemblyMetadataStripper.Strip` to drop non-generic method metadata first.
|
||||
- `HybridCLR/Generate/AOTGenericReference` writes a conservative `PatchedAOTAssemblyList`. Load the whole list when memory is fine. Otherwise start with common dlls such as `mscorlib` and add a dll when a new AOT generic error appears. Supplementary dlls can themselves be hot-updated.
|
||||
|
||||
## Which dll
|
||||
|
||||
The player build copies stripped AOT dlls to `{project}/HybridCLRData/AssembliesPostIl2CppStrip/{target}`. `Generate/AotDlls` can also produce them by exporting a temp project.
|
||||
|
||||
- **Stripped dlls from different BuildTargets are not interchangeable.**
|
||||
- **Freeze the dlls from the shipped player.** Do not replace them with a newer Generate output on every hot update.
|
||||
- `HomologousImageMode.SuperSet`: a superset is enough. Stripped or original AOT dlls both work. Use this by default.
|
||||
- `HomologousImageMode.Consistent`: the bytes must match **that player build's** stripped dll. Original dlls do not work. `Generate/All` output often differs slightly from the real player, so Consistent fails more often.
|
||||
|
||||
## Generic sharing (optional)
|
||||
|
||||
After metadata is loaded, HybridCLR still prefers an il2cpp shared instantiation when one exists. Class type arguments share as `object`. Non-enum value types share only with themselves. Enums share with enums of the same underlying type. Value types do not share across different types the way classes do, so `List<HotUpdateStruct>` is not covered by an AOT `List<int>`.
|
||||
|
||||
Instantiations in `AOTGenericReferences.cs` are comments and are overwritten on regenerate. Copy any you want into another AOT file (for example `new List<object>()`). That is a performance optimization, not a requirement for correctness.
|
||||
|
||||
## Full generic sharing
|
||||
|
||||
Commercial editions only. It removes the size, memory, and interpreted-call cost of supplementary metadata. Do not switch the workflow to it unless the user has that edition.
|
||||
@@ -0,0 +1,48 @@
|
||||
---
|
||||
name: hybridclr-avoid-code-strip
|
||||
description: >-
|
||||
Keep Unity IL2CPP from stripping AOT types and methods that hot-update code calls: Generate/LinkXml, linkPreserveLevel, a hand-written Assets/link.xml, a real reference from the main project, and MissingMetadataChecker. Use for TypeLoadException, MissingMethodException that is not an AOT generic error, code stripping, link.xml, or Generate/LinkXml.
|
||||
---
|
||||
|
||||
# Avoid code stripping
|
||||
|
||||
Doc: `guide/build/codestriping.md` in the HybridCLR documentation.
|
||||
|
||||
If a stripped AOT type or method is called from hot-update code:
|
||||
|
||||
```text
|
||||
TypeLoadException: Could not load type 'Xxx' from assembly 'yyy'
|
||||
MissingMethodException: ...
|
||||
```
|
||||
|
||||
If the log says `AOT generic method not instantiated`, use `hybridclr-aot-generic`. link.xml does not fix that.
|
||||
|
||||
## Before the player build
|
||||
|
||||
Run `HybridCLR/Generate/All` before building the player. It includes `Generate/LinkXml`. LinkXml alone scans AOT references from the current hot-update dlls.
|
||||
|
||||
- Output is Settings `outputLinkFile`, default `Assets/HybridCLR/Generate/link.xml`.
|
||||
- **Do not** point `outputLinkFile` at a hand-maintained `Assets/link.xml`. Generation overwrites it.
|
||||
- `linkPreserveLevel`: default `PreserveAllOfDeclaringType` keeps the whole referenced type. Use `PreserveExactMember` only to shrink the player (referenced fields, methods, properties, and events). A later hot update that touches another member can then miss it.
|
||||
|
||||
## When link.xml has no effect
|
||||
|
||||
If the main project never references any type or method in an AOT assembly, Unity strips that assembly entirely and preserve entries are ignored. Reference one type or method from that dll in the main project.
|
||||
|
||||
`preserve all` on `UnityEngine.Debug` can hit a Unity bug. Since 6.1.0, generated link.xml skips that class. Do not add it back.
|
||||
|
||||
## Reserve types for later hot updates
|
||||
|
||||
`Generate/LinkXml` only covers references in the **current** hot-update dlls. Put types you will need later in a separate `Assets/link.xml`, or call them from the main project. Do not put them in the generated file.
|
||||
|
||||
## Check before publishing a hot update
|
||||
|
||||
Use the stripped AOT dll directory saved from the player build. Do not use `AssembliesPostIl2CppStrip` after a later `Generate/All` has refreshed it.
|
||||
|
||||
```csharp
|
||||
var checker = new HybridCLR.HotUpdate.MissingMetadataChecker(
|
||||
aotDirFromPlayerBuild, SettingsUtil.HotUpdateAssemblyNamesIncludePreserved);
|
||||
bool ok = checker.Check(hotUpdateDllPath); // false: the dll touches a stripped type or method
|
||||
```
|
||||
|
||||
The second argument is hot-update assembly names without `.dll`. If an Ultimate build also has DHE assemblies, include those names in the list.
|
||||
@@ -0,0 +1,51 @@
|
||||
---
|
||||
name: hybridclr-configure
|
||||
description: >-
|
||||
Configure HybridCLR Settings and PlayerSettings: enable, hot-update assembly lists, external dll search paths, link.xml output, linkPreserveLevel, incremental GC, and IL2CPP. Use when the user opens HybridCLR/Settings, edits ProjectSettings/HybridCLRSettings.asset, checks settings before a player build, or asks what a setting does.
|
||||
---
|
||||
|
||||
# Configure HybridCLR
|
||||
|
||||
Docs: `guide/setup/projectsettings.md` and `guide/setup/hybridclr-unity-package.md` in the HybridCLR documentation. Fields follow `Editor/Settings/HybridCLRSettings.cs` in this repo. The asset is `ProjectSettings/HybridCLRSettings.asset`.
|
||||
|
||||
How to split assemblies and create asmdefs is `hybridclr-hotupdate-assembly`. Do not expand that here.
|
||||
|
||||
## PlayerSettings
|
||||
|
||||
- Scripting Backend is **IL2CPP**. WebGL does not use this option. Since v2.4.0 the build check switches this automatically.
|
||||
- Api Compatibility Level is **.NET Framework**.
|
||||
- Incremental GC is allowed since v4.0.0. Older packages must turn it off.
|
||||
|
||||
## Hot-update lists
|
||||
|
||||
`hotUpdateAssemblyDefinitions` and `hotUpdateAssemblies` merge into the final hot-update dll list. **Do not put the same assembly in both.**
|
||||
|
||||
| Source | Where |
|
||||
|---|---|
|
||||
| asmdef | `hotUpdateAssemblyDefinitions` |
|
||||
| External dll, or `Assembly-CSharp` | `hotUpdateAssemblies`, name **without** `.dll` |
|
||||
|
||||
An empty list fails the player-build check. `IFilterBuildAssemblies` removes these dlls from the player build so they are not compiled into AOT.
|
||||
|
||||
## Settings
|
||||
|
||||
- `enable`: default true. Turning it off drops HybridCLR from the player. Also remove the main project's reference to `HybridCLR.Runtime`, or symbols such as `LoadMetadataForAOTAssembly` are missing.
|
||||
- `useGlobalIl2cpp`: default false. Keep the local `UNITY_IL2CPP_PATH`.
|
||||
- `hybridclrRepoURL` / `il2cppPlusRepoURL`: clone URLs for the installer. Default is gitee.
|
||||
- `preserveHotUpdateAssemblies`: names of hot-update dlls that do not exist yet (no `.dll`). The build does not check that the files exist, but it writes the names into `ScriptingAssemblies.json` so scripts can be attached to assets later. Do not list dlls that already exist.
|
||||
- `externalHotUpdateAssembliyDirs`: search paths for external hot-update dlls. The serialized name is spelled `Assembliy`. Do not rename it. Paths are relative to the **project root** (parent of Assets). Each entry is searched as `{dir}/{platform}` first, then `{dir}`. Earlier entries win. The dll name still goes in `hotUpdateAssemblies`.
|
||||
- `outputLinkFile`: output of `Generate/LinkXml`. Default `HybridCLR/Generate/link.xml`, relative to Assets. **Do not** point it at `Assets/link.xml`. Generation overwrites the file.
|
||||
- `linkPreserveLevel`: `PreserveAllOfDeclaringType` (default; keep every member of a referenced type) or `PreserveExactMember` (only referenced fields, methods, properties, and events; smaller).
|
||||
- `outputAOTGenericReferenceFile`: default `HybridCLR/Generate/AOTGenericReferences.cs`.
|
||||
- `maxGenericReferenceIteration` / `maxMethodBridgeGenericIteration`: generic scan iteration cap, default 10. Raise them only if the log shows the scan has not converged.
|
||||
|
||||
## Fixed output directories
|
||||
|
||||
These are not settings:
|
||||
|
||||
- Hot-update dlls: `{project}/HybridCLRData/HotUpdateDlls/{target}`
|
||||
- Stripped AOT dlls: `{project}/HybridCLRData/AssembliesPostIl2CppStrip/{target}`
|
||||
|
||||
## What the package does during a player build
|
||||
|
||||
Do not hand-edit these: set or clear the process `UNITY_IL2CPP_PATH` from `enable`; strip hot-update assemblies from the build; write hot-update dll names into the assembly list; copy stripped AOT dlls to the directory above.
|
||||
@@ -0,0 +1,61 @@
|
||||
---
|
||||
name: hybridclr-hotupdate-assembly
|
||||
description: >-
|
||||
Split, create, compile, and load HybridCLR hot-update assemblies: asmdefs and Assembly-CSharp, forbidding AOT references to hot-update code, CompileDll, Assembly.Load order, and calling hot-update entry points from the main project. Use when the user adds a hot-update module, splits AOT and hot-update code, compiles HotUpdate.dll, loads a dll, hits a duplicate load, or a player build references a hot-update assembly.
|
||||
---
|
||||
|
||||
# Hot-update assemblies
|
||||
|
||||
Docs: `guide/setup/hotupdateassemblysetting.md`, `guide/build/compileassembly.md`, and `guide/build/runhotupdatecodes.md` in the HybridCLR documentation. Settings fields are in `hybridclr-configure`.
|
||||
|
||||
## Split
|
||||
|
||||
Keep at least one **AOT** assembly for startup and for downloading hot-update content. Hot-update code must live in its own assembly.
|
||||
|
||||
Two common layouts:
|
||||
|
||||
- `Assembly-CSharp` stays AOT, and other code is split into AOT and hot-update asmdefs. **Turn off Auto Referenced on hot-update asmdefs.** `Assembly-CSharp` references every other assembly, so Auto Referenced easily creates an AOT reference to a hot-update dll and the player build fails.
|
||||
- `Assembly-CSharp` itself is hot-update. Put the name in `hotUpdateAssemblies` without `.dll`.
|
||||
|
||||
AOT assemblies must not reference hot-update assemblies. Hot-update assemblies may reference each other. Load dependencies first.
|
||||
|
||||
## Create
|
||||
|
||||
1. Create a folder, for example `Assets/HotUpdate`.
|
||||
2. Create → Assembly Definition, named like the module.
|
||||
3. In `HybridCLR/Settings`, put asmdefs in `hotUpdateAssemblyDefinitions`. Put assemblies that have no asmdef in `hotUpdateAssemblies` by name. Do not add the same assembly to both.
|
||||
4. For a prebuilt dll outside the default output directory, put the name in `hotUpdateAssemblies` and the directory in `externalHotUpdateAssembliyDirs` (relative to the project root).
|
||||
|
||||
## Compile
|
||||
|
||||
Do not ship dlls from `Library/ScriptAssemblies`. Those are compiled for the Editor target and depend on the debugger setting.
|
||||
|
||||
- Use `HybridCLR/Compile/{platform}`, or `HybridCLR.Editor.Commands.CompileDllCommand.CompileDll(BuildTarget)`.
|
||||
- Output: `{project}/HybridCLRData/HotUpdateDlls/{target}`. Compile once per BuildTarget so defines such as `UNITY_ANDROID` match.
|
||||
- `HybridCLR/Generate/All` also compiles hot-update dlls. **After the player is shipped**, a normal hot update only recompiles and publishes the dll. Do not run Generate every time.
|
||||
|
||||
When copying into assets, add a `.bytes` extension (`HotUpdate.dll.bytes`).
|
||||
|
||||
## Load
|
||||
|
||||
```csharp
|
||||
// The runtime copies the bytes. Do not keep assemblyData or pdb after the call returns.
|
||||
Assembly ass = Assembly.Load(assemblyData);
|
||||
// Since v6.4.0, symbols can load with the assembly:
|
||||
Assembly ass2 = Assembly.Load(assemblyData, pdbSymbolData);
|
||||
```
|
||||
|
||||
- `Assembly.Load` multiple dlls in dependency order. Move the call to another thread if it stalls the main thread.
|
||||
- **Do not Load again in the Editor.** The assemblies are already in the domain. Wrap the load in `#if !UNITY_EDITOR` and, in the Editor, find them with `AppDomain.CurrentDomain.GetAssemblies()`.
|
||||
- An assembly missing from the hot-update lists is compiled into AOT. Loading it again at runtime is a duplicate load.
|
||||
|
||||
## Call hot-update code from AOT
|
||||
|
||||
The main project cannot reference hot-update types directly. Typical entry points:
|
||||
|
||||
- Reflection: `ass.GetType(...).GetMethod(...).Invoke`
|
||||
- `Delegate.CreateDelegate`, or `Activator.CreateInstance` cast to an interface defined in AOT
|
||||
- `go.AddComponent(type)` after the dll is loaded
|
||||
- Instantiate a prefab or scene packed in an AssetBundle (extra rules for scripts on assets are in `hybridclr-monobehaviour`)
|
||||
|
||||
Load the dll **before** loading an AssetBundle that should restore those scripts.
|
||||
@@ -0,0 +1,28 @@
|
||||
---
|
||||
name: hybridclr-monobehaviour
|
||||
description: >-
|
||||
Use MonoBehaviour and ScriptableObject from HybridCLR hot-update code: AddComponent, scripts on assets, ScriptingAssemblies.json, AssetBundle load order, Script Missing, and the GetComponent(string) limitation. Use when the user attaches a hot-update script to a prefab or scene, hits Script Missing, or asks about the hot-update MonoBehaviour workflow.
|
||||
---
|
||||
|
||||
# Hot-update MonoBehaviour
|
||||
|
||||
Doc: `guide/features/monobehaviour.md` in the HybridCLR documentation. Registering the assembly is `hybridclr-hotupdate-assembly`.
|
||||
|
||||
`AddComponent<T>()` and `AddComponent(Type)` work after that dll has been `Assembly.Load`ed.
|
||||
|
||||
## Scripts and ScriptableObjects on assets
|
||||
|
||||
Deserialization needs all of the following:
|
||||
|
||||
1. The dll that contains the script is already loaded.
|
||||
2. The asset is loaded from an AssetBundle (Addressables and other AB-based systems count). A script on a Resources asset or a scene that ships in the player becomes **Script Missing**. Building that asset into an AssetBundle and then placing the bundle in Resources is fine.
|
||||
3. The dll name is in the generated `ScriptingAssemblies.json`. Hot-update dlls are removed by `IFilterBuildAssemblies`, so they are not listed on their own. `PatchScriptingAssemblyList` writes names from `hotUpdateAssemblyDefinitions`, `hotUpdateAssemblies`, and `preserveHotUpdateAssemblies`. Unlisted assemblies are not restored.
|
||||
|
||||
The hot-update dll itself may live in an AssetBundle, as a raw file, or in an encrypted package. `Assembly.Load` it **before** loading assets that contain the scripts.
|
||||
|
||||
Do not rename these assemblies after release. The assembly list is baked into the player and cannot be hot-updated.
|
||||
|
||||
## Known limits
|
||||
|
||||
- `GetComponent(string)` cannot find a hot-update script that was restored from a hot-update asset. Use `GetComponent<T>()` or `GetComponent(typeof(T))`. Components added with `AddComponent` in code are not affected.
|
||||
- Do not disable TypeTree when building AssetBundles. Script signature checks then fail and a normal load fails. If TypeTree must be off, call `AssetBundleCreateRequest.SetEnableCompatibilityChecks(false)` through reflection and keep code and asset versions matched. A mismatch can crash.
|
||||
@@ -0,0 +1,39 @@
|
||||
---
|
||||
name: hybridclr-monopinvokecallback
|
||||
description: >-
|
||||
Reserve MonoPInvokeCallback and ReversePInvokeWrapper slots for HybridCLR hot-update methods: ReversePInvokeWrapperGenerationAttribute, Generate/ReversePInvokeWrapper, and the lack of automatic marshaling for string and other non-blittable arguments. Use for MonoPInvokeCallback, xlua/tolua/puerts callbacks, too few wrappers, or a crash when native code calls hot-update C#.
|
||||
---
|
||||
|
||||
# MonoPInvokeCallback
|
||||
|
||||
Doc: `guide/features/monopinvokecallback.md` in the HybridCLR documentation. Choosing a Lua, JS, or Python stack is `hybridclr-script-language`.
|
||||
|
||||
A static method with `[MonoPInvokeCallback]` needs a C++ wrapper before `Marshal.GetFunctionPointerForDelegate` can return a pointer. Platforms that cannot JIT, including iOS, cannot create that wrapper at runtime. Generate it in the player build with `HybridCLR/Generate/ReversePInvokeWrapper` (`Generate/All` includes it).
|
||||
|
||||
## Reserve a count
|
||||
|
||||
Generating one wrapper per current callback runs out as soon as a later hot update adds another callback.
|
||||
|
||||
Add `[ReversePInvokeWrapperGeneration(preserveCount)]` (`HybridCLR` namespace) on the callback. **Counts are per signature:**
|
||||
|
||||
wrappers for a signature = sum of `preserveCount` on that signature + number of callbacks of that signature that do not have the attribute.
|
||||
|
||||
```csharp
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
||||
delegate int LuaFunction(IntPtr luaState);
|
||||
|
||||
[ReversePInvokeWrapperGeneration(10)]
|
||||
[MonoPInvokeCallback(typeof(LuaFunction))]
|
||||
public static int LuaCallback(IntPtr luaState) => 0;
|
||||
```
|
||||
|
||||
The reservation is fixed in the player. Hot updates can only consume wrappers that were already generated.
|
||||
|
||||
## Argument marshaling
|
||||
|
||||
HybridCLR does **not** marshal arguments when calling these callbacks. `int` and `float` work. `string` arrives as `char*` and using it as a string crashes.
|
||||
|
||||
Two options:
|
||||
|
||||
1. Put the callback in AOT and call into hot-update code from there. The AOT wrapper has il2cpp marshaling.
|
||||
2. Take `IntPtr` in the hot-update callback and convert with `Marshal.PtrToStringUTF8`. Do the same for other non-primitive types that need marshaling.
|
||||
@@ -0,0 +1,36 @@
|
||||
---
|
||||
name: hybridclr-script-language
|
||||
description: >-
|
||||
Run HybridCLR next to Lua, JavaScript/TypeScript, or Python: prefer ZLua and ZenTS; xlua, tolua, slua, and puerts need reserved ReversePInvokeWrappers and generated binding code moved into a hot-update assembly. Use when the user combines HybridCLR with lua, js, ts, python, xlua, tolua, puerts, zlua, or ZenTS, or is moving script hot update to C#.
|
||||
---
|
||||
|
||||
# Script languages
|
||||
|
||||
Doc: `guide/features/workwithscriptlanguage.md` in the HybridCLR documentation. Wrapper reservation rules are in `hybridclr-monopinvokecallback`. Do not restate them here.
|
||||
|
||||
HybridCLR is native C# hot update. It can sit beside an existing script stack while gameplay moves back to C#.
|
||||
|
||||
## Prefer ZLua / ZenTS
|
||||
|
||||
For a new scripting layer, use the official stacks instead of xlua or puerts.
|
||||
|
||||
- [ZLua](https://github.com/focus-creative-games/zlua) for Lua
|
||||
- [ZenTS](https://github.com/focus-creative-games/zen-ts) for JavaScript / TypeScript
|
||||
|
||||
They talk to il2cpp directly. They do not need `[MonoPInvokeCallback]` or a wrapper quota. Use the path below only when the project is already on xlua, tolua, or puerts.
|
||||
|
||||
## Other script stacks
|
||||
|
||||
xlua, tolua, slua, puerts, and similar binders call C# from native through `[MonoPInvokeCallback]`. Before the player build:
|
||||
|
||||
1. Add `[ReversePInvokeWrapperGeneration(n)]` on signatures that will grow. The count must cover later hot updates, not only the callbacks that exist now.
|
||||
2. Run `HybridCLR/Generate/All` (includes `ReversePInvokeWrapper`).
|
||||
3. Put generated binding code in a **hot-update** assembly and register that assembly. Do not leave it where it will be compiled as AOT.
|
||||
|
||||
### xlua
|
||||
|
||||
xlua emits code into global `Assembly-CSharp` and ties it to runtime types with partial classes. The generated output usually has to be edited before it can live in a hot-update assembly. [HybridCLRXlua](https://gitee.com/ldr123/HybridCLRXlua) is a working reference. Follow that project's assembly split. Do not assume the stock xlua generator supports HybridCLR as-is.
|
||||
|
||||
### tolua, slua, puerts
|
||||
|
||||
Check three things: enough wrappers are reserved, generated code is in the hot-update module, and registration runs after the hot-update dll is loaded.
|
||||
@@ -0,0 +1,47 @@
|
||||
---
|
||||
name: hybridclr-setup
|
||||
description: >-
|
||||
Install and initialize com.code-philosophy.hybridclr: pick a matching Unity and package version, add the package from git or a local Packages folder, run HybridCLR/Installer, and recover from git or network failures. Use when the user installs, upgrades, or initializes HybridCLR, or when install fails, git clone fails, or the player still uses stock IL2CPP.
|
||||
---
|
||||
|
||||
# Install HybridCLR
|
||||
|
||||
Docs: `guide/setup/install.md` and `guide/setup/supported-platforms-and-unity-versions.md` in the HybridCLR documentation. Package and il2cpp branches come from this repo's `Data~/hybridclr_version.json`. Do not change those branches from memory.
|
||||
|
||||
## Versions
|
||||
|
||||
- **v9.x** supports Unity **2022.3.x** and **6000.x** except 6000.5.x. Use **v8.x** for 2019.4, 2020.3, and 2021.3.
|
||||
- The package name is `com.code-philosophy.hybridclr`. Before v3.0.0 it was `com.focus-creative-games.hybridclr_unity`.
|
||||
- Standalone players need the **IL2CPP** module (`Windows Build Support (IL2CPP)` or `Mac Build Support (IL2CPP)`). An editor that only has the iOS or Android module cannot build that Standalone player. Exporting an iOS Xcode project does not require a local signing certificate.
|
||||
|
||||
## Install the package
|
||||
|
||||
Either:
|
||||
|
||||
1. Package Manager → Add package from git URL: `https://gitee.com/focus-creative-games/hybridclr_unity.git` or the GitHub repo with the same name. Pin a tag with `#{tag}`, for example `#v9.0.0`.
|
||||
2. Place the repo at `Packages/com.code-philosophy.hybridclr`.
|
||||
|
||||
## Initialize (required)
|
||||
|
||||
Installing the package does not replace libil2cpp.
|
||||
|
||||
1. **git** must be installed. Restart the Unity Editor and Hub after installing git. Restart the machine if git is on PATH but the installer still cannot find it.
|
||||
2. Open `HybridCLR/Installer...` and use the default remote install. Success prints `安装成功` and the status becomes installed.
|
||||
3. The installer clones the `hybridclr` and `il2cpp_plus` branches listed in `Data~/hybridclr_version.json` for the current Unity major version. Do not edit that file unless the user explicitly wants a non-matching version.
|
||||
4. If git or the network is unavailable, merge a local libil2cpp that already contains HybridCLR, enable "copy libil2cpp from local" in the installer, and install. Merge `il2cpp_plus/libil2cpp` with `hybridclr/hybridclr` into the final libil2cpp (see the install doc).
|
||||
|
||||
Local install lands in `{project}/HybridCLRData/LocalIl2CppData-{platform}/`. The package sets `UNITY_IL2CPP_PATH` only for the **current Editor process**. Leave `useGlobalIl2cpp` off.
|
||||
|
||||
## Updates
|
||||
|
||||
After updating the package, run `HybridCLR/Installer` again. The installer clears `Library/Il2cppBuildCache`. If libil2cpp was replaced by hand, delete that cache or the player build keeps the old IL2CPP.
|
||||
|
||||
## Host tools
|
||||
|
||||
- Windows: Visual Studio 2022 or newer with the Unity game development and C++ game development workloads, plus git.
|
||||
- Mac: macOS 12 or newer, Xcode 13 or newer, plus git and cmake.
|
||||
|
||||
## Do not
|
||||
|
||||
- Do not replace libil2cpp inside the Editor install unless the user explicitly wants a global install and accepts that other projects are affected and that every `Generate` must be copied back over the Editor libil2cpp.
|
||||
- WebGL uses the same local install as other platforms.
|
||||
@@ -1,55 +0,0 @@
|
||||
// Common/CRC.cs
|
||||
|
||||
namespace SevenZip
|
||||
{
|
||||
public class CRC
|
||||
{
|
||||
public static readonly uint[] Table;
|
||||
|
||||
static CRC()
|
||||
{
|
||||
Table = new uint[256];
|
||||
const uint kPoly = 0xEDB88320;
|
||||
for (uint i = 0; i < 256; i++)
|
||||
{
|
||||
uint r = i;
|
||||
for (int j = 0; j < 8; j++)
|
||||
if ((r & 1) != 0)
|
||||
r = (r >> 1) ^ kPoly;
|
||||
else
|
||||
r >>= 1;
|
||||
Table[i] = r;
|
||||
}
|
||||
}
|
||||
|
||||
uint _value = 0xFFFFFFFF;
|
||||
|
||||
public void Init() { _value = 0xFFFFFFFF; }
|
||||
|
||||
public void UpdateByte(byte b)
|
||||
{
|
||||
_value = Table[(((byte)(_value)) ^ b)] ^ (_value >> 8);
|
||||
}
|
||||
|
||||
public void Update(byte[] data, uint offset, uint size)
|
||||
{
|
||||
for (uint i = 0; i < size; i++)
|
||||
_value = Table[(((byte)(_value)) ^ data[offset + i])] ^ (_value >> 8);
|
||||
}
|
||||
|
||||
public uint GetDigest() { return _value ^ 0xFFFFFFFF; }
|
||||
|
||||
static uint CalculateDigest(byte[] data, uint offset, uint size)
|
||||
{
|
||||
CRC crc = new CRC();
|
||||
// crc.Init();
|
||||
crc.Update(data, offset, size);
|
||||
return crc.GetDigest();
|
||||
}
|
||||
|
||||
static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)
|
||||
{
|
||||
return (CalculateDigest(data, offset, size) == digest);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,274 +0,0 @@
|
||||
// CommandLineParser.cs
|
||||
|
||||
using System;
|
||||
using System.Collections;
|
||||
|
||||
namespace SevenZip.CommandLineParser
|
||||
{
|
||||
public enum SwitchType
|
||||
{
|
||||
Simple,
|
||||
PostMinus,
|
||||
LimitedPostString,
|
||||
UnLimitedPostString,
|
||||
PostChar
|
||||
}
|
||||
|
||||
public class SwitchForm
|
||||
{
|
||||
public string IDString;
|
||||
public SwitchType Type;
|
||||
public bool Multi;
|
||||
public int MinLen;
|
||||
public int MaxLen;
|
||||
public string PostCharSet;
|
||||
|
||||
public SwitchForm(string idString, SwitchType type, bool multi,
|
||||
int minLen, int maxLen, string postCharSet)
|
||||
{
|
||||
IDString = idString;
|
||||
Type = type;
|
||||
Multi = multi;
|
||||
MinLen = minLen;
|
||||
MaxLen = maxLen;
|
||||
PostCharSet = postCharSet;
|
||||
}
|
||||
public SwitchForm(string idString, SwitchType type, bool multi, int minLen):
|
||||
this(idString, type, multi, minLen, 0, "")
|
||||
{
|
||||
}
|
||||
public SwitchForm(string idString, SwitchType type, bool multi):
|
||||
this(idString, type, multi, 0)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public class SwitchResult
|
||||
{
|
||||
public bool ThereIs;
|
||||
public bool WithMinus;
|
||||
public ArrayList PostStrings = new ArrayList();
|
||||
public int PostCharIndex;
|
||||
public SwitchResult()
|
||||
{
|
||||
ThereIs = false;
|
||||
}
|
||||
}
|
||||
|
||||
public class Parser
|
||||
{
|
||||
public ArrayList NonSwitchStrings = new ArrayList();
|
||||
SwitchResult[] _switches;
|
||||
|
||||
public Parser(int numSwitches)
|
||||
{
|
||||
_switches = new SwitchResult[numSwitches];
|
||||
for (int i = 0; i < numSwitches; i++)
|
||||
_switches[i] = new SwitchResult();
|
||||
}
|
||||
|
||||
bool ParseString(string srcString, SwitchForm[] switchForms)
|
||||
{
|
||||
int len = srcString.Length;
|
||||
if (len == 0)
|
||||
return false;
|
||||
int pos = 0;
|
||||
if (!IsItSwitchChar(srcString[pos]))
|
||||
return false;
|
||||
while (pos < len)
|
||||
{
|
||||
if (IsItSwitchChar(srcString[pos]))
|
||||
pos++;
|
||||
const int kNoLen = -1;
|
||||
int matchedSwitchIndex = 0;
|
||||
int maxLen = kNoLen;
|
||||
for (int switchIndex = 0; switchIndex < _switches.Length; switchIndex++)
|
||||
{
|
||||
int switchLen = switchForms[switchIndex].IDString.Length;
|
||||
if (switchLen <= maxLen || pos + switchLen > len)
|
||||
continue;
|
||||
if (String.Compare(switchForms[switchIndex].IDString, 0,
|
||||
srcString, pos, switchLen, true) == 0)
|
||||
{
|
||||
matchedSwitchIndex = switchIndex;
|
||||
maxLen = switchLen;
|
||||
}
|
||||
}
|
||||
if (maxLen == kNoLen)
|
||||
throw new Exception("maxLen == kNoLen");
|
||||
SwitchResult matchedSwitch = _switches[matchedSwitchIndex];
|
||||
SwitchForm switchForm = switchForms[matchedSwitchIndex];
|
||||
if ((!switchForm.Multi) && matchedSwitch.ThereIs)
|
||||
throw new Exception("switch must be single");
|
||||
matchedSwitch.ThereIs = true;
|
||||
pos += maxLen;
|
||||
int tailSize = len - pos;
|
||||
SwitchType type = switchForm.Type;
|
||||
switch (type)
|
||||
{
|
||||
case SwitchType.PostMinus:
|
||||
{
|
||||
if (tailSize == 0)
|
||||
matchedSwitch.WithMinus = false;
|
||||
else
|
||||
{
|
||||
matchedSwitch.WithMinus = (srcString[pos] == kSwitchMinus);
|
||||
if (matchedSwitch.WithMinus)
|
||||
pos++;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SwitchType.PostChar:
|
||||
{
|
||||
if (tailSize < switchForm.MinLen)
|
||||
throw new Exception("switch is not full");
|
||||
string charSet = switchForm.PostCharSet;
|
||||
const int kEmptyCharValue = -1;
|
||||
if (tailSize == 0)
|
||||
matchedSwitch.PostCharIndex = kEmptyCharValue;
|
||||
else
|
||||
{
|
||||
int index = charSet.IndexOf(srcString[pos]);
|
||||
if (index < 0)
|
||||
matchedSwitch.PostCharIndex = kEmptyCharValue;
|
||||
else
|
||||
{
|
||||
matchedSwitch.PostCharIndex = index;
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SwitchType.LimitedPostString:
|
||||
case SwitchType.UnLimitedPostString:
|
||||
{
|
||||
int minLen = switchForm.MinLen;
|
||||
if (tailSize < minLen)
|
||||
throw new Exception("switch is not full");
|
||||
if (type == SwitchType.UnLimitedPostString)
|
||||
{
|
||||
matchedSwitch.PostStrings.Add(srcString.Substring(pos));
|
||||
return true;
|
||||
}
|
||||
String stringSwitch = srcString.Substring(pos, minLen);
|
||||
pos += minLen;
|
||||
for (int i = minLen; i < switchForm.MaxLen && pos < len; i++, pos++)
|
||||
{
|
||||
char c = srcString[pos];
|
||||
if (IsItSwitchChar(c))
|
||||
break;
|
||||
stringSwitch += c;
|
||||
}
|
||||
matchedSwitch.PostStrings.Add(stringSwitch);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
public void ParseStrings(SwitchForm[] switchForms, string[] commandStrings)
|
||||
{
|
||||
int numCommandStrings = commandStrings.Length;
|
||||
bool stopSwitch = false;
|
||||
for (int i = 0; i < numCommandStrings; i++)
|
||||
{
|
||||
string s = commandStrings[i];
|
||||
if (stopSwitch)
|
||||
NonSwitchStrings.Add(s);
|
||||
else
|
||||
if (s == kStopSwitchParsing)
|
||||
stopSwitch = true;
|
||||
else
|
||||
if (!ParseString(s, switchForms))
|
||||
NonSwitchStrings.Add(s);
|
||||
}
|
||||
}
|
||||
|
||||
public SwitchResult this[int index] { get { return _switches[index]; } }
|
||||
|
||||
public static int ParseCommand(CommandForm[] commandForms, string commandString,
|
||||
out string postString)
|
||||
{
|
||||
for (int i = 0; i < commandForms.Length; i++)
|
||||
{
|
||||
string id = commandForms[i].IDString;
|
||||
if (commandForms[i].PostStringMode)
|
||||
{
|
||||
if (commandString.IndexOf(id) == 0)
|
||||
{
|
||||
postString = commandString.Substring(id.Length);
|
||||
return i;
|
||||
}
|
||||
}
|
||||
else
|
||||
if (commandString == id)
|
||||
{
|
||||
postString = "";
|
||||
return i;
|
||||
}
|
||||
}
|
||||
postString = "";
|
||||
return -1;
|
||||
}
|
||||
|
||||
static bool ParseSubCharsCommand(int numForms, CommandSubCharsSet[] forms,
|
||||
string commandString, ArrayList indices)
|
||||
{
|
||||
indices.Clear();
|
||||
int numUsedChars = 0;
|
||||
for (int i = 0; i < numForms; i++)
|
||||
{
|
||||
CommandSubCharsSet charsSet = forms[i];
|
||||
int currentIndex = -1;
|
||||
int len = charsSet.Chars.Length;
|
||||
for (int j = 0; j < len; j++)
|
||||
{
|
||||
char c = charsSet.Chars[j];
|
||||
int newIndex = commandString.IndexOf(c);
|
||||
if (newIndex >= 0)
|
||||
{
|
||||
if (currentIndex >= 0)
|
||||
return false;
|
||||
if (commandString.IndexOf(c, newIndex + 1) >= 0)
|
||||
return false;
|
||||
currentIndex = j;
|
||||
numUsedChars++;
|
||||
}
|
||||
}
|
||||
if (currentIndex == -1 && !charsSet.EmptyAllowed)
|
||||
return false;
|
||||
indices.Add(currentIndex);
|
||||
}
|
||||
return (numUsedChars == commandString.Length);
|
||||
}
|
||||
const char kSwitchID1 = '-';
|
||||
const char kSwitchID2 = '/';
|
||||
|
||||
const char kSwitchMinus = '-';
|
||||
const string kStopSwitchParsing = "--";
|
||||
|
||||
static bool IsItSwitchChar(char c)
|
||||
{
|
||||
return (c == kSwitchID1 || c == kSwitchID2);
|
||||
}
|
||||
}
|
||||
|
||||
public class CommandForm
|
||||
{
|
||||
public string IDString = "";
|
||||
public bool PostStringMode = false;
|
||||
public CommandForm(string idString, bool postStringMode)
|
||||
{
|
||||
IDString = idString;
|
||||
PostStringMode = postStringMode;
|
||||
}
|
||||
}
|
||||
|
||||
class CommandSubCharsSet
|
||||
{
|
||||
public string Chars = "";
|
||||
public bool EmptyAllowed = false;
|
||||
}
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
// InBuffer.cs
|
||||
|
||||
namespace SevenZip.Buffer
|
||||
{
|
||||
public class InBuffer
|
||||
{
|
||||
byte[] m_Buffer;
|
||||
uint m_Pos;
|
||||
uint m_Limit;
|
||||
uint m_BufferSize;
|
||||
System.IO.Stream m_Stream;
|
||||
bool m_StreamWasExhausted;
|
||||
ulong m_ProcessedSize;
|
||||
|
||||
public InBuffer(uint bufferSize)
|
||||
{
|
||||
m_Buffer = new byte[bufferSize];
|
||||
m_BufferSize = bufferSize;
|
||||
}
|
||||
|
||||
public void Init(System.IO.Stream stream)
|
||||
{
|
||||
m_Stream = stream;
|
||||
m_ProcessedSize = 0;
|
||||
m_Limit = 0;
|
||||
m_Pos = 0;
|
||||
m_StreamWasExhausted = false;
|
||||
}
|
||||
|
||||
public bool ReadBlock()
|
||||
{
|
||||
if (m_StreamWasExhausted)
|
||||
return false;
|
||||
m_ProcessedSize += m_Pos;
|
||||
int aNumProcessedBytes = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);
|
||||
m_Pos = 0;
|
||||
m_Limit = (uint)aNumProcessedBytes;
|
||||
m_StreamWasExhausted = (aNumProcessedBytes == 0);
|
||||
return (!m_StreamWasExhausted);
|
||||
}
|
||||
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
// m_Stream.Close();
|
||||
m_Stream = null;
|
||||
}
|
||||
|
||||
public bool ReadByte(byte b) // check it
|
||||
{
|
||||
if (m_Pos >= m_Limit)
|
||||
if (!ReadBlock())
|
||||
return false;
|
||||
b = m_Buffer[m_Pos++];
|
||||
return true;
|
||||
}
|
||||
|
||||
public byte ReadByte()
|
||||
{
|
||||
// return (byte)m_Stream.ReadByte();
|
||||
if (m_Pos >= m_Limit)
|
||||
if (!ReadBlock())
|
||||
return 0xFF;
|
||||
return m_Buffer[m_Pos++];
|
||||
}
|
||||
|
||||
public ulong GetProcessedSize()
|
||||
{
|
||||
return m_ProcessedSize + m_Pos;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
// OutBuffer.cs
|
||||
|
||||
namespace SevenZip.Buffer
|
||||
{
|
||||
public class OutBuffer
|
||||
{
|
||||
byte[] m_Buffer;
|
||||
uint m_Pos;
|
||||
uint m_BufferSize;
|
||||
System.IO.Stream m_Stream;
|
||||
ulong m_ProcessedSize;
|
||||
|
||||
public OutBuffer(uint bufferSize)
|
||||
{
|
||||
m_Buffer = new byte[bufferSize];
|
||||
m_BufferSize = bufferSize;
|
||||
}
|
||||
|
||||
public void SetStream(System.IO.Stream stream) { m_Stream = stream; }
|
||||
public void FlushStream() { m_Stream.Flush(); }
|
||||
public void CloseStream() { m_Stream.Close(); }
|
||||
public void ReleaseStream() { m_Stream = null; }
|
||||
|
||||
public void Init()
|
||||
{
|
||||
m_ProcessedSize = 0;
|
||||
m_Pos = 0;
|
||||
}
|
||||
|
||||
public void WriteByte(byte b)
|
||||
{
|
||||
m_Buffer[m_Pos++] = b;
|
||||
if (m_Pos >= m_BufferSize)
|
||||
FlushData();
|
||||
}
|
||||
|
||||
public void FlushData()
|
||||
{
|
||||
if (m_Pos == 0)
|
||||
return;
|
||||
m_Stream.Write(m_Buffer, 0, (int)m_Pos);
|
||||
m_Pos = 0;
|
||||
}
|
||||
|
||||
public ulong GetProcessedSize() { return m_ProcessedSize + m_Pos; }
|
||||
}
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: a83572c42056f474db56e761a4f35e38
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,24 +0,0 @@
|
||||
// IMatchFinder.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
interface IInWindowStream
|
||||
{
|
||||
void SetStream(System.IO.Stream inStream);
|
||||
void Init();
|
||||
void ReleaseStream();
|
||||
Byte GetIndexByte(Int32 index);
|
||||
UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit);
|
||||
UInt32 GetNumAvailableBytes();
|
||||
}
|
||||
|
||||
interface IMatchFinder : IInWindowStream
|
||||
{
|
||||
void Create(UInt32 historySize, UInt32 keepAddBufferBefore,
|
||||
UInt32 matchMaxLen, UInt32 keepAddBufferAfter);
|
||||
UInt32 GetMatches(UInt32[] distances);
|
||||
void Skip(UInt32 num);
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: bfd1ee430d8108042a2607d92d7f58ad
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,367 +0,0 @@
|
||||
// LzBinTree.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
public class BinTree : InWindow, IMatchFinder
|
||||
{
|
||||
UInt32 _cyclicBufferPos;
|
||||
UInt32 _cyclicBufferSize = 0;
|
||||
UInt32 _matchMaxLen;
|
||||
|
||||
UInt32[] _son;
|
||||
UInt32[] _hash;
|
||||
|
||||
UInt32 _cutValue = 0xFF;
|
||||
UInt32 _hashMask;
|
||||
UInt32 _hashSizeSum = 0;
|
||||
|
||||
bool HASH_ARRAY = true;
|
||||
|
||||
const UInt32 kHash2Size = 1 << 10;
|
||||
const UInt32 kHash3Size = 1 << 16;
|
||||
const UInt32 kBT2HashSize = 1 << 16;
|
||||
const UInt32 kStartMaxLen = 1;
|
||||
const UInt32 kHash3Offset = kHash2Size;
|
||||
const UInt32 kEmptyHashValue = 0;
|
||||
const UInt32 kMaxValForNormalize = ((UInt32)1 << 31) - 1;
|
||||
|
||||
UInt32 kNumHashDirectBytes = 0;
|
||||
UInt32 kMinMatchCheck = 4;
|
||||
UInt32 kFixHashSize = kHash2Size + kHash3Size;
|
||||
|
||||
public void SetType(int numHashBytes)
|
||||
{
|
||||
HASH_ARRAY = (numHashBytes > 2);
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
kNumHashDirectBytes = 0;
|
||||
kMinMatchCheck = 4;
|
||||
kFixHashSize = kHash2Size + kHash3Size;
|
||||
}
|
||||
else
|
||||
{
|
||||
kNumHashDirectBytes = 2;
|
||||
kMinMatchCheck = 2 + 1;
|
||||
kFixHashSize = 0;
|
||||
}
|
||||
}
|
||||
|
||||
public new void SetStream(System.IO.Stream stream) { base.SetStream(stream); }
|
||||
public new void ReleaseStream() { base.ReleaseStream(); }
|
||||
|
||||
public new void Init()
|
||||
{
|
||||
base.Init();
|
||||
for (UInt32 i = 0; i < _hashSizeSum; i++)
|
||||
_hash[i] = kEmptyHashValue;
|
||||
_cyclicBufferPos = 0;
|
||||
ReduceOffsets(-1);
|
||||
}
|
||||
|
||||
public new void MovePos()
|
||||
{
|
||||
if (++_cyclicBufferPos >= _cyclicBufferSize)
|
||||
_cyclicBufferPos = 0;
|
||||
base.MovePos();
|
||||
if (_pos == kMaxValForNormalize)
|
||||
Normalize();
|
||||
}
|
||||
|
||||
public new Byte GetIndexByte(Int32 index) { return base.GetIndexByte(index); }
|
||||
|
||||
public new UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit)
|
||||
{ return base.GetMatchLen(index, distance, limit); }
|
||||
|
||||
public new UInt32 GetNumAvailableBytes() { return base.GetNumAvailableBytes(); }
|
||||
|
||||
public void Create(UInt32 historySize, UInt32 keepAddBufferBefore,
|
||||
UInt32 matchMaxLen, UInt32 keepAddBufferAfter)
|
||||
{
|
||||
if (historySize > kMaxValForNormalize - 256)
|
||||
throw new Exception();
|
||||
_cutValue = 16 + (matchMaxLen >> 1);
|
||||
|
||||
UInt32 windowReservSize = (historySize + keepAddBufferBefore +
|
||||
matchMaxLen + keepAddBufferAfter) / 2 + 256;
|
||||
|
||||
base.Create(historySize + keepAddBufferBefore, matchMaxLen + keepAddBufferAfter, windowReservSize);
|
||||
|
||||
_matchMaxLen = matchMaxLen;
|
||||
|
||||
UInt32 cyclicBufferSize = historySize + 1;
|
||||
if (_cyclicBufferSize != cyclicBufferSize)
|
||||
_son = new UInt32[(_cyclicBufferSize = cyclicBufferSize) * 2];
|
||||
|
||||
UInt32 hs = kBT2HashSize;
|
||||
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
hs = historySize - 1;
|
||||
hs |= (hs >> 1);
|
||||
hs |= (hs >> 2);
|
||||
hs |= (hs >> 4);
|
||||
hs |= (hs >> 8);
|
||||
hs >>= 1;
|
||||
hs |= 0xFFFF;
|
||||
if (hs > (1 << 24))
|
||||
hs >>= 1;
|
||||
_hashMask = hs;
|
||||
hs++;
|
||||
hs += kFixHashSize;
|
||||
}
|
||||
if (hs != _hashSizeSum)
|
||||
_hash = new UInt32[_hashSizeSum = hs];
|
||||
}
|
||||
|
||||
public UInt32 GetMatches(UInt32[] distances)
|
||||
{
|
||||
UInt32 lenLimit;
|
||||
if (_pos + _matchMaxLen <= _streamPos)
|
||||
lenLimit = _matchMaxLen;
|
||||
else
|
||||
{
|
||||
lenLimit = _streamPos - _pos;
|
||||
if (lenLimit < kMinMatchCheck)
|
||||
{
|
||||
MovePos();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
UInt32 offset = 0;
|
||||
UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
|
||||
UInt32 cur = _bufferOffset + _pos;
|
||||
UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;
|
||||
UInt32 hashValue, hash2Value = 0, hash3Value = 0;
|
||||
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
UInt32 temp = CRC.Table[_bufferBase[cur]] ^ _bufferBase[cur + 1];
|
||||
hash2Value = temp & (kHash2Size - 1);
|
||||
temp ^= ((UInt32)(_bufferBase[cur + 2]) << 8);
|
||||
hash3Value = temp & (kHash3Size - 1);
|
||||
hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
|
||||
}
|
||||
else
|
||||
hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
|
||||
|
||||
UInt32 curMatch = _hash[kFixHashSize + hashValue];
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
UInt32 curMatch2 = _hash[hash2Value];
|
||||
UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];
|
||||
_hash[hash2Value] = _pos;
|
||||
_hash[kHash3Offset + hash3Value] = _pos;
|
||||
if (curMatch2 > matchMinPos)
|
||||
if (_bufferBase[_bufferOffset + curMatch2] == _bufferBase[cur])
|
||||
{
|
||||
distances[offset++] = maxLen = 2;
|
||||
distances[offset++] = _pos - curMatch2 - 1;
|
||||
}
|
||||
if (curMatch3 > matchMinPos)
|
||||
if (_bufferBase[_bufferOffset + curMatch3] == _bufferBase[cur])
|
||||
{
|
||||
if (curMatch3 == curMatch2)
|
||||
offset -= 2;
|
||||
distances[offset++] = maxLen = 3;
|
||||
distances[offset++] = _pos - curMatch3 - 1;
|
||||
curMatch2 = curMatch3;
|
||||
}
|
||||
if (offset != 0 && curMatch2 == curMatch)
|
||||
{
|
||||
offset -= 2;
|
||||
maxLen = kStartMaxLen;
|
||||
}
|
||||
}
|
||||
|
||||
_hash[kFixHashSize + hashValue] = _pos;
|
||||
|
||||
UInt32 ptr0 = (_cyclicBufferPos << 1) + 1;
|
||||
UInt32 ptr1 = (_cyclicBufferPos << 1);
|
||||
|
||||
UInt32 len0, len1;
|
||||
len0 = len1 = kNumHashDirectBytes;
|
||||
|
||||
if (kNumHashDirectBytes != 0)
|
||||
{
|
||||
if (curMatch > matchMinPos)
|
||||
{
|
||||
if (_bufferBase[_bufferOffset + curMatch + kNumHashDirectBytes] !=
|
||||
_bufferBase[cur + kNumHashDirectBytes])
|
||||
{
|
||||
distances[offset++] = maxLen = kNumHashDirectBytes;
|
||||
distances[offset++] = _pos - curMatch - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
UInt32 count = _cutValue;
|
||||
|
||||
while(true)
|
||||
{
|
||||
if(curMatch <= matchMinPos || count-- == 0)
|
||||
{
|
||||
_son[ptr0] = _son[ptr1] = kEmptyHashValue;
|
||||
break;
|
||||
}
|
||||
UInt32 delta = _pos - curMatch;
|
||||
UInt32 cyclicPos = ((delta <= _cyclicBufferPos) ?
|
||||
(_cyclicBufferPos - delta) :
|
||||
(_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
|
||||
|
||||
UInt32 pby1 = _bufferOffset + curMatch;
|
||||
UInt32 len = Math.Min(len0, len1);
|
||||
if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
|
||||
{
|
||||
while(++len != lenLimit)
|
||||
if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
|
||||
break;
|
||||
if (maxLen < len)
|
||||
{
|
||||
distances[offset++] = maxLen = len;
|
||||
distances[offset++] = delta - 1;
|
||||
if (len == lenLimit)
|
||||
{
|
||||
_son[ptr1] = _son[cyclicPos];
|
||||
_son[ptr0] = _son[cyclicPos + 1];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (_bufferBase[pby1 + len] < _bufferBase[cur + len])
|
||||
{
|
||||
_son[ptr1] = curMatch;
|
||||
ptr1 = cyclicPos + 1;
|
||||
curMatch = _son[ptr1];
|
||||
len1 = len;
|
||||
}
|
||||
else
|
||||
{
|
||||
_son[ptr0] = curMatch;
|
||||
ptr0 = cyclicPos;
|
||||
curMatch = _son[ptr0];
|
||||
len0 = len;
|
||||
}
|
||||
}
|
||||
MovePos();
|
||||
return offset;
|
||||
}
|
||||
|
||||
public void Skip(UInt32 num)
|
||||
{
|
||||
do
|
||||
{
|
||||
UInt32 lenLimit;
|
||||
if (_pos + _matchMaxLen <= _streamPos)
|
||||
lenLimit = _matchMaxLen;
|
||||
else
|
||||
{
|
||||
lenLimit = _streamPos - _pos;
|
||||
if (lenLimit < kMinMatchCheck)
|
||||
{
|
||||
MovePos();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
|
||||
UInt32 cur = _bufferOffset + _pos;
|
||||
|
||||
UInt32 hashValue;
|
||||
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
UInt32 temp = CRC.Table[_bufferBase[cur]] ^ _bufferBase[cur + 1];
|
||||
UInt32 hash2Value = temp & (kHash2Size - 1);
|
||||
_hash[hash2Value] = _pos;
|
||||
temp ^= ((UInt32)(_bufferBase[cur + 2]) << 8);
|
||||
UInt32 hash3Value = temp & (kHash3Size - 1);
|
||||
_hash[kHash3Offset + hash3Value] = _pos;
|
||||
hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
|
||||
}
|
||||
else
|
||||
hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
|
||||
|
||||
UInt32 curMatch = _hash[kFixHashSize + hashValue];
|
||||
_hash[kFixHashSize + hashValue] = _pos;
|
||||
|
||||
UInt32 ptr0 = (_cyclicBufferPos << 1) + 1;
|
||||
UInt32 ptr1 = (_cyclicBufferPos << 1);
|
||||
|
||||
UInt32 len0, len1;
|
||||
len0 = len1 = kNumHashDirectBytes;
|
||||
|
||||
UInt32 count = _cutValue;
|
||||
while (true)
|
||||
{
|
||||
if (curMatch <= matchMinPos || count-- == 0)
|
||||
{
|
||||
_son[ptr0] = _son[ptr1] = kEmptyHashValue;
|
||||
break;
|
||||
}
|
||||
|
||||
UInt32 delta = _pos - curMatch;
|
||||
UInt32 cyclicPos = ((delta <= _cyclicBufferPos) ?
|
||||
(_cyclicBufferPos - delta) :
|
||||
(_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
|
||||
|
||||
UInt32 pby1 = _bufferOffset + curMatch;
|
||||
UInt32 len = Math.Min(len0, len1);
|
||||
if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
|
||||
{
|
||||
while (++len != lenLimit)
|
||||
if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
|
||||
break;
|
||||
if (len == lenLimit)
|
||||
{
|
||||
_son[ptr1] = _son[cyclicPos];
|
||||
_son[ptr0] = _son[cyclicPos + 1];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (_bufferBase[pby1 + len] < _bufferBase[cur + len])
|
||||
{
|
||||
_son[ptr1] = curMatch;
|
||||
ptr1 = cyclicPos + 1;
|
||||
curMatch = _son[ptr1];
|
||||
len1 = len;
|
||||
}
|
||||
else
|
||||
{
|
||||
_son[ptr0] = curMatch;
|
||||
ptr0 = cyclicPos;
|
||||
curMatch = _son[ptr0];
|
||||
len0 = len;
|
||||
}
|
||||
}
|
||||
MovePos();
|
||||
}
|
||||
while (--num != 0);
|
||||
}
|
||||
|
||||
void NormalizeLinks(UInt32[] items, UInt32 numItems, UInt32 subValue)
|
||||
{
|
||||
for (UInt32 i = 0; i < numItems; i++)
|
||||
{
|
||||
UInt32 value = items[i];
|
||||
if (value <= subValue)
|
||||
value = kEmptyHashValue;
|
||||
else
|
||||
value -= subValue;
|
||||
items[i] = value;
|
||||
}
|
||||
}
|
||||
|
||||
void Normalize()
|
||||
{
|
||||
UInt32 subValue = _pos - _cyclicBufferSize;
|
||||
NormalizeLinks(_son, _cyclicBufferSize * 2, subValue);
|
||||
NormalizeLinks(_hash, _hashSizeSum, subValue);
|
||||
ReduceOffsets((Int32)subValue);
|
||||
}
|
||||
|
||||
public void SetCutValue(UInt32 cutValue) { _cutValue = cutValue; }
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 3ba8015d2d5df3a459615ffc06635e6d
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,132 +0,0 @@
|
||||
// LzInWindow.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
public class InWindow
|
||||
{
|
||||
public Byte[] _bufferBase = null; // pointer to buffer with data
|
||||
System.IO.Stream _stream;
|
||||
UInt32 _posLimit; // offset (from _buffer) of first byte when new block reading must be done
|
||||
bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream
|
||||
|
||||
UInt32 _pointerToLastSafePosition;
|
||||
|
||||
public UInt32 _bufferOffset;
|
||||
|
||||
public UInt32 _blockSize; // Size of Allocated memory block
|
||||
public UInt32 _pos; // offset (from _buffer) of curent byte
|
||||
UInt32 _keepSizeBefore; // how many BYTEs must be kept in buffer before _pos
|
||||
UInt32 _keepSizeAfter; // how many BYTEs must be kept buffer after _pos
|
||||
public UInt32 _streamPos; // offset (from _buffer) of first not read byte from Stream
|
||||
|
||||
public void MoveBlock()
|
||||
{
|
||||
UInt32 offset = (UInt32)(_bufferOffset) + _pos - _keepSizeBefore;
|
||||
// we need one additional byte, since MovePos moves on 1 byte.
|
||||
if (offset > 0)
|
||||
offset--;
|
||||
|
||||
UInt32 numBytes = (UInt32)(_bufferOffset) + _streamPos - offset;
|
||||
|
||||
// check negative offset ????
|
||||
for (UInt32 i = 0; i < numBytes; i++)
|
||||
_bufferBase[i] = _bufferBase[offset + i];
|
||||
_bufferOffset -= offset;
|
||||
}
|
||||
|
||||
public virtual void ReadBlock()
|
||||
{
|
||||
if (_streamEndWasReached)
|
||||
return;
|
||||
while (true)
|
||||
{
|
||||
int size = (int)((0 - _bufferOffset) + _blockSize - _streamPos);
|
||||
if (size == 0)
|
||||
return;
|
||||
int numReadBytes = _stream.Read(_bufferBase, (int)(_bufferOffset + _streamPos), size);
|
||||
if (numReadBytes == 0)
|
||||
{
|
||||
_posLimit = _streamPos;
|
||||
UInt32 pointerToPostion = _bufferOffset + _posLimit;
|
||||
if (pointerToPostion > _pointerToLastSafePosition)
|
||||
_posLimit = (UInt32)(_pointerToLastSafePosition - _bufferOffset);
|
||||
|
||||
_streamEndWasReached = true;
|
||||
return;
|
||||
}
|
||||
_streamPos += (UInt32)numReadBytes;
|
||||
if (_streamPos >= _pos + _keepSizeAfter)
|
||||
_posLimit = _streamPos - _keepSizeAfter;
|
||||
}
|
||||
}
|
||||
|
||||
void Free() { _bufferBase = null; }
|
||||
|
||||
public void Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv)
|
||||
{
|
||||
_keepSizeBefore = keepSizeBefore;
|
||||
_keepSizeAfter = keepSizeAfter;
|
||||
UInt32 blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
|
||||
if (_bufferBase == null || _blockSize != blockSize)
|
||||
{
|
||||
Free();
|
||||
_blockSize = blockSize;
|
||||
_bufferBase = new Byte[_blockSize];
|
||||
}
|
||||
_pointerToLastSafePosition = _blockSize - keepSizeAfter;
|
||||
}
|
||||
|
||||
public void SetStream(System.IO.Stream stream) { _stream = stream; }
|
||||
public void ReleaseStream() { _stream = null; }
|
||||
|
||||
public void Init()
|
||||
{
|
||||
_bufferOffset = 0;
|
||||
_pos = 0;
|
||||
_streamPos = 0;
|
||||
_streamEndWasReached = false;
|
||||
ReadBlock();
|
||||
}
|
||||
|
||||
public void MovePos()
|
||||
{
|
||||
_pos++;
|
||||
if (_pos > _posLimit)
|
||||
{
|
||||
UInt32 pointerToPostion = _bufferOffset + _pos;
|
||||
if (pointerToPostion > _pointerToLastSafePosition)
|
||||
MoveBlock();
|
||||
ReadBlock();
|
||||
}
|
||||
}
|
||||
|
||||
public Byte GetIndexByte(Int32 index) { return _bufferBase[_bufferOffset + _pos + index]; }
|
||||
|
||||
// index + limit have not to exceed _keepSizeAfter;
|
||||
public UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit)
|
||||
{
|
||||
if (_streamEndWasReached)
|
||||
if ((_pos + index) + limit > _streamPos)
|
||||
limit = _streamPos - (UInt32)(_pos + index);
|
||||
distance++;
|
||||
// Byte *pby = _buffer + (size_t)_pos + index;
|
||||
UInt32 pby = _bufferOffset + _pos + (UInt32)index;
|
||||
|
||||
UInt32 i;
|
||||
for (i = 0; i < limit && _bufferBase[pby + i] == _bufferBase[pby + i - distance]; i++);
|
||||
return i;
|
||||
}
|
||||
|
||||
public UInt32 GetNumAvailableBytes() { return _streamPos - _pos; }
|
||||
|
||||
public void ReduceOffsets(Int32 subValue)
|
||||
{
|
||||
_bufferOffset += (UInt32)subValue;
|
||||
_posLimit -= (UInt32)subValue;
|
||||
_pos -= (UInt32)subValue;
|
||||
_streamPos -= (UInt32)subValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 333112c3785a6ec4cbbfec8515081cac
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,110 +0,0 @@
|
||||
// LzOutWindow.cs
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
public class OutWindow
|
||||
{
|
||||
byte[] _buffer = null;
|
||||
uint _pos;
|
||||
uint _windowSize = 0;
|
||||
uint _streamPos;
|
||||
System.IO.Stream _stream;
|
||||
|
||||
public uint TrainSize = 0;
|
||||
|
||||
public void Create(uint windowSize)
|
||||
{
|
||||
if (_windowSize != windowSize)
|
||||
{
|
||||
// System.GC.Collect();
|
||||
_buffer = new byte[windowSize];
|
||||
}
|
||||
_windowSize = windowSize;
|
||||
_pos = 0;
|
||||
_streamPos = 0;
|
||||
}
|
||||
|
||||
public void Init(System.IO.Stream stream, bool solid)
|
||||
{
|
||||
ReleaseStream();
|
||||
_stream = stream;
|
||||
if (!solid)
|
||||
{
|
||||
_streamPos = 0;
|
||||
_pos = 0;
|
||||
TrainSize = 0;
|
||||
}
|
||||
}
|
||||
|
||||
public bool Train(System.IO.Stream stream)
|
||||
{
|
||||
long len = stream.Length;
|
||||
uint size = (len < _windowSize) ? (uint)len : _windowSize;
|
||||
TrainSize = size;
|
||||
stream.Position = len - size;
|
||||
_streamPos = _pos = 0;
|
||||
while (size > 0)
|
||||
{
|
||||
uint curSize = _windowSize - _pos;
|
||||
if (size < curSize)
|
||||
curSize = size;
|
||||
int numReadBytes = stream.Read(_buffer, (int)_pos, (int)curSize);
|
||||
if (numReadBytes == 0)
|
||||
return false;
|
||||
size -= (uint)numReadBytes;
|
||||
_pos += (uint)numReadBytes;
|
||||
_streamPos += (uint)numReadBytes;
|
||||
if (_pos == _windowSize)
|
||||
_streamPos = _pos = 0;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
Flush();
|
||||
_stream = null;
|
||||
}
|
||||
|
||||
public void Flush()
|
||||
{
|
||||
uint size = _pos - _streamPos;
|
||||
if (size == 0)
|
||||
return;
|
||||
_stream.Write(_buffer, (int)_streamPos, (int)size);
|
||||
if (_pos >= _windowSize)
|
||||
_pos = 0;
|
||||
_streamPos = _pos;
|
||||
}
|
||||
|
||||
public void CopyBlock(uint distance, uint len)
|
||||
{
|
||||
uint pos = _pos - distance - 1;
|
||||
if (pos >= _windowSize)
|
||||
pos += _windowSize;
|
||||
for (; len > 0; len--)
|
||||
{
|
||||
if (pos >= _windowSize)
|
||||
pos = 0;
|
||||
_buffer[_pos++] = _buffer[pos++];
|
||||
if (_pos >= _windowSize)
|
||||
Flush();
|
||||
}
|
||||
}
|
||||
|
||||
public void PutByte(byte b)
|
||||
{
|
||||
_buffer[_pos++] = b;
|
||||
if (_pos >= _windowSize)
|
||||
Flush();
|
||||
}
|
||||
|
||||
public byte GetByte(uint distance)
|
||||
{
|
||||
uint pos = _pos - distance - 1;
|
||||
if (pos >= _windowSize)
|
||||
pos += _windowSize;
|
||||
return _buffer[pos];
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: bb296a6e14ab7c44cb6388693d581a62
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,8 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 5fcd2f5c8b724164a8a01cee73896d1a
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,76 +0,0 @@
|
||||
// LzmaBase.cs
|
||||
|
||||
namespace SevenZip.Compression.LZMA
|
||||
{
|
||||
internal abstract class Base
|
||||
{
|
||||
public const uint kNumRepDistances = 4;
|
||||
public const uint kNumStates = 12;
|
||||
|
||||
// static byte []kLiteralNextStates = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};
|
||||
// static byte []kMatchNextStates = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
|
||||
// static byte []kRepNextStates = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
|
||||
// static byte []kShortRepNextStates = {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
|
||||
|
||||
public struct State
|
||||
{
|
||||
public uint Index;
|
||||
public void Init() { Index = 0; }
|
||||
public void UpdateChar()
|
||||
{
|
||||
if (Index < 4) Index = 0;
|
||||
else if (Index < 10) Index -= 3;
|
||||
else Index -= 6;
|
||||
}
|
||||
public void UpdateMatch() { Index = (uint)(Index < 7 ? 7 : 10); }
|
||||
public void UpdateRep() { Index = (uint)(Index < 7 ? 8 : 11); }
|
||||
public void UpdateShortRep() { Index = (uint)(Index < 7 ? 9 : 11); }
|
||||
public bool IsCharState() { return Index < 7; }
|
||||
}
|
||||
|
||||
public const int kNumPosSlotBits = 6;
|
||||
public const int kDicLogSizeMin = 0;
|
||||
// public const int kDicLogSizeMax = 30;
|
||||
// public const uint kDistTableSizeMax = kDicLogSizeMax * 2;
|
||||
|
||||
public const int kNumLenToPosStatesBits = 2; // it's for speed optimization
|
||||
public const uint kNumLenToPosStates = 1 << kNumLenToPosStatesBits;
|
||||
|
||||
public const uint kMatchMinLen = 2;
|
||||
|
||||
public static uint GetLenToPosState(uint len)
|
||||
{
|
||||
len -= kMatchMinLen;
|
||||
if (len < kNumLenToPosStates)
|
||||
return len;
|
||||
return (uint)(kNumLenToPosStates - 1);
|
||||
}
|
||||
|
||||
public const int kNumAlignBits = 4;
|
||||
public const uint kAlignTableSize = 1 << kNumAlignBits;
|
||||
public const uint kAlignMask = (kAlignTableSize - 1);
|
||||
|
||||
public const uint kStartPosModelIndex = 4;
|
||||
public const uint kEndPosModelIndex = 14;
|
||||
public const uint kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
|
||||
|
||||
public const uint kNumFullDistances = 1 << ((int)kEndPosModelIndex / 2);
|
||||
|
||||
public const uint kNumLitPosStatesBitsEncodingMax = 4;
|
||||
public const uint kNumLitContextBitsMax = 8;
|
||||
|
||||
public const int kNumPosStatesBitsMax = 4;
|
||||
public const uint kNumPosStatesMax = (1 << kNumPosStatesBitsMax);
|
||||
public const int kNumPosStatesBitsEncodingMax = 4;
|
||||
public const uint kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);
|
||||
|
||||
public const int kNumLowLenBits = 3;
|
||||
public const int kNumMidLenBits = 3;
|
||||
public const int kNumHighLenBits = 8;
|
||||
public const uint kNumLowLenSymbols = 1 << kNumLowLenBits;
|
||||
public const uint kNumMidLenSymbols = 1 << kNumMidLenBits;
|
||||
public const uint kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols +
|
||||
(1 << kNumHighLenBits);
|
||||
public const uint kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 62f365191077342479f8227edadf57e3
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,398 +0,0 @@
|
||||
// LzmaDecoder.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZMA
|
||||
{
|
||||
using RangeCoder;
|
||||
|
||||
public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
|
||||
{
|
||||
class LenDecoder
|
||||
{
|
||||
BitDecoder m_Choice = new BitDecoder();
|
||||
BitDecoder m_Choice2 = new BitDecoder();
|
||||
BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
|
||||
BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
|
||||
BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
|
||||
uint m_NumPosStates = 0;
|
||||
|
||||
public void Create(uint numPosStates)
|
||||
{
|
||||
for (uint posState = m_NumPosStates; posState < numPosStates; posState++)
|
||||
{
|
||||
m_LowCoder[posState] = new BitTreeDecoder(Base.kNumLowLenBits);
|
||||
m_MidCoder[posState] = new BitTreeDecoder(Base.kNumMidLenBits);
|
||||
}
|
||||
m_NumPosStates = numPosStates;
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
m_Choice.Init();
|
||||
for (uint posState = 0; posState < m_NumPosStates; posState++)
|
||||
{
|
||||
m_LowCoder[posState].Init();
|
||||
m_MidCoder[posState].Init();
|
||||
}
|
||||
m_Choice2.Init();
|
||||
m_HighCoder.Init();
|
||||
}
|
||||
|
||||
public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)
|
||||
{
|
||||
if (m_Choice.Decode(rangeDecoder) == 0)
|
||||
return m_LowCoder[posState].Decode(rangeDecoder);
|
||||
else
|
||||
{
|
||||
uint symbol = Base.kNumLowLenSymbols;
|
||||
if (m_Choice2.Decode(rangeDecoder) == 0)
|
||||
symbol += m_MidCoder[posState].Decode(rangeDecoder);
|
||||
else
|
||||
{
|
||||
symbol += Base.kNumMidLenSymbols;
|
||||
symbol += m_HighCoder.Decode(rangeDecoder);
|
||||
}
|
||||
return symbol;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class LiteralDecoder
|
||||
{
|
||||
struct Decoder2
|
||||
{
|
||||
BitDecoder[] m_Decoders;
|
||||
public void Create() { m_Decoders = new BitDecoder[0x300]; }
|
||||
public void Init() { for (int i = 0; i < 0x300; i++) m_Decoders[i].Init(); }
|
||||
|
||||
public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint symbol = 1;
|
||||
do
|
||||
symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
|
||||
while (symbol < 0x100);
|
||||
return (byte)symbol;
|
||||
}
|
||||
|
||||
public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)
|
||||
{
|
||||
uint symbol = 1;
|
||||
do
|
||||
{
|
||||
uint matchBit = (uint)(matchByte >> 7) & 1;
|
||||
matchByte <<= 1;
|
||||
uint bit = m_Decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);
|
||||
symbol = (symbol << 1) | bit;
|
||||
if (matchBit != bit)
|
||||
{
|
||||
while (symbol < 0x100)
|
||||
symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (symbol < 0x100);
|
||||
return (byte)symbol;
|
||||
}
|
||||
}
|
||||
|
||||
Decoder2[] m_Coders;
|
||||
int m_NumPrevBits;
|
||||
int m_NumPosBits;
|
||||
uint m_PosMask;
|
||||
|
||||
public void Create(int numPosBits, int numPrevBits)
|
||||
{
|
||||
if (m_Coders != null && m_NumPrevBits == numPrevBits &&
|
||||
m_NumPosBits == numPosBits)
|
||||
return;
|
||||
m_NumPosBits = numPosBits;
|
||||
m_PosMask = ((uint)1 << numPosBits) - 1;
|
||||
m_NumPrevBits = numPrevBits;
|
||||
uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
|
||||
m_Coders = new Decoder2[numStates];
|
||||
for (uint i = 0; i < numStates; i++)
|
||||
m_Coders[i].Create();
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
|
||||
for (uint i = 0; i < numStates; i++)
|
||||
m_Coders[i].Init();
|
||||
}
|
||||
|
||||
uint GetState(uint pos, byte prevByte)
|
||||
{ return ((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits)); }
|
||||
|
||||
public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)
|
||||
{ return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }
|
||||
|
||||
public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)
|
||||
{ return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }
|
||||
};
|
||||
|
||||
LZ.OutWindow m_OutWindow = new LZ.OutWindow();
|
||||
RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();
|
||||
|
||||
BitDecoder[] m_IsMatchDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
|
||||
BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
|
||||
|
||||
BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
|
||||
BitDecoder[] m_PosDecoders = new BitDecoder[Base.kNumFullDistances - Base.kEndPosModelIndex];
|
||||
|
||||
BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
|
||||
|
||||
LenDecoder m_LenDecoder = new LenDecoder();
|
||||
LenDecoder m_RepLenDecoder = new LenDecoder();
|
||||
|
||||
LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
|
||||
|
||||
uint m_DictionarySize;
|
||||
uint m_DictionarySizeCheck;
|
||||
|
||||
uint m_PosStateMask;
|
||||
|
||||
public Decoder()
|
||||
{
|
||||
m_DictionarySize = 0xFFFFFFFF;
|
||||
for (int i = 0; i < Base.kNumLenToPosStates; i++)
|
||||
m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
|
||||
}
|
||||
|
||||
void SetDictionarySize(uint dictionarySize)
|
||||
{
|
||||
if (m_DictionarySize != dictionarySize)
|
||||
{
|
||||
m_DictionarySize = dictionarySize;
|
||||
m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1);
|
||||
uint blockSize = Math.Max(m_DictionarySizeCheck, (1 << 12));
|
||||
m_OutWindow.Create(blockSize);
|
||||
}
|
||||
}
|
||||
|
||||
void SetLiteralProperties(int lp, int lc)
|
||||
{
|
||||
if (lp > 8)
|
||||
throw new InvalidParamException();
|
||||
if (lc > 8)
|
||||
throw new InvalidParamException();
|
||||
m_LiteralDecoder.Create(lp, lc);
|
||||
}
|
||||
|
||||
void SetPosBitsProperties(int pb)
|
||||
{
|
||||
if (pb > Base.kNumPosStatesBitsMax)
|
||||
throw new InvalidParamException();
|
||||
uint numPosStates = (uint)1 << pb;
|
||||
m_LenDecoder.Create(numPosStates);
|
||||
m_RepLenDecoder.Create(numPosStates);
|
||||
m_PosStateMask = numPosStates - 1;
|
||||
}
|
||||
|
||||
bool _solid = false;
|
||||
void Init(System.IO.Stream inStream, System.IO.Stream outStream)
|
||||
{
|
||||
m_RangeDecoder.Init(inStream);
|
||||
m_OutWindow.Init(outStream, _solid);
|
||||
|
||||
uint i;
|
||||
for (i = 0; i < Base.kNumStates; i++)
|
||||
{
|
||||
for (uint j = 0; j <= m_PosStateMask; j++)
|
||||
{
|
||||
uint index = (i << Base.kNumPosStatesBitsMax) + j;
|
||||
m_IsMatchDecoders[index].Init();
|
||||
m_IsRep0LongDecoders[index].Init();
|
||||
}
|
||||
m_IsRepDecoders[i].Init();
|
||||
m_IsRepG0Decoders[i].Init();
|
||||
m_IsRepG1Decoders[i].Init();
|
||||
m_IsRepG2Decoders[i].Init();
|
||||
}
|
||||
|
||||
m_LiteralDecoder.Init();
|
||||
for (i = 0; i < Base.kNumLenToPosStates; i++)
|
||||
m_PosSlotDecoder[i].Init();
|
||||
// m_PosSpecDecoder.Init();
|
||||
for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)
|
||||
m_PosDecoders[i].Init();
|
||||
|
||||
m_LenDecoder.Init();
|
||||
m_RepLenDecoder.Init();
|
||||
m_PosAlignDecoder.Init();
|
||||
}
|
||||
|
||||
public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
|
||||
Int64 inSize, Int64 outSize, ICodeProgress progress)
|
||||
{
|
||||
Init(inStream, outStream);
|
||||
|
||||
Base.State state = new Base.State();
|
||||
state.Init();
|
||||
uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
|
||||
|
||||
UInt64 nowPos64 = 0;
|
||||
UInt64 outSize64 = (UInt64)outSize;
|
||||
if (nowPos64 < outSize64)
|
||||
{
|
||||
if (m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)
|
||||
throw new DataErrorException();
|
||||
state.UpdateChar();
|
||||
byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
|
||||
m_OutWindow.PutByte(b);
|
||||
nowPos64++;
|
||||
}
|
||||
while (nowPos64 < outSize64)
|
||||
{
|
||||
// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
|
||||
// while(nowPos64 < next)
|
||||
{
|
||||
uint posState = (uint)nowPos64 & m_PosStateMask;
|
||||
if (m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
byte b;
|
||||
byte prevByte = m_OutWindow.GetByte(0);
|
||||
if (!state.IsCharState())
|
||||
b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,
|
||||
(uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));
|
||||
else
|
||||
b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);
|
||||
m_OutWindow.PutByte(b);
|
||||
state.UpdateChar();
|
||||
nowPos64++;
|
||||
}
|
||||
else
|
||||
{
|
||||
uint len;
|
||||
if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
|
||||
{
|
||||
if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
if (m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
state.UpdateShortRep();
|
||||
m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));
|
||||
nowPos64++;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
UInt32 distance;
|
||||
if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
distance = rep1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
|
||||
distance = rep2;
|
||||
else
|
||||
{
|
||||
distance = rep3;
|
||||
rep3 = rep2;
|
||||
}
|
||||
rep2 = rep1;
|
||||
}
|
||||
rep1 = rep0;
|
||||
rep0 = distance;
|
||||
}
|
||||
len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;
|
||||
state.UpdateRep();
|
||||
}
|
||||
else
|
||||
{
|
||||
rep3 = rep2;
|
||||
rep2 = rep1;
|
||||
rep1 = rep0;
|
||||
len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
|
||||
state.UpdateMatch();
|
||||
uint posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);
|
||||
if (posSlot >= Base.kStartPosModelIndex)
|
||||
{
|
||||
int numDirectBits = (int)((posSlot >> 1) - 1);
|
||||
rep0 = ((2 | (posSlot & 1)) << numDirectBits);
|
||||
if (posSlot < Base.kEndPosModelIndex)
|
||||
rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
|
||||
rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
|
||||
else
|
||||
{
|
||||
rep0 += (m_RangeDecoder.DecodeDirectBits(
|
||||
numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);
|
||||
rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
|
||||
}
|
||||
}
|
||||
else
|
||||
rep0 = posSlot;
|
||||
}
|
||||
if (rep0 >= m_OutWindow.TrainSize + nowPos64 || rep0 >= m_DictionarySizeCheck)
|
||||
{
|
||||
if (rep0 == 0xFFFFFFFF)
|
||||
break;
|
||||
throw new DataErrorException();
|
||||
}
|
||||
m_OutWindow.CopyBlock(rep0, len);
|
||||
nowPos64 += len;
|
||||
}
|
||||
}
|
||||
}
|
||||
m_OutWindow.Flush();
|
||||
m_OutWindow.ReleaseStream();
|
||||
m_RangeDecoder.ReleaseStream();
|
||||
}
|
||||
|
||||
public void SetDecoderProperties(byte[] properties)
|
||||
{
|
||||
if (properties.Length < 5)
|
||||
throw new InvalidParamException();
|
||||
int lc = properties[0] % 9;
|
||||
int remainder = properties[0] / 9;
|
||||
int lp = remainder % 5;
|
||||
int pb = remainder / 5;
|
||||
if (pb > Base.kNumPosStatesBitsMax)
|
||||
throw new InvalidParamException();
|
||||
UInt32 dictionarySize = 0;
|
||||
for (int i = 0; i < 4; i++)
|
||||
dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);
|
||||
SetDictionarySize(dictionarySize);
|
||||
SetLiteralProperties(lp, lc);
|
||||
SetPosBitsProperties(pb);
|
||||
}
|
||||
|
||||
public bool Train(System.IO.Stream stream)
|
||||
{
|
||||
_solid = true;
|
||||
return m_OutWindow.Train(stream);
|
||||
}
|
||||
|
||||
/*
|
||||
public override bool CanRead { get { return true; }}
|
||||
public override bool CanWrite { get { return true; }}
|
||||
public override bool CanSeek { get { return true; }}
|
||||
public override long Length { get { return 0; }}
|
||||
public override long Position
|
||||
{
|
||||
get { return 0; }
|
||||
set { }
|
||||
}
|
||||
public override void Flush() { }
|
||||
public override int Read(byte[] buffer, int offset, int count)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
public override void Write(byte[] buffer, int offset, int count)
|
||||
{
|
||||
}
|
||||
public override long Seek(long offset, System.IO.SeekOrigin origin)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
public override void SetLength(long value) {}
|
||||
*/
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c60a9ce2c6df6774498e337ad69a356b
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 37dcefc9d952dc34f9fba085a160a968
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,8 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 73c80167cede90a4a8fc4938bab053c8
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,234 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.RangeCoder
|
||||
{
|
||||
class Encoder
|
||||
{
|
||||
public const uint kTopValue = (1 << 24);
|
||||
|
||||
System.IO.Stream Stream;
|
||||
|
||||
public UInt64 Low;
|
||||
public uint Range;
|
||||
uint _cacheSize;
|
||||
byte _cache;
|
||||
|
||||
long StartPosition;
|
||||
|
||||
public void SetStream(System.IO.Stream stream)
|
||||
{
|
||||
Stream = stream;
|
||||
}
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
Stream = null;
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
StartPosition = Stream.Position;
|
||||
|
||||
Low = 0;
|
||||
Range = 0xFFFFFFFF;
|
||||
_cacheSize = 1;
|
||||
_cache = 0;
|
||||
}
|
||||
|
||||
public void FlushData()
|
||||
{
|
||||
for (int i = 0; i < 5; i++)
|
||||
ShiftLow();
|
||||
}
|
||||
|
||||
public void FlushStream()
|
||||
{
|
||||
Stream.Flush();
|
||||
}
|
||||
|
||||
public void CloseStream()
|
||||
{
|
||||
Stream.Close();
|
||||
}
|
||||
|
||||
public void Encode(uint start, uint size, uint total)
|
||||
{
|
||||
Low += start * (Range /= total);
|
||||
Range *= size;
|
||||
while (Range < kTopValue)
|
||||
{
|
||||
Range <<= 8;
|
||||
ShiftLow();
|
||||
}
|
||||
}
|
||||
|
||||
public void ShiftLow()
|
||||
{
|
||||
if ((uint)Low < (uint)0xFF000000 || (uint)(Low >> 32) == 1)
|
||||
{
|
||||
byte temp = _cache;
|
||||
do
|
||||
{
|
||||
Stream.WriteByte((byte)(temp + (Low >> 32)));
|
||||
temp = 0xFF;
|
||||
}
|
||||
while (--_cacheSize != 0);
|
||||
_cache = (byte)(((uint)Low) >> 24);
|
||||
}
|
||||
_cacheSize++;
|
||||
Low = ((uint)Low) << 8;
|
||||
}
|
||||
|
||||
public void EncodeDirectBits(uint v, int numTotalBits)
|
||||
{
|
||||
for (int i = numTotalBits - 1; i >= 0; i--)
|
||||
{
|
||||
Range >>= 1;
|
||||
if (((v >> i) & 1) == 1)
|
||||
Low += Range;
|
||||
if (Range < kTopValue)
|
||||
{
|
||||
Range <<= 8;
|
||||
ShiftLow();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void EncodeBit(uint size0, int numTotalBits, uint symbol)
|
||||
{
|
||||
uint newBound = (Range >> numTotalBits) * size0;
|
||||
if (symbol == 0)
|
||||
Range = newBound;
|
||||
else
|
||||
{
|
||||
Low += newBound;
|
||||
Range -= newBound;
|
||||
}
|
||||
while (Range < kTopValue)
|
||||
{
|
||||
Range <<= 8;
|
||||
ShiftLow();
|
||||
}
|
||||
}
|
||||
|
||||
public long GetProcessedSizeAdd()
|
||||
{
|
||||
return _cacheSize +
|
||||
Stream.Position - StartPosition + 4;
|
||||
// (long)Stream.GetProcessedSize();
|
||||
}
|
||||
}
|
||||
|
||||
class Decoder
|
||||
{
|
||||
public const uint kTopValue = (1 << 24);
|
||||
public uint Range;
|
||||
public uint Code;
|
||||
// public Buffer.InBuffer Stream = new Buffer.InBuffer(1 << 16);
|
||||
public System.IO.Stream Stream;
|
||||
|
||||
public void Init(System.IO.Stream stream)
|
||||
{
|
||||
// Stream.Init(stream);
|
||||
Stream = stream;
|
||||
|
||||
Code = 0;
|
||||
Range = 0xFFFFFFFF;
|
||||
for (int i = 0; i < 5; i++)
|
||||
Code = (Code << 8) | (byte)Stream.ReadByte();
|
||||
}
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
// Stream.ReleaseStream();
|
||||
Stream = null;
|
||||
}
|
||||
|
||||
public void CloseStream()
|
||||
{
|
||||
Stream.Close();
|
||||
}
|
||||
|
||||
public void Normalize()
|
||||
{
|
||||
while (Range < kTopValue)
|
||||
{
|
||||
Code = (Code << 8) | (byte)Stream.ReadByte();
|
||||
Range <<= 8;
|
||||
}
|
||||
}
|
||||
|
||||
public void Normalize2()
|
||||
{
|
||||
if (Range < kTopValue)
|
||||
{
|
||||
Code = (Code << 8) | (byte)Stream.ReadByte();
|
||||
Range <<= 8;
|
||||
}
|
||||
}
|
||||
|
||||
public uint GetThreshold(uint total)
|
||||
{
|
||||
return Code / (Range /= total);
|
||||
}
|
||||
|
||||
public void Decode(uint start, uint size, uint total)
|
||||
{
|
||||
Code -= start * Range;
|
||||
Range *= size;
|
||||
Normalize();
|
||||
}
|
||||
|
||||
public uint DecodeDirectBits(int numTotalBits)
|
||||
{
|
||||
uint range = Range;
|
||||
uint code = Code;
|
||||
uint result = 0;
|
||||
for (int i = numTotalBits; i > 0; i--)
|
||||
{
|
||||
range >>= 1;
|
||||
/*
|
||||
result <<= 1;
|
||||
if (code >= range)
|
||||
{
|
||||
code -= range;
|
||||
result |= 1;
|
||||
}
|
||||
*/
|
||||
uint t = (code - range) >> 31;
|
||||
code -= range & (t - 1);
|
||||
result = (result << 1) | (1 - t);
|
||||
|
||||
if (range < kTopValue)
|
||||
{
|
||||
code = (code << 8) | (byte)Stream.ReadByte();
|
||||
range <<= 8;
|
||||
}
|
||||
}
|
||||
Range = range;
|
||||
Code = code;
|
||||
return result;
|
||||
}
|
||||
|
||||
public uint DecodeBit(uint size0, int numTotalBits)
|
||||
{
|
||||
uint newBound = (Range >> numTotalBits) * size0;
|
||||
uint symbol;
|
||||
if (Code < newBound)
|
||||
{
|
||||
symbol = 0;
|
||||
Range = newBound;
|
||||
}
|
||||
else
|
||||
{
|
||||
symbol = 1;
|
||||
Code -= newBound;
|
||||
Range -= newBound;
|
||||
}
|
||||
Normalize();
|
||||
return symbol;
|
||||
}
|
||||
|
||||
// ulong GetProcessedSize() {return Stream.GetProcessedSize(); }
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: a855cbfe314340a43b3d71672dcbb058
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,117 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.RangeCoder
|
||||
{
|
||||
struct BitEncoder
|
||||
{
|
||||
public const int kNumBitModelTotalBits = 11;
|
||||
public const uint kBitModelTotal = (1 << kNumBitModelTotalBits);
|
||||
const int kNumMoveBits = 5;
|
||||
const int kNumMoveReducingBits = 2;
|
||||
public const int kNumBitPriceShiftBits = 6;
|
||||
|
||||
uint Prob;
|
||||
|
||||
public void Init() { Prob = kBitModelTotal >> 1; }
|
||||
|
||||
public void UpdateModel(uint symbol)
|
||||
{
|
||||
if (symbol == 0)
|
||||
Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
|
||||
else
|
||||
Prob -= (Prob) >> kNumMoveBits;
|
||||
}
|
||||
|
||||
public void Encode(Encoder encoder, uint symbol)
|
||||
{
|
||||
// encoder.EncodeBit(Prob, kNumBitModelTotalBits, symbol);
|
||||
// UpdateModel(symbol);
|
||||
uint newBound = (encoder.Range >> kNumBitModelTotalBits) * Prob;
|
||||
if (symbol == 0)
|
||||
{
|
||||
encoder.Range = newBound;
|
||||
Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
|
||||
}
|
||||
else
|
||||
{
|
||||
encoder.Low += newBound;
|
||||
encoder.Range -= newBound;
|
||||
Prob -= (Prob) >> kNumMoveBits;
|
||||
}
|
||||
if (encoder.Range < Encoder.kTopValue)
|
||||
{
|
||||
encoder.Range <<= 8;
|
||||
encoder.ShiftLow();
|
||||
}
|
||||
}
|
||||
|
||||
private static UInt32[] ProbPrices = new UInt32[kBitModelTotal >> kNumMoveReducingBits];
|
||||
|
||||
static BitEncoder()
|
||||
{
|
||||
const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);
|
||||
for (int i = kNumBits - 1; i >= 0; i--)
|
||||
{
|
||||
UInt32 start = (UInt32)1 << (kNumBits - i - 1);
|
||||
UInt32 end = (UInt32)1 << (kNumBits - i);
|
||||
for (UInt32 j = start; j < end; j++)
|
||||
ProbPrices[j] = ((UInt32)i << kNumBitPriceShiftBits) +
|
||||
(((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));
|
||||
}
|
||||
}
|
||||
|
||||
public uint GetPrice(uint symbol)
|
||||
{
|
||||
return ProbPrices[(((Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];
|
||||
}
|
||||
public uint GetPrice0() { return ProbPrices[Prob >> kNumMoveReducingBits]; }
|
||||
public uint GetPrice1() { return ProbPrices[(kBitModelTotal - Prob) >> kNumMoveReducingBits]; }
|
||||
}
|
||||
|
||||
struct BitDecoder
|
||||
{
|
||||
public const int kNumBitModelTotalBits = 11;
|
||||
public const uint kBitModelTotal = (1 << kNumBitModelTotalBits);
|
||||
const int kNumMoveBits = 5;
|
||||
|
||||
uint Prob;
|
||||
|
||||
public void UpdateModel(int numMoveBits, uint symbol)
|
||||
{
|
||||
if (symbol == 0)
|
||||
Prob += (kBitModelTotal - Prob) >> numMoveBits;
|
||||
else
|
||||
Prob -= (Prob) >> numMoveBits;
|
||||
}
|
||||
|
||||
public void Init() { Prob = kBitModelTotal >> 1; }
|
||||
|
||||
public uint Decode(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint newBound = (uint)(rangeDecoder.Range >> kNumBitModelTotalBits) * (uint)Prob;
|
||||
if (rangeDecoder.Code < newBound)
|
||||
{
|
||||
rangeDecoder.Range = newBound;
|
||||
Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
|
||||
if (rangeDecoder.Range < Decoder.kTopValue)
|
||||
{
|
||||
rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
|
||||
rangeDecoder.Range <<= 8;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
rangeDecoder.Range -= newBound;
|
||||
rangeDecoder.Code -= newBound;
|
||||
Prob -= (Prob) >> kNumMoveBits;
|
||||
if (rangeDecoder.Range < Decoder.kTopValue)
|
||||
{
|
||||
rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
|
||||
rangeDecoder.Range <<= 8;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: f3fd3305ff6e02448a7b0470cfe65b77
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,157 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.RangeCoder
|
||||
{
|
||||
struct BitTreeEncoder
|
||||
{
|
||||
BitEncoder[] Models;
|
||||
int NumBitLevels;
|
||||
|
||||
public BitTreeEncoder(int numBitLevels)
|
||||
{
|
||||
NumBitLevels = numBitLevels;
|
||||
Models = new BitEncoder[1 << numBitLevels];
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
for (uint i = 1; i < (1 << NumBitLevels); i++)
|
||||
Models[i].Init();
|
||||
}
|
||||
|
||||
public void Encode(Encoder rangeEncoder, UInt32 symbol)
|
||||
{
|
||||
UInt32 m = 1;
|
||||
for (int bitIndex = NumBitLevels; bitIndex > 0; )
|
||||
{
|
||||
bitIndex--;
|
||||
UInt32 bit = (symbol >> bitIndex) & 1;
|
||||
Models[m].Encode(rangeEncoder, bit);
|
||||
m = (m << 1) | bit;
|
||||
}
|
||||
}
|
||||
|
||||
public void ReverseEncode(Encoder rangeEncoder, UInt32 symbol)
|
||||
{
|
||||
UInt32 m = 1;
|
||||
for (UInt32 i = 0; i < NumBitLevels; i++)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
Models[m].Encode(rangeEncoder, bit);
|
||||
m = (m << 1) | bit;
|
||||
symbol >>= 1;
|
||||
}
|
||||
}
|
||||
|
||||
public UInt32 GetPrice(UInt32 symbol)
|
||||
{
|
||||
UInt32 price = 0;
|
||||
UInt32 m = 1;
|
||||
for (int bitIndex = NumBitLevels; bitIndex > 0; )
|
||||
{
|
||||
bitIndex--;
|
||||
UInt32 bit = (symbol >> bitIndex) & 1;
|
||||
price += Models[m].GetPrice(bit);
|
||||
m = (m << 1) + bit;
|
||||
}
|
||||
return price;
|
||||
}
|
||||
|
||||
public UInt32 ReverseGetPrice(UInt32 symbol)
|
||||
{
|
||||
UInt32 price = 0;
|
||||
UInt32 m = 1;
|
||||
for (int i = NumBitLevels; i > 0; i--)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
symbol >>= 1;
|
||||
price += Models[m].GetPrice(bit);
|
||||
m = (m << 1) | bit;
|
||||
}
|
||||
return price;
|
||||
}
|
||||
|
||||
public static UInt32 ReverseGetPrice(BitEncoder[] Models, UInt32 startIndex,
|
||||
int NumBitLevels, UInt32 symbol)
|
||||
{
|
||||
UInt32 price = 0;
|
||||
UInt32 m = 1;
|
||||
for (int i = NumBitLevels; i > 0; i--)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
symbol >>= 1;
|
||||
price += Models[startIndex + m].GetPrice(bit);
|
||||
m = (m << 1) | bit;
|
||||
}
|
||||
return price;
|
||||
}
|
||||
|
||||
public static void ReverseEncode(BitEncoder[] Models, UInt32 startIndex,
|
||||
Encoder rangeEncoder, int NumBitLevels, UInt32 symbol)
|
||||
{
|
||||
UInt32 m = 1;
|
||||
for (int i = 0; i < NumBitLevels; i++)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
Models[startIndex + m].Encode(rangeEncoder, bit);
|
||||
m = (m << 1) | bit;
|
||||
symbol >>= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct BitTreeDecoder
|
||||
{
|
||||
BitDecoder[] Models;
|
||||
int NumBitLevels;
|
||||
|
||||
public BitTreeDecoder(int numBitLevels)
|
||||
{
|
||||
NumBitLevels = numBitLevels;
|
||||
Models = new BitDecoder[1 << numBitLevels];
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
for (uint i = 1; i < (1 << NumBitLevels); i++)
|
||||
Models[i].Init();
|
||||
}
|
||||
|
||||
public uint Decode(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint m = 1;
|
||||
for (int bitIndex = NumBitLevels; bitIndex > 0; bitIndex--)
|
||||
m = (m << 1) + Models[m].Decode(rangeDecoder);
|
||||
return m - ((uint)1 << NumBitLevels);
|
||||
}
|
||||
|
||||
public uint ReverseDecode(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint m = 1;
|
||||
uint symbol = 0;
|
||||
for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
|
||||
{
|
||||
uint bit = Models[m].Decode(rangeDecoder);
|
||||
m <<= 1;
|
||||
m += bit;
|
||||
symbol |= (bit << bitIndex);
|
||||
}
|
||||
return symbol;
|
||||
}
|
||||
|
||||
public static uint ReverseDecode(BitDecoder[] Models, UInt32 startIndex,
|
||||
RangeCoder.Decoder rangeDecoder, int NumBitLevels)
|
||||
{
|
||||
uint m = 1;
|
||||
uint symbol = 0;
|
||||
for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
|
||||
{
|
||||
uint bit = Models[startIndex + m].Decode(rangeDecoder);
|
||||
m <<= 1;
|
||||
m += bit;
|
||||
symbol |= (bit << bitIndex);
|
||||
}
|
||||
return symbol;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: ef79f786b772db344a4792a5cba382ff
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,157 +0,0 @@
|
||||
// ICoder.h
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip
|
||||
{
|
||||
/// <summary>
|
||||
/// The exception that is thrown when an error in input stream occurs during decoding.
|
||||
/// </summary>
|
||||
class DataErrorException : ApplicationException
|
||||
{
|
||||
public DataErrorException(): base("Data Error") { }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The exception that is thrown when the value of an argument is outside the allowable range.
|
||||
/// </summary>
|
||||
class InvalidParamException : ApplicationException
|
||||
{
|
||||
public InvalidParamException(): base("Invalid Parameter") { }
|
||||
}
|
||||
|
||||
public interface ICodeProgress
|
||||
{
|
||||
/// <summary>
|
||||
/// Callback progress.
|
||||
/// </summary>
|
||||
/// <param name="inSize">
|
||||
/// input size. -1 if unknown.
|
||||
/// </param>
|
||||
/// <param name="outSize">
|
||||
/// output size. -1 if unknown.
|
||||
/// </param>
|
||||
void SetProgress(Int64 inSize, Int64 outSize);
|
||||
};
|
||||
|
||||
public interface ICoder
|
||||
{
|
||||
/// <summary>
|
||||
/// Codes streams.
|
||||
/// </summary>
|
||||
/// <param name="inStream">
|
||||
/// input Stream.
|
||||
/// </param>
|
||||
/// <param name="outStream">
|
||||
/// output Stream.
|
||||
/// </param>
|
||||
/// <param name="inSize">
|
||||
/// input Size. -1 if unknown.
|
||||
/// </param>
|
||||
/// <param name="outSize">
|
||||
/// output Size. -1 if unknown.
|
||||
/// </param>
|
||||
/// <param name="progress">
|
||||
/// callback progress reference.
|
||||
/// </param>
|
||||
/// <exception cref="SevenZip.DataErrorException">
|
||||
/// if input stream is not valid
|
||||
/// </exception>
|
||||
void Code(System.IO.Stream inStream, System.IO.Stream outStream,
|
||||
Int64 inSize, Int64 outSize, ICodeProgress progress);
|
||||
};
|
||||
|
||||
/*
|
||||
public interface ICoder2
|
||||
{
|
||||
void Code(ISequentialInStream []inStreams,
|
||||
const UInt64 []inSizes,
|
||||
ISequentialOutStream []outStreams,
|
||||
UInt64 []outSizes,
|
||||
ICodeProgress progress);
|
||||
};
|
||||
*/
|
||||
|
||||
/// <summary>
|
||||
/// Provides the fields that represent properties idenitifiers for compressing.
|
||||
/// </summary>
|
||||
public enum CoderPropID
|
||||
{
|
||||
/// <summary>
|
||||
/// Specifies default property.
|
||||
/// </summary>
|
||||
DefaultProp = 0,
|
||||
/// <summary>
|
||||
/// Specifies size of dictionary.
|
||||
/// </summary>
|
||||
DictionarySize,
|
||||
/// <summary>
|
||||
/// Specifies size of memory for PPM*.
|
||||
/// </summary>
|
||||
UsedMemorySize,
|
||||
/// <summary>
|
||||
/// Specifies order for PPM methods.
|
||||
/// </summary>
|
||||
Order,
|
||||
/// <summary>
|
||||
/// Specifies Block Size.
|
||||
/// </summary>
|
||||
BlockSize,
|
||||
/// <summary>
|
||||
/// Specifies number of postion state bits for LZMA (0 <= x <= 4).
|
||||
/// </summary>
|
||||
PosStateBits,
|
||||
/// <summary>
|
||||
/// Specifies number of literal context bits for LZMA (0 <= x <= 8).
|
||||
/// </summary>
|
||||
LitContextBits,
|
||||
/// <summary>
|
||||
/// Specifies number of literal position bits for LZMA (0 <= x <= 4).
|
||||
/// </summary>
|
||||
LitPosBits,
|
||||
/// <summary>
|
||||
/// Specifies number of fast bytes for LZ*.
|
||||
/// </summary>
|
||||
NumFastBytes,
|
||||
/// <summary>
|
||||
/// Specifies match finder. LZMA: "BT2", "BT4" or "BT4B".
|
||||
/// </summary>
|
||||
MatchFinder,
|
||||
/// <summary>
|
||||
/// Specifies the number of match finder cyckes.
|
||||
/// </summary>
|
||||
MatchFinderCycles,
|
||||
/// <summary>
|
||||
/// Specifies number of passes.
|
||||
/// </summary>
|
||||
NumPasses,
|
||||
/// <summary>
|
||||
/// Specifies number of algorithm.
|
||||
/// </summary>
|
||||
Algorithm,
|
||||
/// <summary>
|
||||
/// Specifies the number of threads.
|
||||
/// </summary>
|
||||
NumThreads,
|
||||
/// <summary>
|
||||
/// Specifies mode with end marker.
|
||||
/// </summary>
|
||||
EndMarker
|
||||
};
|
||||
|
||||
|
||||
public interface ISetCoderProperties
|
||||
{
|
||||
void SetCoderProperties(CoderPropID[] propIDs, object[] properties);
|
||||
};
|
||||
|
||||
public interface IWriteCoderProperties
|
||||
{
|
||||
void WriteCoderProperties(System.IO.Stream outStream);
|
||||
}
|
||||
|
||||
public interface ISetDecoderProperties
|
||||
{
|
||||
void SetDecoderProperties(byte[] properties);
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 9f4fba00efa28594ea18888f574d028a
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,8 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 59ab7ccacd9a9944bb9456da235d6760
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,14 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
[Flags]
|
||||
public enum ArchiveFlags
|
||||
{
|
||||
CompressionTypeMask = 0x3f,
|
||||
BlocksAndDirectoryInfoCombined = 0x40,
|
||||
BlocksInfoAtTheEnd = 0x80,
|
||||
OldWebPluginCompatibility = 0x100,
|
||||
BlockInfoNeedPaddingAtStart = 0x200
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 099de05eebdffaf4baeed3290dc98aaf
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,51 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Text;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public static class BinaryReaderExtensions
|
||||
{
|
||||
|
||||
public static void AlignStream(this BinaryReader reader, int alignment)
|
||||
{
|
||||
var pos = reader.BaseStream.Position;
|
||||
var mod = pos % alignment;
|
||||
if (mod != 0)
|
||||
{
|
||||
reader.BaseStream.Position += alignment - mod;
|
||||
}
|
||||
}
|
||||
|
||||
public static string ReadAlignedString(this BinaryReader reader)
|
||||
{
|
||||
var length = reader.ReadInt32();
|
||||
if (length > 0 && length <= reader.BaseStream.Length - reader.BaseStream.Position)
|
||||
{
|
||||
var stringData = reader.ReadBytes(length);
|
||||
var result = Encoding.UTF8.GetString(stringData);
|
||||
reader.AlignStream(4);
|
||||
return result;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
public static string ReadStringToNull(this BinaryReader reader, int maxLength = 32767)
|
||||
{
|
||||
var bytes = new List<byte>();
|
||||
int count = 0;
|
||||
while (reader.BaseStream.Position != reader.BaseStream.Length && count < maxLength)
|
||||
{
|
||||
var b = reader.ReadByte();
|
||||
if (b == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
bytes.Add(b);
|
||||
count++;
|
||||
}
|
||||
return Encoding.UTF8.GetString(bytes.ToArray());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: a84e427dd05adde44b4345b3fd49007a
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,33 +0,0 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Text;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public static class BinaryWriterExtensions
|
||||
{
|
||||
public static void AlignStream(this BinaryWriter writer, int alignment)
|
||||
{
|
||||
var pos = writer.BaseStream.Position;
|
||||
var mod = pos % alignment;
|
||||
if (mod != 0)
|
||||
{
|
||||
writer.Write(new byte[alignment - mod]);
|
||||
}
|
||||
}
|
||||
|
||||
public static void WriteAlignedString(this BinaryWriter writer, string str)
|
||||
{
|
||||
var bytes = Encoding.UTF8.GetBytes(str);
|
||||
writer.Write(bytes.Length);
|
||||
writer.Write(bytes);
|
||||
writer.AlignStream(4);
|
||||
}
|
||||
|
||||
public static void WriteNullEndString(this BinaryWriter writer, string str)
|
||||
{
|
||||
writer.Write(Encoding.UTF8.GetBytes(str));
|
||||
writer.Write((byte)0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 02eda21769c083346a5bd9b7dca49427
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,24 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public class BundleSubFile
|
||||
{
|
||||
public string file;
|
||||
public byte[] data;
|
||||
}
|
||||
|
||||
public class BundleFileInfo
|
||||
{
|
||||
public string signature;
|
||||
public uint version;
|
||||
public string unityVersion;
|
||||
public string unityRevision;
|
||||
public ArchiveFlags flags;
|
||||
public List<BundleSubFile> files;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 1a72550a949e322419b9c5d6e4fe495d
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,212 +0,0 @@
|
||||
using LZ4;
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using UnityEngine;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
|
||||
public class BundleFileReader
|
||||
{
|
||||
|
||||
private Header m_Header;
|
||||
private StorageBlock[] m_BlocksInfo;
|
||||
private Node[] m_DirectoryInfo;
|
||||
|
||||
private StreamFile[] fileList;
|
||||
|
||||
public BundleFileReader()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public void Load(EndianBinaryReader reader)
|
||||
{
|
||||
Debug.Log($"reader. pos:{reader.Position} length:{reader.BaseStream.Length}");
|
||||
m_Header = new Header();
|
||||
m_Header.signature = reader.ReadStringToNull();
|
||||
m_Header.version = reader.ReadUInt32();
|
||||
m_Header.unityVersion = reader.ReadStringToNull();
|
||||
m_Header.unityRevision = reader.ReadStringToNull();
|
||||
System.Diagnostics.Debug.Assert(m_Header.signature == "UnityFS");
|
||||
|
||||
|
||||
m_Header.size = reader.ReadInt64();
|
||||
Debug.Log($"header size:{m_Header.size}");
|
||||
m_Header.compressedBlocksInfoSize = reader.ReadUInt32();
|
||||
m_Header.uncompressedBlocksInfoSize = reader.ReadUInt32();
|
||||
m_Header.flags = (ArchiveFlags)reader.ReadUInt32();
|
||||
if (m_Header.signature != "UnityFS")
|
||||
{
|
||||
reader.ReadByte();
|
||||
}
|
||||
|
||||
ReadMetadata(reader);
|
||||
using (var blocksStream = CreateBlocksStream())
|
||||
{
|
||||
ReadBlocks(reader, blocksStream);
|
||||
ReadFiles(blocksStream);
|
||||
}
|
||||
}
|
||||
|
||||
public BundleFileInfo CreateBundleFileInfo()
|
||||
{
|
||||
return new BundleFileInfo
|
||||
{
|
||||
signature = m_Header.signature,
|
||||
version = m_Header.version,
|
||||
unityVersion = m_Header.unityVersion,
|
||||
unityRevision = m_Header.unityRevision,
|
||||
files = fileList.Select(f => new BundleSubFile { file = f.path, data = f.stream.ReadAllBytes() }).ToList(),
|
||||
};
|
||||
}
|
||||
|
||||
private byte[] ReadBlocksInfoAndDirectoryMetadataUnCompressedBytes(EndianBinaryReader reader)
|
||||
{
|
||||
byte[] metadataUncompressBytes;
|
||||
if (m_Header.version >= 7)
|
||||
{
|
||||
reader.AlignStream(16);
|
||||
}
|
||||
if ((m_Header.flags & ArchiveFlags.BlocksInfoAtTheEnd) != 0)
|
||||
{
|
||||
var position = reader.Position;
|
||||
reader.Position = reader.BaseStream.Length - m_Header.compressedBlocksInfoSize;
|
||||
metadataUncompressBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize);
|
||||
reader.Position = position;
|
||||
}
|
||||
else //0x40 BlocksAndDirectoryInfoCombined
|
||||
{
|
||||
metadataUncompressBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize);
|
||||
}
|
||||
return metadataUncompressBytes;
|
||||
}
|
||||
|
||||
private byte[] DecompressBytes(CompressionType compressionType, byte[] compressedBytes, uint uncompressedSize)
|
||||
{
|
||||
switch (compressionType)
|
||||
{
|
||||
case CompressionType.None:
|
||||
{
|
||||
return compressedBytes;
|
||||
}
|
||||
case CompressionType.Lzma:
|
||||
{
|
||||
var uncompressedStream = new MemoryStream((int)(uncompressedSize));
|
||||
using (var compressedStream = new MemoryStream(compressedBytes))
|
||||
{
|
||||
ComparessHelper.Decompress7Zip(compressedStream, uncompressedStream, m_Header.compressedBlocksInfoSize, m_Header.uncompressedBlocksInfoSize);
|
||||
}
|
||||
return uncompressedStream.ReadAllBytes();
|
||||
}
|
||||
case CompressionType.Lz4:
|
||||
case CompressionType.Lz4HC:
|
||||
{
|
||||
var uncompressedBytes = new byte[uncompressedSize];
|
||||
var numWrite = LZ4Codec.Decode(compressedBytes, 0, compressedBytes.Length, uncompressedBytes, 0, uncompressedBytes.Length, true);
|
||||
if (numWrite != uncompressedSize)
|
||||
{
|
||||
throw new IOException($"Lz4 decompression error, write {numWrite} bytes but expected {uncompressedSize} bytes");
|
||||
}
|
||||
return uncompressedBytes;
|
||||
}
|
||||
default:
|
||||
throw new IOException($"Unsupported compression type {compressionType}");
|
||||
}
|
||||
}
|
||||
|
||||
private void ReadMetadata(EndianBinaryReader reader)
|
||||
{
|
||||
byte[] compressMetadataBytes = ReadBlocksInfoAndDirectoryMetadataUnCompressedBytes(reader);
|
||||
MemoryStream metadataStream = new MemoryStream(DecompressBytes((CompressionType)(m_Header.flags & ArchiveFlags.CompressionTypeMask), compressMetadataBytes, m_Header.uncompressedBlocksInfoSize));
|
||||
using (var blocksInfoReader = new EndianBinaryReader(metadataStream))
|
||||
{
|
||||
var uncompressedDataHash = blocksInfoReader.ReadBytes(16);
|
||||
var blocksInfoCount = blocksInfoReader.ReadInt32();
|
||||
m_BlocksInfo = new StorageBlock[blocksInfoCount];
|
||||
for (int i = 0; i < blocksInfoCount; i++)
|
||||
{
|
||||
m_BlocksInfo[i] = new StorageBlock
|
||||
{
|
||||
uncompressedSize = blocksInfoReader.ReadUInt32(),
|
||||
compressedSize = blocksInfoReader.ReadUInt32(),
|
||||
flags = (StorageBlockFlags)blocksInfoReader.ReadUInt16()
|
||||
};
|
||||
}
|
||||
|
||||
var nodesCount = blocksInfoReader.ReadInt32();
|
||||
m_DirectoryInfo = new Node[nodesCount];
|
||||
for (int i = 0; i < nodesCount; i++)
|
||||
{
|
||||
m_DirectoryInfo[i] = new Node
|
||||
{
|
||||
offset = blocksInfoReader.ReadInt64(),
|
||||
size = blocksInfoReader.ReadInt64(),
|
||||
flags = blocksInfoReader.ReadUInt32(),
|
||||
path = blocksInfoReader.ReadStringToNull(),
|
||||
};
|
||||
}
|
||||
}
|
||||
if (m_Header.flags.HasFlag(ArchiveFlags.BlockInfoNeedPaddingAtStart))
|
||||
{
|
||||
reader.AlignStream(16);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private Stream CreateBlocksStream()
|
||||
{
|
||||
Stream blocksStream;
|
||||
var uncompressedSizeSum = m_BlocksInfo.Sum(x => x.uncompressedSize);
|
||||
if (uncompressedSizeSum >= int.MaxValue)
|
||||
{
|
||||
throw new Exception($"too fig file");
|
||||
}
|
||||
else
|
||||
{
|
||||
blocksStream = new MemoryStream((int)uncompressedSizeSum);
|
||||
}
|
||||
return blocksStream;
|
||||
}
|
||||
|
||||
public void ReadFiles(Stream blocksStream)
|
||||
{
|
||||
fileList = new StreamFile[m_DirectoryInfo.Length];
|
||||
for (int i = 0; i < m_DirectoryInfo.Length; i++)
|
||||
{
|
||||
var node = m_DirectoryInfo[i];
|
||||
var file = new StreamFile();
|
||||
fileList[i] = file;
|
||||
file.path = node.path;
|
||||
file.fileName = Path.GetFileName(node.path);
|
||||
if (node.size >= int.MaxValue)
|
||||
{
|
||||
throw new Exception($"exceed max file size");
|
||||
/*var memoryMappedFile = MemoryMappedFile.CreateNew(null, entryinfo_size);
|
||||
file.stream = memoryMappedFile.CreateViewStream();*/
|
||||
//var extractPath = path + "_unpacked" + Path.DirectorySeparatorChar;
|
||||
//Directory.CreateDirectory(extractPath);
|
||||
//file.stream = new FileStream(extractPath + file.fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
|
||||
}
|
||||
file.stream = new MemoryStream((int)node.size);
|
||||
blocksStream.Position = node.offset;
|
||||
blocksStream.CopyTo(file.stream, node.size);
|
||||
file.stream.Position = 0;
|
||||
}
|
||||
}
|
||||
|
||||
private void ReadBlocks(EndianBinaryReader reader, Stream blocksStream)
|
||||
{
|
||||
foreach (var blockInfo in m_BlocksInfo)
|
||||
{
|
||||
var compressedSize = (int)blockInfo.compressedSize;
|
||||
byte[] compressedBlockBytes = reader.ReadBytes(compressedSize);
|
||||
var compressionType = (CompressionType)(blockInfo.flags & StorageBlockFlags.CompressionTypeMask);
|
||||
byte[] uncompressedBlockBytes = DecompressBytes(compressionType, compressedBlockBytes, blockInfo.uncompressedSize);
|
||||
blocksStream.Write(uncompressedBlockBytes, 0, uncompressedBlockBytes.Length);
|
||||
}
|
||||
blocksStream.Position = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: f9b938458cc610e4d8a910c4499693cf
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,112 +0,0 @@
|
||||
using LZ4;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using UnityEngine;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public class BundleFileWriter
|
||||
{
|
||||
private readonly BundleFileInfo _bundle;
|
||||
|
||||
private readonly List<Node> _files = new List<Node>();
|
||||
private readonly List<StorageBlock> _blocks = new List<StorageBlock>();
|
||||
|
||||
private readonly EndianBinaryWriter _blockDirectoryMetadataStream = new EndianBinaryWriter(new MemoryStream());
|
||||
private byte[] _blockBytes;
|
||||
|
||||
public BundleFileWriter(BundleFileInfo bundle)
|
||||
{
|
||||
_bundle = bundle;
|
||||
}
|
||||
|
||||
public void Write(EndianBinaryWriter output)
|
||||
{
|
||||
InitBlockAndDirectories();
|
||||
|
||||
output.WriteNullEndString(_bundle.signature);
|
||||
output.Write(_bundle.version);
|
||||
output.WriteNullEndString(_bundle.unityVersion);
|
||||
output.WriteNullEndString(_bundle.unityRevision);
|
||||
|
||||
BuildBlockDirectoryMetadata();
|
||||
|
||||
|
||||
long sizePos = output.Position;
|
||||
output.Write(0L);
|
||||
output.Write((uint)_blockDirectoryMetadataStream.Length);
|
||||
output.Write((uint)_blockDirectoryMetadataStream.Length);
|
||||
ArchiveFlags flags = ArchiveFlags.BlocksAndDirectoryInfoCombined | (uint)CompressionType.None;
|
||||
output.Write((uint)flags);
|
||||
|
||||
if (_bundle.version >= 7)
|
||||
{
|
||||
output.AlignStream(16);
|
||||
}
|
||||
byte[] metadataBytes = _blockDirectoryMetadataStream.BaseStream.ReadAllBytes();
|
||||
output.Write(metadataBytes, 0, metadataBytes.Length);
|
||||
|
||||
byte[] dataBytes = _blockBytes;
|
||||
output.Write(dataBytes, 0, dataBytes.Length);
|
||||
|
||||
output.Position = sizePos;
|
||||
output.Write(output.Length);
|
||||
}
|
||||
|
||||
private void InitBlockAndDirectories()
|
||||
{
|
||||
var dataStream = new MemoryStream();
|
||||
foreach(var file in _bundle.files)
|
||||
{
|
||||
byte[] data = file.data;
|
||||
_files.Add(new Node { path = file.file, flags = 0, offset = dataStream.Length, size = data.LongLength });
|
||||
dataStream.Write(data, 0, data.Length);
|
||||
}
|
||||
byte[] dataBytes = dataStream.ToArray();
|
||||
|
||||
var compressedBlockStream = new MemoryStream(dataBytes.Length / 2);
|
||||
int blockByteSize = 128 * 1024;
|
||||
long dataSize = dataBytes.Length;
|
||||
byte[] tempCompressBlock = new byte[blockByteSize * 2];
|
||||
for(long i = 0, blockNum = (dataSize + blockByteSize - 1) / blockByteSize; i < blockNum; i++)
|
||||
{
|
||||
long curBlockSize = Math.Min(dataSize, blockByteSize);
|
||||
dataSize -= curBlockSize;
|
||||
|
||||
int compressedSize = LZ4Codec.Encode(dataBytes, (int)(i * blockByteSize), (int)curBlockSize, tempCompressBlock, 0, tempCompressBlock.Length);
|
||||
compressedBlockStream.Write(tempCompressBlock, 0, compressedSize);
|
||||
_blocks.Add(new StorageBlock { flags = (StorageBlockFlags)(int)CompressionType.Lz4, compressedSize = (uint)compressedSize, uncompressedSize = (uint)curBlockSize });
|
||||
//Debug.Log($"== block[{i}] uncompressedSize:{curBlockSize} compressedSize:{compressedSize} totalblocksize:{compressedBlockStream.Length}");
|
||||
}
|
||||
_blockBytes = compressedBlockStream.ToArray();
|
||||
}
|
||||
|
||||
private void BuildBlockDirectoryMetadata()
|
||||
{
|
||||
var hash = new byte[16];
|
||||
_blockDirectoryMetadataStream.Write(hash, 0, 16);
|
||||
|
||||
_blockDirectoryMetadataStream.Write((uint)_blocks.Count);
|
||||
foreach(var b in _blocks)
|
||||
{
|
||||
_blockDirectoryMetadataStream.Write(b.uncompressedSize);
|
||||
_blockDirectoryMetadataStream.Write(b.compressedSize);
|
||||
_blockDirectoryMetadataStream.Write((ushort)b.flags);
|
||||
}
|
||||
|
||||
_blockDirectoryMetadataStream.Write((uint)_files.Count);
|
||||
foreach(var f in _files)
|
||||
{
|
||||
_blockDirectoryMetadataStream.Write(f.offset);
|
||||
_blockDirectoryMetadataStream.Write(f.size);
|
||||
_blockDirectoryMetadataStream.Write(f.flags);
|
||||
_blockDirectoryMetadataStream.WriteNullEndString(f.path);
|
||||
}
|
||||
//Debug.Log($"block and directory metadata size:{_blockDirectoryMetadataStream.Length}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: d6705163b267de54a868f5e84f6c7024
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,11 +0,0 @@
|
||||
namespace UnityFS
|
||||
{
|
||||
public enum CompressionType
|
||||
{
|
||||
None,
|
||||
Lzma,
|
||||
Lz4,
|
||||
Lz4HC,
|
||||
Lzham
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: ddcd6644c83d2a94f9668d6e913bd80e
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,107 +0,0 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public class EndianBinaryReader : BinaryReader
|
||||
{
|
||||
private readonly byte[] buffer;
|
||||
|
||||
public EndianType Endian;
|
||||
|
||||
public EndianBinaryReader(Stream stream, EndianType endian = EndianType.BigEndian) : base(stream)
|
||||
{
|
||||
Endian = endian;
|
||||
buffer = new byte[8];
|
||||
}
|
||||
|
||||
public long Position
|
||||
{
|
||||
get => BaseStream.Position;
|
||||
set => BaseStream.Position = value;
|
||||
}
|
||||
|
||||
private unsafe void ReadBufferBigEndian(byte* dst, byte[] src, int size)
|
||||
{
|
||||
System.Diagnostics.Debug.Assert(BitConverter.IsLittleEndian);
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
dst[i] = src[size - i - 1];
|
||||
}
|
||||
}
|
||||
|
||||
public override short ReadInt16()
|
||||
{
|
||||
return (short)ReadUInt16();
|
||||
}
|
||||
|
||||
public unsafe override ushort ReadUInt16()
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
Read(buffer, 0, 2);
|
||||
ushort x = 0;
|
||||
ReadBufferBigEndian((byte*)&x, buffer, 2);
|
||||
return x;
|
||||
}
|
||||
return base.ReadUInt16();
|
||||
}
|
||||
|
||||
public override int ReadInt32()
|
||||
{
|
||||
return (int)ReadUInt32();
|
||||
}
|
||||
|
||||
public unsafe override uint ReadUInt32()
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
Read(buffer, 0, 4);
|
||||
uint x = 0;
|
||||
ReadBufferBigEndian((byte*)&x, buffer, 4);
|
||||
return x;
|
||||
}
|
||||
return base.ReadUInt32();
|
||||
}
|
||||
|
||||
public override long ReadInt64()
|
||||
{
|
||||
return (long)ReadUInt64();
|
||||
}
|
||||
|
||||
public unsafe override ulong ReadUInt64()
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
Read(buffer, 0, 8);
|
||||
|
||||
ulong x = 0;
|
||||
ReadBufferBigEndian((byte*)&x, buffer, 8);
|
||||
return x;
|
||||
}
|
||||
return base.ReadUInt64();
|
||||
}
|
||||
|
||||
public override float ReadSingle()
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
Read(buffer, 0, 4);
|
||||
Array.Reverse(buffer, 0, 4);
|
||||
return BitConverter.ToSingle(buffer, 0);
|
||||
}
|
||||
return base.ReadSingle();
|
||||
}
|
||||
|
||||
public override double ReadDouble()
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
Read(buffer, 0, 8);
|
||||
Array.Reverse(buffer);
|
||||
return BitConverter.ToDouble(buffer, 0);
|
||||
}
|
||||
return base.ReadDouble();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 9b02c037f0fa1014da65773804248d8d
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,107 +0,0 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public class EndianBinaryWriter : BinaryWriter
|
||||
{
|
||||
private readonly byte[] buffer;
|
||||
|
||||
public EndianType Endian;
|
||||
|
||||
public EndianBinaryWriter(Stream stream, EndianType endian = EndianType.BigEndian) : base(stream)
|
||||
{
|
||||
Endian = endian;
|
||||
buffer = new byte[8];
|
||||
}
|
||||
|
||||
public long Position
|
||||
{
|
||||
get => BaseStream.Position;
|
||||
set => BaseStream.Position = value;
|
||||
}
|
||||
|
||||
public long Length => BaseStream.Length;
|
||||
|
||||
public override void Write(short x)
|
||||
{
|
||||
Write((ushort)x);
|
||||
}
|
||||
|
||||
private unsafe void WriteBufferBigEndian(byte[] dst, byte* src, int size)
|
||||
{
|
||||
System.Diagnostics.Debug.Assert(BitConverter.IsLittleEndian);
|
||||
for(int i = 0; i < size; i++)
|
||||
{
|
||||
dst[i] = src[size - i - 1];
|
||||
}
|
||||
}
|
||||
|
||||
public unsafe override void Write(ushort x)
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
WriteBufferBigEndian(buffer, (byte*)&x, 2);
|
||||
Write(buffer, 0, 2);
|
||||
return;
|
||||
}
|
||||
base.Write(x);
|
||||
}
|
||||
|
||||
public override void Write(int x)
|
||||
{
|
||||
Write((uint)x);
|
||||
}
|
||||
|
||||
public unsafe override void Write(uint x)
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
WriteBufferBigEndian(buffer, (byte*)&x, 4);
|
||||
Write(buffer, 0, 4);
|
||||
return;
|
||||
}
|
||||
base.Write(x);
|
||||
}
|
||||
|
||||
public override void Write(long x)
|
||||
{
|
||||
Write((ulong)x);
|
||||
}
|
||||
|
||||
public unsafe override void Write(ulong x)
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
WriteBufferBigEndian(buffer, (byte*)&x, 8);
|
||||
Write(buffer, 0, 8);
|
||||
return;
|
||||
}
|
||||
base.Write(x);
|
||||
}
|
||||
|
||||
public override void Write(float x)
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
var buf = BitConverter.GetBytes(x);
|
||||
Array.Reverse(buf, 0, 4);
|
||||
Write(buf, 0, 4);
|
||||
return;
|
||||
}
|
||||
base.Write(x);
|
||||
}
|
||||
|
||||
public override void Write(double x)
|
||||
{
|
||||
if (Endian == EndianType.BigEndian)
|
||||
{
|
||||
var buf = BitConverter.GetBytes(x);
|
||||
Array.Reverse(buf, 0, 8);
|
||||
Write(buf, 0, 8);
|
||||
return;
|
||||
}
|
||||
base.Write(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 4107364c7434b2042ad647b28e322513
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,14 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public enum EndianType
|
||||
{
|
||||
LittleEndian,
|
||||
BigEndian
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 2f6cbab4506c18248b410a164be891d2
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,53 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using UnityEngine;
|
||||
using UnityFS;
|
||||
|
||||
namespace HybridCLR.Editor.UnityBinFileReader
|
||||
{
|
||||
public class Dataunity3dPatcher
|
||||
{
|
||||
|
||||
public void ApplyPatch(string dataunity3dFile, List<string> hotUpdateAssemblies)
|
||||
{
|
||||
var reader = new BundleFileReader();
|
||||
using (var fs = new EndianBinaryReader(new MemoryStream(File.ReadAllBytes(dataunity3dFile))))
|
||||
{
|
||||
reader.Load(fs);
|
||||
}
|
||||
|
||||
var info = reader.CreateBundleFileInfo();
|
||||
//Debug.Log($"name:{info.signature} version:{info.version} files:{info.files.Count}");
|
||||
//foreach (var file in info.files)
|
||||
//{
|
||||
// Debug.Log($"file:{file.file} size:{file.data.Length}");
|
||||
//}
|
||||
|
||||
var globalgamemanagersFile = info.files.Find(f => f.file == "globalgamemanagers");
|
||||
//Debug.LogFormat("gobalgamemanagers origin size:{0}", globalgamemanagersFile.data.Length);
|
||||
|
||||
var ggdBinFile = new UnityBinFile();
|
||||
ggdBinFile.LoadFromStream(new MemoryStream(globalgamemanagersFile.data));
|
||||
ggdBinFile.AddScriptingAssemblies(hotUpdateAssemblies);
|
||||
byte[] patchedGlobalgamedatasBytes = ggdBinFile.CreatePatchedBytes();
|
||||
//Debug.LogFormat("gobalgamemanagers post patche size:{0}", patchedGlobalgamedatasBytes.Length);
|
||||
globalgamemanagersFile.data = patchedGlobalgamedatasBytes;
|
||||
|
||||
var writer = new BundleFileWriter(info);
|
||||
var output = new MemoryStream();
|
||||
writer.Write(new EndianBinaryWriter(output));
|
||||
Debug.Log($"patch file:{dataunity3dFile} size:{output.Length}");
|
||||
|
||||
//string bakFile = dataunity3dFile + ".bak";
|
||||
//if (!File.Exists(bakFile))
|
||||
//{
|
||||
// File.Copy(dataunity3dFile, bakFile);
|
||||
//}
|
||||
File.WriteAllBytes(dataunity3dFile, output.ToArray());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 653a22d285c79f44a8113c5571b2d26b
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,14 +0,0 @@
|
||||
namespace UnityFS
|
||||
{
|
||||
public class Header
|
||||
{
|
||||
public string signature;
|
||||
public uint version;
|
||||
public string unityVersion;
|
||||
public string unityRevision;
|
||||
public long size;
|
||||
public uint compressedBlocksInfoSize;
|
||||
public uint uncompressedBlocksInfoSize;
|
||||
public ArchiveFlags flags;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: f121e0520fa65c240884d43fd00b3c2a
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,10 +0,0 @@
|
||||
namespace UnityFS
|
||||
{
|
||||
public class Node
|
||||
{
|
||||
public long offset;
|
||||
public long size;
|
||||
public uint flags;
|
||||
public string path;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: e3eea8a6a32b6ac4ba609b39715e25e2
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,50 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using UnityEngine;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public class ScriptingAssembliesJsonPatcher
|
||||
{
|
||||
[Serializable]
|
||||
private class ScriptingAssemblies
|
||||
{
|
||||
public List<string> names;
|
||||
public List<int> types;
|
||||
}
|
||||
|
||||
private string _file;
|
||||
ScriptingAssemblies _scriptingAssemblies;
|
||||
|
||||
public void Load(string file)
|
||||
{
|
||||
_file = file;
|
||||
string content = File.ReadAllText(file);
|
||||
_scriptingAssemblies = JsonUtility.FromJson<ScriptingAssemblies>(content);
|
||||
}
|
||||
|
||||
public void AddScriptingAssemblies(List<string> assemblies)
|
||||
{
|
||||
foreach (string name in assemblies)
|
||||
{
|
||||
if (!_scriptingAssemblies.names.Contains(name))
|
||||
{
|
||||
_scriptingAssemblies.names.Add(name);
|
||||
_scriptingAssemblies.types.Add(16); // user dll type
|
||||
Debug.Log($"[PatchScriptAssembliesJson] add hotfix assembly:{name} to {_file}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void Save(string jsonFile)
|
||||
{
|
||||
string content = JsonUtility.ToJson(_scriptingAssemblies);
|
||||
|
||||
File.WriteAllText(jsonFile, content);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 8f2dd29d56a640d4ebd1c2fd374b7638
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,49 +0,0 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using SevenZip.Compression.LZMA;
|
||||
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public static class ComparessHelper
|
||||
{
|
||||
public static MemoryStream Decompress7Zip(MemoryStream inStream)
|
||||
{
|
||||
var decoder = new Decoder();
|
||||
|
||||
inStream.Seek(0, SeekOrigin.Begin);
|
||||
var newOutStream = new MemoryStream();
|
||||
|
||||
var properties = new byte[5];
|
||||
if (inStream.Read(properties, 0, 5) != 5)
|
||||
throw new Exception("input .lzma is too short");
|
||||
long outSize = 0;
|
||||
for (var i = 0; i < 8; i++)
|
||||
{
|
||||
var v = inStream.ReadByte();
|
||||
if (v < 0)
|
||||
throw new Exception("Can't Read 1");
|
||||
outSize |= ((long)(byte)v) << (8 * i);
|
||||
}
|
||||
decoder.SetDecoderProperties(properties);
|
||||
|
||||
var compressedSize = inStream.Length - inStream.Position;
|
||||
decoder.Code(inStream, newOutStream, compressedSize, outSize, null);
|
||||
|
||||
newOutStream.Position = 0;
|
||||
return newOutStream;
|
||||
}
|
||||
|
||||
public static void Decompress7Zip(Stream compressedStream, Stream decompressedStream, long compressedSize, long decompressedSize)
|
||||
{
|
||||
var basePosition = compressedStream.Position;
|
||||
var decoder = new Decoder();
|
||||
var properties = new byte[5];
|
||||
if (compressedStream.Read(properties, 0, 5) != 5)
|
||||
throw new Exception("input .lzma is too short");
|
||||
decoder.SetDecoderProperties(properties);
|
||||
decoder.Code(compressedStream, decompressedStream, compressedSize - 5, decompressedSize, null);
|
||||
compressedStream.Position = basePosition + compressedSize;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 6606a654e10b3ba48b76b566b903b353
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,9 +0,0 @@
|
||||
namespace UnityFS
|
||||
{
|
||||
public class StorageBlock
|
||||
{
|
||||
public uint compressedSize;
|
||||
public uint uncompressedSize;
|
||||
public StorageBlockFlags flags;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 40dc58bec5631f14c9c17c8a486496d4
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,11 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
[Flags]
|
||||
public enum StorageBlockFlags
|
||||
{
|
||||
CompressionTypeMask = 0x3f,
|
||||
Streamed = 0x40
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 79b9ed6799d3caf459cf2dfae5765a23
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,32 +0,0 @@
|
||||
using System.IO;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public static class StreamExtensions
|
||||
{
|
||||
private const int BufferSize = 81920;
|
||||
|
||||
public static void CopyTo(this Stream source, Stream destination, long size)
|
||||
{
|
||||
var buffer = new byte[BufferSize];
|
||||
for (var left = size; left > 0; left -= BufferSize)
|
||||
{
|
||||
int toRead = BufferSize < left ? BufferSize : (int)left;
|
||||
int read = source.Read(buffer, 0, toRead);
|
||||
destination.Write(buffer, 0, read);
|
||||
if (read != toRead)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static byte[] ReadAllBytes(this Stream source)
|
||||
{
|
||||
source.Position = 0;
|
||||
var bytes = new byte[source.Length];
|
||||
source.Read(bytes, 0, bytes.Length);
|
||||
return bytes;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 2262fbf5672028a48b0c63821d7ff0c0
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,11 +0,0 @@
|
||||
using System.IO;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public class StreamFile
|
||||
{
|
||||
public string path;
|
||||
public string fileName;
|
||||
public Stream stream;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: fad7df04825c947489aad0d5d0c191a7
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,124 +0,0 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using UnityEngine;
|
||||
using System.Text;
|
||||
using System.Reflection;
|
||||
using System;
|
||||
using System.Linq;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
/// <summary>
|
||||
/// Unity 生成的二进制文件(本代码不支持5.x之前的版本)
|
||||
/// </summary>
|
||||
public unsafe class UnityBinFile
|
||||
{
|
||||
/*
|
||||
* MonoManager: idx: 6;
|
||||
* type: metaData.types[objects[6].typeID]
|
||||
*/
|
||||
public const int kMonoManagerIdx = 6;
|
||||
|
||||
public FileHeader header;
|
||||
public MetaData metaData;
|
||||
public ScriptsData scriptsData;
|
||||
|
||||
private Stream _originStream;
|
||||
|
||||
public void LoadFromStream(Stream source)
|
||||
{
|
||||
_originStream = source;
|
||||
using (var br = new BinaryReader(source, Encoding.UTF8, true))
|
||||
{
|
||||
header.LoadFromStream(br);
|
||||
// 按理说 metaData 应该新开一个buffer来避免加载时的对齐逻辑问题,但由于 sizeof(Header) = 20,已经对齐到4了,所以可以连续读
|
||||
metaData.LoadFromStream(br, header.dataOffset);
|
||||
scriptsData = metaData.GetScriptData(br);
|
||||
}
|
||||
}
|
||||
|
||||
public void Load(string path)
|
||||
{
|
||||
LoadFromStream(new MemoryStream(File.ReadAllBytes(path)));
|
||||
}
|
||||
|
||||
public void AddScriptingAssemblies(List<string> assemblies)
|
||||
{
|
||||
foreach (string name in assemblies)
|
||||
{
|
||||
if (!scriptsData.dllNames.Contains(name))
|
||||
{
|
||||
scriptsData.dllNames.Add(name);
|
||||
scriptsData.dllTypes.Add(16); // user dll type
|
||||
Debug.Log($"[PatchScriptAssembliesJson] add dll:{name} to globalgamemanagers");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] CreatePatchedBytes()
|
||||
{
|
||||
var fsR = _originStream;
|
||||
fsR.Position = 0;
|
||||
var brR = new BinaryReader(fsR, Encoding.UTF8, true);
|
||||
|
||||
var ms = new MemoryStream((int)(header.fileSize * 1.5f));
|
||||
var bw = new BinaryWriter(ms, Encoding.UTF8, true);
|
||||
|
||||
/*
|
||||
* 开始写入data
|
||||
* dll名称列表存储于 data 区段,修改其数据并不会影响 MetaData 大小,因此 dataOffset 不会改变
|
||||
*/
|
||||
ms.Position = header.dataOffset;
|
||||
|
||||
Dictionary<long, ObjectInfo> newObjInfos = new Dictionary<long, ObjectInfo>();
|
||||
foreach (var kv in metaData.objects)
|
||||
{
|
||||
long objID = kv.Key;
|
||||
ObjectInfo objInfo = kv.Value;
|
||||
|
||||
byte[] buff = new byte[objInfo.size];
|
||||
fsR.Position = objInfo.realPos;
|
||||
brR.Read(buff, 0, buff.Length);
|
||||
|
||||
|
||||
{// unity 的数据偏移貌似会对齐到 8
|
||||
int newPos = (((int)ms.Position + 7) >> 3) << 3;
|
||||
int gapSize = newPos - (int)ms.Position;
|
||||
|
||||
for (int i = 0; i < gapSize; i++)
|
||||
bw.Write((byte)0);
|
||||
|
||||
objInfo.dataPos = (uint)ms.Position - header.dataOffset; // 重定位数据偏移
|
||||
}
|
||||
|
||||
if (objID != kMonoManagerIdx)
|
||||
bw.Write(buff, 0, buff.Length);
|
||||
else
|
||||
objInfo.size = (uint)scriptsData.SaveToStream(bw);
|
||||
|
||||
newObjInfos.Add(objID, objInfo);
|
||||
}
|
||||
|
||||
metaData.objects = newObjInfos;
|
||||
header.fileSize = (uint)ms.Position;
|
||||
|
||||
ms.Position = 0;
|
||||
header.SaveToStream(bw);
|
||||
metaData.SaveToStream(bw);
|
||||
|
||||
brR.Close();
|
||||
|
||||
// 写入新文件
|
||||
ms.Position = 0;
|
||||
return ms.ToArray();
|
||||
}
|
||||
|
||||
public void Save(string newPath)
|
||||
{
|
||||
byte[] patchedBytes = CreatePatchedBytes();
|
||||
File.WriteAllBytes(newPath, patchedBytes);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 7f9902041e9a1ff4c9f2d65d6384530d
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,397 +0,0 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using UnityEngine;
|
||||
using static UnityFS.UnityBinUtils;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public struct FileHeader
|
||||
{
|
||||
public const int kSize = 20;
|
||||
|
||||
public uint dataSize => fileSize - metadataSize;
|
||||
|
||||
public uint metadataSize;
|
||||
public uint fileSize;
|
||||
public uint version;
|
||||
public uint dataOffset;
|
||||
public byte endianess;
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
long startPos = br.BaseStream.Position;
|
||||
metadataSize = br.ReadUInt32();
|
||||
fileSize = br.ReadUInt32();
|
||||
version = br.ReadUInt32();
|
||||
dataOffset = br.ReadUInt32();
|
||||
endianess = br.ReadByte();
|
||||
br.BaseStream.Position = startPos + kSize;
|
||||
|
||||
SwapEndianess();
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
SwapEndianess();
|
||||
|
||||
long startPos = bw.BaseStream.Position;
|
||||
bw.Write(metadataSize);
|
||||
bw.Write(fileSize);
|
||||
bw.Write(version);
|
||||
bw.Write(dataOffset);
|
||||
bw.Write(endianess);
|
||||
bw.BaseStream.Position = startPos + kSize;
|
||||
return kSize;
|
||||
}
|
||||
|
||||
void SwapEndianess()
|
||||
{
|
||||
SwapUInt(ref metadataSize);
|
||||
SwapUInt(ref fileSize);
|
||||
SwapUInt(ref version);
|
||||
SwapUInt(ref dataOffset);
|
||||
}
|
||||
}
|
||||
|
||||
public struct MetaData
|
||||
{
|
||||
public long dataStartPos;
|
||||
|
||||
public string version;
|
||||
public uint platform;
|
||||
public bool enableTypeTree;
|
||||
public int typeCount;
|
||||
public ObjectType[] types;
|
||||
public int objectCount;
|
||||
public Dictionary<long, ObjectInfo> objects;
|
||||
public int scriptTypeCount;
|
||||
public ScriptType[] scriptTypes;
|
||||
public int externalsCount;
|
||||
public ExternalInfo[] externals;
|
||||
|
||||
#if UNITY_2019_2_OR_NEWER
|
||||
public int refTypeCount;
|
||||
public ObjectType[] refTypes;
|
||||
#endif
|
||||
public string dummyStr;
|
||||
|
||||
public void LoadFromStream(BinaryReader br, uint dataOffset)
|
||||
{
|
||||
long startPos = br.BaseStream.Position;
|
||||
dataStartPos = startPos;
|
||||
|
||||
version = br.ReadRawString();
|
||||
platform = br.ReadUInt32();
|
||||
enableTypeTree = br.ReadBoolean();
|
||||
typeCount = br.ReadInt32();
|
||||
types = new ObjectType[typeCount];
|
||||
|
||||
for (int i = 0; i < typeCount; i++)
|
||||
{
|
||||
types[i].LoadFromStream(br);
|
||||
}
|
||||
|
||||
objectCount = br.ReadInt32();
|
||||
objects = new Dictionary<long, ObjectInfo>();
|
||||
for(int i = 0; i < objectCount; i++)
|
||||
{
|
||||
long id = br.AlignedReadInt64();
|
||||
ObjectInfo objInfo = new ObjectInfo();
|
||||
objInfo.LoadFromStream(br);
|
||||
objInfo.realPos = objInfo.dataPos + dataOffset;
|
||||
|
||||
objects.Add(id, objInfo);
|
||||
}
|
||||
|
||||
scriptTypeCount = br.ReadInt32();
|
||||
scriptTypes = new ScriptType[scriptTypeCount];
|
||||
for(int i = 0; i < scriptTypeCount; i++)
|
||||
{
|
||||
scriptTypes[i].LoadFromStream(br);
|
||||
}
|
||||
|
||||
externalsCount = br.ReadInt32();
|
||||
externals = new ExternalInfo[externalsCount];
|
||||
for(int i = 0; i < externalsCount; i++)
|
||||
{
|
||||
externals[i].LoadFromStream(br);
|
||||
}
|
||||
|
||||
#if UNITY_2019_2_OR_NEWER
|
||||
refTypeCount = br.ReadInt32();
|
||||
refTypes = new ObjectType[refTypeCount];
|
||||
for(int i = 0; i < refTypeCount; i++)
|
||||
{
|
||||
refTypes[i].LoadFromStream(br);
|
||||
}
|
||||
#endif
|
||||
dummyStr = br.ReadRawString();
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
long startPos = bw.BaseStream.Position;
|
||||
bw.WriteRawString(version);
|
||||
bw.Write(platform);
|
||||
bw.Write(enableTypeTree);
|
||||
|
||||
bw.Write(typeCount);
|
||||
foreach(var type in types)
|
||||
type.SaveToStream(bw);
|
||||
|
||||
bw.Write(objectCount);
|
||||
foreach (var kv in objects)
|
||||
{
|
||||
bw.AlignedWriteInt64(kv.Key);
|
||||
kv.Value.SaveToStream(bw);
|
||||
}
|
||||
|
||||
bw.Write(scriptTypeCount);
|
||||
foreach(var st in scriptTypes)
|
||||
st.SaveToStream(bw);
|
||||
|
||||
bw.Write(externalsCount);
|
||||
foreach(var external in externals)
|
||||
external.SaveToStream(bw);
|
||||
|
||||
#if UNITY_2019_2_OR_NEWER
|
||||
bw.Write(refTypeCount);
|
||||
foreach(var refT in refTypes)
|
||||
refT.SaveToStream(bw);
|
||||
#endif
|
||||
|
||||
bw.WriteRawString(dummyStr);
|
||||
|
||||
return bw.BaseStream.Position - startPos;
|
||||
}
|
||||
|
||||
public ScriptsData GetScriptData(BinaryReader br)
|
||||
{
|
||||
ObjectInfo objInfo = objects[UnityBinFile.kMonoManagerIdx];
|
||||
br.BaseStream.Seek(objInfo.realPos, SeekOrigin.Begin);
|
||||
|
||||
ScriptsData data = new ScriptsData();
|
||||
data.LoadFromStream(br);
|
||||
return data;
|
||||
}
|
||||
}
|
||||
|
||||
public struct ObjectType
|
||||
{
|
||||
public int typeID;
|
||||
public bool isStriped;
|
||||
public short scriptTypeIndex;
|
||||
|
||||
public bool needReadScriptHash; // dont save
|
||||
|
||||
public Hash scriptSigHash;
|
||||
public Hash typeHash;
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
typeID = br.ReadInt32();
|
||||
isStriped = br.ReadBoolean();
|
||||
scriptTypeIndex = br.ReadInt16();
|
||||
|
||||
needReadScriptHash = typeID == -1 || typeID == 0x72;
|
||||
if(needReadScriptHash)
|
||||
scriptSigHash.LoadFromStream(br);
|
||||
|
||||
typeHash.LoadFromStream(br);
|
||||
|
||||
// GlobalManagers does not has TypeTrees
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
long startPos = bw.BaseStream.Position;
|
||||
bw.Write(typeID);
|
||||
bw.Write(isStriped);
|
||||
bw.Write(scriptTypeIndex);
|
||||
|
||||
if(needReadScriptHash)
|
||||
scriptSigHash.SaveToStream(bw);
|
||||
|
||||
typeHash.SaveToStream(bw);
|
||||
return bw.BaseStream.Position - startPos;
|
||||
}
|
||||
|
||||
public int Size()
|
||||
{
|
||||
int ret = 0;
|
||||
ret += sizeof(int);
|
||||
ret += sizeof(bool);
|
||||
ret += sizeof(short);
|
||||
|
||||
if (needReadScriptHash)
|
||||
ret += Hash.kSize;
|
||||
|
||||
ret += Hash.kSize;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
public struct ObjectInfo
|
||||
{
|
||||
public const int kSize = 12;
|
||||
|
||||
public uint dataPos;
|
||||
public uint size;
|
||||
public uint typeID;
|
||||
|
||||
public uint realPos; // dataPos + Header.dataOffset; // dont save
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
dataPos = br.ReadUInt32();
|
||||
size = br.ReadUInt32();
|
||||
typeID = br.ReadUInt32();
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
bw.Write(dataPos);
|
||||
bw.Write(size);
|
||||
bw.Write(typeID);
|
||||
return kSize;
|
||||
}
|
||||
}
|
||||
|
||||
public struct ScriptType
|
||||
{
|
||||
public int localFileIndex;
|
||||
public long localIdentifierOfBin;
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
localFileIndex = br.ReadInt32();
|
||||
localIdentifierOfBin = br.AlignedReadInt64();
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
long startPos = bw.BaseStream.Position;
|
||||
bw.Write(localFileIndex);
|
||||
bw.AlignedWriteInt64(localIdentifierOfBin);
|
||||
return bw.BaseStream.Position - startPos;
|
||||
}
|
||||
}
|
||||
|
||||
public struct ExternalInfo
|
||||
{
|
||||
public string dummy;
|
||||
public Hash guid;
|
||||
public int type;
|
||||
public string name;
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
dummy = br.ReadRawString();
|
||||
guid.LoadFromStream(br);
|
||||
type = br.ReadInt32();
|
||||
name = br.ReadRawString();
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
long startPos = bw.BaseStream.Position;
|
||||
bw.WriteRawString(dummy);
|
||||
guid.SaveToStream(bw);
|
||||
bw.Write(type);
|
||||
bw.WriteRawString(name);
|
||||
return bw.BaseStream.Position - startPos;
|
||||
}
|
||||
}
|
||||
|
||||
public struct ScriptsData
|
||||
{
|
||||
public ScriptID[] scriptIDs;
|
||||
public List<string> dllNames;
|
||||
public List<int> dllTypes; // 16 is user type
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
{
|
||||
int count = br.ReadInt32();
|
||||
scriptIDs = new ScriptID[count];
|
||||
for(int i = 0; i < count; i++)
|
||||
scriptIDs[i].LoadFromStream(br);
|
||||
}
|
||||
{
|
||||
int count = br.ReadInt32();
|
||||
dllNames = new List<string>(count);
|
||||
for (var i = 0; i < count; i++)
|
||||
dllNames.Add(br.ReadSizeString());
|
||||
}
|
||||
{
|
||||
int count = br.ReadInt32();
|
||||
dllTypes = new List<int>(count);
|
||||
for(var i = 0; i < count; i++)
|
||||
dllTypes.Add(br.ReadInt32());
|
||||
}
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
long startPos = bw.BaseStream.Position;
|
||||
bw.Write(scriptIDs.Length);
|
||||
for(int i = 0; i < scriptIDs.Length; i++)
|
||||
scriptIDs[i].SaveToStream(bw);
|
||||
|
||||
bw.Write(dllNames.Count);
|
||||
for(int i = 0, imax = dllNames.Count; i < imax; i++)
|
||||
bw.WriteSizeString(dllNames[i]);
|
||||
|
||||
bw.Write(dllTypes.Count);
|
||||
for(int i = 0, imax = dllTypes.Count; i < imax; i++)
|
||||
bw.Write(dllTypes[i]);
|
||||
|
||||
return bw.BaseStream.Position - startPos;
|
||||
}
|
||||
}
|
||||
|
||||
public struct ScriptID
|
||||
{
|
||||
public int fileID;
|
||||
public long pathID; // localIdentifier
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
fileID = br.ReadInt32();
|
||||
pathID = br.ReadInt64();
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
bw.Write(fileID);
|
||||
bw.Write(pathID);
|
||||
return 4 + 8;
|
||||
}
|
||||
}
|
||||
|
||||
public struct Hash
|
||||
{
|
||||
public const int kSize = 16;
|
||||
|
||||
public int[] data;
|
||||
|
||||
public void LoadFromStream(BinaryReader br)
|
||||
{
|
||||
data = new int[4];
|
||||
for(int i = 0; i < data.Length; i++)
|
||||
{
|
||||
data[i] = br.ReadInt32();
|
||||
}
|
||||
}
|
||||
|
||||
public long SaveToStream(BinaryWriter bw)
|
||||
{
|
||||
for(int i = 0; i < data.Length; i++)
|
||||
{
|
||||
bw.Write(data[i]);
|
||||
}
|
||||
return kSize;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 10655ce82e730324db6ae297f77df04b
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,78 +0,0 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using UnityEngine;
|
||||
using System.Text;
|
||||
|
||||
namespace UnityFS
|
||||
{
|
||||
public static class UnityBinUtils
|
||||
{
|
||||
public static void SwapUInt(ref uint val)
|
||||
{
|
||||
val = (val >> 24) | ((val >> 8) & 0x0000ff00) | ((val << 8) & 0x00ff0000) | (val << 24);
|
||||
}
|
||||
|
||||
public static string ReadRawString(this BinaryReader br)
|
||||
{
|
||||
long startPos = br.BaseStream.Position;
|
||||
while (true)
|
||||
{
|
||||
byte val = br.ReadByte();
|
||||
if(val == 0)
|
||||
break;
|
||||
}
|
||||
int size = (int)(br.BaseStream.Position - startPos);
|
||||
br.BaseStream.Position = startPos;
|
||||
|
||||
byte[] buffer = br.ReadBytes(size);
|
||||
string ret = Encoding.UTF8.GetString(buffer, 0, size - 1);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static void WriteRawString(this BinaryWriter bw, string str)
|
||||
{
|
||||
byte[] buffer = Encoding.UTF8.GetBytes(str);
|
||||
bw.Write(buffer, 0, buffer.Length);
|
||||
bw.Write((byte)0);
|
||||
}
|
||||
|
||||
public static string ReadSizeString(this BinaryReader br)
|
||||
{
|
||||
int size = br.ReadInt32();
|
||||
byte[] buff = br.ReadBytes(size);
|
||||
br.BaseStream.AlignOffset4();
|
||||
|
||||
string ret = Encoding.UTF8.GetString(buff);
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static void WriteSizeString(this BinaryWriter bw, string str)
|
||||
{
|
||||
byte[] buff = Encoding.UTF8.GetBytes(str);
|
||||
bw.Write(buff.Length);
|
||||
bw.Write(buff, 0, buff.Length);
|
||||
bw.BaseStream.AlignOffset4();
|
||||
}
|
||||
|
||||
public static void AlignOffset4(this Stream stream)
|
||||
{
|
||||
int offset = (((int)stream.Position + 3) >> 2) << 2;
|
||||
stream.Position = offset;
|
||||
}
|
||||
|
||||
public static long AlignedReadInt64(this BinaryReader br)
|
||||
{
|
||||
br.BaseStream.AlignOffset4();
|
||||
return br.ReadInt64();
|
||||
}
|
||||
|
||||
public static void AlignedWriteInt64(this BinaryWriter bw, long val)
|
||||
{
|
||||
bw.BaseStream.AlignOffset4();
|
||||
bw.Write(val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 12a24c30a3914be418be10cfebfa9649
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,9 +1,5 @@
|
||||
using DotNetDetour;
|
||||
using DotNetDetour;
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
using System.Linq;
|
||||
|
||||
namespace MonoHook
|
||||
{
|
||||
@@ -11,16 +7,16 @@ namespace MonoHook
|
||||
{
|
||||
public bool isValid { get; protected set; }
|
||||
|
||||
protected void* _pTarget, _pReplace, _pProxy;
|
||||
protected int _jmpCodeSize;
|
||||
protected byte[] _targetHeaderBackup;
|
||||
protected void* _pTarget, _pReplace, _pProxy;
|
||||
protected int _jmpCodeSize;
|
||||
protected byte[] _targetHeaderBackup;
|
||||
|
||||
public CodePatcher(IntPtr target, IntPtr replace, IntPtr proxy, int jmpCodeSize)
|
||||
{
|
||||
_pTarget = target.ToPointer();
|
||||
_pReplace = replace.ToPointer();
|
||||
_pProxy = proxy.ToPointer();
|
||||
_jmpCodeSize = jmpCodeSize;
|
||||
_pTarget = target.ToPointer();
|
||||
_pReplace = replace.ToPointer();
|
||||
_pProxy = proxy.ToPointer();
|
||||
_jmpCodeSize = jmpCodeSize;
|
||||
}
|
||||
|
||||
public void ApplyPatch()
|
||||
@@ -47,7 +43,7 @@ namespace MonoHook
|
||||
if (_targetHeaderBackup != null)
|
||||
return;
|
||||
|
||||
uint requireSize = LDasm.SizeofMinNumByte(_pTarget, _jmpCodeSize);
|
||||
uint requireSize = LDasm.SizeofMinNumByte(_pTarget, _jmpCodeSize);
|
||||
_targetHeaderBackup = new byte[requireSize];
|
||||
|
||||
fixed (void* ptr = _targetHeaderBackup)
|
||||
@@ -76,8 +72,8 @@ namespace MonoHook
|
||||
HookUtils.MemCpy_Jit(_pProxy, _targetHeaderBackup);
|
||||
|
||||
// jmp to target's new position
|
||||
long jmpFrom = (long)_pProxy + _targetHeaderBackup.Length;
|
||||
long jmpTo = (long)_pTarget + _targetHeaderBackup.Length;
|
||||
long jmpFrom = (long)_pProxy + _targetHeaderBackup.Length;
|
||||
long jmpTo = (long)_pTarget + _targetHeaderBackup.Length;
|
||||
|
||||
byte[] buff = GenJmpCode((void*)jmpFrom, (void*)jmpTo);
|
||||
HookUtils.MemCpy_Jit((void*)jmpFrom, buff);
|
||||
@@ -121,7 +117,7 @@ namespace MonoHook
|
||||
byte[] ret = new byte[s_jmpCode.Length];
|
||||
int val = (int)jmpTo - (int)jmpFrom - 5;
|
||||
|
||||
fixed(void * p = &ret[0])
|
||||
fixed (void* p = &ret[0])
|
||||
{
|
||||
byte* ptr = (byte*)p;
|
||||
*ptr = 0xE9;
|
||||
@@ -259,10 +255,19 @@ namespace MonoHook
|
||||
0x00, 0x00, 0x00, 0x14, // B $val ; $val = (($dst - $src)/4) & 7FFFFFF
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// B 指令的 imm26 是有符号数,以 4 字节为单位,可达范围是 -128MB ~ +128MB-4
|
||||
/// </summary>
|
||||
public const long MaxJmpOffset = (1L << 27) - 4;
|
||||
|
||||
public CodePatcher_arm64_near(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy, s_jmpCode.Length)
|
||||
{
|
||||
if (Math.Abs((long)target - (long)replace) >= ((1 << 26) - 1) * 4)
|
||||
throw new ArgumentException("address offset of target and replace must less than (1 << 26) - 1) * 4");
|
||||
if (Math.Abs((long)target - (long)replace) > MaxJmpOffset)
|
||||
throw new ArgumentException("address offset of target and replace must not exceed ±128MB, please use CodePatcher_arm64_far instead");
|
||||
|
||||
// proxy 末尾要跳回 target,距离同样受 B 指令范围限制
|
||||
if (proxy != IntPtr.Zero && Math.Abs((long)target - (long)proxy) > MaxJmpOffset)
|
||||
throw new ArgumentException("address offset of target and proxy must not exceed ±128MB, please use CodePatcher_arm64_far instead");
|
||||
|
||||
#if ENABLE_HOOK_DEBUG
|
||||
Debug.Log($"CodePatcher_arm64: {PrintAddrs()}");
|
||||
@@ -292,29 +297,143 @@ namespace MonoHook
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// arm64 远距离跳转
|
||||
/// arm64 下距离超过 ±128MB 的跳转
|
||||
/// 会覆盖 target 开头 4 条指令,并把它们原样搬到 proxy 执行,所以这 4 条指令里不能有 PC 相对寻址或跳转,否则拒绝 hook
|
||||
/// </summary>
|
||||
public unsafe class CodePatcher_arm64_far : CodePatcher
|
||||
{
|
||||
private static readonly byte[] s_jmpCode = new byte[] // 20 bytes(字节数过多,太危险了,不建议使用)
|
||||
private static readonly byte[] s_jmpCode = new byte[] // 16 bytes
|
||||
{
|
||||
/*
|
||||
* ADR: https://developer.arm.com/documentation/ddi0596/2021-09/Base-Instructions/ADR--Form-PC-relative-address-
|
||||
* LDR(literal): https://developer.arm.com/documentation/ddi0596/2021-09/Base-Instructions/LDR--literal---Load-Register--literal--
|
||||
* BR: https://developer.arm.com/documentation/ddi0596/2021-09/Base-Instructions/BR--Branch-to-Register-
|
||||
* X16/X17(IP0/IP1) 是 AAPCS64 规定的过程间临时寄存器,函数入口处本就允许被 veneer 改写,用来中转是安全的
|
||||
*/
|
||||
0x6A, 0x00, 0x00, 0x10, // ADR X10, #C
|
||||
0x4A, 0x01, 0x40, 0xF9, // LDR X10, [X10,#0]
|
||||
0x40, 0x01, 0x1F, 0xD6, // BR X10
|
||||
0x50, 0x00, 0x00, 0x58, // LDR X16, #8
|
||||
0x00, 0x02, 0x1F, 0xD6, // BR X16
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // $dst
|
||||
};
|
||||
|
||||
public CodePatcher_arm64_far(IntPtr target, IntPtr replace, IntPtr proxy, int jmpCodeSize) : base(target, replace, proxy, jmpCodeSize)
|
||||
private readonly int _scratchReg;
|
||||
|
||||
public CodePatcher_arm64_far(IntPtr target, IntPtr replace, IntPtr proxy) : base(target, replace, proxy, s_jmpCode.Length)
|
||||
{
|
||||
int insCount = s_jmpCode.Length / 4;
|
||||
uint* ins = (uint*)_pTarget;
|
||||
|
||||
// 没有 proxy:被覆盖的指令不会再执行,只要求函数不短于 16 字节;函数入口处 X16 可以随意改写
|
||||
if (proxy == IntPtr.Zero)
|
||||
{
|
||||
for (int i = 0; i < insCount - 1; i++)
|
||||
{
|
||||
if (IsFunctionEnd(ins[i]))
|
||||
throw new ArgumentException($"can not hook target 0x{(long)target:x}: instruction {i} (0x{ins[i]:X8}) ends the function, it is shorter than {s_jmpCode.Length} bytes");
|
||||
}
|
||||
_scratchReg = 16;
|
||||
#if ENABLE_HOOK_DEBUG
|
||||
Debug.Log($"CodePatcher_arm64_far: {PrintAddrs()}, scratch: X{_scratchReg}");
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = 0; i < insCount; i++)
|
||||
{
|
||||
if (IsPcRelativeOrBranch(ins[i]))
|
||||
throw new ArgumentException($"can not hook target 0x{(long)target:x}: instruction {i} (0x{ins[i]:X8}) is pc-relative or a branch, can not be relocated");
|
||||
}
|
||||
|
||||
// proxy 执行完搬过去的指令后跳回 target 时会改写中转寄存器,X16/X17 里挑一个此时已经没用的
|
||||
if (IsDeadAfter(ins, insCount, 16))
|
||||
_scratchReg = 16;
|
||||
else if (IsDeadAfter(ins, insCount, 17))
|
||||
_scratchReg = 17;
|
||||
else
|
||||
throw new ArgumentException($"can not hook target 0x{(long)target:x}: X16 and X17 may both be live after the first {insCount} instructions " +
|
||||
$"({ins[0]:X8} {ins[1]:X8} {ins[2]:X8} {ins[3]:X8})");
|
||||
|
||||
// proxy 要写入 32 字节(搬过去的 4 条指令 + 跳回 target),前 7 条里就出现 RET 说明 proxy 太短,会写坏后面的函数
|
||||
uint* proxyIns = (uint*)_pProxy;
|
||||
for (int i = 0; i < s_jmpCode.Length * 2 / 4 - 1; i++)
|
||||
{
|
||||
if ((proxyIns[i] & 0xFFFFFC1F) == 0xD65F0000) // RET Xn
|
||||
throw new ArgumentException($"proxy method at 0x{(long)proxy:x} is too short for arm64 far jump (need {s_jmpCode.Length * 2} bytes), please fill some dummy code inside");
|
||||
}
|
||||
|
||||
#if ENABLE_HOOK_DEBUG
|
||||
Debug.Log($"CodePatcher_arm64_far: {PrintAddrs()}, scratch: X{_scratchReg}");
|
||||
#endif
|
||||
}
|
||||
|
||||
protected override unsafe byte[] GenJmpCode(void* jmpFrom, void* jmpTo)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
byte[] ret = new byte[s_jmpCode.Length];
|
||||
|
||||
fixed (void* p = &ret[0])
|
||||
{
|
||||
uint* ptr = (uint*)p;
|
||||
*ptr++ = 0x58000040u | (uint)_scratchReg; // LDR Xn, #8
|
||||
*ptr++ = 0xD61F0000u | ((uint)_scratchReg << 5); // BR Xn
|
||||
*(long*)ptr = (long)jmpTo;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private static bool IsPcRelativeOrBranch(uint ins)
|
||||
{
|
||||
return (ins & 0x1F000000) == 0x10000000 // ADR / ADRP
|
||||
|| (ins & 0x7C000000) == 0x14000000 // B / BL
|
||||
|| (ins & 0xFF000000) == 0x54000000 // B.cond
|
||||
|| (ins & 0x7E000000) == 0x34000000 // CBZ / CBNZ
|
||||
|| (ins & 0x7E000000) == 0x36000000 // TBZ / TBNZ
|
||||
|| (ins & 0x3B000000) == 0x18000000 // LDR / LDRSW / PRFM (literal)
|
||||
|| (ins & 0xFE000000) == 0xD6000000; // BR / BLR / RET 等寄存器跳转
|
||||
}
|
||||
|
||||
private static bool IsFunctionEnd(uint ins)
|
||||
{
|
||||
return (ins & 0xFFFFFC1F) == 0xD65F0000 // RET
|
||||
|| (ins & 0xFFFFFC1F) == 0xD61F0000 // BR
|
||||
|| (ins & 0xFC000000) == 0x14000000; // B
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 粗略判断:凡是可能放寄存器号的字段等于 reg 就算用到,宁可多判
|
||||
/// </summary>
|
||||
private static bool MayUseReg(uint ins, int reg)
|
||||
{
|
||||
uint r = (uint)reg;
|
||||
return (ins & 0x1F) == r || ((ins >> 5) & 0x1F) == r || ((ins >> 10) & 0x1F) == r || ((ins >> 16) & 0x1F) == r;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 判断执行完前 count 条指令后 reg 是否已经没用:
|
||||
/// 1. 这几条指令根本没碰它:函数入口处 X16/X17 本就没有有效值(AAPCS64 允许 veneer 随意改写);
|
||||
/// 2. 最后一次访问是 add/sub/mov 把它当源操作数读掉:mono 只把 IP0/IP1 当作单条 IR 内的临时寄存器,
|
||||
/// 如大栈帧序言 movz x16, #size; sub x17, sp, x16; mov sp, x17。
|
||||
/// 其它指令不区分读写,一律当作可能仍在用。
|
||||
/// </summary>
|
||||
private static bool IsDeadAfter(uint* ins, int count, int reg)
|
||||
{
|
||||
uint r = (uint)reg;
|
||||
for (int i = count - 1; i >= 0; i--)
|
||||
{
|
||||
uint x = ins[i];
|
||||
if (!MayUseReg(x, reg))
|
||||
continue;
|
||||
|
||||
bool addSubImm = (x & 0x1F000000) == 0x11000000; // ADD/SUB (immediate),含 mov sp, xN
|
||||
bool addSubLogicReg = (x & 0x1F000000) == 0x0B000000 // ADD/SUB (shifted / extended register)
|
||||
|| (x & 0x1F000000) == 0x0A000000; // AND/ORR/EOR (shifted register),含 mov xd, xm
|
||||
if (!addSubImm && !addSubLogicReg)
|
||||
return false;
|
||||
|
||||
if ((x & 0x1F) == r) // Rd:被改写,值可能留到后面用
|
||||
return false;
|
||||
if (((x >> 5) & 0x1F) == r || (addSubLogicReg && ((x >> 16) & 0x1F) == r))
|
||||
return true; // Rn / Rm:作为源操作数读掉
|
||||
// 只是立即数字段恰好等于 reg,不算访问,继续往前看
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +1,7 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
using UnityEngine;
|
||||
using System.Linq;
|
||||
using System.IO;
|
||||
using System.Reflection;
|
||||
#if UNITY_EDITOR
|
||||
using UnityEditor;
|
||||
#endif
|
||||
|
||||
namespace MonoHook
|
||||
@@ -60,7 +56,7 @@ namespace MonoHook
|
||||
var list = _hooks.Values.ToList();
|
||||
foreach (var hook in list)
|
||||
{
|
||||
if(hook.tag == tag)
|
||||
if (hook.tag == tag)
|
||||
hook.Uninstall();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
#if !(UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX)
|
||||
#if !(UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX)
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
@@ -15,7 +15,7 @@ namespace MonoHook
|
||||
|
||||
static DelegateFlushICache flush_icache;
|
||||
private static readonly long _Pagesize;
|
||||
|
||||
|
||||
static HookUtils()
|
||||
{
|
||||
PropertyInfo p_SystemPageSize = typeof(Environment).GetProperty("SystemPageSize");
|
||||
@@ -50,7 +50,7 @@ namespace MonoHook
|
||||
if (ptr == IntPtr.Zero)
|
||||
return;
|
||||
|
||||
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
|
||||
#if UNITY_EDITOR_WIN || (!UNITY_EDITOR && UNITY_STANDALONE_WIN)
|
||||
uint oldProtect;
|
||||
bool ret = VirtualProtect(ptr, (uint)size, Protection.PAGE_EXECUTE_READWRITE, out oldProtect);
|
||||
UnityEngine.Debug.Assert(ret);
|
||||
@@ -73,9 +73,9 @@ namespace MonoHook
|
||||
|
||||
public static KeyValuePair<long, long> GetPageAlignedAddr(long code, int size)
|
||||
{
|
||||
long pagesize = _Pagesize;
|
||||
long startPage = (code) & ~(pagesize - 1);
|
||||
long endPage = (code + size + pagesize - 1) & ~(pagesize - 1);
|
||||
long pagesize = _Pagesize;
|
||||
long startPage = (code) & ~(pagesize - 1);
|
||||
long endPage = (code + size + pagesize - 1) & ~(pagesize - 1);
|
||||
return new KeyValuePair<long, long>(startPage, endPage);
|
||||
}
|
||||
|
||||
@@ -110,14 +110,14 @@ namespace MonoHook
|
||||
count++;
|
||||
}
|
||||
}
|
||||
END:;
|
||||
END:;
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
static void SetupFlushICacheFunc()
|
||||
{
|
||||
string processorType = SystemInfo.processorType;
|
||||
if (processorType.Contains("Intel") || processorType.Contains("AMD"))
|
||||
string processorType = SystemInfo.processorType.ToLowerInvariant();
|
||||
if (processorType.Contains("intel") || processorType.Contains("amd"))
|
||||
return;
|
||||
|
||||
if (IntPtr.Size == 4)
|
||||
@@ -223,7 +223,7 @@ namespace MonoHook
|
||||
};
|
||||
|
||||
|
||||
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
|
||||
#if UNITY_EDITOR_WIN || (!UNITY_EDITOR && UNITY_STANDALONE_WIN)
|
||||
[Flags]
|
||||
public enum Protection
|
||||
{
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
#if (UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX)
|
||||
#if (UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX)
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
@@ -16,7 +16,11 @@ namespace MonoHook
|
||||
|
||||
static HookUtils()
|
||||
{
|
||||
jit_write_protect_supported = pthread_jit_write_protect_supported_np() != 0;
|
||||
try
|
||||
{
|
||||
jit_write_protect_supported = pthread_jit_write_protect_supported_np() != 0;
|
||||
}
|
||||
catch { }
|
||||
|
||||
PropertyInfo p_SystemPageSize = typeof(Environment).GetProperty("SystemPageSize");
|
||||
if (p_SystemPageSize == null)
|
||||
@@ -35,6 +39,16 @@ namespace MonoHook
|
||||
|
||||
public static void MemCpy_Jit(void* pDst, byte[] src)
|
||||
{
|
||||
if (!jit_write_protect_supported)
|
||||
{
|
||||
fixed(void * pSrc = &src[0])
|
||||
{
|
||||
MemCpy(pDst, pSrc, src.Length);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
fixed(void * p = &src[0])
|
||||
{
|
||||
memcpy_jit(new IntPtr(pDst), new IntPtr(p), src.Length);
|
||||
|
||||
@@ -1,63 +0,0 @@
|
||||
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
using UnityEngine;
|
||||
using UnityEditor;
|
||||
using System.Runtime.CompilerServices;
|
||||
using MonoHook;
|
||||
using HybridCLR.Editor.BuildProcessors;
|
||||
using System.IO;
|
||||
|
||||
namespace HybridCLR.MonoHook
|
||||
{
|
||||
#if (UNITY_2021_1_OR_NEWER && UNITY_WEBGL) || TUANJIE_2022
|
||||
[InitializeOnLoad]
|
||||
public class PatchScriptingAssembliesJsonHook
|
||||
{
|
||||
private static MethodHook _hook;
|
||||
|
||||
static PatchScriptingAssembliesJsonHook()
|
||||
{
|
||||
if (_hook == null)
|
||||
{
|
||||
Type type = typeof(UnityEditor.EditorApplication);
|
||||
MethodInfo miTarget = type.GetMethod("BuildMainWindowTitle", BindingFlags.Static | BindingFlags.NonPublic);
|
||||
|
||||
MethodInfo miReplacement = new Func<string>(BuildMainWindowTitle).Method;
|
||||
MethodInfo miProxy = new Func<string>(BuildMainWindowTitleProxy).Method;
|
||||
|
||||
_hook = new MethodHook(miTarget, miReplacement, miProxy);
|
||||
_hook.Install();
|
||||
}
|
||||
}
|
||||
|
||||
private static string BuildMainWindowTitle()
|
||||
{
|
||||
string tempJsonPath = $"{Application.dataPath}/../Library/PlayerDataCache/WebGL/Data/ScriptingAssemblies.json";
|
||||
#if TUANJIE_2022
|
||||
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.WeixinMiniGame)
|
||||
{
|
||||
tempJsonPath = $"{Application.dataPath}/../Library/PlayerDataCache/WeixinMiniGame/Data/ScriptingAssemblies.json";
|
||||
}
|
||||
#endif
|
||||
if (File.Exists(tempJsonPath))
|
||||
{
|
||||
var patcher = new PatchScriptingAssemblyList();
|
||||
patcher.PathScriptingAssembilesFile(Path.GetDirectoryName(tempJsonPath));
|
||||
}
|
||||
string newTitle = BuildMainWindowTitleProxy();
|
||||
return newTitle;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.NoOptimization)]
|
||||
private static string BuildMainWindowTitleProxy()
|
||||
{
|
||||
// 为满足MonoHook要求的最小代码长度而特地加入的无用填充代码,
|
||||
UnityEngine.Debug.Log(12345.ToString());
|
||||
return string.Empty;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
using System;
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace DotNetDetour
|
||||
@@ -631,7 +631,7 @@ namespace DotNetDetour
|
||||
|
||||
code = (void*)((ulong)code + Length);
|
||||
|
||||
} while (Length>0);
|
||||
} while (Length > 0);
|
||||
|
||||
return Result;
|
||||
}
|
||||
@@ -639,7 +639,7 @@ namespace DotNetDetour
|
||||
static bool? s_isArm;
|
||||
public static bool IsARM()
|
||||
{
|
||||
if(s_isArm.HasValue)
|
||||
if (s_isArm.HasValue)
|
||||
return s_isArm.Value;
|
||||
|
||||
var arch = RuntimeInformation.ProcessArchitecture;
|
||||
@@ -661,7 +661,7 @@ namespace DotNetDetour
|
||||
static bool? s_isiOS;
|
||||
public static bool IsiOS()
|
||||
{
|
||||
if(s_isiOS.HasValue)
|
||||
if (s_isiOS.HasValue)
|
||||
return s_isiOS.Value;
|
||||
|
||||
s_isiOS = UnityEngine.SystemInfo.operatingSystem.ToLower().Contains("ios");
|
||||
@@ -692,7 +692,7 @@ namespace DotNetDetour
|
||||
|
||||
public static bool IsThumb(IntPtr code)
|
||||
{
|
||||
return IsArm32() && ((long)code & 0x1) == 0x1;
|
||||
return IsArm32() && ((long)code & 0x1) == 0x1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -733,14 +733,14 @@ namespace DotNetDetour
|
||||
s = rexw = pr_66 = pr_67 = 0;
|
||||
|
||||
/* dummy check */
|
||||
if ((int)code==0)
|
||||
if ((int)code == 0)
|
||||
return 0;
|
||||
|
||||
/* init output data */
|
||||
//memset(ld, 0, sizeof(ldasm_data));
|
||||
|
||||
/* phase 1: parse prefixies */
|
||||
while ((cflags(*p) & OP_PREFIX)!=0)
|
||||
while ((cflags(*p) & OP_PREFIX) != 0)
|
||||
{
|
||||
if (*p == 0x66)
|
||||
pr_66 = 1;
|
||||
@@ -783,19 +783,20 @@ namespace DotNetDetour
|
||||
op = *p++; s++;
|
||||
ld.opcd_size++;
|
||||
f = cflags_ex(op);
|
||||
if ((f & OP_INVALID)!=0)
|
||||
if ((f & OP_INVALID) != 0)
|
||||
{
|
||||
ld.flags |= F_INVALID;
|
||||
return s;
|
||||
}
|
||||
/* for SSE instructions */
|
||||
if ((f & OP_EXTENDED)!=0)
|
||||
if ((f & OP_EXTENDED) != 0)
|
||||
{
|
||||
op = *p++; s++;
|
||||
ld.opcd_size++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
else
|
||||
{
|
||||
f = cflags(op);
|
||||
/* pr_66 = pr_67 for opcodes A0-A3 */
|
||||
if (op >= 0xA0 && op <= 0xA3)
|
||||
@@ -803,7 +804,7 @@ namespace DotNetDetour
|
||||
}
|
||||
|
||||
/* phase 3: parse ModR/M, SIB and DISP */
|
||||
if ((f & OP_MODRM)!=0)
|
||||
if ((f & OP_MODRM) != 0)
|
||||
{
|
||||
byte mod = (byte)(*p >> 6);
|
||||
byte ro = (byte)((*p & 0x38) >> 3);
|
||||
@@ -819,7 +820,7 @@ namespace DotNetDetour
|
||||
f |= OP_DATA_I16_I32_I64;
|
||||
|
||||
/* is SIB byte exist? */
|
||||
if (mod != 3 && rm == 4 && !(!is64 && pr_67!=0))
|
||||
if (mod != 3 && rm == 4 && !(!is64 && pr_67 != 0))
|
||||
{
|
||||
ld.sib = *p++; s++;
|
||||
ld.flags |= F_SIB;
|
||||
@@ -833,40 +834,41 @@ namespace DotNetDetour
|
||||
|
||||
switch (mod)
|
||||
{
|
||||
case 0:
|
||||
case 0:
|
||||
if (is64)
|
||||
{
|
||||
if (rm == 5)
|
||||
{
|
||||
ld.disp_size = 4;
|
||||
if (is64)
|
||||
{
|
||||
if (rm == 5)
|
||||
{
|
||||
ld.disp_size = 4;
|
||||
if (is64)
|
||||
ld.flags |= F_RELATIVE;
|
||||
}
|
||||
}
|
||||
else if (pr_67!=0)
|
||||
{
|
||||
if (rm == 6)
|
||||
ld.disp_size = 2;
|
||||
}
|
||||
else {
|
||||
if (rm == 5)
|
||||
ld.disp_size = 4;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
ld.disp_size = 1;
|
||||
break;
|
||||
case 2:
|
||||
if (is64)
|
||||
ld.disp_size = 4;
|
||||
else if (pr_67!=0)
|
||||
ld.disp_size = 2;
|
||||
else
|
||||
ld.disp_size = 4;
|
||||
break;
|
||||
ld.flags |= F_RELATIVE;
|
||||
}
|
||||
}
|
||||
else if (pr_67 != 0)
|
||||
{
|
||||
if (rm == 6)
|
||||
ld.disp_size = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (rm == 5)
|
||||
ld.disp_size = 4;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
ld.disp_size = 1;
|
||||
break;
|
||||
case 2:
|
||||
if (is64)
|
||||
ld.disp_size = 4;
|
||||
else if (pr_67 != 0)
|
||||
ld.disp_size = 2;
|
||||
else
|
||||
ld.disp_size = 4;
|
||||
break;
|
||||
}
|
||||
|
||||
if (ld.disp_size>0)
|
||||
if (ld.disp_size > 0)
|
||||
{
|
||||
ld.disp_offset = (byte)(p - (byte*)code);
|
||||
p += ld.disp_size;
|
||||
@@ -876,20 +878,20 @@ namespace DotNetDetour
|
||||
}
|
||||
|
||||
/* phase 4: parse immediate data */
|
||||
if (rexw!=0 && (f & OP_DATA_I16_I32_I64)!=0)
|
||||
if (rexw != 0 && (f & OP_DATA_I16_I32_I64) != 0)
|
||||
ld.imm_size = 8;
|
||||
else if ((f & OP_DATA_I16_I32)!=0 || (f & OP_DATA_I16_I32_I64)!=0)
|
||||
else if ((f & OP_DATA_I16_I32) != 0 || (f & OP_DATA_I16_I32_I64) != 0)
|
||||
ld.imm_size = (byte)(4 - (pr_66 << 1));
|
||||
|
||||
/* if exist, add OP_DATA_I16 and OP_DATA_I8 size */
|
||||
ld.imm_size += (byte)(f & 3);
|
||||
|
||||
if ((ld.imm_size)!=0)
|
||||
if ((ld.imm_size) != 0)
|
||||
{
|
||||
s += ld.imm_size;
|
||||
ld.imm_offset = (byte)(p - (byte*)code);
|
||||
ld.flags |= F_IMM;
|
||||
if ((f & OP_RELATIVE)!=0)
|
||||
if ((f & OP_RELATIVE) != 0)
|
||||
ld.flags |= F_RELATIVE;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2018 Misaka Mikoto
|
||||
|
||||
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:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
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.
|
||||
@@ -1,6 +1,5 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 08f44f6e8bfbc2c45afae7bdd2d7f21f
|
||||
folderAsset: yes
|
||||
guid: 9298d9b76a5b2074da06bd90eb3bb6fd
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
@@ -6,15 +6,11 @@
|
||||
|
||||
using DotNetDetour;
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using System.Reflection;
|
||||
using System.Runtime.InteropServices;
|
||||
using Unity.Collections.LowLevel.Unsafe;
|
||||
#if UNITY_EDITOR
|
||||
using UnityEditor;
|
||||
#endif
|
||||
using UnityEngine;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
|
||||
/*
|
||||
@@ -110,9 +106,9 @@ namespace MonoHook
|
||||
/// <param name="proxyMethod">如果还需要调用原始目标方法,可以通过此参数的方法调用,如果不需要可以填 null</param>
|
||||
public MethodHook(MethodBase targetMethod, MethodBase replacementMethod, MethodBase proxyMethod, string data = "")
|
||||
{
|
||||
this.targetMethod = targetMethod;
|
||||
this.replacementMethod = replacementMethod;
|
||||
this.proxyMethod = proxyMethod;
|
||||
this.targetMethod = targetMethod;
|
||||
this.replacementMethod = replacementMethod;
|
||||
this.proxyMethod = proxyMethod;
|
||||
this.tag = data;
|
||||
|
||||
CheckMethod();
|
||||
@@ -218,15 +214,23 @@ namespace MonoHook
|
||||
|
||||
private void CreateCodePatcher()
|
||||
{
|
||||
long addrOffset = Math.Abs(_targetPtr.ToInt64() - _proxyPtr.ToInt64());
|
||||
|
||||
if(_proxyPtr != IntPtr.Zero)
|
||||
long addrOffset = Math.Abs(_targetPtr.ToInt64() - _replacementPtr.ToInt64());
|
||||
|
||||
if (_proxyPtr != IntPtr.Zero)
|
||||
addrOffset = Math.Max(addrOffset, Math.Abs(_targetPtr.ToInt64() - _proxyPtr.ToInt64()));
|
||||
|
||||
if (LDasm.IsARM())
|
||||
{
|
||||
if (IntPtr.Size == 8)
|
||||
_codePatcher = new CodePatcher_arm64_near(_targetPtr, _replacementPtr, _proxyPtr);
|
||||
{
|
||||
if (addrOffset <= CodePatcher_arm64_near.MaxJmpOffset)
|
||||
_codePatcher = new CodePatcher_arm64_near(_targetPtr, _replacementPtr, _proxyPtr);
|
||||
else
|
||||
{
|
||||
UnityEngine.Debug.Log($"[MonoHook] {targetMethod.DeclaringType.Name}.{targetMethod.Name}: address offset {addrOffset / (1024 * 1024)}MB exceeds ±128MB, use arm64 far jump");
|
||||
_codePatcher = new CodePatcher_arm64_far(_targetPtr, _replacementPtr, _proxyPtr);
|
||||
}
|
||||
}
|
||||
else if (addrOffset < ((1 << 25) - 1))
|
||||
_codePatcher = new CodePatcher_arm32_near(_targetPtr, _replacementPtr, _proxyPtr);
|
||||
else if (addrOffset < ((1 << 27) - 1))
|
||||
@@ -238,7 +242,7 @@ namespace MonoHook
|
||||
{
|
||||
if (IntPtr.Size == 8)
|
||||
{
|
||||
if(addrOffset < 0x7fffffff) // 2G
|
||||
if (addrOffset < 0x7fffffff) // 2G
|
||||
_codePatcher = new CodePatcher_x64_near(_targetPtr, _replacementPtr, _proxyPtr);
|
||||
else
|
||||
_codePatcher = new CodePatcher_x64_far(_targetPtr, _replacementPtr, _proxyPtr);
|
||||
@@ -263,7 +267,7 @@ namespace MonoHook
|
||||
if (proxyMethod != null && _proxyPtr == null)
|
||||
return false;
|
||||
|
||||
if(_replacementPtr == _targetPtr)
|
||||
if (_replacementPtr == _targetPtr)
|
||||
{
|
||||
throw new Exception($"the addresses of target method {targetMethod.Name} and replacement method {replacementMethod.Name} can not be same");
|
||||
}
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: d26c8b77c84f09442a05f2c67e5e09b8
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,23 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace HybridCLR.Editor.ABI
|
||||
{
|
||||
public static class ABIUtil
|
||||
{
|
||||
public static string GetHybridCLRPlatformMacro(PlatformABI abi)
|
||||
{
|
||||
switch(abi)
|
||||
{
|
||||
case PlatformABI.Arm64: return "HYBRIDCLR_ABI_ARM_64";
|
||||
case PlatformABI.Universal64: return "HYBRIDCLR_ABI_UNIVERSAL_64";
|
||||
case PlatformABI.Universal32: return "HYBRIDCLR_ABI_UNIVERSAL_32";
|
||||
case PlatformABI.WebGL32: return "HYBRIDCLR_ABI_WEBGL32";
|
||||
default: throw new NotSupportedException();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
fileFormatVersion: 2
|
||||
guid: edeb86f4b5b13ca4cb0fe9d87ce509bb
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,30 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace HybridCLR.Editor.ABI
|
||||
{
|
||||
|
||||
public class ParamInfo
|
||||
{
|
||||
public TypeInfo Type { get; set; }
|
||||
|
||||
public int Index { get; set; }
|
||||
|
||||
}
|
||||
|
||||
public class ReturnInfo
|
||||
{
|
||||
public TypeInfo Type { get; set; }
|
||||
|
||||
public bool IsVoid => Type.PorType == ParamOrReturnType.VOID;
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
return Type.GetTypeName();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace HybridCLR.Editor.ABI
|
||||
{
|
||||
public enum ParamOrReturnType
|
||||
{
|
||||
VOID,
|
||||
I1,
|
||||
U1,
|
||||
I2,
|
||||
U2,
|
||||
I4,
|
||||
U4,
|
||||
I8,
|
||||
U8,
|
||||
R4,
|
||||
R8,
|
||||
I,
|
||||
U,
|
||||
TYPEDBYREF,
|
||||
STRUCT,
|
||||
}
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
namespace HybridCLR.Editor.ABI
|
||||
{
|
||||
public enum PlatformABI
|
||||
{
|
||||
Universal32,
|
||||
Universal64,
|
||||
Arm64,
|
||||
WebGL32,
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user