Compare commits

..

1 Commits

Author SHA1 Message Date
coah
df3d79b4a1 cleanup(iplChannelScriptManager): name CSData mbHasNewMessage
unk_0x1A -> mbHasNewMessage

Set true when starting channel script, cleared when the title has no new
NWC24 message (isNewMessageThere).

Touched channelSelect / channelTitle / sdChannelTitle writers.

Matching 100% before/after; DOL sha1 unchanged.
2026-10-02 14:15:16 -05:00
134 changed files with 1442 additions and 18941 deletions

View File

@@ -2,8 +2,8 @@ name: README progress
# runs on the self-hosted runner on cole's server so it doesn't use hosted minutes.
# only push/schedule/manual triggers, never pull_request, so fork PRs can't reach this machine.
# it never commits to main: it rebuilds, publishes the numbers to the job summary, and force-pushes
# the README badge JSON as a single commit on the orphan progress-data branch.
# README progress is written inside each landing commit by the orchestrator, so this job never commits;
# it only rebuilds and publishes the current numbers to the job summary.
on:
push:
branches: [main]
@@ -17,7 +17,7 @@ concurrency:
cancel-in-progress: true
permissions:
contents: write
contents: read
jobs:
progress:
@@ -55,17 +55,3 @@ jobs:
python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
sed -n '/progress:start/,/progress:end/p' README.md >> "$GITHUB_STEP_SUMMARY"
git checkout -- README.md
- name: Publish badges
if: github.ref == 'refs/heads/main'
run: |
out="$RUNNER_TEMP/progress-data"
rm -rf "$out"
python3 tools/progress_badges.py build/43U/report.json "$out"
cd "$out"
git init -q -b progress-data
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git add .
git commit -q -m "progress for $GITHUB_SHA"
git push -q -f "https://x-access-token:${{ github.token }}@github.com/$GITHUB_REPOSITORY.git" HEAD:refs/heads/progress-data

View File

@@ -7,23 +7,23 @@
<!--- Github Actions Badge -->
[Build Status]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml/badge.svg?branch=main
[actions]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml
[Build Status]: https://github.com/coah80/wii-ipl/actions/workflows/build.yml/badge.svg
[actions]: https://github.com/coah80/wii-ipl/actions/workflows/build.yml
<!--- Discord Badge -->
[Discord Badge]: https://img.shields.io/discord/727908905392275526?color=%237289DA&logo=discord&logoColor=%23FFFFFF
[discord]: https://discord.gg/hKx3FJJgrV
<!-- Progress badges: JSON on the progress-data branch, refreshed by the README progress workflow on every push to main -->
<!-- Progress links -->
[progress]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml
[DecompiledBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fdecompiled.json
[MatchedBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fmatched.json
[LinkedBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Flinked.json
[DataBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fdata.json
[FunctionsBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Ffunctions.json
[UnitsBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Funits.json
[V43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U
<!--- Version 4.3U progress Badge -->
[DecompBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=code&label=Decompiled&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
[LinkBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=complete_code&label=Linked&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
[FuncBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=functions&label=Functions&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
<!--- Header -->
@@ -43,17 +43,28 @@ Live decomp status
[![Build status]][actions]
Every push to `main` rebuilds 4.3U, checks the DOL hash, and refreshes the progress badges below. Open the latest [README progress run][actions] for the full objdiff summary.
Open the latest successful [Build workflow run][actions] and check its summary for the current objdiff metrics. It includes perfect-match/decompiled, fuzzy-match, fully linked, data, function, unit, and category breakdowns. The run also publishes the 43U report artifact and generated decomp-status report.
Supported versions:
- `43U` - Version **4.3U** (USA)
Progress
========
[![DecompiledBadge]][progress] [![MatchedBadge]][progress] [![LinkedBadge]][progress] [![DataBadge]][progress]
[![FunctionsBadge]][progress] [![UnitsBadge]][progress]
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 99.59% | 90.81% | 71.43% | 99.37% |
units 956/1027 complete, functions 12365/12563 matched.
decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, linked = code actually linked into the DOL, data = byte-exact data
<!-- progress:end -->
| Version | Progress |
|-----------------------|------------------------------------------------------------------------------|
| [Wii Menu 4.3U][V43U] | [![FuncBadgeV43U]][V43U] [![DecompBadgeV43U]][V43U] [![LinkBadgeV43U]][V43U] |
> You can see the full progress and its history by clicking on one of the versions in the table.
Dependencies
============

View File

@@ -37,9 +37,6 @@ force_active:
# textinput::toolbar::csPaneToAnimation points one past the end of csAninationFile.
block_relocations:
# Run establishes a fixed stack at 0x81600000, not __pformatter + 0x280.
- source: .text:0x8137B468
- source: .text:0x8137B46C
- source: .data:0x8165E15C
- source: .data:0x8165E19C

View File

@@ -13904,15 +13904,10 @@ lbl_81610608 = .rodata:0x81610608; // type:object size:0x300
lbl_81610908 = .rodata:0x81610908; // type:object size:0x10
sCaptureSizes__Q23ipl5scene = .rodata:0x81610918; // type:object size:0x10
lbl_81610928 = .rodata:0x81610928; // type:object size:0x20 data:4byte
scAnmTable__Q23ipl5scene = .rodata:0x81610948; // type:object size:0xE8 scope:local
@17203 = .rodata:0x81610A30; // type:object size:0x1C scope:local
@17212 = .rodata:0x81610A4C; // type:object size:0x30 scope:local
@17223 = .rodata:0x81610A7C; // type:object size:0x28 scope:local
@17227 = .rodata:0x81610AA4; // type:object size:0x30 scope:local
@17254 = .rodata:0x81610AD4; // type:object size:0x1C scope:local
@18816 = .rodata:0x81610AF0; // type:object size:0x30 scope:local data:4byte
@18818 = .rodata:0x81610B20; // type:object size:0x60 scope:local data:4byte
@19272 = .rodata:0x81610B80; // type:object size:0x20 scope:local data:wstring
scAnmTable__Q23ipl5scene = .rodata:0x81610948; // type:object size:0x1A8 scope:local
lbl_81610AF0 = .rodata:0x81610AF0; // type:object size:0x30 data:4byte
lbl_81610B20 = .rodata:0x81610B20; // type:object size:0x60 data:4byte
lbl_81610B80 = .rodata:0x81610B80; // type:object size:0x20 data:wstring
scNumber__Q23ipl5scene = .rodata:0x81610BA0; // type:object size:0x14 scope:local data:2byte
scNumber2__Q23ipl5scene = .rodata:0x81610BB4; // type:object size:0x14 scope:local data:2byte
lbl_81610BC8 = .rodata:0x81610BC8; // type:object size:0x1000
@@ -17170,23 +17165,7 @@ sSettingAPPaneNames__Q23ipl5scene = .data:0x81656978; // type:object size:0x68 d
sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C data:4byte
@25442 = .data:0x81656BB8; // type:object size:0xF scope:local data:string
@25443 = .data:0x81656BC7; // type:object size:0x1C scope:local data:string
@25501 = .data:0x81656BE3; // type:object size:0xF scope:local data:string
@25502 = .data:0x81656BF2; // type:object size:0x14 scope:local data:string
@25503 = .data:0x81656C06; // type:object size:0x18 scope:local data:string
@25505 = .data:0x81656C1E; // type:object size:0x1A scope:local data:string
@25506 = .data:0x81656C38; // type:object size:0x13 scope:local data:string
@25508 = .data:0x81656C4B; // type:object size:0x9 scope:local data:string
@25509 = .data:0x81656C54; // type:object size:0x12 scope:local data:string
@25510 = .data:0x81656C66; // type:object size:0xC scope:local data:string
@25616 = .data:0x81656C72; // type:object size:0xD scope:local data:string
@25618 = .data:0x81656C7F; // type:object size:0xF scope:local data:string
@25620 = .data:0x81656C8E; // type:object size:0x14 scope:local data:string
@25621 = .data:0x81656CA2; // type:object size:0x1A scope:local data:string
@25622 = .data:0x81656CBC; // type:object size:0x19 scope:local data:string
@25623 = .data:0x81656CD5; // type:object size:0xE scope:local data:string
@25624 = .data:0x81656CE3; // type:object size:0x13 scope:local data:string
@25625 = .data:0x81656CF6; // type:object size:0x18 scope:local data:string
@25628 = .data:0x81656D0E; // type:object size:0x19 scope:local data:string
@17193 = .data:0x81656D27; // type:object size:0xC scope:local data:string
@17194 = .data:0x81656D33; // type:object size:0x20 scope:local data:string
@17197 = .data:0x81656D53; // type:object size:0xD scope:local data:string
@@ -17200,32 +17179,10 @@ sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C
@17250 = .data:0x81656DFA; // type:object size:0x11 scope:local data:string
@17251 = .data:0x81656E0B; // type:object size:0x9 scope:local data:string
@17252 = .data:0x81656E14; // type:object size:0xD scope:local data:string
@25720 = .data:0x81656E21; // type:object size:0x23 scope:local data:string
@25721 = .data:0x81656E44; // type:object size:0xD scope:local data:string
@25722 = .data:0x81656E51; // type:object size:0xD scope:local data:string
@25723 = .data:0x81656E5E; // type:object size:0xD scope:local data:string
@25724 = .data:0x81656E6B; // type:object size:0x25 scope:local data:string
@25726 = .data:0x81656E90; // type:object size:0x15 scope:local data:string
@25747 = .data:0x81656EA5; // type:object size:0x1B scope:local data:string
@25766 = .data:0x81656EC0; // type:object size:0x1D scope:local data:string
@25767 = .data:0x81656EDD; // type:object size:0x11 scope:local data:string
@25768 = .data:0x81656EEE; // type:object size:0x1D scope:local data:string
@26292 = .data:0x81656F0B; // type:object size:0xF scope:local data:string
@26293 = .data:0x81656F1A; // type:object size:0xD scope:local data:string
@26294 = .data:0x81656F27; // type:object size:0x11 scope:local data:string
@26295 = .data:0x81656F38; // type:object size:0x11 scope:local data:string
@26296 = .data:0x81656F49; // type:object size:0xA scope:local data:string
@26297 = .data:0x81656F53; // type:object size:0xD scope:local data:string
@26300 = .data:0x81656F60; // type:object size:0x1A0 scope:local
@26299 = .data:0x81657100; // type:object size:0x48 scope:local
@26346 = .data:0x81657148; // type:object size:0x26 scope:local data:string
@26347 = .data:0x8165716E; // type:object size:0xF scope:local data:string
@26348 = .data:0x8165717D; // type:object size:0xE scope:local data:string
@26349 = .data:0x8165718B; // type:object size:0xA scope:local data:string
@26350 = .data:0x81657195; // type:object size:0xB scope:local data:string
@26351 = .data:0x816571A0; // type:object size:0x16 scope:local data:string
@26353 = .data:0x816571B6; // type:object size:0x11 scope:local data:string
@26354 = .data:0x816571C7; // type:object size:0x16 scope:local data:string
@26502 = .data:0x816571DD; // type:object size:0xF scope:local data:string
@26534 = .data:0x816571EC; // type:object size:0x18 scope:local data:string
@26536 = .data:0x81657204; // type:object size:0x44 scope:local
@@ -17259,11 +17216,6 @@ sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C
@28326 = .data:0x81657642; // type:object size:0x2A scope:local data:string
@28370 = .data:0x8165766C; // type:object size:0x10 scope:local data:string
@28383 = .data:0x8165767C; // type:object size:0x14 scope:local data:string
@28436 = .data:0x81657690; // type:object size:0x16 scope:local data:string
@28437 = .data:0x816576A6; // type:object size:0xF scope:local data:string
@28438 = .data:0x816576B5; // type:object size:0x13 scope:local data:string
@28439 = .data:0x816576C8; // type:object size:0x1A scope:local data:string
@28440 = .data:0x816576E2; // type:object size:0x1B scope:local data:string
@28442 = .data:0x81657700; // type:object size:0x84 scope:local
__vt__Q33ipl5scene7APEvent = .data:0x81657784; // type:object size:0x18
__vt__Q33ipl5scene7Setting = .data:0x8165779C; // type:object size:0x68
@@ -18106,7 +18058,7 @@ __vt__Q49textinput6extend4memo15AppearMemoState = .data:0x81667FA0; // type:obje
__vt__Q49textinput6extend4memo13DispMemoState = .data:0x81667FF8; // type:object size:0x58
__vt__Q49textinput6extend4memo5State = .data:0x81668050; // type:object size:0x58
__vt__Q49textinput6extend4memo7Manager = .data:0x816680A8; // type:object size:0x140
lbl_816681E8 = .data:0x816681E8; // type:object size:0x24
lbl_816681E8 = .data:0x816681E8; // type:object size:0x28
lbl_81668210 = .data:0x81668210; // type:object size:0x9 data:string
lbl_8166821C = .data:0x8166821C; // type:object size:0x9 data:string
lbl_81668228 = .data:0x81668228; // type:object size:0x9 data:string
@@ -22421,93 +22373,93 @@ lbl_81696FD0 = .sdata:0x81696FD0; // type:object size:0x6 data:wstring
lbl_81696FD6 = .sdata:0x81696FD6; // type:object size:0x4 data:wstring
lbl_81696FDA = .sdata:0x81696FDA; // type:object size:0x7 data:string
lbl_81696FE1 = .sdata:0x81696FE1; // type:object size:0x7 data:string
@16789 = .sdata:0x81696FE8; // type:object size:0x6 data:string
@16790 = .sdata:0x81696FEE; // type:object size:0x6 data:string
@16791 = .sdata:0x81696FF4; // type:object size:0x6 data:string
@16792 = .sdata:0x81696FFA; // type:object size:0x6 data:string
@16793 = .sdata:0x81697000; // type:object size:0x7 data:string
@16794 = .sdata:0x81697007; // type:object size:0x7 data:string
sSettingArrowNames__Q23ipl5scene = .sdata:0x81697010; // type:object size:0x8 data:4byte
@16795 = .sdata:0x81697018; // type:object size:0x8 data:string
@16796 = .sdata:0x81697020; // type:object size:0x8 data:string
@16797 = .sdata:0x81697028; // type:object size:0x8 data:string
@16798 = .sdata:0x81697030; // type:object size:0x8 data:string
@16799 = .sdata:0x81697038; // type:object size:0x8 data:string
@16800 = .sdata:0x81697040; // type:object size:0x8 data:string
@16801 = .sdata:0x81697048; // type:object size:0x6 data:string
@16802 = .sdata:0x8169704E; // type:object size:0x6 data:string
@16803 = .sdata:0x81697054; // type:object size:0x6 data:string
@16804 = .sdata:0x8169705A; // type:object size:0x6 data:string
@16805 = .sdata:0x81697060; // type:object size:0x6 data:string
@16806 = .sdata:0x81697066; // type:object size:0x6 data:string
@16809 = .sdata:0x8169706C; // type:object size:0x7 data:string
@16810 = .sdata:0x81697073; // type:object size:0x7 data:string
@16811 = .sdata:0x8169707A; // type:object size:0x8 data:string
@16812 = .sdata:0x81697082; // type:object size:0x7 data:string
@16813 = .sdata:0x81697089; // type:object size:0x6 data:string
@16814 = .sdata:0x8169708F; // type:object size:0x6 data:string
@16815 = .sdata:0x81697095; // type:object size:0x6 data:string
@16816 = .sdata:0x8169709B; // type:object size:0x6 data:string
@16817 = .sdata:0x816970A1; // type:object size:0x6 data:string
@16818 = .sdata:0x816970A7; // type:object size:0x6 data:string
@16819 = .sdata:0x816970AD; // type:object size:0x6 data:string
@16820 = .sdata:0x816970B3; // type:object size:0x6 data:string
@16827 = .sdata:0x816970B9; // type:object size:0x8 data:string
@16828 = .sdata:0x816970C1; // type:object size:0x8 data:string
@16829 = .sdata:0x816970C9; // type:object size:0x8 data:string
@16830 = .sdata:0x816970D1; // type:object size:0x8 data:string
@16831 = .sdata:0x816970D9; // type:object size:0x8 data:string
@16832 = .sdata:0x816970E1; // type:object size:0x8 data:string
@25504 = .sdata:0x816970E9; // type:object size:0x4 data:string
@25507 = .sdata:0x816970ED; // type:object size:0x4 data:string
@25617 = .sdata:0x816970F1; // type:object size:0x5 data:string
@25619 = .sdata:0x816970F6; // type:object size:0x4 data:string
@25626 = .sdata:0x816970FA; // type:object size:0x7 data:string
@25627 = .sdata:0x81697101; // type:object size:0x7 data:string
@17202 = .sdata:0x81697108; // type:object size:0x3 data:string
@17205 = .sdata:0x8169710B; // type:object size:0x6 data:string
@17206 = .sdata:0x81697111; // type:object size:0x7 data:string
@17207 = .sdata:0x81697118; // type:object size:0x6 data:string
@17208 = .sdata:0x8169711E; // type:object size:0x1
@17209 = .sdata:0x8169711F; // type:object size:0x6 data:string
@17210 = .sdata:0x81697125; // type:object size:0x6 data:string
@17211 = .sdata:0x8169712B; // type:object size:0x6 data:string
@17214 = .sdata:0x81697131; // type:object size:0x4 data:string
@17215 = .sdata:0x81697135; // type:object size:0x4 data:string
@17216 = .sdata:0x81697139; // type:object size:0x4 data:string
@17217 = .sdata:0x8169713D; // type:object size:0x4 data:string
@17218 = .sdata:0x81697141; // type:object size:0x4 data:string
@17219 = .sdata:0x81697145; // type:object size:0x4 data:string
@17220 = .sdata:0x81697149; // type:object size:0x4 data:string
@17221 = .sdata:0x8169714D; // type:object size:0x4 data:string
@17222 = .sdata:0x81697151; // type:object size:0x4 data:string
@17248 = .sdata:0x81697155; // type:object size:0x8 data:string
@17249 = .sdata:0x8169715D; // type:object size:0x6 data:string
@17253 = .sdata:0x81697163; // type:object size:0x7 data:string
@25725 = .sdata:0x8169716A; // type:object size:0x4 data:string
@26352 = .sdata:0x8169716E; // type:object size:0x5 data:string
@26503 = .sdata:0x81697173; // type:object size:0x7 data:string
@26504 = .sdata:0x8169717A; // type:object size:0x5 data:string
@26505 = .sdata:0x8169717F; // type:object size:0x5 data:string
@26506 = .sdata:0x81697184; // type:object size:0x5 data:string
@26625 = .sdata:0x8169718A; // type:object size:0x2
@26851 = .sdata:0x8169718C; // type:object size:0x3 data:string
@18811 = .sdata:0x8169718F; // type:object size:0x2 data:string
@18812 = .sdata:0x81697191; // type:object size:0x2 data:string
@18813 = .sdata:0x81697193; // type:object size:0x2 data:string
@18814 = .sdata:0x81697195; // type:object size:0x2 data:string
@18815 = .sdata:0x81697197; // type:object size:0x2 data:string
@27404 = .sdata:0x81697199; // type:object size:0x6 data:string
@27405 = .sdata:0x8169719F; // type:object size:0x6 data:string
@27406 = .sdata:0x816971A5; // type:object size:0x6 data:string
@27407 = .sdata:0x816971AB; // type:object size:0x6 data:string
@27556 = .sdata:0x816971B1; // type:object size:0x6 data:string
@27557 = .sdata:0x816971B7; // type:object size:0x6 data:string
@27558 = .sdata:0x816971BD; // type:object size:0x6 data:string
@27559 = .sdata:0x816971C3; // type:object size:0x6 data:string
@27560 = .sdata:0x816971C9; // type:object size:0x7 data:string
@27862 = .sdata:0x816971D0; // type:object size:0x3 data:string
@28152 = .sdata:0x816971D4; // type:object size:0x8 data:wstring
lbl_81696FE8 = .sdata:0x81696FE8; // type:object size:0x6 data:string
lbl_81696FEE = .sdata:0x81696FEE; // type:object size:0x6 data:string
lbl_81696FF4 = .sdata:0x81696FF4; // type:object size:0x6 data:string
lbl_81696FFA = .sdata:0x81696FFA; // type:object size:0x6 data:string
lbl_81697000 = .sdata:0x81697000; // type:object size:0x7 data:string
lbl_81697007 = .sdata:0x81697007; // type:object size:0x7 data:string
lbl_81697010 = .sdata:0x81697010; // type:object size:0x8 data:4byte
lbl_81697018 = .sdata:0x81697018; // type:object size:0x8 data:string
lbl_81697020 = .sdata:0x81697020; // type:object size:0x8 data:string
lbl_81697028 = .sdata:0x81697028; // type:object size:0x8 data:string
lbl_81697030 = .sdata:0x81697030; // type:object size:0x8 data:string
lbl_81697038 = .sdata:0x81697038; // type:object size:0x8 data:string
lbl_81697040 = .sdata:0x81697040; // type:object size:0x8 data:string
lbl_81697048 = .sdata:0x81697048; // type:object size:0x6 data:string
lbl_8169704E = .sdata:0x8169704E; // type:object size:0x6 data:string
lbl_81697054 = .sdata:0x81697054; // type:object size:0x6 data:string
lbl_8169705A = .sdata:0x8169705A; // type:object size:0x6 data:string
lbl_81697060 = .sdata:0x81697060; // type:object size:0x6 data:string
lbl_81697066 = .sdata:0x81697066; // type:object size:0x6 data:string
lbl_8169706C = .sdata:0x8169706C; // type:object size:0x7 data:string
lbl_81697073 = .sdata:0x81697073; // type:object size:0x7 data:string
lbl_8169707A = .sdata:0x8169707A; // type:object size:0x8 data:string
lbl_81697082 = .sdata:0x81697082; // type:object size:0x7 data:string
lbl_81697089 = .sdata:0x81697089; // type:object size:0x6 data:string
lbl_8169708F = .sdata:0x8169708F; // type:object size:0x6 data:string
lbl_81697095 = .sdata:0x81697095; // type:object size:0x6 data:string
lbl_8169709B = .sdata:0x8169709B; // type:object size:0x6 data:string
lbl_816970A1 = .sdata:0x816970A1; // type:object size:0x6 data:string
lbl_816970A7 = .sdata:0x816970A7; // type:object size:0x6 data:string
lbl_816970AD = .sdata:0x816970AD; // type:object size:0x6 data:string
lbl_816970B3 = .sdata:0x816970B3; // type:object size:0x6 data:string
lbl_816970B9 = .sdata:0x816970B9; // type:object size:0x8 data:string
lbl_816970C1 = .sdata:0x816970C1; // type:object size:0x8 data:string
lbl_816970C9 = .sdata:0x816970C9; // type:object size:0x8 data:string
lbl_816970D1 = .sdata:0x816970D1; // type:object size:0x8 data:string
lbl_816970D9 = .sdata:0x816970D9; // type:object size:0x8 data:string
lbl_816970E1 = .sdata:0x816970E1; // type:object size:0x8 data:string
lbl_816970E9 = .sdata:0x816970E9; // type:object size:0x4 data:string
lbl_816970ED = .sdata:0x816970ED; // type:object size:0x4 data:string
lbl_816970F1 = .sdata:0x816970F1; // type:object size:0x5 data:string
lbl_816970F6 = .sdata:0x816970F6; // type:object size:0x4 data:string
lbl_816970FA = .sdata:0x816970FA; // type:object size:0x7 data:string
lbl_81697101 = .sdata:0x81697101; // type:object size:0x7 data:string
lbl_81697108 = .sdata:0x81697108; // type:object size:0x3 data:string
lbl_8169710B = .sdata:0x8169710B; // type:object size:0x6 data:string
lbl_81697111 = .sdata:0x81697111; // type:object size:0x7 data:string
lbl_81697118 = .sdata:0x81697118; // type:object size:0x6 data:string
lbl_8169711E = .sdata:0x8169711E; // type:object size:0x1
lbl_8169711F = .sdata:0x8169711F; // type:object size:0x6 data:string
lbl_81697125 = .sdata:0x81697125; // type:object size:0x6 data:string
lbl_8169712B = .sdata:0x8169712B; // type:object size:0x6 data:string
lbl_81697131 = .sdata:0x81697131; // type:object size:0x4 data:string
lbl_81697135 = .sdata:0x81697135; // type:object size:0x4 data:string
lbl_81697139 = .sdata:0x81697139; // type:object size:0x4 data:string
lbl_8169713D = .sdata:0x8169713D; // type:object size:0x4 data:string
lbl_81697141 = .sdata:0x81697141; // type:object size:0x4 data:string
lbl_81697145 = .sdata:0x81697145; // type:object size:0x4 data:string
lbl_81697149 = .sdata:0x81697149; // type:object size:0x4 data:string
lbl_8169714D = .sdata:0x8169714D; // type:object size:0x4 data:string
lbl_81697151 = .sdata:0x81697151; // type:object size:0x4 data:string
lbl_81697155 = .sdata:0x81697155; // type:object size:0x8 data:string
lbl_8169715D = .sdata:0x8169715D; // type:object size:0x6 data:string
lbl_81697163 = .sdata:0x81697163; // type:object size:0x7 data:string
lbl_8169716A = .sdata:0x8169716A; // type:object size:0x4 data:string
lbl_8169716E = .sdata:0x8169716E; // type:object size:0x5 data:string
lbl_81697173 = .sdata:0x81697173; // type:object size:0x7 data:string
lbl_8169717A = .sdata:0x8169717A; // type:object size:0x5 data:string
lbl_8169717F = .sdata:0x8169717F; // type:object size:0x5 data:string
lbl_81697184 = .sdata:0x81697184; // type:object size:0x5 data:string
lbl_8169718A = .sdata:0x8169718A; // type:object size:0x2
lbl_8169718C = .sdata:0x8169718C; // type:object size:0x3 data:string
lbl_8169718F = .sdata:0x8169718F; // type:object size:0x2 data:string
lbl_81697191 = .sdata:0x81697191; // type:object size:0x2 data:string
lbl_81697193 = .sdata:0x81697193; // type:object size:0x2 data:string
lbl_81697195 = .sdata:0x81697195; // type:object size:0x2 data:string
lbl_81697197 = .sdata:0x81697197; // type:object size:0x2 data:string
lbl_81697199 = .sdata:0x81697199; // type:object size:0x6 data:string
lbl_8169719F = .sdata:0x8169719F; // type:object size:0x6 data:string
lbl_816971A5 = .sdata:0x816971A5; // type:object size:0x6 data:string
lbl_816971AB = .sdata:0x816971AB; // type:object size:0x6 data:string
lbl_816971B1 = .sdata:0x816971B1; // type:object size:0x6 data:string
lbl_816971B7 = .sdata:0x816971B7; // type:object size:0x6 data:string
lbl_816971BD = .sdata:0x816971BD; // type:object size:0x6 data:string
lbl_816971C3 = .sdata:0x816971C3; // type:object size:0x6 data:string
lbl_816971C9 = .sdata:0x816971C9; // type:object size:0x7 data:string
lbl_816971D0 = .sdata:0x816971D0; // type:object size:0x3 data:string
lbl_816971D4 = .sdata:0x816971D4; // type:object size:0x8 data:wstring
@12299 = .sdata:0x816971E0; // type:object size:0x5 scope:local data:string
@12302 = .sdata:0x816971E5; // type:object size:0x5 scope:local data:string
lbl_816971F0 = .sdata:0x816971F0; // type:object size:0x4 data:string
@@ -23275,7 +23227,7 @@ lbl_81698388 = .sdata:0x81698388; // type:object size:0x2 data:string
lbl_8169838C = .sdata:0x8169838C; // type:object size:0x4 data:string
lbl_81698390 = .sdata:0x81698390; // type:object size:0x1 data:byte
lbl_81698391 = .sdata:0x81698391; // type:object size:0x1 data:byte
lbl_81698394 = .sdata:0x81698394; // type:object size:0x4 data:string
lbl_81698394 = .sdata:0x81698394; // type:object size:0x2 data:string
lbl_81698398 = .sdata:0x81698398; // type:object size:0x2 data:string
lbl_8169839C = .sdata:0x8169839C; // type:object size:0x4
drvInitFunc = .sdata:0x816983A0; // type:object size:0x8 scope:local data:4byte

View File

@@ -766,9 +766,9 @@ config.libs = [
]
),
IPLSection("channelSelect", [
Object(Matching, "scene/channelSelect/iplChannelSelect.cpp"),
Object(Equivalent, "scene/channelSelect/iplChannelSelect.cpp"),
Object(Matching, "scene/channelSelect/iplClock.cpp"),
Object(Matching, "scene/channelSelect/iplChannelObj.cpp"),
Object(Equivalent, "scene/channelSelect/iplChannelObj.cpp"),
]
),
IPLSection("channelTitle", [
@@ -1299,7 +1299,7 @@ config.libs = [
Object(Matching, "ut/ut_RomFont.cpp"),
Object(Matching, "ut/ut_ResFontBase.cpp"),
Object(Matching, "ut/ut_ResFont.cpp"),
Object(Matching, "ut/ut_ArchiveFontBase.cpp"),
Object(NonMatching, "ut/ut_ArchiveFontBase.cpp"),
Object(Matching, "ut/ut_ArchiveFont.cpp"),
Object(Matching, "ut/ut_CharWriter.cpp"),
Object(Matching, "ut/ut_TextWriterBase.cpp"),
@@ -1388,7 +1388,7 @@ config.libs = [
]
),
RVLSDKLib("vi", [
Object(Matching, "vi/vi.c"),
Object(NonMatching, "vi/vi.c"),
Object(Matching, "vi/i2c.c"),
Object(Matching, "vi/vi3in1.c"),
]
@@ -1970,7 +1970,7 @@ config.libs = [
Object(Matching, "MSL_Common/time.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/wctype.c"),
Object(Matching, "MSL_Common/wmem.c"),
Object(Matching, "MSL_Common/wprintf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(NonMatching, "MSL_Common/wprintf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/wstring.c"),
Object(Matching, "MSL_Common/wchar_io.c"),
Object(Matching, "PPC_EABI/time.dolphin.c"),

View File

@@ -43,7 +43,7 @@ private:
bool mIsPlaying; // 0xB2
bool mIsSetBuf; // 0xB3
bool mThreadRunning; // 0xB4
bool mbFillInCallback; // 0xB5
bool unk_0xB5; // 0xB5
WaveFileAiff mAiff; // 0xB8
WaveFileWav mWav; // 0xE8

View File

@@ -16,12 +16,12 @@ public:
AXVPB* getAXVPB() { return mpVPB; }
u32 getState() { return mState; }
u32 getUnk_0x08() { return unk_0x08; }
int getUpdateFlag() { return mUpdateFlag; }
int getUnk_0x0C() { return unk_0x0C; }
void setAXVPB(AXVPB* newVal) { mpVPB = newVal; }
void setState(u32 newVal) { mState = newVal; }
void setUnk_0x08(u32 newVal) { unk_0x08 = newVal; }
void setUpdateFlag(u32 newVal) { mUpdateFlag = newVal; }
void setUnk_0x0C(u32 newVal) { unk_0x0C = newVal; }
AXPBMIX* getMix() { return &mMix; }
@@ -31,7 +31,7 @@ private:
AXVPB* mpVPB; // 0x00
u32 mState; // 0x04
u32 unk_0x08; // 0x08
int mUpdateFlag; // 0x0c
int unk_0x0C; // 0x0c
AXPBMIX mMix; // 0x10
};

View File

@@ -163,9 +163,6 @@ namespace ipl {
void init(const f32& start, const f32& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD,
f32 speed = 1.0f);
#ifdef IPL_SD_CHANNEL_TITLE_CPP
f32 get() const;
#else
f32 get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
@@ -184,7 +181,6 @@ namespace ipl {
return r;
}
#endif
protected:
f32 mStart;
@@ -270,32 +266,6 @@ namespace ipl {
};
#endif
#ifdef IPL_CHANNEL_SELECT_CPP
template <>
class HermiteIntp<f32> : public utility::FrameController {
public:
HermiteIntp() {}
virtual ~HermiteIntp() {}
void init(const f32& start, const f32& end, f32 maxFrame, f32 startTangent,
f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f) {
mStart = start;
mEnd = end;
utility::FrameController::init(playback, maxFrame, 0.0f, speed);
mStartTangent = startTangent;
mEndTangent = endTangent;
}
inline f32 get() const;
protected:
f32 mStart;
f32 mEnd;
f32 mStartTangent;
f32 mEndTangent;
};
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
} // namespace math
} // namespace ipl

View File

@@ -103,7 +103,7 @@ namespace ipl {
y = r.y;
z = 0.0f;
}
#if defined(IPL_ADDRESS_EDIT_CPP) || defined(IPL_SD_CHANNEL_SELECT_CPP) || defined(IPL_GC_WINDOW_CPP) || defined(IPL_SD_CHANNEL_TITLE_CPP)
#if defined(IPL_ADDRESS_EDIT_CPP) || defined(IPL_SD_CHANNEL_SELECT_CPP) || defined(IPL_GC_WINDOW_CPP)
VEC3(f32 fx, f32 fy, f32 fz);
#else
VEC3(f32 fx, f32 fy, f32 fz) {

View File

@@ -259,8 +259,8 @@ namespace ipl {
f32 mChanThumbOff_X; // 0xD0
f32 mChanThumbOff_Y; // 0xD4
math::VEC3 mOrthoTrans;
math::VEC2 mOrthoScale;
math::VEC3 unk_0xD8;
math::VEC2 unk_0xE4;
f32 mScaleAdjust; // 0xEC
int mDiskState; // 0xF0

View File

@@ -31,12 +31,8 @@ namespace ipl {
virtual void calc();
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual void initCalcNormal();
#else
virtual void initCalcNormal() {
} // 0x4C
#endif
virtual void initCalcFadeout() {
} // 0x50
@@ -53,12 +49,8 @@ namespace ipl {
return FADER_SCN_NEXT;
} // 0x60
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual void calcCommonAfter();
#else
virtual void calcCommonAfter() {
} // 0x64
#endif
int getSceneFadeState() {
return mScnFadeState;

View File

@@ -62,11 +62,7 @@ namespace ipl {
virtual ~Base();
/** @brief If the scene is ready */
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual BOOL isReady() const;
#else
virtual BOOL isReady() const { return FALSE; }
#endif
/** @brief If the user can power off/reset the system */
#ifdef IPL_SD_CHANNEL_TITLE_CPP
@@ -77,11 +73,7 @@ namespace ipl {
/** @brief The scene running code when powering off/resetting the system */
virtual void startResetting() {}
/** @brief If the scene has finished its powering off/resetting task */
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual BOOL isResetProcessDone();
#else
virtual BOOL isResetProcessDone() { return TRUE; }
#endif
/** @brief Prepare to create scene */
virtual void prepare() {}
@@ -94,17 +86,10 @@ namespace ipl {
/** @brief Destroy the scene and clear from memory */
virtual void destroy() {}
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual Base* getParent();
virtual Base* getChild();
virtual Base* getNext();
virtual Base* getPrev();
#else
virtual Base* getParent() { return (Base*)mpParent; }
virtual Base* getChild() { return (Base*)mpChild; }
virtual Base* getNext() { return (Base*)mpNext; }
virtual Base* getPrev() { return (Base*)mpPrev; }
#endif
/** @brief Check if scene has been created.*/
bool isSceneCreated() const { return (mScnState & SCN_STATE_CREATED); }

View File

@@ -185,8 +185,8 @@ namespace ipl {
gui::PaneManager* mpGui; // 0x74
BOOL mbHovered[BTN_MAX]; // 0x78
u32 mPendingSceneId;
u32 mExitSeqStep;
u32 unk_0x90;
u32 unk_0x94;
static const char* smButtonName[BTN_MAX];
};

View File

@@ -365,8 +365,8 @@ namespace ipl {
int getChJumpChanPage() { return mChJumpPage; }
int getChJumpChanIndex() { return mChJumpIndex; }
void setDiskChannelReady(bool flag) { mbDiskChannelReady = flag; }
bool isDiskChannelReady() { return mbDiskChannelReady; }
void setUnk_0x1B81(bool flag) { unk_0x1B81 = flag; }
bool isUnk_0x1B81() { return unk_0x1B81; }
void resetChJumpLoad() { mbLoadedChJump = false; }
bool hasLoadedChJump() { return mbLoadedChJump; }
@@ -399,7 +399,7 @@ namespace ipl {
int mBS2State; // 0x1B7C
bool mbCanRefresh; // 0x1B80
bool mbDiskChannelReady;
bool unk_0x1B81;
u8* mpDiskIconBuf; // 0x1B84
u8* mpDiskBannerBuf; // 0x1B88

View File

@@ -118,26 +118,26 @@ namespace ipl {
public:
Base(int chan, KPADStatus& status) {
mButton = 0;
mDecideHoldCount = 0;
unk_0x08 = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = 2;
mbForceInvalid = 0;
unk_0x1C = 0;
KPADEnableDPD(chan);
mbPinching = 0;
mbWasPinching = 0;
mpKpadStatus = &status;
unk_0x1D = 0;
unk_0x1E = 0;
unk_0x20 = &status;
}
Base(int chan, int type, KPADStatus& status) {
mButton = 0;
mDecideHoldCount = 0;
unk_0x08 = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = type;
mbForceInvalid = 0;
unk_0x1C = 0;
KPADEnableDPD(chan);
}
@@ -152,15 +152,15 @@ namespace ipl {
protected:
u8 mButton;
u32 mDecideHoldCount;
u32 unk_0x08;
OSTick mLastRumbleTime;
s32 mRumbleType;
u32 mChan;
u32 mType;
u8 mbForceInvalid;
u8 mbPinching;
u8 mbWasPinching;
KPADStatus* mpKpadStatus;
u8 unk_0x1C;
u8 unk_0x1D;
u8 unk_0x1E;
KPADStatus* unk_0x20;
};
class Revolution : public Base {
@@ -206,8 +206,8 @@ namespace ipl {
virtual BOOL isValidDpdClassic() const;
private:
math::VEC2 mClassicCursorPos;
int mClassicCursorTimer;
math::VEC2 unk_0x24;
int unk_0x2C;
};
class Master : public Interface {
@@ -264,18 +264,18 @@ namespace ipl {
public:
Base(int chan, KPADStatus& arg1) {
mButton = 0;
mDecideHoldCount = 0;
unk_0x08 = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = 2;
mbForceInvalid = 0;
unk_0x1C = 0;
KPADEnableDPD(chan);
mbPinching = 0;
mbWasPinching = 0;
mpKpadStatus = &arg1;
unk_0x1D = 0;
unk_0x1E = 0;
unk_0x20 = &arg1;
}
virtual ~Base(); // 0x08
@@ -326,15 +326,15 @@ namespace ipl {
// protected:
u8 mButton; // 0x4
u32 mDecideHoldCount; // 0x8
u32 unk_0x08; // 0x8
OSTick mLastRumbleTime; // 0xC
s32 mRumbleType; // 0x10
u32 mChan; // 0x14
u32 mType; // 0x18
u8 mbForceInvalid;
u8 mbPinching; // 0x1D
u8 mbWasPinching; // 0x1E
KPADStatus* mpKpadStatus; // 0x20
u8 unk_0x1C;
u8 unk_0x1D; // 0x1D
u8 unk_0x1E; // 0x1E
KPADStatus* unk_0x20; // 0x20
};
class Interface : public Base {
@@ -446,8 +446,8 @@ namespace ipl {
virtual BOOL isValidDpdClassic() const; // 0x8C
private:
math::VEC2 mClassicCursorPos;
int mClassicCursorTimer;
math::VEC2 unk_0x24;
int unk_0x2C;
};
class Manager {

View File

@@ -65,13 +65,8 @@ namespace ipl {
/** @brief Writes the file contents. */
virtual void write(); // 0x10
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual bool isFinished();
virtual int checkData();
#else
virtual bool isFinished() { return mbDoneTask; } // 0x14
virtual int checkData() { return mResult; } // 0x18
#endif
virtual bool isFatalError(); // 0x1C
u8* getBuffer() const { return mpBuffer; }

View File

@@ -50,7 +50,7 @@ namespace ipl {
static BOOL IsLastTicketExpired(ESTitleId* titleId);
static void DeleteExpiredFlagFile();
static s32 DeleteUnauthorizedData(EGG::Heap* heap);
static void DeleteUnauthorizedData(EGG::Heap* heap);
static u32 CheckTmdCountryCode(ESTmdView* tmdView);
static u32 CheckTmdParentalControl(ESTmdView* tmdView);

View File

@@ -27,11 +27,7 @@ namespace ipl {
void init(int type, f32 maxFrame, f32 minFrame, f32 speed = 1.0f);
void initFrame();
#ifdef IPL_CHANNEL_SELECT_CPP
virtual inline void calc();
#else
virtual void calc(); // 0x0C
#endif
void setMaxFrame(f32 value) { mMaxFrame = value; }
f32 getMaxFrame() const { return mMaxFrame; }

View File

@@ -51,17 +51,12 @@ namespace ipl {
mArg.mOrthoScale = scale;
}
#ifdef IPL_SD_CHANNEL_TITLE_CPP
static void setOrthoTrans(const math::VEC3& translate);
static void setOrthoScale(const math::VEC2& scale);
#else
static void setOrthoTrans(const math::VEC3& translate) { mArg.mOrthoTrans = translate; }
static void setOrthoScale(const math::VEC2& scale) NO_INLINE {
mArg.mOrthoScale.x = scale.x;
mArg.mOrthoScale.y = scale.y;
}
#endif
private:
static Arg mArg;

View File

@@ -1120,28 +1120,32 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
case 's':
if (format.argument_options == wchar_argument) {
wchar_t* wcs_ptr = va_arg(args, wchar_t*);
int wideLength;
if (wcs_ptr == NULL) {
wcs_ptr = L"";
}
if (format.alternate_form) {
num_chars = (unsigned char)*wcs_ptr++;
wchar_t first = *wcs_ptr++;
wideLength = (unsigned char)first;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;
if (format.precision_specified && wideLength > format.precision) {
wideLength = format.precision;
}
} else if (format.precision_specified) {
num_chars = format.precision;
wideLength = format.precision;
if ((string_end = wmemchr(wcs_ptr, 0, num_chars)) != 0) {
num_chars = string_end - wcs_ptr;
if ((string_end = wmemchr((wchar_t*)wcs_ptr, 0, wideLength)) != 0) {
wideLength = string_end - wcs_ptr;
}
} else {
num_chars = wcslen(wcs_ptr);
wideLength = wcslen(wcs_ptr);
}
num_chars = wideLength;
buff_ptr = wcs_ptr;
break;
} else {
@@ -1152,7 +1156,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
}
if (format.alternate_form) {
num_chars = (unsigned char)*buff_ptr;
num_chars = (unsigned char)*(const wchar_t*)wcs_ptr;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;

View File

@@ -9,7 +9,7 @@ namespace nw4r {
namespace ut {
class Rect {
public:
#if defined(IPL_SOUND_RECT_OUT_OF_LINE) || defined(IPL_SD_CHANNEL_TITLE_CPP)
#ifdef IPL_SOUND_RECT_OUT_OF_LINE
Rect();
#else
Rect() : left(), top(), right(), bottom() {}
@@ -20,7 +20,7 @@ namespace nw4r {
Rect(f32 l, f32 t, f32 r, f32 b) : left(l), top(t), right(r), bottom(b) {}
#endif
#if !defined(IPL_CONTROLLER_TRIVIAL_RECT_DTOR) && !defined(IPL_MEMORYCARD_BASE_CPP) && !defined(IPL_SD_CHANNEL_TITLE_CPP)
#if !defined(IPL_CONTROLLER_TRIVIAL_RECT_DTOR) && !defined(IPL_MEMORYCARD_BASE_CPP)
~Rect() {}
#endif

View File

@@ -37,7 +37,7 @@ namespace nw4r {
} // namespace detail
template <typename TDerived, typename TBase>
#if defined(IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST) || defined(IPL_MEMORYCARD_BASE_CPP) || defined(IPL_SD_CHANNEL_TITLE_CPP)
#if defined(IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST) || defined(IPL_MEMORYCARD_BASE_CPP)
TDerived DynamicCast(TBase* pPtr);
#else
inline TDerived DynamicCast(TBase* pPtr) {

View File

@@ -252,17 +252,14 @@ namespace nw4r {
}
inline void updateSheetFlags(const void* glgrHdr, u32 groupIdx, u16* sheetOffsets, u32 flagsStep, const u32* sheetFlags) {
const GlyphGroups* glgr = (const GlyphGroups*)((const u8*)glgrHdr + sizeof(BinaryBlockHeader));
int sheetIndex;
u32 groupBitOffset;
u16* sheetOffset = sheetOffsets;
groupBitOffset = groupIdx * flagsStep * 8;
for (sheetIndex = 0; sheetIndex < glgr->sheetCount; sheetOffset++, sheetIndex++) {
u32 groupBitIdx = sheetIndex + groupBitOffset;
const GlyphGroups* glgr = (GlyphGroups*)((u8*)glgrHdr + sizeof(BinaryBlockHeader));
for (int sheetI = 0; sheetI < glgr->sheetCount; sheetI++) {
u32 groupBitIdx = sheetI + groupIdx * flagsStep * 8;
const u32* bitBlockPtr = sheetFlags + (groupBitIdx & ~0x1F) / 32;
u32 bitBlock = *bitBlockPtr;
u32 bitBlock = *(u32*)bitBlockPtr;
if (((bitBlock << (groupBitIdx & 0x1F)) & 0x80000000) != 0) {
*sheetOffset = 1;
sheetOffsets[sheetI] = 1;
}
}
}
@@ -271,16 +268,14 @@ namespace nw4r {
const u32* bitBlocksPtr, u32 sheetFlagsSize) {
HeaderedGlyphGroups* pGlgr = (HeaderedGlyphGroups*)glgrHdr;
int i;
u16* sheetOffset;
for (i = 0, sheetOffset = sheetOffsets; i < pGlgr->inner.sheetCount; sheetOffset++, i++) {
*sheetOffset = 0;
for (int i = 0; i < pGlgr->inner.sheetCount; i++) {
sheetOffsets[i] = 0;
}
for (int i = 0; i < pGlgr->inner.nameCount; i++) {
const char* includedGroups = ctx->pIncludedGroups;
u16 offset = pGlgr->inner.nameOffsets[i];
char* name = (char*)(offset + (u32)hdr);
char* name = (char*)((u8*)hdr + offset);
if (*includedGroups != 0) {
if (!ArchiveFontBase::IncludeName(includedGroups, name)) {
continue;
@@ -293,23 +288,21 @@ namespace nw4r {
inline void convertSheetOffsetBooleansToOffsets(const void* glgrHdr, u16* sheetOffsets) {
HeaderedGlyphGroups* pGlgr = (HeaderedGlyphGroups*)glgrHdr;
int i;
u16 glyphIdxOffset = 0;
u16* sheetOffset;
for (i = 0, sheetOffset = sheetOffsets; i < pGlgr->inner.sheetCount; sheetOffset++, i++) {
if (*sheetOffset == 1) {
*sheetOffset = glyphIdxOffset;
for (int i = 0; i < pGlgr->inner.sheetCount; i++) {
if (sheetOffsets[i] == 1) {
sheetOffsets[i] = glyphIdxOffset;
} else {
*sheetOffset = -1;
sheetOffsets[i] = -1;
glyphIdxOffset += pGlgr->inner.sheetGlyphCount;
}
}
}
inline void copyFlagOffsets(ArchiveFontBase::ConstructContext* ctx, u16* sheetOffsetsScratch, u32 workSize, const u16* sheetOffsetsScratchEnd) {
inline void copyFlagOffsets(ArchiveFontBase::ConstructContext* ctx, u16* sheetOffsetsScratch, u32 workSize, u32 scratchSize) {
u8* sheetOffsets = ctx->pWorkCurr;
ctx->pWorkCurr = sheetOffsets + workSize;
memmove(sheetOffsets, sheetOffsetsScratch, (sheetOffsetsScratchEnd - sheetOffsetsScratch) * sizeof(u16));
memmove(sheetOffsets, sheetOffsetsScratch, scratchSize);
ctx->pSheetOffsets = (u16*)sheetOffsets;
}
@@ -318,64 +311,31 @@ namespace nw4r {
// *sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)fontData + remWorkSpace) - sheetOffsetsSize, 2);
// return sheetOffsetsSize;
// }
class FontGlyphGroupsAcs {
public:
explicit FontGlyphGroupsAcs(const ArchiveFontBinaryLayout* font)
: mFont(font), mGroups(&font->glgr) {}
const GlyphGroups& GetGroups() const { return mGroups->inner; }
void SetSheetFlags(u32 flagsStep, const u32* sheetFlags) {
mFlagsStep = flagsStep;
mSheetFlags = sheetFlags;
}
u16 GetNumSheet() const { return mGroups->inner.sheetCount; }
int GetGlyphsPerSheet() const { return mGroups->inner.sheetGlyphCount; }
u16 GetNumSet() const { return mGroups->inner.nameCount; }
const char* GetSetName(int groupIndex) const {
const u16 nameOffset = mGroups->inner.nameOffsets[groupIndex];
return (const char*)(nameOffset + (u32)mFont);
}
bool IsUseSheet(int groupIndex, int sheetIndex) const {
const u32 groupBitIndex = sheetIndex + groupIndex * mFlagsStep * 8;
const u32* bitBlock = mSheetFlags + (groupBitIndex & ~0x1F) / 32;
return ((*bitBlock << (groupBitIndex & 0x1F)) & 0x80000000) != 0;
}
private:
const ArchiveFontBinaryLayout* mFont;
const HeaderedGlyphGroups* mGroups;
u32 mFlagsStep;
const u32* mSheetFlags;
};
ArchiveFontBase::ConstructState ArchiveFontBase::ConstructOpAnalyzeGLGR(ConstructContext* ctx, CachedStreamReader* reader) {
const u32* flagsSheets;
u32 sheetOffsetsSize;
u32 flagsSheetsOff;
u32 glgrInnerLen;
const ArchiveFontBinaryLayout* font;
u16 sheetGlyphCount;
u32 countSheet;
HeaderedGlyphGroups* pGlgr;
const ArchiveFontBinaryLayout* font;
u8* glgrEnd;
u32 expectedMaxSize;
u32 dataBlockCount;
u16* sheetOffsetsScratch;
int groupIndex;
font = (ArchiveFontBinaryLayout*)ctx->pWorkCurr;
glgrInnerLen = ctx->mNextBlockHdr.size - sizeof(BinaryBlockHeader);
// Check for RFNA
if (font->hdr.signature != SIGNATURE_FONT_ARCHIVE) {
return CONSTRUCT_STATE_FATAL_ERR;
}
// Check that there's enough data available, and the space to
// put that data
ENSURE_READER_HAS_SIZE(ctx, reader, glgrInnerLen);
ENSURE_WORK_HAS_SIZE(ctx, glgrInnerLen);
expectedMaxSize = ctx->mNextBlockHdr.size + sizeof(BinaryFileHeader);
// Copy the glgr to work
{
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
glgrEnd = (u8*)pGlgr + (u32)ctx->mNextBlockHdr.size;
@@ -388,45 +348,80 @@ namespace nw4r {
return CONSTRUCT_STATE_FATAL_ERR;
}
FontGlyphGroupsAcs gg(font);
sheetGlyphCount = gg.GetGlyphsPerSheet();
dataBlockCount = font->hdr.dataBlocks;
countSheet = gg.GetNumSheet();
const u32 stepSheetFlags = detail::CalcSizeFlagSet(countSheet);
flagsSheetsOff = detail::CalcOffsetSheetFlags(gg.GetGroups().nameCount, countSheet, gg.GetGroups().smthCount_0x0a,
gg.GetGroups().smthCount_0x0c);
flagsSheets = (const u32*)((flagsSheetsOff & ~3) + (u32)font);
gg.SetSheetFlags(stepSheetFlags, flagsSheets);
// Before here is fine (other than regswaps)
// u16 sheetGlyphCount = FORCE_REACCESS_2(font->glgr.inner.sheetGlyphCount, u16); // 0x1C
// u16 dataBlockCount = FORCE_REACCESS_2(font->hdr.dataBlocks, u16); // 0x0E
// FORCE_REACCESS_2(font->glgr.inner.sheetCount, u16);
// return ConstructOpAnalyzeGLGRInner(ctx, font, pGlgr, glgrEnd);
sheetOffsetsSize = (RoundUp)(countSheet * sizeof(u16), 4);
// u32 fontSizeToEndOfGlgr;
u16 countSheet;
u16 sheetGlyphCount, dataBlockCount;
u32 stepSheetFlags;
u32 flagsSheetsOff;
const u32* flagsSheets;
u32 sheetOffsetsSize;
u16* sheetOffsetsScratch;
u32 sheetOffsetsScratchSize;
sheetGlyphCount = font->glgr.inner.sheetGlyphCount; // 0x1C
dataBlockCount = font->hdr.dataBlocks; // 0x0E
// countName = font->glgr.inner.nameCount;
countSheet = font->glgr.inner.sheetCount;
// count0A = font->glgr.inner.smthCount_0x0a;
// count0C = font->glgr.inner.smthCount_0x0c;
stepSheetFlags = detail::CalcSizeFlagSet(countSheet);
flagsSheetsOff = detail::CalcOffsetSheetFlags(font->glgr.inner.nameCount, countSheet, font->glgr.inner.smthCount_0x0a,
font->glgr.inner.smthCount_0x0c);
flagsSheets = (const u32*)font + (flagsSheetsOff >> 2);
sheetOffsetsSize = ROUNDUP(countSheet * sizeof(u16), 4);
sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)font + ctx->remWorkSpace()) - sheetOffsetsSize, 2);
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
ENSURE_WORK_HAS_SIZE(ctx, glgrEnd - (u8*)font + sheetOffsetsSize);
// if (ctx->pWorkEnd - workCurr < fontSizeToEndOfGlgr + sheetOffsetsSize) {
// return CONSTRUCT_STATE_FATAL_ERR;
// }
{
u16* sheetOffset;
int sheetIndex;
for (sheetIndex = 0, sheetOffset = sheetOffsetsScratch; sheetIndex < gg.GetNumSheet(); sheetOffset++, sheetIndex++) {
*sheetOffset = 0;
}
for (groupIndex = 0; groupIndex < gg.GetNumSet(); groupIndex++) {
const char* includedGroups = ctx->pIncludedGroups;
const char* name = gg.GetSetName(groupIndex);
if (*includedGroups && !ArchiveFontBase::IncludeName(includedGroups, name)) {
continue;
}
for (int sheetIndex = 0; sheetIndex < gg.GetNumSheet(); sheetIndex++) {
if (gg.IsUseSheet(groupIndex, sheetIndex)) {
sheetOffsetsScratch[sheetIndex] = 1;
}
}
}
}
// Clear sheet offsets scratch
// for (s32 i = 0; i < pGlgr->inner.sheetCount; i++) {
// sheetOffsetsScratch[i] = 0;
// }
// for (s32 i = 0; i < pGlgr->inner.nameCount; i++) {
// // const char* includedGroups = ctx->pIncludedGroups;
// u16 offset = pGlgr->inner.nameOffsets[i];
// const char* name = (char*)((u8*)font + offset);
// if (*ctx->pIncludedGroups != 0) {
// if (!ArchiveFontBase::IncludeName(ctx->pIncludedGroups, name)) {
// continue;
// }
// }
// updateSheetFlags(pGlgr, i, sheetOffsetsScratch, stepSheetFlags, flagsSheets);
// }
setSheetOffsetBooleans(ctx, pGlgr, font, sheetOffsetsScratch, flagsSheets, stepSheetFlags);
// u16 glyphIdxOffset = 0;
// for (s32 i = 0; i < pGlgr->inner.sheetCount; i++) {
// if (sheetOffsetsScratch[i] == 1) {
// sheetOffsetsScratch[i] = glyphIdxOffset;
// } else {
// sheetOffsetsScratch[i] = -1;
// glyphIdxOffset += pGlgr->inner.sheetGlyphCount;
// }
// }
convertSheetOffsetBooleansToOffsets(pGlgr, sheetOffsetsScratch);
copyFlagOffsets(ctx, sheetOffsetsScratch, sheetOffsetsSize, sheetOffsetsScratch + (u16)countSheet);
sheetOffsetsScratchSize = (u32)countSheet << 1;
sheetOffsetsScratchSize += (sheetOffsetsScratchSize >> 31);
sheetOffsetsScratchSize &= ~1;
copyFlagOffsets(ctx, sheetOffsetsScratch, sheetOffsetsSize, sheetOffsetsScratchSize);
ctx->mSheetCount = countSheet;
ctx->mGlyphsPerSheet = sheetGlyphCount;

View File

@@ -15,11 +15,11 @@ static void readHuffmanLimit(const TMCHuffmanEntry* entries, TMCHuffmanEntry* li
limit->symbol = entries->symbol;
}
static inline s32 decodeLongHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u16* entry;
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u32 bitData;
u32 code;
u32 length;
const TMCHuffmanEntry* entry;
if (bitCount <= 17) {
s32 result = TMCJPEGDEC_load_buff(work);
@@ -28,16 +28,16 @@ static inline s32 decodeLongHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TM
}
}
bitCount = work->bitCount;
entry = (u16*)(huff_tbl + 9);
bitData = work->bitBuf;
length = 9;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry = table + 9;
goto read_entry;
while (1) {
length++;
entry += 2;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
@@ -49,23 +49,21 @@ static inline s32 decodeLongHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TM
code |= (bitData >> bitCount) & 1;
read_entry:
{
limit->bitLength = entry[0];
limit->symbol = entry[1];
readHuffmanLimit(entry, limit);
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
continue;
}
{
u32 relativeCode = code - limit->bitLength;
u32 symbolIndex = relativeCode + limit->symbol;
u32 relativeCode = code - entry->bitLength;
u32 symbolIndex = relativeCode + entry->symbol;
return symbols[symbolIndex & 0xFF];
}
}
}
}
static inline s32 decodeACHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u16* entry;
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u32 bitData;
u32 code;
u32 length;
@@ -77,16 +75,16 @@ static inline s32 decodeACHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCC
}
}
bitCount = work->bitCount;
entry = (u16*)(huff_tbl + 9);
bitData = work->bitBuf;
length = 9;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry += 9;
goto read_entry;
while (1) {
length++;
entry += 2;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
@@ -98,22 +96,20 @@ static inline s32 decodeACHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCC
code |= (bitData >> bitCount) & 1;
read_entry:
{
limit->bitLength = entry[0];
limit->symbol = entry[1];
readHuffmanLimit(entry, limit);
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
continue;
}
{
u32 relativeCode = code - limit->bitLength;
u32 symbolIndex = relativeCode + limit->symbol;
u32 relativeCode = code - entry->bitLength;
u32 symbolIndex = relativeCode + entry->symbol;
return symbols[symbolIndex & 0xFF];
}
}
}
}
s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_ptr, TMCCJPEGDecWork* work) {
TMCHuffmanEntry dcEntry;
TMCHuffmanEntry dcDecoded;
@@ -121,7 +117,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
TMCHuffmanEntry acDecoded;
TMCHuffmanEntry acLimit;
u8* huff_sym;
u16* ac_fast;
const TMCHuffmanEntry* ac_fast;
s32 idx;
u32* huff_tbl;
s32 bit_pos;
@@ -134,13 +130,11 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
s32 t;
s32 zz;
s32 q;
u16* dc_fast;
const TMCHuffmanEntry* dc_fast;
const u8* zztbl;
s32* conv_row;
conv_row = (s32*)conv_row_ptr;
bit_pos = work->bitCount;
dc_fast = work->pDCFast;
dc_fast = (const TMCHuffmanEntry*)work->pDCFast;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
@@ -152,7 +146,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
bit_pos = work->bitCount;
bit_data = work->bitBuf;
{
dcEntry = readHuffmanEntry((const TMCHuffmanEntry*)dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
dcEntry = readHuffmanEntry(dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
r = dcEntry.bitLength;
extra = dcEntry.symbol;
}
@@ -163,28 +157,30 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
} else {
huff_sym = work->pDCHuffSym;
huff_tbl = work->pDCHuffTbl;
r = decodeLongHuffman(bit_pos, huff_tbl, huff_sym, work, &dcLimit, &dcDecoded);
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &dcLimit, &dcDecoded);
if (r < 0) {
return r;
}
}
blk0 = conv_row[0];
blk0 = ((s32*)conv_row_ptr)[0];
if (r != 0) {
if (work->bitCount <= r) {
s32 load_ret;
if (load_ret = TMCJPEGDEC_load_buff(work), load_ret < 0) {
bit_pos = work->bitCount;
if (bit_pos <= r) {
s32 load_ret = TMCJPEGDEC_load_buff(work);
if (load_ret < 0) {
return load_ret;
}
}
tmp = 1UL << r;
bit_pos = work->bitCount - r;
work->bitCount = bit_pos;
bit_pos = work->bitCount;
bit_data = work->bitBuf;
tmp = 1 << r;
extra = tmp - 1;
bit_pos -= r;
work->bitCount = bit_pos;
extra = extra & (bit_data >> bit_pos);
if (((s32)tmp >> 1) > extra) {
extra -= (tmp - 1);
extra -= tmp - 1;
}
dc_predict_row_ptr[0] += extra;
}
@@ -192,7 +188,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
*block = dc_predict_row_ptr[0] * blk0;
{
ac_fast = work->pACFast;
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
@@ -210,7 +206,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
zztbl = TMCJPEGDEC_Zigzag_data;
bit_data = work->bitBuf;
t = bit_pos - 8;
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, (bit_data >> t) & 0xFF);
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
do {
s32 ac_thresh = acEntry.bitLength;
@@ -221,7 +217,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
r = acEntry.symbol;
} else {
bit_pos = work->bitCount;
r = decodeACHuffman(bit_pos, huff_tbl, huff_sym, work, &acLimit, &acDecoded);
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &acLimit, &acDecoded);
if (r < 0) {
return r;
}
@@ -245,18 +241,19 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
return r;
}
}
tmp = 1UL << t;
bit_pos = work->bitCount - t;
work->bitCount = bit_pos;
bit_pos = work->bitCount;
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
extra = extra & (bit_data >> bit_pos);
bit_pos -= t;
work->bitCount = bit_pos;
t = bit_pos - 8;
q = conv_row[(u8)zz];
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, (bit_data >> t) & 0xFF);
extra = extra & (bit_data >> bit_pos);
q = ((s32*)conv_row_ptr)[(u8)zz];
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
if (((s32)tmp >> 1) > extra) {
extra -= (tmp - 1);
extra -= tmp - 1;
}
block[(u8)zz] = extra * q;
@@ -277,7 +274,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
bit_pos = work->bitCount;
t = bit_pos - 8;
tmp = ((bit_data >> t) & 0xFF) << 2;
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, tmp >> 2);
acEntry = readHuffmanEntry(ac_fast, tmp >> 2);
idx += 16;
}

View File

@@ -92,20 +92,18 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
dst[0] = val;
} else {
s32 oddLowSum;
s32 oddLowDifference;
s32 oddHighSum;
s32 oddHighDifference;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
oddLowDifference = b5 - b3;
b5 = b5 - b3;
oddHighSum = b1 + b7;
oddHighDifference = b1 - b7;
b1 = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = oddLowDifference + oddHighDifference;
z_factor = b5 + b1;
dcValue = block[0];
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
@@ -115,14 +113,14 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
z = z_factor * 0x62 >> 8;
w = d + u;
y = d - u;
m_part = oddHighDifference * 0x14E >> 8;
m_part = b1 * 0x14E >> 8;
e = a - t;
m = m_part - z;
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
dst[0] = w + n;
p_part = oddLowDifference * 0x8B;
p_part = b5 * 0x8B;
dst[7] = w - n;
p_part >>= 8;
dst[1] = v + o;

View File

@@ -3,7 +3,7 @@
#include <tmc_jpeg_internal.h>
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo);
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry);
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
static s32 TMCJPEGDEC_ThumbnailCheck(TMCCJPEGDecInitParam* param, TMCCJPEGDecExifInfo* info, u32 totalSize);
@@ -280,7 +280,7 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)entries);
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
remaining -= entriesSize;
@@ -331,19 +331,19 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)entries);
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
}
return 0;
}
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry) {
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry) {
s32 tag;
u32 type;
u16 type;
tag = readExifU16(entry, byteOrder);
type = readExifU16(entry + 2, byteOrder);
tag = readU16(entry, byteOrder);
type = readU16(entry + 2, byteOrder);
switch (tag) {
case 0x0103:
@@ -366,7 +366,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->xResNum = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -386,7 +386,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->yResNum = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -501,10 +501,6 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x8769:
case 0x9000:
case 0x9101:
case 0x011C:
case 0xA000:
case 0xA001:
case 0xA002:
case 0xA003: {
break;
}
@@ -520,7 +516,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->xResNumIfd1 = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -542,7 +538,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->planarConfigIfd1 = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}

View File

@@ -816,6 +816,7 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
u8* luminance;
u8* cb;
u8* cr;
s32 value;
s32 column;
s32 xEnd;
s32 cbValue;
@@ -843,17 +844,17 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
for (column = x; column < xEnd; column++) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
red = *luminance++;
green = red + (-(cbValue * 88 + crValue * 183) >> 8);
blue = red + ((cbValue * 454) >> 8);
red = red + ((crValue * 359) >> 8);
value = *luminance++;
green = value + (-(cbValue * 88 + crValue * 183) >> 8);
red = value + ((crValue * 359) >> 8);
blue = value + ((cbValue * 454) >> 8);
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
luminance += rowSkip;
cb += rowSkip;

View File

@@ -656,10 +656,10 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
blueOffset = (cbValue * 454) >> 8;
}
{
s32 red = *luminance++;
s32 green = red + greenOffset;
s32 blue = red + blueOffset;
red = red + redOffset;
s32 value = *luminance++;
s32 green = value + greenOffset;
s32 red = value + redOffset;
s32 blue = value + blueOffset;
if ((green | red | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;

View File

@@ -163,12 +163,12 @@ typedef struct _ziGetParam {
ziWChar* candidates; // 0x18
ziU8 maxCandidates; // 0x1C
ziWChar firstCandidate; // 0x1E
ziU8 count; // 0x20 (EZTXGetParam.count)
ziU8 unk_0x20; // 0x20
ziU8 letters; // 0x21
ziU8 completion; // 0x22 (EZTXGetParam.completion)
ziU8* scratch; // 0x24
ziU32 unk_0x28; // 0x28
ziU8 letters; // 0x21
ziU8 count; // 0x22
ziU8* scratch; // 0x24
ziU32 unk_0x28; // 0x28
} ziGetParam;
typedef struct _ziLanguageEntry {
@@ -195,7 +195,7 @@ typedef struct _zi8DawgCtx {
ziU8* table; // 0x10
ziU8* p14; // 0x14
zi8DawgRec recs[0x32]; // 0x18
ziU32 endNode; // 0x338
ziU32 unk_0x338; // 0x338
} zi8DawgCtx;
typedef struct _ziUwdNode {
@@ -204,34 +204,34 @@ typedef struct _ziUwdNode {
} ziUwdNode;
struct __zi8_work_data_s {
ziU8 getcPhase; // 0x00
ziU8 unk_0x00;
ziU8 countOnly; // 0x01
ziU8 unk_0x02[2];
ziLanguageEntry* langEntries; // 0x04
ziU8 unk_0x08;
ziU8 unk_0x09;
ziU8 maxWordLength;
ziU8 unk_0x0A;
ziU8 unk_0x0B;
ziU32 targetCount; // 0x0C
ziU32 unk_0x0C;
ziU32 unk_0x10;
ziU16 unk_0x14;
ziU8 cangjieEnabled; // 0x16
ziU8 zhPudMinPrefix;
ziU8 unk_0x17;
ziU8 subLanguage; // 0x18
ziU8 unk_0x19;
ziU16 separator; // 0x1A
ziU8 unk_0x1C[3];
ziU8 ignoreCase;
ziU8 unk_0x1F;
ziU16 unk_0x20[0x40];
ziU16 unk_0xA0[0x42];
ziU16* unk_0x124[1];
ziU8* unk_0x128;
ziU8 uwdPtrCount; // 0x12C
ziU8 unk_0x12C;
ziU8 unk_0x12D;
ziU8 uwdPrioritySort; // 0x12E
ziU8 unk_0x12E;
ziU8 unk_0x12F;
ziPtr uwdDicts[2]; // 0x130
ziU8 uwdDictCount; // 0x138
ziPtr unk_0x130[2];
ziU8 unk_0x138;
ziU8 unk_0x139[3];
ziU32 unk_0x13C;
ziU8 unk_0x140;
@@ -269,10 +269,10 @@ struct __zi8_work_data_s {
ziU8 unk_0x1414[4];
ziU8 formatCount;
ziU8 unk_0x1419;
ziU16 capacity; // 0x141A
ziU8 forceAltGraph; // 0x141C (lang FI + group 0xC -> graphTableId 0x10)
ziU8 advanceGroup; // 0x141D (nonzero: skip first dawg group)
ziU8 graphTableId; // 0x141E
ziU16 unk_0x141A;
ziU8 unk_0x141C;
ziU8 unk_0x141D;
ziU8 unk_0x141E;
ziU8 maxCnt; // 0x141F
ziU8 unk_0x1420[4];
zi8DawgCtx dawgCtx; // 0x1424
@@ -309,26 +309,26 @@ struct __zi8_work_data_s {
ziWChar unk_0x1A92[0x41];
ziU8 unk_0x1B14;
ziU8 unk_0x1B15[3];
ziU16* unicodeMap; // 0x1B18
ziU16 unicodeRange1Min; // 0x1B1C
ziU16 unicodeRange1Max; // 0x1B1E
ziU16 unicodeRange2Min; // 0x1B20
ziU16 unicodeRange2Max; // 0x1B22
ziU8 unicodeMapSubLang; // 0x1B24
ziU16* unk_0x1B18;
ziU16 unk_0x1B1C;
ziU16 unk_0x1B1E;
ziU16 unk_0x1B20;
ziU16 unk_0x1B22;
ziU8 unk_0x1B24;
ziU8 unk_0x1B25[3];
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} pyFuzzy; // 0x1B28
} unk_0x1B28;
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} unk_0x1B2C;
ziU8 koAltTables; // 0x1B30
ziU8 unk_0x1B30;
ziU8 unk_0x1B31;
ziU16 unk_0x1B32;
ziU16 unk_0x1B34;

View File

@@ -21,7 +21,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
}
if (fc == 0) {
count++;
if (ZI_WORK->getcPhase == 0) {
if (ZI_WORK->unk_0x00 == 0) {
param->candidates[i++] = Zi8PunctTable[j];
if ((param->context & 0x10) != 0) {
param->candidates[i++] = 0x20;
@@ -33,7 +33,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
break;
}
} else {
if (count >= (ziS32)ZI_WORK->targetCount) {
if (count >= (ziS32)ZI_WORK->unk_0x0C) {
return count;
}
}
@@ -42,7 +42,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
}
j++;
}
if (ZI_WORK->getcPhase == 0) {
if (ZI_WORK->unk_0x00 == 0) {
param->letters = count;
}
return count;

View File

@@ -311,21 +311,21 @@ Zi8UInt Zi8SpellingPY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
return length;
}
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,ziU16 key,ziU8 requireFull,ziU8 usePinyin,ziU8 tone)
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,Zi8UInt key,ziU8 requireFull,ziU8 usePinyin,ziU8 tone)
{
ziU16 spelling[16];
Zi8UInt spellingLength;
if (key == 0) {
if ((key & 0xffff) == 0) {
return 0;
}
if ((inputLength & 0xff) == 0) {
return 1;
}
if (usePinyin != 0) {
spellingLength = Zi8SpellingPY(spelling,key,tone & 0xff);
spellingLength = Zi8SpellingPY(spelling,key & 0xffff,tone & 0xff);
} else {
spellingLength = Zi8SpellingZY(spelling,key,tone & 0xff);
spellingLength = Zi8SpellingZY(spelling,key & 0xffff,tone & 0xff);
}
if ((requireFull != 0) && ((inputLength & 0xff) != (spellingLength & 0xff))) {
return 0;
@@ -1327,7 +1327,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
}
if (elementIndex == 0) continue;
if (!emitWords) {
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
if (trackDuplicates && Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
for (index = 0; index < candidateCount; index++) {
if (candidateCharacter == output[index]) break;
}
@@ -1396,7 +1396,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
}
if (elementIndex == 0) continue;
if (!emitWords) {
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
if (trackDuplicates && Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
for (index = 0; index < candidateCount; index++) {
if (candidateCharacter == output[index]) break;
}
@@ -1519,7 +1519,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
}
if (elementIndex == 0) goto nextPhrase;
if (!emitWords) {
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,phraseCharacter,work) != 0) goto nextPhrase;
if (trackDuplicates && Zi8SetFindCand(params->scratch,phraseCharacter,work) != 0) goto nextPhrase;
for (index = 0; index < candidateCount; index++) {
if (firstOrdinal == output[index]) goto nextPhrase;
}
@@ -1601,7 +1601,7 @@ finishPhrases:
}
if (elementIndex == 0) goto nextSortedOrdinal;
if (!emitWords) {
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextSortedOrdinal;
if (trackDuplicates && Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextSortedOrdinal;
ordinal = Zi8Ord2Uni(ordinal,work);
for (index = 0; index < candidateCount; index++) {
if (ordinal == output[index]) break;
@@ -1629,11 +1629,11 @@ nextSortedOrdinal:
;
}
}
if ((options->countOnly == '\0') && (ziU8)Zi8GetZHuwdPtr(&userEntries,&userCount,work) != 0)
if ((options->countOnly == '\0') && Zi8GetZHuwdPtr(&userEntries,&userCount,work) != 0)
{
for (phraseOrdinal = 0; phraseOrdinal < userCount;) {
if ((params->elementCount == '\0') || ((userEntries[1] & 0x80) != 0)) {
userOrdinal = (ziU16)(userEntries[1] & 0x7f) << 8 | (ziU16)userEntries[2];
userOrdinal = (userEntries[1] & 0x7f) << 8 | (ziU16)userEntries[2];
phraseTable = syllableTable + (Zi8UInt)userOrdinal * 0xc;
if (((*phraseTable & languageMask) != 0) &&
((characterSetTable == 0 || ((characterSet & characterSetTable[(Zi8UInt)userOrdinal]) != 0)))) {
@@ -1654,7 +1654,7 @@ nextSortedOrdinal:
}
if (elementIndex == 0) goto nextUserOrdinal;
if (!emitWords) {
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,userOrdinal,work) != 0) goto nextUserOrdinal;
if (trackDuplicates && Zi8SetFindCand(params->scratch,userOrdinal,work) != 0) goto nextUserOrdinal;
userCharacter = Zi8Ord2Uni(userOrdinal,work);
for (duplicateIndex = 0; duplicateIndex < candidateCount; duplicateIndex++) {
if (userCharacter == output[duplicateIndex]) break;
@@ -1710,7 +1710,7 @@ nextUserOrdinal:
if (unicodeCharacter == previousCharacter) goto nextOrdinal;
previousCharacter = unicodeCharacter;
if (!emitWords) {
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextOrdinal;
if (trackDuplicates && Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextOrdinal;
for (index = 0; index < candidateCount; index++) {
if (unicodeCharacter == output[index]) break;
}
@@ -1738,7 +1738,8 @@ nextOrdinal:
}
finishCandidates:
if ((emitWords) && (outputIndex != 0)) {
output[outputIndex++] = 0;
output[outputIndex] = 0;
outputIndex++;
}
params->count = candidateCount;
Zi8LogError(100,work);

View File

@@ -2,14 +2,14 @@
#include <zi8clib/zitypes.h>
ziU32 Zi8GetZHuwdPtr(ziU32* arg0, ziU16* arg1 ZI_NEED_WORK) {
if (ZI_WORK->uwdPtrCount == 0) {
if (ZI_WORK->unk_0x12C == 0) {
*arg0 = 0;
*arg1 = 0;
Zi8LogError(0x1A5, ZI_WORK);
return 0;
} else {
*arg1 = ZI_WORK->unk_0x124[ZI_WORK->uwdPtrCount - 1][1] / 3;
*arg0 = (ziU32)ZI_WORK->unk_0x124[ZI_WORK->uwdPtrCount - 1];
*arg1 = ZI_WORK->unk_0x124[ZI_WORK->unk_0x12C - 1][1] / 3;
*arg0 = (ziU32)ZI_WORK->unk_0x124[ZI_WORK->unk_0x12C - 1];
*arg0 += 8;
Zi8LogError(0x64, ZI_WORK);
return 1;

View File

@@ -920,7 +920,8 @@ selectDictionary:
if ((((wordLength == 0) && (*punctuationCursor != 0)) && (dictionaryExact != 0)) &&
((((ZiAlphaWork*)workData)->singleCharacter != 0 && (parameters->elementCount == 2)))) {
*wordCursor = ((ZiAlphaWork*)workData)->singleCharacter;
wordCursor[1] = *punctuationCursor++;
wordCursor[1] = *punctuationCursor;
punctuationCursor = punctuationCursor + 1;
wordCursor[2] = 0;
wordLength = 2;
}
@@ -1067,7 +1068,7 @@ filterVowelCandidate:
(((ZiAlphaWork*)workData)->requiredLength != parameters->elementCount)) &&
(((((ZiAlphaWork*)workData)->prefixLength == '\0' ||
(((ZiAlphaWork*)workData)->prefixLength + 1 >= parameters->elementCount)) && (dictionaryExact != 0)))
))) && ((((currentVowelRestriction && (prefixCount == 0)) && (dictionaryKind != 0xb)) &&
))) && ((((completionAllowed && (prefixCount == 0)) && (dictionaryKind != 0xb)) &&
((((int)dictionaryIndex < (int)(unsigned int)((ZiAlphaWork*)workData)->dictionaryCount &&
(((ZiAlphaOptions*)optionData)->lookupMode == '\0')) &&
(((ZiAlphaWork*)workData)->dictionaries[language] == 0)))))) {
@@ -1083,7 +1084,7 @@ filterVowelCandidate:
goto retryDictionary;
}
}
if ((((((dictionaryExact == 0) || (!currentVowelRestriction)) || (prefixCount != 0)) ||
if ((((((dictionaryExact == 0) || (!completionAllowed)) || (prefixCount != 0)) ||
((dictionaryKind == 0xb ||
(dictionaryIndex >= ((ZiAlphaWork*)workData)->dictionaryCount)))) ||
(elements == 0)) ||
@@ -1138,7 +1139,7 @@ prepareCandidate:
Zi8ChangeWordCase(wordCursor - prefixCount,language,workData);
}
if ((((ZiAlphaOptions*)optionData)->suffixOnly != '\0') &&
((wordLength + prefixCount) > ((ZiAlphaOptions*)optionData)->maxWordLength)) {
((int)((ZiAlphaOptions*)optionData)->maxWordLength < (int)(wordLength + prefixCount))) {
wordLength = ((ZiAlphaOptions*)optionData)->maxWordLength - prefixCount;
wordCursor[wordLength] = 0;
}
@@ -1207,14 +1208,16 @@ emitCandidate:
if (((ZiAlphaOptions*)optionData)->maxResults <= candidateCount) goto finishCandidates;
} else {
if (((ZiAlphaOptions*)optionData)->lookupMode != '\0') {
for (index = 0; index <= wordLength; index++) {
if (wordCursor[index] != ((ZiAlphaOptions*)optionData)->dictionary[index]) break;
for (index = 0;
(index <= (int)wordLength &&
(wordCursor[index] == ((ZiAlphaOptions*)optionData)->dictionary[index]));
index = index + 1) {
}
if ((((((ZiAlphaWork*)workData)->operation != '\0') || (index >= wordLength))
if ((((((ZiAlphaWork*)workData)->operation != '\0') || ((int)wordLength <= index))
&& ((((ZiAlphaWork*)workData)->operation == '\0' ||
((exactLengthOnly == 0 ||
(index >= (int)(ziU16)Zi8WCharCount(((ZiAlphaOptions*)optionData)->dictionary,workData))))))) &&
((exactLengthOnly != 0 || (index >= wordLength)))) {
((int)(ziU16)Zi8WCharCount(((ZiAlphaOptions*)optionData)->dictionary,workData) <= index)))))) &&
((exactLengthOnly != 0 || ((int)wordLength <= index)))) {
candidateCount = 1;
goto finishCandidates;
}
@@ -1364,7 +1367,7 @@ emitCandidate:
}
}
retryDictionary:;
} while (dictionaryIndex != 0);
} while (dictionaryKind != 0);
}
finishDictionaryPass:;
}
@@ -1373,23 +1376,27 @@ finishDictionaryPass:;
(((parameters->elementCount == 1 &&
(((Zi8GetTableCount(parameters->language,0x1f,workData)) & 0x40) == 0)) &&
(*parameters->elements >= 0xeff1)))))) &&
((*parameters->elements <= 0xf010 &&
((*parameters->elements < 0xf011 &&
((Zi8getKeyLayout(parameters->language,*parameters->elements,&punctuationBuffer[0],1,workData)) != '\0')))) {
punctuationCandidate = ZI8_TRUE;
}
if (((candidateCount == 0) && (punctuationCandidate)) && (firstCandidate == 0)) {
candidateCount = 1;
if (((ZiAlphaOptions*)optionData)->countOnly != 0 || (parameters->getOptions & 0xFD) == 0x81) {
if ((((ZiAlphaOptions*)optionData)->countOnly == '\0') && ((parameters->getOptions & 0xfd) != 0x81)) {
*encodedOutput = 0x3e;
encodedOutput[2] = 0;
encodedOutput[1] = 0;
}
else {
if (parameters->getMode == 1) {
*wordCursor = *elements;
} else {
*wordCursor = 0x3E;
}
wordCursor[1] = wordCursor[2] = 0;
wordCursor += 2;
} else {
*encodedOutput = 0x3E;
encodedOutput[1] = encodedOutput[2] = 0;
else {
*wordCursor = 0x3e;
}
wordCursor[2] = 0;
wordCursor[1] = 0;
wordCursor = wordCursor + 2;
}
if (((ZiAlphaOptions*)optionData)->lookupMode == '\0') {
((ZiAlphaWork*)workData)->singleCharacter = 0;
@@ -1399,13 +1406,13 @@ finishDictionaryPass:;
secondLanguagePass = ZI8_TRUE;
languagePassCount = 0;
language = parameters->subLanguage;
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
dictionaryStatus[9] = 0;
dictionaryStatus[5] = 0;
dictionaryStatus[6] = 0;
dictionaryStatus[7] = 0;
dictionaryStatus[8] = 0;
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
if (switchedLanguage) {
secondLanguagePass = ZI8_FALSE;
dictionaryStatus[1] = 0;
@@ -1419,15 +1426,14 @@ finishDictionaryPass:;
if (language == 0) {
language = parameters->language;
}
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
if (language == parameters->language) {
completionAllowed = primaryCompletionAllowed;
currentVowelRestriction = primaryVowelRestriction;
} else {
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
}
if ((((ZiAlphaOptions*)optionData)->lookupMode != '\0') || ((!completionAllowed && (!currentVowelRestriction)))) goto finishCandidates;
if ((currentVowelRestriction) &&
if ((((ZiAlphaOptions*)optionData)->lookupMode != '\0') || ((!currentVowelRestriction && (!completionAllowed)))) goto finishCandidates;
if ((completionAllowed) &&
((((((ZiAlphaWork*)workData)->suffixMode == '\0' && (2 < (int)elementCount)) &&
(elements[elementCount - 2] == 0xeff1)) &&
((int)((ZiAlphaWork*)workData)->prefixCount == elementCount - 2)))) {
@@ -1438,65 +1444,66 @@ finishDictionaryPass:;
prefixPrepared = ZI8_TRUE;
goto preparePrefix;
}
if (currentVowelRestriction && ((ZiAlphaWork*)workData)->suffixMode != 0 &&
((ZiAlphaWork*)workData)->suffixLocked == 0 && elementCount > 2 &&
((elements[elementCount - 2] == 0xEFF1 &&
((ZiAlphaWork*)workData)->suffixCount == elementCount - 2) ||
(((ZiAlphaWork*)workData)->suffixCount == elementCount - 1 &&
Zi8IsAlphaPunct(elements[elementCount - 1]) != 0))) {
if (((ZiAlphaWork*)workData)->prefixEnabled >= 1 && elements[elementCount - 1] == 0xEFF1) {
goto checkPrefixPunctuation;
}
if (!primaryMatched && !secondaryMatched) {
((ZiAlphaWork*)workData)->suffixLocked = 1;
((ZiAlphaWork*)workData)->suffixElementCount = parameters->elementCount - 1;
if (prefixCount != 0) {
if (!((((completionAllowed) && (((ZiAlphaWork*)workData)->suffixMode != '\0')) &&
((((ZiAlphaWork*)workData)->suffixLocked == '\0' && (2 < (int)elementCount)))) &&
(((elements[elementCount - 2] == 0xeff1 &&
((int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 2)) ||
(((int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 1 &&
((Zi8IsAlphaPunct(elements[elementCount - 1])) != '\0'))))))) {
tryAlternatePrefix:
if ((prefixPrepared) && (1 < ((ZiAlphaWork*)workData)->alternatePrefixCount)) {
if (language == parameters->language) {
if (primaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
else if (secondaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
if (((ZiAlphaWork*)workData)->alternatePrefixCount != '\0') {
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
}
goto preparePrefix;
}
}
if ((prefixPrepared) && (1 < ((ZiAlphaWork*)workData)->alternatePrefixCount)) {
if (language == parameters->language) {
if (primaryMatched) {
prefixPrepared = ZI8_FALSE;
((ZiAlphaWork*)workData)->suffixMode = 0;
((ZiAlphaWork*)workData)->suffixLocked = 0;
((ZiAlphaWork*)workData)->suffixCount = 0;
for (index = 0; index < (int)(unsigned int)((ZiAlphaWork*)workData)->alternatePrefixCount; index = index + 1) {
((ZiAlphaWork*)workData)->prefix[index] =
((ZiAlphaWork*)workData)->alternatePrefix[index];
}
((ZiAlphaWork*)workData)->prefixCount = (ziU8)index;
if (((ZiAlphaWork*)workData)->language == parameters->language) {
((ZiAlphaWork*)workData)->language = parameters->subLanguage;
}
else {
((ZiAlphaWork*)workData)->language = parameters->language;
}
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
else if (secondaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
if ((((primaryMatched) && (secondaryMatched)) || (elementCount == 0)) ||
(((language == parameters->language && (primaryMatched)) || ((language == parameters->subLanguage && (secondaryMatched))))))
goto finishCandidates;
if (completionAllowed) goto checkPrefixPunctuation;
} else {
if ((((ZiAlphaWork*)workData)->prefixEnabled == '\0') || (elements[elementCount - 1] != 0xeff1)) {
if ((!primaryMatched) && (!secondaryMatched)) {
((ZiAlphaWork*)workData)->suffixLocked = 1;
((ZiAlphaWork*)workData)->suffixElementCount = parameters->elementCount - 1;
if (prefixCount != 0) {
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
}
goto preparePrefix;
}
goto tryAlternatePrefix;
}
if (((ZiAlphaWork*)workData)->alternatePrefixCount != '\0') {
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
prefixPrepared = ZI8_FALSE;
((ZiAlphaWork*)workData)->suffixMode = 0;
((ZiAlphaWork*)workData)->suffixLocked = 0;
((ZiAlphaWork*)workData)->suffixCount = 0;
for (index = 0; index < (int)(unsigned int)((ZiAlphaWork*)workData)->alternatePrefixCount; index = index + 1) {
((ZiAlphaWork*)workData)->prefix[index] =
((ZiAlphaWork*)workData)->alternatePrefix[index];
}
((ZiAlphaWork*)workData)->prefixCount = (ziU8)index;
if (((ZiAlphaWork*)workData)->language == parameters->language) {
((ZiAlphaWork*)workData)->language = parameters->subLanguage;
}
else {
((ZiAlphaWork*)workData)->language = parameters->language;
}
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
if ((((primaryMatched) && (secondaryMatched)) || (elementCount == 0)) ||
(((language == parameters->language && (primaryMatched)) || ((language == parameters->subLanguage && (secondaryMatched))))))
goto finishCandidates;
if (currentVowelRestriction) {
checkPrefixPunctuation:
if ((1 < ((ZiAlphaWork*)workData)->prefixEnabled) &&
(parameters->elements[parameters->elementCount - 1] != 0xEFF1))
@@ -1569,17 +1576,17 @@ checkPrefixFields:
finishCandidates:
((ZiAlphaWork*)workData)->usePrefixAsElements = 0;
if (((ZiAlphaOptions*)optionData)->countOnly != '\0') {
parameters->letters = 0;
if (((ZiAlphaOptions*)optionData)->countOnly == '\0') {
parameters->letters = candidateCount;
}
else {
parameters->letters = candidateCount;
parameters->letters = 0;
}
wordCursor[-prefixCount] = 0;
if (((((ZiAlphaOptions*)optionData)->countOnly == '\0') && (((ZiAlphaOptions*)optionData)->lookupMode == '\0')) && (parameters->elementCount != 0)) {
elementIndex = parameters->elementCount - 1;
if (((primaryVowelRestriction) || (secondaryVowelRestriction)) &&
((((ZiAlphaWork*)workData)->prefixEnabled <= 1 ||
((((ZiAlphaWork*)workData)->prefixEnabled < 2 ||
(parameters->elements[elementIndex] == 0xEFF1)))) {
index = 0;
while (elementIndex >= 0) {

View File

@@ -425,8 +425,8 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
charset <<= 4;
skipCount = request->firstCandidate;
request->letters = 0;
request->completion = 0;
request->count = 0;
request->unk_0x20 = 0;
if (getMode != 7 && getMode != 10 && getMode != 8 && getMode != 9) {
Zi8PrepareMatch(request, &match, 0, work);
} else {
@@ -577,27 +577,27 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (getMode == 1) {
switch ((int)match.phon2[index] >> 9) {
case 24: case 25:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->cANDch) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->cANDch) ordinalIndex = 0xFDFF;
break;
case 26: case 27:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->sANDsh) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->sANDsh) ordinalIndex = 0xFDFF;
break;
case 28: case 29:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->zANDzh) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->zANDzh) ordinalIndex = 0xFDFF;
break;
case 56: case 59:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->fANDh) ordinalIndex = 0xF9FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 38:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl) ordinalIndex = 0xE5FF;
break;
case 43:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl && ((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl && ((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl) ordinalIndex = 0xE5FF;
break;
case 44:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xF1FF;
break;
}
} else {
@@ -650,13 +650,13 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (getMode == 1) {
switch (match.phon2[index] & 0x1F0) {
case 0x10: case 0x80: case 0x100:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->anANDang) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->anANDang) ordinalIndex = 0xFFF7;
break;
case 0x180:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->enANDeng) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->enANDeng) ordinalIndex = 0xFFF7;
break;
case 0x60:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->inANDing) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->inANDing) ordinalIndex = 0xFFF7;
break;
}
} else {
@@ -720,7 +720,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
return 0;
}
emitWords = 1;
if (request->completion) request->completion = request->elementCount;
if (request->count) request->count = request->elementCount;
}
if (!options->candidateMode) Zi8InitDupWordBuf(work);
records = (ziU8*)Zi8GetTableAddress(1, 0, work);
@@ -930,13 +930,13 @@ engine_search:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
}
@@ -981,7 +981,7 @@ pud_candidate:
++rangeIndex;
}
if (rangeIndex == request->elementCount) {
if (!(request->context & 0x10)) request->completion = request->elementCount;
if (!(request->context & 0x10)) request->count = request->elementCount;
candidateStatus = 1;
character = currentSpelling[wordLength];
candidateOrdinal = 0xFFFF;
@@ -1108,13 +1108,13 @@ pud_charset:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
}
@@ -1302,13 +1302,13 @@ context_word_lookup:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = previousOrdinal;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
}
@@ -1321,7 +1321,7 @@ context_phrase_next:
}
}
context_results_done:
if (request->wordCharCount) request->count = emittedCount;
if (request->wordCharCount) request->unk_0x20 = emittedCount;
if (getOptions == 5) goto engine_finish;
if ((wordLength && (getMode == 1 || getMode == 2) && match.nCand > 1) ||
(wordLength && getMode == 0 && match.nSeg > 1)) {
@@ -1752,7 +1752,7 @@ tone_candidates:
}
}
user_character_search:
if (((struct __zi8_work_data_s*)work)->uwdPtrCount && (getMode != 0 || !firstPhoneticPass) &&
if (((struct __zi8_work_data_s*)work)->unk_0x12C && (getMode != 0 || !firstPhoneticPass) &&
!options->countOnly && (match.nCand <= 1 || (getMode != 1 && getMode != 2)) &&
Zi8GetZHuwdPtr(&userEntries, &userCount, work) && (getMode != 0 || match.nSeg <= 1)) {
userIndex = 0;
@@ -2572,7 +2572,7 @@ filtered_accept:
if (totalResults >= options->maxResults) goto engine_finish;
} else if (!options->countOnly) {
if (++((ZiChineseWork*)work)->duplicateIndex >= 64) ((ZiChineseWork*)work)->duplicateIndex = 0;
if (filteringMode == 4) request->count = emittedCount + 1;
if (filteringMode == 4) request->unk_0x20 = emittedCount + 1;
if (emitWords) {
++emittedCount;
outputIndex += rangeCount;

View File

@@ -32,17 +32,17 @@ ziU32 Zi8MatchROMdata0(ziWChar* elements, ziU8 count, ziU8 language,
if (language != context->lang || graphTable != context->key) records[0].key = 0;
if (count == 1 && mode != 0 && graphTable == 0xe) goto finish_graph;
if (status != 0) {
if (records[context->cnt - 1].node == (ziU8*)context->endNode) goto finish_graph;
if (records[context->cnt - 1].node == (ziU8*)context->unk_0x338) goto finish_graph;
for (index = 0; index < count; index++) {
if (records[index].key != elements[index] &&
(ziU16)records[index].attr != elements[index]) goto finish_graph;
}
if (mode == 1) acceptPrefix = 0;
} else {
if (ZI_WORK->graphTableId != 0 && graphTable == 0xc &&
Zi8GetTableSize(language, ZI_WORK->graphTableId, ZI_WORK) != 0) {
graphData = (ziU8*)Zi8GetTableAddress(language, ZI_WORK->graphTableId, ZI_WORK);
keyTable = ZI_WORK->graphTableId + 1;
if (ZI_WORK->unk_0x141E != 0 && graphTable == 0xc &&
Zi8GetTableSize(language, ZI_WORK->unk_0x141E, ZI_WORK) != 0) {
graphData = (ziU8*)Zi8GetTableAddress(language, ZI_WORK->unk_0x141E, ZI_WORK);
keyTable = ZI_WORK->unk_0x141E + 1;
} else {
if (Zi8GetTableSize(language, graphTable, ZI_WORK) == 0) {
Zi8LogError(0x961, ZI_WORK);
@@ -82,7 +82,7 @@ check_keys:
records[0].node = ZiDAWGGetGraphInfo(context, keyData, (ziS16*)keys);
} else {
records[0].node = ZiDAWGGetGraph(context);
context->endNode = 0;
context->unk_0x338 = 0;
context->p14 = 0;
}
records[0].key = 0;
@@ -98,7 +98,7 @@ check_keys:
}
searching = 1;
current = &records[context->cnt - 1];
while (searching && context->cnt != 0 && current->node != (ziU8*)context->endNode) {
while (searching && context->cnt != 0 && current->node != (ziU8*)context->unk_0x338) {
if (capacity < context->cnt) goto finish_graph;
current->attr = ZiDAWGgetCHARattribute(context, current->node, ZI_WORK);
if (context->cnt <= count) {
@@ -159,7 +159,7 @@ ziU8* NextDawgGroup(ziU8* group, ziU8 language, ziPtr __zi8_work_data)
Zi8LogError(0x962,ZI_WORK);
return 0;
}
if (ZI_WORK->advanceGroup == 0) {
if (ZI_WORK->unk_0x141D == 0) {
return group;
}
}
@@ -231,10 +231,10 @@ unsigned int Zi8MatchROMdata2(ziWChar* elements, ziU8 count, ziU8 language,
if (status == 0) {
ZI_WORK->unk_0x1768 = 0;
ZI_WORK->matchOffset = 0;
if (group != 0 && *group == 0xc && language == 10 && ZI_WORK->forceAltGraph != 0) {
ZI_WORK->graphTableId = 0x10;
if (group != 0 && *group == 0xc && language == 10 && ZI_WORK->unk_0x141C != 0) {
ZI_WORK->unk_0x141E = 0x10;
} else {
ZI_WORK->graphTableId = 0;
ZI_WORK->unk_0x141E = 0;
}
}
search_segment:
@@ -273,14 +273,14 @@ search_segment:
if (ZI_WORK->matchOffset == count) return 0;
ZI_WORK->unk_0x1768++;
status = 0;
ZI_WORK->graphTableId = 0;
ZI_WORK->unk_0x141E = 0;
if (ZI_WORK->dawgCtx.key == 0 && language == 10) {
for (index = 0; index < ZI_WORK->matchOffset; index++) {
switch (ZI_WORK->unk_0x17F4[index]) {
case 0x61:
case 0x6f:
case 0x75:
ZI_WORK->graphTableId = 0x10;
ZI_WORK->unk_0x141E = 0x10;
goto search_segment;
}
}

View File

@@ -8,15 +8,11 @@ extern ziU8 Zi8SyllablesROMdata(ziWChar* keys, ziU8 count, ziU8 lang, ziWChar* o
ziU16 a, ziU8 b, ziU8* cntOut, ziU8 c ZI_NEED_WORK);
typedef struct _ziSwParam {
ziU8 countOnly; // 0x00 - same layout as ZiCandidateOptions
ziU8 maxWordLength; // 0x01
ziU8 lookupMode; // 0x02
ziU8 suffixOnly; // 0x03
ziU8 controls[8]; // 0x04
ziS32 maxCount; // 0x0C - signed view of ZiCandidateOptions.maxCount
ziU16 capacity; // 0x10
ziU8 minWordLength; // 0x12
ziU8 flags; // 0x13
ziU8 flag;
ziU8 unk_0x01[0xB];
ziS32 count;
ziU16 cap;
ziU8 unk_0x12[2];
} ziSwParam;
ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
@@ -58,16 +54,16 @@ ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
goto end;
}
if (sw->countOnly != 0 || (param->getOptions & 0xFD) != 0x81) {
if (sw->flag != 0 || (param->getOptions & 0xFD) != 0x81) {
out = buf;
rem = 0x40;
} else {
out = (ziWChar*)param->candidates;
rem = sw->capacity - 1;
rem = sw->cap - 1;
}
if ((param->getOptions & 0xFD) == 0x80) {
u28 = (ziU8*)param->candidates;
rem = sw->capacity - 1;
rem = sw->cap - 1;
}
if (rem <= param->elementCount) {
@@ -98,8 +94,8 @@ ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
firstCand--;
goto L5dc;
}
if (sw->countOnly != 0) {
if (++count >= sw->maxCount) goto end;
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
goto L5dc;
}
@@ -151,8 +147,8 @@ L464b:
firstCand--;
goto L560;
}
if (sw->countOnly != 0) {
if (++count >= sw->maxCount) goto end;
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
goto L560;
}
if (u28 != 0) {
@@ -206,7 +202,7 @@ dec:
goto L560;
end:
if (sw->countOnly != 0) {
if (sw->flag != 0) {
param->letters = 0;
} else {
param->letters = (ziU8)count;

View File

@@ -32,9 +32,9 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
ziBool Zi8ZHsetPYfuzzyPairs(ziFuzzyPYPairs pairs ZI_NEED_WORK) {
if (pairs.ziDefault) {
ZI_WORK->pyFuzzy.word = *(const ziU32*)&Zi8PYdefaultFuzzyPairs;
ZI_WORK->unk_0x1B28.word = *(const ziU32*)&Zi8PYdefaultFuzzyPairs;
} else {
ZI_WORK->pyFuzzy.word = *(ziU32*)&pairs;
ZI_WORK->unk_0x1B28.word = *(ziU32*)&pairs;
}
return 1;
}
@@ -158,7 +158,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
length = length - parameters->firstCandidate;
if (countOnly != 0) {
parameters->letters = length;
ZI_WORK->maxWordLength = 0xff;
ZI_WORK->unk_0x0A = 0xff;
return 1;
}
if (parameters->maxCandidates < length) length = parameters->maxCandidates;
@@ -175,7 +175,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
current = signatures.first;
length = signatures.length;
}
if (length > ZI_WORK->maxWordLength) length = ZI_WORK->maxWordLength;
if (length > ZI_WORK->unk_0x0A) length = ZI_WORK->unk_0x0A;
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) && length > parameters->elementCount) {
length = parameters->elementCount;
@@ -185,7 +185,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
if (parameters->letters == 2) {
current = signatures.second;
length = secondLength;
if (length > ZI_WORK->maxWordLength) length = ZI_WORK->maxWordLength;
if (length > ZI_WORK->unk_0x0A) length = ZI_WORK->unk_0x0A;
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) && length > parameters->elementCount) {
length = parameters->elementCount;
@@ -194,7 +194,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
*output++ = 0;
}
*output++ = 0;
ZI_WORK->maxWordLength = 0xff;
ZI_WORK->unk_0x0A = 0xff;
return 1;
}
@@ -226,7 +226,7 @@ static ziBool Zi8ZhSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED_WO
length = length - parameters->firstCandidate;
if (countOnly != 0) {
parameters->letters = length;
ZI_WORK->maxWordLength = 0xff;
ZI_WORK->unk_0x0A = 0xff;
return 1;
}
if (parameters->maxCandidates < length) length = parameters->maxCandidates;
@@ -279,13 +279,13 @@ static ziBool Zi8ZhSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED_WO
ziU8 _Zi8GetCandidates(ziGetParam* parameters ZI_NEED_WORK) {
ZiCandidateOptions options = {0};
options.capacity = ZI_WORK->capacity;
options.capacity = ZI_WORK->unk_0x141A;
return Zi8GetCandidatesOrCount(parameters, &options, ZI_WORK);
}
ziU8 _Zi8CheckCandidates(ziGetParam* parameters ZI_NEED_WORK) {
ZiCandidateOptions options = {0};
options.capacity = ZI_WORK->capacity;
options.capacity = ZI_WORK->unk_0x141A;
options.flags = 1;
return Zi8GetCandidatesOrCount(parameters, &options, ZI_WORK);
}
@@ -324,7 +324,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
saved.savedCandidates = 0;
saved.restoreCandidates = 0;
if (options->lookupMode == '\0') {
if (((ZI_WORK->getcPhase == '\t') && (parameters->elementCount != 0)) &&
if (((ZI_WORK->unk_0x00 == '\t') && (parameters->elementCount != 0)) &&
(((parameters->elements[parameters->elementCount - 1] == 0xEFF8 &&
((ziU8)Zi8AlphaSignature(parameters,options->countOnly,ZI_WORK) != 0)) ||
((parameters->elements[parameters->elementCount - 1] == 0xEF04 &&
@@ -339,22 +339,22 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
if ((parameters->elementCount == 1) && (parameters->firstCandidate == 0)) {
switch (parameters->language) {
case 1:
if ((ZI_WORK->getcPhase == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
switch(ZI_WORK->getcPhase) {
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
switch(ZI_WORK->unk_0x00) {
case '\0':
if (parameters->elements[0] == 0xEF04) {
ZI_WORK->countOnly = options->countOnly;
ZI_WORK->getcPhase = '\x01';
ZI_WORK->unk_0x00 = '\x01';
}
break;
case '\x02':
case '\x04':
case '\x06':
if (parameters->elements[0] == 0xEF04) {
++ZI_WORK->getcPhase;
++ZI_WORK->unk_0x00;
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\x01':
@@ -362,17 +362,17 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
case '\x05':
case '\a':
if (parameters->elements[0] == 0xEF01) {
++ZI_WORK->getcPhase;
++ZI_WORK->unk_0x00;
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\b':
case '\t':
if ((parameters->elements[0] == 0xEF04) &&
((ziU8)Zi8ZhSignature(parameters,options->countOnly,ZI_WORK) != 0)) {
ZI_WORK->getcPhase = '\t';
ZI_WORK->unk_0x00 = '\t';
candidateCount = (unsigned int)parameters->letters;
if (options->countOnly != '\0') {
parameters->letters = 0;
@@ -381,10 +381,10 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
return candidateCount;
}
default:
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
if ((ZI_WORK->getcPhase == '\0') && (parameters->elements[0] == 0xEF04)) {
ZI_WORK->getcPhase = '\x01';
if ((ZI_WORK->unk_0x00 == '\0') && (parameters->elements[0] == 0xEF04)) {
ZI_WORK->unk_0x00 = '\x01';
}
}
break;
@@ -400,75 +400,75 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
break;
case 0x11:
default:
if ((ZI_WORK->getcPhase == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
switch(ZI_WORK->getcPhase) {
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
switch(ZI_WORK->unk_0x00) {
case '\0':
if (parameters->elements[0] == 0xEFF2) {
ZI_WORK->countOnly = options->countOnly;
ZI_WORK->getcPhase = '\x01';
ZI_WORK->unk_0x00 = '\x01';
}
break;
case '\x01':
if (parameters->elements[0] == 0xEFF3) {
ZI_WORK->getcPhase = '\x02';
ZI_WORK->unk_0x00 = '\x02';
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\x02':
if (parameters->elements[0] == 0xEFF5) {
ZI_WORK->getcPhase = '\x03';
ZI_WORK->unk_0x00 = '\x03';
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\x03':
if (parameters->elements[0] == 0xEFF7) {
ZI_WORK->getcPhase = '\x04';
ZI_WORK->unk_0x00 = '\x04';
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\x04':
if (parameters->elements[0] == 0xEFF8) {
ZI_WORK->getcPhase = '\x05';
ZI_WORK->unk_0x00 = '\x05';
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\x05':
if (parameters->elements[0] == 0xEFF9) {
ZI_WORK->getcPhase = '\x06';
ZI_WORK->unk_0x00 = '\x06';
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\x06':
if (parameters->elements[0] == 0xEFF2) {
ZI_WORK->getcPhase = '\a';
ZI_WORK->unk_0x00 = '\a';
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\a':
if (parameters->elements[0] == 0xEFF5) {
ZI_WORK->getcPhase = '\b';
ZI_WORK->unk_0x00 = '\b';
}
else {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\b':
case '\t':
if ((parameters->elements[0] == 0xEFF8) &&
((ziU8)Zi8AlphaSignature(parameters,options->countOnly,ZI_WORK) != 0)) {
ZI_WORK->getcPhase = '\t';
ZI_WORK->unk_0x00 = '\t';
candidateCount = (unsigned int)parameters->letters;
if (options->countOnly != '\0') {
parameters->letters = 0;
@@ -477,24 +477,24 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
return candidateCount;
}
default:
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
if ((ZI_WORK->getcPhase == '\0') && (parameters->elements[0] == 0xEFF2)) {
ZI_WORK->getcPhase = '\x01';
if ((ZI_WORK->unk_0x00 == '\0') && (parameters->elements[0] == 0xEFF2)) {
ZI_WORK->unk_0x00 = '\x01';
}
}
break;
}
}
else if (1 < parameters->elementCount) {
ZI_WORK->getcPhase = '\0';
ZI_WORK->unk_0x00 = '\0';
}
}
ZI_WORK->subLanguage = parameters->subLanguage;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1,ZI_WORK) & 2;
options->maxCount = ZI_WORK->unk_0x10;
options->maxWordLength = ZI_WORK->maxWordLength;
ZI_WORK->maxWordLength = -1;
options->maxWordLength = ZI_WORK->unk_0x0A;
ZI_WORK->unk_0x0A = -1;
if ((ziU8)Zi8LangSupported(parameters->language,ZI_WORK) == 0) {
Zi8LogError(0x163,ZI_WORK);
return 0;
@@ -521,7 +521,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
((ziU8)Zi8IsCharacter(parameters->elements[0],ZI_WORK) != 0)))) {
saved.convertedElementCount = Zi8GetCharInfo(parameters->elements[0],characterInfo,0x10,1,ZI_WORK);
if (saved.convertedElementCount == 0) {
parameters->letters = parameters->completion = parameters->count = 0;
parameters->letters = parameters->count = parameters->unk_0x20 = 0;
candidateCount = 0;
error = 900;
}
@@ -540,7 +540,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
parameters->elements = saved.savedElements;
parameters->elementCount = saved.savedElementCount;
parameters->getMode = saved.savedGetMode;
parameters->completion = 1;
parameters->count = 1;
}
}
else if ((parameters->language == 1) && (parameters->getMode == 0xf)) {
@@ -711,6 +711,6 @@ void Zi8Memcpy(ziU8* destination, ziU8* source, ziS32 count) {
}
ziBool Zi8SetMaxWordLength(ziU8 length ZI_NEED_WORK) {
ZI_WORK->maxWordLength = length;
ZI_WORK->unk_0x0A = length;
return 1;
}

View File

@@ -18,12 +18,12 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
Zi8Memset(__zi8_work_data, 0, 0x1B44);
ZI_WORK->unk_0x08 = 1;
ZI_WORK->unk_0x09 = 1;
ZI_WORK->maxWordLength = 0xFF;
ZI_WORK->unk_0x0A = 0xFF;
ZI_WORK->unk_0x10 = 0x64;
*(ziU16*)&ZI_WORK->targetCount = 0xFFFF;
*(ziU16*)&ZI_WORK->unk_0x0C = 0xFFFF;
ZI_WORK->separator = 0x20;
ZI_WORK->unk_0x1C[2] = 0;
ZI_WORK->koAltTables = 0;
ZI_WORK->unk_0x1B30 = 0;
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
@@ -44,17 +44,17 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
ZI_WORK->unk_0x1874 = 0x2D;
ZI_WORK->language = 0;
ZI_WORK->unk_0x1C[3] = 0;
ZI_WORK->capacity = 0x100;
ZI_WORK->unk_0x141A = 0x100;
Zi8SetLatinSearchOrder(0, 0, ZI_WORK);
ZADP_Zi8SetPDremoveOpt(1, ZI_WORK);
ZI_WORK->zhPudMinPrefix = 5;
ZI_WORK->unk_0x17 = 5;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->pyFuzzy.bits.msb = 1;
ZI_WORK->unk_0x1B28.bits.msb = 1;
ZI_WORK->unk_0x1B2C.bits.msb = 1;
zyFuzzy = ZI_WORK->unk_0x1B2C.word;
pzyFuzzy = &zyFuzzy;
Zi8ZHsetZYfuzzyPairs(pzyFuzzy, ZI_WORK);
pyFuzzy = ZI_WORK->pyFuzzy.word;
pyFuzzy = ZI_WORK->unk_0x1B28.word;
ppyFuzzy = &pyFuzzy;
Zi8ZHsetPYfuzzyPairs(ppyFuzzy, ZI_WORK);
Zi8SetParentalControls(2, ZI_WORK);

View File

@@ -65,19 +65,19 @@ ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
}
}
e = (ziU8*)table;
if (WORKP->unicodeMap != ZI8_NULL && WORKP->unicodeMapSubLang == WORKP->subLanguage) {
if ((ziU16)ch >= WORKP->unicodeRange1Min && (ziU16)ch <= WORKP->unicodeRange1Max) {
i = (ziU16)(ch - WORKP->unicodeRange1Min);
if (WORKP->unk_0x1B18 != ZI8_NULL && WORKP->unk_0x1B24 == WORKP->subLanguage) {
if ((ziU16)ch >= WORKP->unk_0x1B1C && (ziU16)ch <= WORKP->unk_0x1B1E) {
i = (ziU16)(ch - WORKP->unk_0x1B1C);
goto map;
}
if ((ziU16)ch >= WORKP->unicodeRange2Min && (ziU16)ch <= WORKP->unicodeRange2Max) {
i = (ziU16)(WORKP->unicodeRange1Max + (ch - WORKP->unicodeRange2Min) -
WORKP->unicodeRange1Min + 1);
if ((ziU16)ch >= WORKP->unk_0x1B20 && (ziU16)ch <= WORKP->unk_0x1B22) {
i = (ziU16)(WORKP->unk_0x1B1E + (ch - WORKP->unk_0x1B20) -
WORKP->unk_0x1B1C + 1);
goto map;
}
return 0xFFFF;
map:
i = WORKP->unicodeMap[i];
i = WORKP->unk_0x1B18[i];
if (i != 0xFFFF) {
e = (ziU8*)table + i * 0xC;
if (hi == e[6] && lo == e[7]) {

View File

@@ -102,7 +102,7 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
wordSize = *word++;
entrySize = wordSize;
if (language == 1) {
if (ZI_WORK->zhPudMinPrefix > *word) goto next;
if (ZI_WORK->unk_0x17 > *word) goto next;
wordSize--;
entrySize--;
word++;
@@ -126,7 +126,7 @@ matchText:
if (pattern[index] != Zi8ConvertUC2Key(word[index], language, __zi8_work_data)) goto next;
} else {
folded = Zi8ConvertUC2WC(word[index], language, __zi8_work_data);
if (folded != pattern[index] && (!ZI_WORK->ignoreCase || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
if (folded != pattern[index] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
}
}
matched:

View File

@@ -41,7 +41,7 @@ ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
current = ZI_WORK->uwdList;
while (current != 0) {
candidate = (ziUserWord*)current->word;
if (ZI_WORK->uwdPrioritySort == 1 && candidate->priority < word->priority) break;
if (ZI_WORK->unk_0x12E == 1 && candidate->priority < word->priority) break;
if (candidate->length == length) {
position = 0;
while (position < length) {
@@ -105,11 +105,11 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
int position;
int prefixLength;
Zi8LogError(100, __zi8_work_data);
if (!(ZI_WORK->uwdDictCount <= 2 && ZI_WORK->uwdDictCount != 0 && ZI_WORK->uwdDicts[ZI_WORK->uwdDictCount - 1] != 0)) {
if (!(ZI_WORK->unk_0x138 <= 2 && ZI_WORK->unk_0x138 != 0 && ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1] != 0)) {
Zi8ReplaceLastError(0x19C, __zi8_work_data);
return 0;
}
dictionary = ZI_WORK->uwdDicts[ZI_WORK->uwdDictCount - 1];
dictionary = ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1];
if (continuation != 0) {
text = (ziU8*)Zi8_814803F4(__zi8_work_data);
entryLength = 0;
@@ -148,7 +148,7 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
folded = currentWord[position];
ZI_WORK->unk_0x141[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = 0;
if (ZI_WORK->ignoreCase != 0) {
if (ZI_WORK->unk_0x1F != 0) {
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data)) Zi8ChangeCharCase(0, &folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
}
@@ -192,7 +192,7 @@ next:
if (pattern[position] != Zi8ConvertUC2Key(text[position], language, __zi8_work_data)) goto next;
} else {
folded = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
if (folded != pattern[position] && (!ZI_WORK->ignoreCase || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
if (folded != pattern[position] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
}
}
if (ZI_WORK->unk_0x140 != 0) {

View File

@@ -199,10 +199,10 @@ checkEntry:
}
result = graph + (ziU32)entry[4] * 0x10000 + (((ziU16)entry[5] << 8) + entry[6]);
((zi8DawgCtx*)context)->endNode =
((zi8DawgCtx*)context)->unk_0x338 =
graph + (ziU32)entry[7] * 0x10000 + (((ziU16)entry[8] << 8) + entry[9]);
if (((zi8DawgCtx*)context)->endNode == graph) {
((zi8DawgCtx*)context)->endNode = 0;
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
((zi8DawgCtx*)context)->unk_0x338 = 0;
}
if ((((ziU16)entry[0] << 8) + entry[1]) == 0) {

View File

@@ -52,7 +52,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
result = 0;
state.characterIndex = 0xFF;
state.currentCandidate = params->firstCandidate;
params->letters = params->completion = params->count = 0;
params->letters = params->count = params->unk_0x20 = 0;
if ((argument != 0) && (*argument != 0)) {
Zi8LogError(0x7D0, workData);
return 0;
@@ -104,7 +104,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
state.characterIndex,
(state.elementIndex - currentCharacter) - 1,
workData);
if ((((struct __zi8_work_data_s*)workData)->koAltTables == 1)) {
if ((((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 1)) {
switch (state.characterIndex) {
case 1:
selectedTable = (ziU8*)Zi8GetTableAddress(ZI8_LANG_KO, 0x1E, workData);
@@ -179,13 +179,13 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
} else {
params->candidates[(ziU8)result] =
((ziU16)selectedTable[state.nextIndex * 2] << 8) | (selectedTable + state.nextIndex * 2)[1];
if ((state.tableCount6 != 0) && (((struct __zi8_work_data_s*)workData)->koAltTables == 0)) {
if ((state.tableCount6 != 0) && (((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 0)) {
params->candidates[(ziU8)result] += state.inputIndex * state.tableCount3;
}
result++;
}
if (currentCharacter == 0) {
params->completion = state.matched + 1;
params->count = state.matched + 1;
}
currentCharacter += state.matched;
} else {
@@ -199,14 +199,14 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
state.currentCandidate--;
}
if (currentCharacter == 0) {
params->completion = 1;
params->count = 1;
}
} else {
for (state.index = 0; state.index < state.tableCount31; state.index++) {
if ((state.table31[(state.index * 3)] == buffer[currentCharacter]) &&
((state.table31 + state.index * 3)[1] == buffer[currentCharacter + 1])) {
if (currentCharacter == 0) {
params->completion = 1;
params->count = 1;
}
params->candidates[(ziU8)result] =
state.tableCount0 + (state.table31 + state.index * 3)[2];
@@ -218,7 +218,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
if (state.index == state.tableCount31) {
if ((params->candidates[(ziU8)result] = buffer[currentCharacter]) < 0xFF) {
if (currentCharacter == 0) {
params->completion = 1;
params->count = 1;
}
params->candidates[(ziU8)result] += state.tableCount0;
result++;
@@ -249,7 +249,7 @@ ziU8 Zi8MatchKoreanSequence(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 c
firstCharacter = input[0];
mappedCharacter = 0xFF;
if (((struct __zi8_work_data_s*)workData)->koAltTables == 0) {
if (((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 0) {
table = (ziU8*)Zi8GetTableAddress(ZI8_LANG_KO, 3, workData);
tableCount = Zi8GetTableCount(ZI8_LANG_KO, 3, workData);
} else {

View File

@@ -309,7 +309,7 @@ ziU32 Zi8GetKOcandidates(ziGetParam* param, ZiKoreanCandidateOptions* options ZI
}
if (options->countOnly == 0) {
param->letters = 0;
param->count = 0;
param->unk_0x20 = 0;
param->candidates[0] = 0;
}
Zi8LogError(100, ZI_WORK);
@@ -365,22 +365,22 @@ match_word:
return options->maxCount;
}
param->candidates[search.candidateCount++] = search.character;
++param->count;
++param->unk_0x20;
if (++param->letters >= param->maxCandidates) {
return param->letters;
}
}
} else {
param->candidates[search.candidateCount++] = search.character;
++param->count;
++param->unk_0x20;
if (++param->letters >= param->maxCandidates) {
Zi8_814834AC(param, &search.remainingCandidates, &search.candidateCount, &search.inserted, ZI_WORK);
param->count = search.candidateCount;
param->unk_0x20 = search.candidateCount;
param->letters = search.candidateCount;
if (search.candidateCount < param->maxCandidates) goto skip_word;
if (options->countOnly != 0) {
if ((search.prefixCount += search.candidateCount) >= (ziS32)options->maxCount) return options->maxCount;
param->count = 0;
param->unk_0x20 = 0;
param->letters = 0;
search.candidateCount = 0;
} else {
@@ -395,17 +395,17 @@ match_word:
if ((search.candidateIndex == search.candidateCount) &&
(Zi8_814833F0(param, search.character, ZI_WORK) == 0)) {
param->candidates[search.candidateCount++] = search.character;
++param->count;
++param->unk_0x20;
if (++param->letters < param->maxCandidates) {
goto skip_word;
}
Zi8_814834AC(param, &search.remainingCandidates, &search.candidateCount, &search.inserted, ZI_WORK);
param->count = search.candidateCount;
param->unk_0x20 = search.candidateCount;
param->letters = search.candidateCount;
if (search.candidateCount < param->maxCandidates) goto skip_word;
if (options->countOnly != 0) {
if ((search.prefixCount += search.candidateCount) >= (ziS32)options->maxCount) return options->maxCount;
param->count = 0;
param->unk_0x20 = 0;
param->letters = 0;
search.candidateCount = 0;
} else {
@@ -435,7 +435,7 @@ search_table:
if ((search.prefixCount += search.candidateCount) >= (ziS32)options->maxCount) return options->maxCount;
search.resultCount = search.prefixCount;
}
param->count = search.candidateCount;
param->unk_0x20 = search.candidateCount;
param->letters = search.candidateCount;
}
if (param->elementCount > 9) {

View File

@@ -45,7 +45,7 @@ posEntry:
if (pattern[position] == Zi8ConvertWC2Key(word[position], language, __zi8_work_data)) continue;
break;
} else if (word[position] != pattern[position]) {
if (!ZI_WORK->ignoreCase || language == 1) break;
if (!ZI_WORK->unk_0x1F || language == 1) break;
folded = pattern[position];
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data) || folded != word[position]) break;
}

View File

@@ -239,7 +239,7 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
if ((request->getMode == '\x01') || (request->getMode == '\f')) {
match->nCand = Zi8GetPyPhonetic(request->elements,elementCount,match->phon,match->phon2,
&request->completion,&match->first,&match->first2,__zi8_work_data);
&request->count,&match->first,&match->first2,__zi8_work_data);
}
else {
initial = 0;
@@ -250,7 +250,7 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
previousFinal = 0;
buffers.phoneticInput = request->elements;
match->nCand = 0;
request->completion = request->elementCount;
request->count = request->elementCount;
phoneticLength = 1;
for (index = 0; index < elementCount; index++) {
stroke = Zi8GetBpmfPhonetic(buffers.phoneticInput,phoneticLength,&initial,&final,&bestInitial,&bestFinal,
@@ -287,7 +287,7 @@ savePhonetic:
goto savePhonetic;
}
if (match->nCand == 1) {
request->completion = phoneticLength - 1;
request->count = phoneticLength - 1;
}
buffers.phoneticInput = buffers.phoneticInput + phoneticLength - 1;
phoneticLength = 0;
@@ -306,7 +306,7 @@ savePhonetic:
}
}
if (((request->context & contextMask) != 0) &&
((1 < match->nCand || (request->completion != elementCount)))) {
((1 < match->nCand || (request->count != elementCount)))) {
match->phon[0] = 0xFFFF;
match->phon2[0] = 0xFFFF;
match->nCand = 0;

View File

@@ -152,10 +152,10 @@ u32 __SCGetConfBufSize();
typedef struct SC_BT_DEV_INFO {
u8 devName[20]; // 0x00
u8 pad_0x14; // 0x14
u8 pad_0x15[0xB]; // 0x15
u8 unk_0x14;
u8 unk_0x15[0xB];
LINK_KEY linkKey; // 0x20
u8 pad_0x30[0x10]; // 0x30
u8 unk_0x30[0x10];
} SC_BT_DEV_INFO;
typedef struct SCBtDeviceInfo {

View File

@@ -10,7 +10,7 @@ extern "C" {
#endif
typedef void (*USBCallback)(IOSError result, void* arg);
typedef void (*USBIsoCallback)(IOSError err, void* isoArg, void* cbArg);
typedef void (*USBIsoCallback)(IOSError err, void* unkIsoArg, void* cbArg);
IOSError IUSB_OpenLib();
IOSError IUSB_CloseLib();

View File

@@ -133,11 +133,11 @@ typedef struct WPADExtConfig {
union {
struct WPADFSConfig {
s16 stickXCenter; // 0x00
s16 stickXMin; // 0x02
s16 stickXMax; // 0x04
s16 unk_0x02; // 0x02
s16 unk_0x04; // 0x04
s16 stickYCenter; // 0x06
s16 stickYMin; // 0x08
s16 stickYMax; // 0x0A
s16 unk_0x08; // 0x08
s16 unk_0x0A; // 0x0A
s16 accX0g; // 0x0C
s16 accY0g; // 0x0E
@@ -150,18 +150,18 @@ typedef struct WPADExtConfig {
struct WPADCLConfig {
s16 lStickXCenter; // 0x00
s16 lStickXMin; // 0x02
s16 lStickXMax; // 0x04
s16 unk_0x02; // 0x02
s16 unk_0x04; // 0x04
s16 lStickYCenter; // 0x06
s16 lStickYMin; // 0x08
s16 lStickYMax; // 0x0A
s16 unk_0x08; // 0x08
s16 unk_0x0A; // 0x0A
s16 rStickXCenter; // 0x0C
s16 rStickXMin; // 0x0E
s16 rStickXMax; // 0x10
s16 unk_0x0E; // 0x0E
s16 unk_0x10; // 0x10
s16 rStickYCenter; // 0x12
s16 rStickYMin; // 0x14
s16 rStickYMax; // 0x16
s16 unk_0x14; // 0x14
s16 unk_0x16; // 0x16
u8 triggerLZero; // 0x18
u8 triggerRZero; // 0x19
@@ -171,7 +171,7 @@ typedef struct WPADExtConfig {
typedef struct WPADCB {
WPADGameInfo gameInfo; // 0x00
s32 gameInfoStatus[2]; // 0x38
s32 unk_0x38[2];
u8 rxBufMain[RX_BUFFER_SIZE]; // 0x40
u8 rxBufs[2][RX_BUFFER_SIZE]; // 0xA0
WPADCommandQueue stdCmdQueue; // 0x160
@@ -223,7 +223,7 @@ typedef struct WPADCB {
u16 filterDiffExt; // 0x900
u16 filterSameExt; // 0x902
s64 lastReportSendTime; // 0x908
u8 suppressDisconnect; // 0x910
u8 unk_0x910;
u8 calibrated; // 0x911
u16 comboHeld; // 0x912
u8 encryptionKey[16]; // 0x914

View File

@@ -26,7 +26,7 @@ typedef struct USBKBDCmdLED {
typedef struct USBKBDCmdLEDAsync {
USBKBDCmdLED base; // 0x00
u8 pad_0x08[0x10]; // 0x08
u8 unk_0x08[0x10];
USBKBDCmdLEDCallback cb; // 0x18
void* cbArg; // 0x1C
} USBKBDCmdLEDAsync;

View File

@@ -66,16 +66,16 @@
typedef struct
{
HC_BT_HDR *p_rx_msg[3]; // 0x00
UINT16 bytes_left[3]; // 0x0c
UINT16 buf_size; // 0x12
UINT8 pkt_type[3]; // 0x14
UINT8 len_hi[3]; // 0x17
UINT8 rx_state[3]; // 0x1a
HC_BT_HDR *at_0x00[3]; // 0x00
UINT16 at_0x0c[3]; // 0x0c
UINT16 at_0x12; // 0x12
UINT8 at_0x14[3]; // 0x14
UINT8 at_0x17[3]; // 0x17
UINT8 at_0x1a[3]; // 0x1a
char pad4_[1]; // 0x1d
UINT8 open_state; // 0x1e
UINT8 task_id; // 0x1f
UINT8 mbox; // 0x20
UINT8 at_0x1e; // 0x1e
UINT8 at_0x1f; // 0x1f
UINT8 at_0x20; // 0x20
char pad5_[2]; // 0x21
/* 1 byte padding */
} tHCISU_H2_CB; // size 0x24
@@ -135,7 +135,7 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
UINT8 msg_received;
UINT16 r27;
if (p_cb->open_state != 2)
if (p_cb->at_0x1e != 2)
return 0;
r27 = pipe + 1;
@@ -148,36 +148,36 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
++bytes_read;
msg_received = FALSE;
switch (p_cb->rx_state[pipe])
switch (p_cb->at_0x1a[pipe])
{
case 0:
if (r27 == 1)
{
p_cb->p_rx_msg[pipe] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->pkt_type[pipe] = 4;
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->at_0x14[pipe] = 4;
}
else if (r27 == 2)
{
p_cb->p_rx_msg[pipe] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->pkt_type[pipe] = 2;
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->at_0x14[pipe] = 2;
}
else if (r27 == 3)
{
p_cb->p_rx_msg[pipe] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->pkt_type[pipe] = 3;
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->at_0x14[pipe] = 3;
}
else
{
break;
}
if (p_cb->p_rx_msg[pipe])
if (p_cb->at_0x00[pipe])
{
p_cb->p_rx_msg[pipe]->len = 0;
p_cb->p_rx_msg[pipe]->event =
hcisu_msg_evt_table[p_cb->pkt_type[pipe] - 1];
p_cb->p_rx_msg[pipe]->offset = 0;
p_cb->rx_state[pipe] = 1;
p_cb->at_0x00[pipe]->len = 0;
p_cb->at_0x00[pipe]->event =
hcisu_msg_evt_table[p_cb->at_0x14[pipe] - 1];
p_cb->at_0x00[pipe]->offset = 0;
p_cb->at_0x1a[pipe] = 1;
}
else
{
@@ -185,54 +185,54 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
"HCIS: Unable to allocate buffer for incoming HCI "
"message.");
p_cb->rx_state[pipe] = 2;
p_cb->at_0x1a[pipe] = 2;
}
p_cb->bytes_left[pipe] =
hcisu_preamble_table[p_cb->pkt_type[pipe] - 1];
p_cb->at_0x0c[pipe] =
hcisu_preamble_table[p_cb->at_0x14[pipe] - 1];
/* fallthrough */
case 1:
*((UINT8 *)(p_cb->p_rx_msg[pipe] + 1)
+ p_cb->p_rx_msg[pipe]->len++) = byte;
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
--p_cb->bytes_left[pipe];
--p_cb->at_0x0c[pipe];
if (p_cb->bytes_left[pipe] == 0)
if (p_cb->at_0x0c[pipe] == 0)
{
msg_len = byte;
if (p_cb->pkt_type[pipe] == 2)
if (p_cb->at_0x14[pipe] == 2)
{
msg_len = (msg_len << 8) + p_cb->len_hi[pipe];
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
if ((p_cb->p_rx_msg[pipe] =
if ((p_cb->at_0x00[pipe] =
(HC_BT_HDR *)l2cap_link_chk_pkt_start(
(BT_HDR *)p_cb->p_rx_msg[pipe]))
(BT_HDR *)p_cb->at_0x00[pipe]))
== 0)
{
p_cb->bytes_left[pipe] = msg_len;
p_cb->at_0x0c[pipe] = msg_len;
if (msg_len == 0)
p_cb->rx_state[pipe] = 0;
p_cb->at_0x1a[pipe] = 0;
else
p_cb->rx_state[pipe] = 4;
p_cb->at_0x1a[pipe] = 4;
break;
}
}
p_cb->bytes_left[pipe] = msg_len;
p_cb->at_0x0c[pipe] = msg_len;
if (sizeof(HC_BT_HDR)
+ hcisu_preamble_table[p_cb->pkt_type[pipe] - 1]
+ hcisu_preamble_table[p_cb->at_0x14[pipe] - 1]
+ msg_len
> GKI_get_buf_size(p_cb->p_rx_msg[pipe]))
> GKI_get_buf_size(p_cb->at_0x00[pipe]))
{
GKI_freebuf(p_cb->p_rx_msg[pipe]);
p_cb->p_rx_msg[pipe] = NULL;
p_cb->rx_state[pipe] = 4;
GKI_freebuf(p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
p_cb->at_0x1a[pipe] = 4;
BT_TRACE(HCI, ERROR,
"HCIS: Invalid length for incoming HCI message.");
@@ -242,85 +242,85 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
if (msg_len != 0)
{
p_cb->rx_state[pipe] = 3;
p_cb->at_0x1a[pipe] = 3;
}
else
{
msg_received = TRUE;
p_cb->rx_state[pipe] = 0;
p_cb->at_0x1a[pipe] = 0;
}
}
else
{
p_cb->len_hi[pipe] = byte;
p_cb->at_0x17[pipe] = byte;
}
break;
case 2:
--p_cb->bytes_left[pipe];
--p_cb->at_0x0c[pipe];
if (p_cb->bytes_left[pipe] == 0)
if (p_cb->at_0x0c[pipe] == 0)
{
msg_len = byte;
if (p_cb->pkt_type[pipe] == 2)
msg_len = (msg_len << 8) + p_cb->len_hi[pipe];
if (p_cb->at_0x14[pipe] == 2)
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
p_cb->bytes_left[pipe] = msg_len;
p_cb->rx_state[pipe] = 4;
p_cb->at_0x0c[pipe] = msg_len;
p_cb->at_0x1a[pipe] = 4;
}
else
{
p_cb->len_hi[pipe] = byte;
p_cb->at_0x17[pipe] = byte;
}
break;
case 3:
*((UINT8 *)(p_cb->p_rx_msg[pipe] + 1)
+ p_cb->p_rx_msg[pipe]->len++) = byte;
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
--p_cb->bytes_left[pipe];
--p_cb->at_0x0c[pipe];
len = UUSB_Read(pipe + 1,
(UINT8 *)(p_cb->p_rx_msg[pipe] + 1)
+ p_cb->p_rx_msg[pipe]->len,
p_cb->bytes_left[pipe]);
(UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len,
p_cb->at_0x0c[pipe]);
p_cb->p_rx_msg[pipe]->len += len;
p_cb->bytes_left[pipe] -= len;
p_cb->at_0x00[pipe]->len += len;
p_cb->at_0x0c[pipe] -= len;
bytes_read += len;
if (p_cb->bytes_left[pipe] == 0)
if (p_cb->at_0x0c[pipe] == 0)
{
if (p_cb->pkt_type[pipe] == 2
if (p_cb->at_0x14[pipe] == 2
&& l2cap_link_chk_pkt_end() == 0)
{
p_cb->rx_state[pipe] = 0;
p_cb->at_0x1a[pipe] = 0;
}
else
{
msg_received = TRUE;
p_cb->rx_state[pipe] = 0;
p_cb->at_0x1a[pipe] = 0;
}
}
break;
case 4:
--p_cb->bytes_left[pipe];
--p_cb->at_0x0c[pipe];
if (p_cb->bytes_left[pipe] == 0)
p_cb->rx_state[pipe] = 0;
if (p_cb->at_0x0c[pipe] == 0)
p_cb->at_0x1a[pipe] = 0;
break;
}
if (msg_received)
{
GKI_send_msg(hcisu_h2_cb.task_id, 0, p_cb->p_rx_msg[pipe]);
p_cb->p_rx_msg[pipe] = NULL;
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
}
}
@@ -382,7 +382,7 @@ void hcisu_h2_send_msg_now(tHCISU_H2_CB *cb, HC_BT_HDR *p_msg)
{
p_msg->event = MSG_HC_TO_STACK_L2C_SEG_XMIT;
GKI_send_msg(hcisu_h2_cb.task_id, 0, p_msg);
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_msg);
return;
}
@@ -405,15 +405,15 @@ void hcisu_h2_send_msg(tHCISU_H2_CB *p_cb, HC_BT_HDR *p_msg)
void hcisu_h2_init(UINT8 taskId, UINT8 mbox, UINT16 bufSize)
{
hcisu_h2_cb.open_state = 0;
hcisu_h2_cb.at_0x1e = 0;
hcisu_h2_cb.rx_state[0] = 0;
hcisu_h2_cb.rx_state[1] = 0;
hcisu_h2_cb.rx_state[2] = 0;
hcisu_h2_cb.at_0x1a[0] = 0;
hcisu_h2_cb.at_0x1a[1] = 0;
hcisu_h2_cb.at_0x1a[2] = 0;
hcisu_h2_cb.task_id = taskId;
hcisu_h2_cb.mbox = mbox;
hcisu_h2_cb.buf_size = bufSize;
hcisu_h2_cb.at_0x1f = taskId;
hcisu_h2_cb.at_0x20 = mbox;
hcisu_h2_cb.at_0x12 = bufSize;
}
BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)
@@ -424,9 +424,9 @@ BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)
uusb.at_0x0b = 0;
uusb.at_0x04 = p_cfg->at_0x00;
uusb.at_0x06 = p_cfg->at_0x02;
uusb.at_0x08 = hcisu_h2_cb.task_id;
uusb.at_0x08 = hcisu_h2_cb.at_0x1f;
hcisu_h2_cb.open_state = 2;
hcisu_h2_cb.at_0x1e = 2;
UUSB_Register(&uusb);
UUSB_Open(&uusb, &hcisu_h2_usb_cback);
@@ -436,7 +436,7 @@ BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)
void hcisu_h2_close(void)
{
hcisu_h2_cb.open_state = 0;
hcisu_h2_cb.at_0x1e = 0;
UUSB_Close();
UUSB_Unregister();
@@ -454,7 +454,7 @@ int hcisu_h2_handle_event(UINT16 len)
UINT16 bytes_read;
bytes_read = hcisu_h2_receive_msg(
len - sizeof(HC_BT_HDR) - hcisu_h2_cb.buf_size, &hcisu_h2_cb);
len - sizeof(HC_BT_HDR) - hcisu_h2_cb.at_0x12, &hcisu_h2_cb);
return 0;
}

View File

@@ -33,7 +33,7 @@ typedef struct
u8 bulkEndpoint1;
u8 bulkEndpoint2;
u8 intrEndpoint1;
u8 intrEndpoint2;
char at_0x13; // intrEndpoint2?
int vid;
int pid;
UINT8 cmd_buffer_pool;
@@ -46,9 +46,9 @@ typedef struct
char pad4_[1];
UINT8 reading_intr_data;
BUFFER_Q bulk_buffer_q;
UINT8 bulk_outstanding;
UINT8 at_0x38;
BUFFER_Q intr_buffer_q;
UINT8 intr_outstanding;
UINT8 at_0x48;
char pad8_[3];
} tUUSB_CB;
@@ -158,7 +158,7 @@ static void uusb_CloseDeviceCB(long result, void *p_data)
usb.bulkEndpoint1 = 0;
usb.bulkEndpoint2 = 0;
usb.intrEndpoint1 = 0;
usb.intrEndpoint2 = 0;
usb.at_0x13 = 0;
usb.fd = 0;
@@ -363,12 +363,12 @@ static void uusb_WriteCtrlDataCB(long result, void *p_data)
GKI_disable();
--usb.intr_outstanding;
--usb.at_0x48;
GKI_enable();
}
if (usb.intr_outstanding >= 5)
if (usb.at_0x48 >= 5)
return;
if (usb.intr_buffer_q.count == 0)
@@ -389,7 +389,7 @@ static void uusb_WriteCtrlDataCB(long result, void *p_data)
{
GKI_disable();
++usb.intr_outstanding;
++usb.at_0x48;
GKI_enable();
}
@@ -411,12 +411,12 @@ static void uusb_WriteBulkDataCB(long result, void *p_data)
GKI_disable();
--usb.bulk_outstanding;
--usb.at_0x38;
GKI_enable();
}
if (usb.bulk_outstanding >= 5)
if (usb.at_0x38 >= 5)
return;
if (usb.bulk_buffer_q.count == 0)
@@ -436,7 +436,7 @@ static void uusb_WriteBulkDataCB(long result, void *p_data)
{
GKI_disable();
++usb.bulk_outstanding;
++usb.at_0x38;
GKI_enable();
}
@@ -504,7 +504,7 @@ void UUSB_Register(tUUSB *uusb)
usb.bulkEndpoint1 = 0;
usb.bulkEndpoint2 = 0;
usb.intrEndpoint1 = 0;
usb.intrEndpoint2 = 0;
usb.at_0x13 = 0;
if (uusb_get_devId(usb.vid, usb.pid) < 0)
return;
@@ -512,13 +512,13 @@ void UUSB_Register(tUUSB *uusb)
usb.bulkEndpoint1 = 2;
usb.bulkEndpoint2 = 130;
usb.intrEndpoint1 = 129;
usb.intrEndpoint2 = 0;
usb.at_0x13 = 0;
GKI_init_q(&usb.bulk_buffer_q);
usb.bulk_outstanding = 0;
usb.at_0x38 = 0;
GKI_init_q(&usb.intr_buffer_q);
usb.intr_outstanding = 0;
usb.at_0x48 = 0;
usb.cmd_buffer_pool = GKI_create_pool(660, 45, 1, NULL);
usb.acl_buffer_pool = GKI_create_pool(1800, 30, 1, NULL);
@@ -607,7 +607,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
memcpy(p_buffer, p_data, len);
if (usb.intr_outstanding < 5 && usb.intr_buffer_q.count == 0)
if (usb.at_0x48 < 5 && usb.intr_buffer_q.count == 0)
{
ret = IUSB_WriteCtrlMsgAsync(usb.fd, 0x20, 0, 0, 0, len, p_buffer,
uusb_WriteCtrlDataCB, p_buf);
@@ -634,7 +634,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
{
GKI_disable();
++usb.intr_outstanding;
++usb.at_0x48;
GKI_enable();
}
@@ -658,7 +658,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
if (len > 190)
UUSBDBG(" woah ! thats pretty Big ! :%d", len);
if (usb.bulk_outstanding < 5 && usb.bulk_buffer_q.count == 0)
if (usb.at_0x38 < 5 && usb.bulk_buffer_q.count == 0)
{
ret = IUSB_WriteBlkMsgAsync(usb.fd, usb.bulkEndpoint1, len,
p_buffer, uusb_WriteBulkDataCB, p_buf);
@@ -685,7 +685,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
{
GKI_disable();
++usb.bulk_outstanding;
++usb.at_0x38;
GKI_enable();
}

View File

@@ -749,8 +749,7 @@ s32 pfd_sddrv_get_total_sectors(u32* sectors, u16* bytes_per_sector) {
minimum_multiplier = multiplier >= 9 ? multiplier : 9;
max_multiplier = minimum_multiplier <= 11 ? minimum_multiplier : 11;
multiplier_factor = 1;
max_multiplier = (u16)(max_multiplier - 9);
multiplier_factor = (u16)(multiplier_factor << max_multiplier);
multiplier_factor <<= (u16)(max_multiplier - 9);
*sectors = cluster_blocks * multiplier_factor;
} else {
*sectors = ((csd[1] >> 8 & 0x3fffff) + 1) * 0x400;

View File

@@ -1,15 +1,11 @@
#include <private/fa/pdm.h>
#include <revolution/types.h>
#define MBR_WORD(buf, offset) (((pf_u32)(buf)[(offset) + 3] << 24) + ((pf_u32)(buf)[(offset) + 2] << 16) + ((pf_u32)(buf)[(offset) + 1] << 8) + (buf)[offset])
static inline pf_u16 read_boot_u16(pf_u8* buf, pf_u32 offset) {
if ((pf_u32)&buf[offset] & 1) { return (buf[offset + 1] << 8) | buf[offset]; }
return PF_SWAP_16(*(pf_u16*)&buf[(offset + 1) & ~1]);
}
static inline pf_u32 read_partition_u32(const pf_u8* buf, pf_u32 offset) {
return (((pf_u32)buf[offset + 2] << 16) + buf[offset]) +
(((pf_u32)buf[offset + 3] << 24) + ((pf_u32)buf[offset + 1] << 8));
}
pf_s32 pdm_part_is_master_boot_sector(pf_u8* buf, pf_u32 total, pf_bool* p_is_mbr) {
pf_s16 index;
pf_u32 start[4];
@@ -22,8 +18,8 @@ pf_s32 pdm_part_is_master_boot_sector(pf_u8* buf, pf_u32 total, pf_bool* p_is_mb
p_count = count;
for (index = 0; index < 4; index++) {
*p_start = 0;
*p_start = read_partition_u32(buf, 454);
*p_count = read_partition_u32(buf, 458);
*p_start = (((pf_u32)buf[456] << 16) + buf[454]) + (((pf_u32)buf[457] << 24) + ((pf_u32)buf[455] << 8));
*p_count = (((pf_u32)buf[460] << 16) + buf[458]) + (((pf_u32)buf[461] << 24) + ((pf_u32)buf[459] << 8));
if (*p_start != 0 && *p_count != 0) {
if (index == 0) { *p_is_mbr = 1; }
} else {
@@ -95,14 +91,14 @@ pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
if (err != 0) { return err; }
pdm_part_is_master_boot_sector(buf, p_part->p_disk->disk_info.total_sectors, &is_mbr);
if (is_mbr) {
start[0] = read_partition_u32(buf, 454);
start[1] = read_partition_u32(buf, 470);
start[2] = read_partition_u32(buf, 486);
start[3] = read_partition_u32(buf, 502);
count[0] = read_partition_u32(buf, 458);
count[1] = read_partition_u32(buf, 474);
count[2] = read_partition_u32(buf, 490);
count[3] = read_partition_u32(buf, 506);
start[0] = MBR_WORD(buf, 454);
start[1] = MBR_WORD(buf, 470);
start[2] = MBR_WORD(buf, 486);
start[3] = MBR_WORD(buf, 502);
count[0] = MBR_WORD(buf, 458);
count[1] = MBR_WORD(buf, 474);
count[2] = MBR_WORD(buf, 490);
count[3] = MBR_WORD(buf, 506);
part_index = 0;
for (index = 0; index < 4; index++) {
sector = start[index];
@@ -116,15 +112,15 @@ pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
sector = base;
for (extended_index = 0; extended_index < 2; extended_index++) {
if (extended_index == 0) {
sector = sector + read_partition_u32(buf, 454);
length = read_partition_u32(buf, 458);
sector = sector + MBR_WORD(buf, 454);
length = MBR_WORD(buf, 458);
err = pdm_disk_physical_read(p_part->p_disk, buf, sector, 1, 512, &success);
if (err != 0) { return err; }
if (requested == part_index) { p_part->start_sector = sector; p_part->total_sector = length; return 0; }
part_index++;
} else {
sector = base + read_partition_u32(buf, 470);
length = read_partition_u32(buf, 474);
sector = base + MBR_WORD(buf, 470);
length = MBR_WORD(buf, 474);
if (sector == 0 || length == 0) { break; }
err = pdm_disk_physical_read(p_part->p_disk, buf, sector, 1, 512, &success);
if (err != 0) { return err; }

View File

@@ -557,11 +557,15 @@ static void kbdSendKey(KBDKeyEventData* event) {
}
}
static inline u32 kbdChannelFlags(u32 channel) {
return kbdData[channel].flags;
}
static void kbd_led_handler(BOOL success, void* callbackArg) {
const KBDLEDCallbackData* callback;
s32 index;
u32 index;
u32 err;
index = (s32)callbackArg;
index = (u32)callbackArg;
callback = &kbdLCBuf[index];
kbdCmdBuf[index].device = 0;
if (callback->callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[index].device) {
@@ -575,11 +579,12 @@ static void kbd_led_handler(BOOL success, void* callbackArg) {
err = 0;
break;
}
kbdLCBuf[(u32)callbackArg].callbackAddress(err, kbdLCBuf[(u32)callbackArg].callbackArg);
kbdLCBuf[index].callbackAddress(err, kbdLCBuf[index].callbackArg);
}
USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback, void* callbackArg) {
u32 index;
s32 index;
u32 ofs;
u8 ledBits;
BOOL interrupts;
USBKBDErr result;
@@ -589,18 +594,14 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
if (channel >= 4) {
return 4;
}
{
KBDChannel* data = &kbdData[(s32)channel];
if ((s32)data->flags == 1 || (s32)data->flags == 4) {
return 5;
}
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
return 5;
}
ledBits = leds;
interrupts = OSDisableInterrupts();
for (index = 0; index < 12; index++) {
if (kbdCmdBuf[(s32)index].device == 0) {
KBDChannel* data = &kbdData[channel];
kbdCmdBuf[(s32)index].device = (u32)data->device;
for (index = 0, ofs = 0; index < 12; index++, ofs += sizeof(KBDLEDCommand)) {
if (*(u32*)&((u8*)kbdCmdBuf)[ofs] == 0) {
*(u32*)&((u8*)kbdCmdBuf)[ofs] = (u32)kbdData[channel].device;
break;
}
}
@@ -608,14 +609,11 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
if (index == 12) {
return 7;
}
{
KBDChannel* data = &kbdData[channel];
kbdLCBuf[index].callbackAddress = callback;
kbdLCBuf[index].callbackArg = callbackArg;
result = USBKBDSetLEDAsync((u32)data->device, ledBits,
(USBKBDCmdLEDAsync*)&kbdCmdBuf[index],
kbd_led_handler, (void*)index);
}
kbdLCBuf[index].callbackAddress = callback;
kbdLCBuf[index].callbackArg = callbackArg;
result = USBKBDSetLEDAsync((u32)kbdData[channel].device, ledBits,
(USBKBDCmdLEDAsync*)&kbdCmdBuf[index],
kbd_led_handler, (void*)index);
switch (result) {
default:
return 7;
@@ -626,6 +624,7 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
u32 index;
KBDLEDCommand* command;
BOOL interrupts;
USBKBDErr result;
u8 ledBits;
@@ -635,16 +634,20 @@ USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
if (channel >= 4) {
return 4;
}
if ((s32)kbdData[(s32)channel].flags == 1 || (s32)kbdData[(s32)channel].flags == 4) {
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
return 5;
}
ledBits = leds & 0xff;
interrupts = OSDisableInterrupts();
for (index = 0; index < 12; index++) {
if (kbdCmdBuf[(s32)index].device == 0) {
kbdCmdBuf[(s32)index].device = (u32)kbdData[channel].device;
index = 0;
command = kbdCmdBuf;
while (index < 12) {
if (command->device == 0) {
command->device = (u32)kbdData[channel].device;
break;
}
index++;
command++;
}
OSRestoreInterrupts(interrupts);
if (index == 12) {
@@ -652,7 +655,7 @@ USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
}
result = USBKBDSetLED((u32)kbdData[channel].device, ledBits,
(USBKBDCmdLED*)&kbdCmdBuf[index]);
kbdCmdBuf[(s32)index].device = 0;
kbdCmdBuf[index].device = 0;
switch (result) {
default:
return 7;

View File

@@ -353,41 +353,38 @@ static void reset_kpad(KPADInside* kpad) {
}
void KPADGetProjectionPos(Vec2* dest, Vec2* src, const Rect* rect, f32 scale) {
f32 aspect;
f32 halfHeight;
f32 half;
f32 x;
f32 height;
height = rect->bottom - rect->top;
half = 0.5f;
halfHeight = height * half;
x = src->x * halfHeight;
aspect = 1.2f;
x = aspect * x;
dest->y = aspect * (src->y * halfHeight);
dest->x = (f32)(x * (0.908 * scale));
f64 scaled;
f32 height = rect->bottom - rect->top;
f32 halfHeight = height * 0.5f;
f32 x = src->x * halfHeight;
f32 y = src->y * halfHeight;
x *= 1.2f;
y *= 1.2f;
scaled = 0.908 * scale;
dest->y = y;
dest->x = (f32)(x * scaled);
}
void KPADSetSensorHeight(s32 chan, f32 sensorHeight) {
KPADInside* kpad;
f32 halfHeightSquared;
f32 halfHeight;
f32 barOffsetX;
f32 barDiagonal;
f32 halfWidthSquared;
f32 halfWidth;
f32 negativeSensorHeight;
f32 zero;
f32 barDiagonalSquared;
f32 halfHeightSquared;
halfWidth = 1.0f;
kpad = chan + inside_kpads;
kpad = &inside_kpads[chan];
halfHeight = 0.75f;
negativeSensorHeight = -sensorHeight;
halfWidthSquared = halfWidth * halfWidth;
halfHeightSquared = halfHeight * halfHeight;
zero = 0.0f;
kpad->sensorBarCenter.x = zero;
kpad->sensorBarCenter.x = 0.0f;
kpad->sensorBarCenter.y = negativeSensorHeight;
barDiagonal = (f32)sqrt(halfWidthSquared + halfHeightSquared);
barDiagonalSquared = halfWidthSquared + halfHeightSquared;
barDiagonal = (f32)sqrt(barDiagonalSquared);
barOffsetX = kpad->sensorBarCenter.x;
if (barOffsetX < 0.0f) {
halfWidth += barOffsetX;
@@ -468,24 +465,29 @@ static void calc_button_repeat(KPADInside* kpad, u8 extension, s32 elapsed) {
}
static void calc_acc_horizon(KPADInside* kpad) {
f32 magnitude;
f32 magnitude = (f32)sqrt(kpad->acceleration.x * kpad->acceleration.x + kpad->acceleration.y * kpad->acceleration.y);
f32 normalizedX;
f32 normalizedY;
f32 targetY;
f32 targetX;
f32 productX;
f32 oldX;
f32 oldY;
f32 blend;
f32 projectedX;
f32 smoothing;
f32 deltaX;
f32 nextX;
f32 nextY;
f32 normalized;
f32 oldCircleY;
f32 circleX;
f32 oldCircleX;
f32 unitY;
f32 unitX;
f32 oldCircleX;
f32 oldCircleY;
f32 unitY;
f32 circleX;
f32 deltaCircleX;
f32 circleY;
f32 deltaCircleY;
magnitude = (f32)sqrt(kpad->acceleration.x * kpad->acceleration.x + kpad->acceleration.y * kpad->acceleration.y);
if (magnitude == 0.0f || magnitude >= 2.0f) {
return;
}
@@ -495,12 +497,17 @@ static void calc_acc_horizon(KPADInside* kpad) {
if (magnitude > 1.0f) {
magnitude = 2.0f - magnitude;
}
targetY = kpad->accelNormal.y;
targetX = kpad->accelNormal.x;
productX = targetX * normalizedX;
oldX = kpad->horizonAxis.x;
oldY = kpad->horizonAxis.y;
blend = magnitude * kp_acc_horizon_pw;
projectedX = kpad->accelNormal.x * normalizedX + kpad->accelNormal.y * normalizedY;
magnitude *= blend;
deltaX = magnitude * (projectedX - kpad->horizonAxis.x);
nextX = kpad->horizonAxis.x + deltaX;
nextY = kpad->horizonAxis.y + magnitude * (((kpad->accelNormal.y * normalizedX) - (kpad->accelNormal.x * normalizedY)) - kpad->horizonAxis.y);
projectedX = productX + targetY * normalizedY;
smoothing = magnitude * blend;
deltaX = smoothing * (projectedX - oldX);
nextX = oldX + deltaX;
nextY = oldY + smoothing * (((targetY * normalizedX) - (targetX * normalizedY)) - oldY);
normalized = (f32)sqrt(nextX * nextX + nextY * nextY);
if (normalized != 0.0f) {
unitX = nextX / normalized;
@@ -781,18 +788,24 @@ nextObject:
static s8 select_1obj_first(KPADInside* kpad) {
KPADDPDObject* object = kpad->dpdState.objects;
f32 offsetX = kpad->horizonTangent.x * kpad->horizonAxis.x + kpad->horizonTangent.y * kpad->horizonAxis.y;
f32 offsetY = kpad->horizonTangent.y * kpad->horizonAxis.x - kpad->horizonTangent.x * kpad->horizonAxis.y;
offsetX *= kpad->dpdObjectScale;
offsetY *= kpad->dpdObjectScale;
KPADDPDObject* end = kpad->dpdState.candidates;
f32 scale = kpad->dpdObjectScale;
f32 productX = kpad->horizonTangent.x * kpad->horizonAxis.x;
f32 productY = kpad->horizonTangent.y * kpad->horizonAxis.x;
f32 offsetX = productX + kpad->horizonTangent.y * kpad->horizonAxis.y;
f32 offsetY = productY - kpad->horizonTangent.x * kpad->horizonAxis.y;
offsetX *= scale;
offsetY *= scale;
do {
if ((s8)object->metadata.bytes.flags == 0) {
f32 x = object->x;
f32 y = object->y;
Vec2 leftPosition;
Vec2 rightPosition;
leftPosition.x = object->x - offsetX;
leftPosition.y = object->y - offsetY;
rightPosition.x = object->x + offsetX;
rightPosition.y = object->y + offsetY;
leftPosition.x = x - offsetX;
leftPosition.y = y - offsetY;
rightPosition.x = x + offsetX;
rightPosition.y = y + offsetY;
if (leftPosition.x <= kpad->value4F4 || leftPosition.x >= kpad->value4FC || leftPosition.y <= kpad->value4F8 || leftPosition.y >= kpad->value500) {
if (rightPosition.x > kpad->value4F4 && rightPosition.x < kpad->value4FC && rightPosition.y > kpad->value4F8 && rightPosition.y < kpad->value500) {
kpad->dpdState.candidates[1] = *object;
@@ -809,7 +822,7 @@ static s8 select_1obj_first(KPADInside* kpad) {
return -1;
}
}
} while (++object < kpad->dpdState.candidates);
} while (++object < end);
return 0;
}

View File

@@ -41,13 +41,13 @@ typedef struct USBCommandBlock {
USBCallback callback; // 0x00
USBIsoCallback isoCallback; // 0x04
void* callbackArg; // 0x08
void* isoArg; // 0x0C
void* unkIsoArg; // 0x0C
char pad_0x10[0x4];
char unk_0x10[0x4];
void* clean[USB_NCLEAN_MAX]; // 0x14
u32 nclean; // 0x34
char pad_0x38[0x40 - 0x38];
char unk_0x38[0x40 - 0x38];
union {
char path[FS_MAX_PATH];
USBMsg msg;
@@ -174,7 +174,7 @@ static s32 _intrBlkCtrlIsoCb(s32 result, void* arg) {
block->callback(result, block->callbackArg);
} else if (block->isoCallback != NULL) {
USB_LOG("calling iso callback\n");
block->isoCallback(result, block->isoArg, block->callbackArg);
block->isoCallback(result, block->unkIsoArg, block->callbackArg);
}
IOSFree(block);

View File

@@ -7,9 +7,9 @@
static struct {
struct {
OSMessageQueue* queue; // 0x00
void* messages; // 0x04 (OSMessage* array for OSInitMessageQueue)
void* unk_0x04;
} entries[MAX_PUH_SEM]; // 0x00
void* pad_0x14; // unused
void* unk_0x14;
} st_uhs_ker_msg_mng;
s32 uhf_ker_send_message(int index, void* message) {

View File

@@ -7,12 +7,12 @@
static struct {
struct {
OSSemaphore* sem; // 0x00
u32 initCount;
u32 flags;
u32 unk_0x04;
u32 unk_0x08;
} entries[MAX_PUH_SEM]; // 0x00
u32 usedCount;
OSSemaphore* lockSem;
u8 pad[0x0C];
u32 unk_0x90;
OSSemaphore* unk_0x94;
u8 unk_0x98[0x0C];
} st_uhs_ker_sem_mng;
static OSSemaphore st_uhf_ker_sem[MAX_PUH_SEM];
@@ -20,17 +20,17 @@ static OSSemaphore st_uhf_ker_sem[MAX_PUH_SEM];
static s32 st_uhs_ker_sem_status;
static int uhf_ker_sem_inline_0() {
if (st_uhs_ker_sem_status != 1 || st_uhs_ker_sem_mng.lockSem == 0) {
if (st_uhs_ker_sem_status != 1 || st_uhs_ker_sem_mng.unk_0x94 == 0) {
return -1;
} else {
OSWaitSemaphore(st_uhs_ker_sem_mng.lockSem);
OSWaitSemaphore(st_uhs_ker_sem_mng.unk_0x94);
return 0;
}
}
static void uhf_ker_sem_inline_1() {
if (st_uhs_ker_sem_status == 1 && st_uhs_ker_sem_mng.lockSem != 0) {
OSSignalSemaphore(st_uhs_ker_sem_mng.lockSem);
if (st_uhs_ker_sem_status == 1 && st_uhs_ker_sem_mng.unk_0x94 != 0) {
OSSignalSemaphore(st_uhs_ker_sem_mng.unk_0x94);
}
}
@@ -48,7 +48,7 @@ s32 uhf_ker_create_sem(u32 initCount, int flags) {
return -5;
}
if (st_uhs_ker_sem_mng.usedCount == 12) {
if (st_uhs_ker_sem_mng.unk_0x90 == 12) {
uhf_ker_sem_inline_1();
return -24;
}
@@ -65,9 +65,9 @@ s32 uhf_ker_create_sem(u32 initCount, int flags) {
}
st_uhs_ker_sem_mng.entries[i].sem = sem;
st_uhs_ker_sem_mng.entries[i].initCount = initCount;
st_uhs_ker_sem_mng.entries[i].flags = flags;
st_uhs_ker_sem_mng.usedCount++;
st_uhs_ker_sem_mng.entries[i].unk_0x04 = initCount;
st_uhs_ker_sem_mng.entries[i].unk_0x08 = flags;
st_uhs_ker_sem_mng.unk_0x90++;
uhf_ker_sem_inline_1();
@@ -97,9 +97,9 @@ s32 uhf_ker_delete_sem(int sem) {
}
st_uhs_ker_sem_mng.entries[sem - 1].sem = NULL;
st_uhs_ker_sem_mng.entries[sem - 1].initCount = 0;
st_uhs_ker_sem_mng.entries[sem - 1].flags = 0;
st_uhs_ker_sem_mng.usedCount--;
st_uhs_ker_sem_mng.entries[sem - 1].unk_0x04 = 0;
st_uhs_ker_sem_mng.entries[sem - 1].unk_0x08 = 0;
st_uhs_ker_sem_mng.unk_0x90--;
uhf_ker_sem_inline_1();

View File

@@ -6,13 +6,13 @@
static struct {
struct {
OSThread* thread; // 0x00
u8 stack[0x33C]; // 0x04
OSThread* unk_0x00;
u8 unk_0x04[0x33C];
} entries[MAX_PUH_TSK]; // 0x00
u32 pad_0x680;
u32 pad_0x684;
u32 pad_0x688;
u32 pad_0x68C;
u32 unk_0x680;
u32 unk_0x684;
u32 unk_0x688;
u32 unk_0x68C;
} st_uhs_ker_tsk_mng;
s32 uhf_ker_set_priority(int tsk, int priority) {
@@ -24,9 +24,9 @@ s32 uhf_ker_set_priority(int tsk, int priority) {
return -5;
}
if (st_uhs_ker_tsk_mng.entries[tsk - 1].thread == NULL) {
if (st_uhs_ker_tsk_mng.entries[tsk - 1].unk_0x00 == NULL) {
return -1;
}
return OSSetThreadPriority(st_uhs_ker_tsk_mng.entries[tsk - 1].thread, priority) ? 0 : -20;
return OSSetThreadPriority(st_uhs_ker_tsk_mng.entries[tsk - 1].unk_0x00, priority) ? 0 : -20;
}

View File

@@ -20,7 +20,7 @@ typedef struct _usbKbdAsyncMem {
u32 state; // 0x00
void* kbd; // 0x04
char modifiers; // 0x08
u8 reserved; // 0x09
u8 unk_0x09;
u8 keys[6]; // 0x0A
} usbKbdAsyncMem;

View File

@@ -580,7 +580,7 @@ void VIInit(void)
u16 displayConfig;
u32 __VIDVDStopFlag_Enable_old;
s32 format;
u16 value;
u32 value;
u32 tv;
u32 bootromTv;

View File

@@ -190,7 +190,7 @@ static s32 WPADiSendData(s32 chan, WPADCommand command) {
if (status == WPAD_ERR_COMMUNICATION_ERROR) {
if ((s32)OSTicksToSeconds(__OSGetSystemTime() - p->lastReportSendTime) > 1 && _sleepTime != 0) {
if (!p->suppressDisconnect) {
if (!p->unk_0x910) {
p->lastReportSendTime = __OSGetSystemTime();
WPADiDisconnect(chan, FALSE);
} else {
@@ -1263,7 +1263,7 @@ static void __ClearControlBlock(s32 chan) {
p->lastControllerDataUpdate = __OSGetSystemTime();
p->lastReportSendTime = __OSGetSystemTime();
p->suppressDisconnect = 0;
p->unk_0x910 = 0;
p->unk_0x8C9 = 0;
p->unk_0x8C4 = 0;
p->wmReadDataPtr = NULL;
@@ -1298,8 +1298,8 @@ static void __ClearControlBlock(s32 chan) {
memset(&p->decryptXorTable, 0, sizeof(p->decryptXorTable));
memset(&p->gameInfo, 0, sizeof(WPADGameInfo));
p->gameInfoStatus[0] = -1;
p->gameInfoStatus[1] = -1;
p->unk_0x38[0] = -1;
p->unk_0x38[1] = -1;
p->stdCmdQueue.buffer = p->stdCmdQueueList;
p->stdCmdQueue.capacity = ARRAY_LENGTH(p->stdCmdQueueList);
@@ -2692,7 +2692,7 @@ static void __SendData(s32 chan, WPADCommand command) {
u32 time;
memcpy(&time, command.dataBuf, sizeof(u32));
p->lastReportSendTime = __OSGetSystemTime() + time;
p->suppressDisconnect = 1;
p->unk_0x910 = 1;
return;
}
default: {
@@ -2704,7 +2704,7 @@ static void __SendData(s32 chan, WPADCommand command) {
p->cmdBlkCB = command.cmdCB;
p->lastReportID = reportID;
p->lastReportSendTime = __OSGetSystemTime() + OSSecondsToTicks(2);
p->suppressDisconnect = 0;
p->unk_0x910 = 0;
OSRestoreInterrupts(enabled);
}

View File

@@ -393,48 +393,48 @@ static void getExtConfig(s32 chan, s32 result) {
p_wpd->extConfig.u.fs.accX1g = (s16)((u16)(((u16)(p_buf[index + 4]) << 2) & 0xFFFC) | (u16)(((u16)(p_buf[index + 7]) >> 4) & 3));
p_wpd->extConfig.u.fs.accY1g = (s16)((u16)(((u16)(p_buf[index + 5]) << 2) & 0xFFFC) | (u16)(((u16)(p_buf[index + 7]) >> 2) & 3));
p_wpd->extConfig.u.fs.accZ1g = (s16)((u16)(((u16)(p_buf[index + 6]) << 2) & 0xFFFC) | (u16)(((u16)(p_buf[index + 7])) & 3));
p_wpd->extConfig.u.fs.stickXMax = (s8)p_buf[index + 8];
p_wpd->extConfig.u.fs.stickXMin = (s8)p_buf[index + 9];
p_wpd->extConfig.u.fs.unk_0x04 = (s8)p_buf[index + 8];
p_wpd->extConfig.u.fs.unk_0x02 = (s8)p_buf[index + 9];
p_wpd->extConfig.u.fs.stickXCenter = (s8)p_buf[index + 10];
p_wpd->extConfig.u.fs.stickYMax = (s8)p_buf[index + 11];
p_wpd->extConfig.u.fs.stickYMin = (s8)p_buf[index + 12];
p_wpd->extConfig.u.fs.unk_0x0A = (s8)p_buf[index + 11];
p_wpd->extConfig.u.fs.unk_0x08 = (s8)p_buf[index + 12];
p_wpd->extConfig.u.fs.stickYCenter = (s8)p_buf[index + 13];
DEBUGPrint("0G: fsaccX = %d, fsaccY = %d, fsaccZ = %d\n", p_wpd->extConfig.u.fs.accX0g, p_wpd->extConfig.u.fs.accY0g,
p_wpd->extConfig.u.fs.accZ0g);
DEBUGPrint("1G: fsaccX = %d, fsaccY = %d, fsaccZ = %d\n", p_wpd->extConfig.u.fs.accX1g, p_wpd->extConfig.u.fs.accY1g,
p_wpd->extConfig.u.fs.accZ1g);
DEBUGPrint("FS: X = %d, X max = %d, X min = %d\n", p_wpd->extConfig.u.fs.stickXCenter, p_wpd->extConfig.u.fs.stickXMax,
p_wpd->extConfig.u.fs.stickXMin);
DEBUGPrint("FS: Y = %d, Y max = %d, Y min = %d\n", p_wpd->extConfig.u.fs.stickYCenter, p_wpd->extConfig.u.fs.stickYMax,
p_wpd->extConfig.u.fs.stickYMin);
DEBUGPrint("FS: X = %d, X max = %d, X min = %d\n", p_wpd->extConfig.u.fs.stickXCenter, p_wpd->extConfig.u.fs.unk_0x04,
p_wpd->extConfig.u.fs.unk_0x02);
DEBUGPrint("FS: Y = %d, Y max = %d, Y min = %d\n", p_wpd->extConfig.u.fs.stickYCenter, p_wpd->extConfig.u.fs.unk_0x0A,
p_wpd->extConfig.u.fs.unk_0x08);
}
break;
case WPAD_DEV_CLASSIC:
p_wpd->extConfig.u.cl.lStickXMax = (s8)p_buf[index + 0];
p_wpd->extConfig.u.cl.lStickXMin = (s8)p_buf[index + 1];
p_wpd->extConfig.u.cl.unk_0x04 = (s8)p_buf[index + 0];
p_wpd->extConfig.u.cl.unk_0x02 = (s8)p_buf[index + 1];
p_wpd->extConfig.u.cl.lStickXCenter = (s8)p_buf[index + 2];
p_wpd->extConfig.u.cl.lStickYMax = (s8)p_buf[index + 3];
p_wpd->extConfig.u.cl.lStickYMin = (s8)p_buf[index + 4];
p_wpd->extConfig.u.cl.unk_0x0A = (s8)p_buf[index + 3];
p_wpd->extConfig.u.cl.unk_0x08 = (s8)p_buf[index + 4];
p_wpd->extConfig.u.cl.lStickYCenter = (s8)p_buf[index + 5];
p_wpd->extConfig.u.cl.rStickXMax = (s8)p_buf[index + 6];
p_wpd->extConfig.u.cl.rStickXMin = (s8)p_buf[index + 7];
p_wpd->extConfig.u.cl.unk_0x10 = (s8)p_buf[index + 6];
p_wpd->extConfig.u.cl.unk_0x0E = (s8)p_buf[index + 7];
p_wpd->extConfig.u.cl.rStickXCenter = (s8)p_buf[index + 8];
p_wpd->extConfig.u.cl.rStickYMax = (s8)p_buf[index + 9];
p_wpd->extConfig.u.cl.rStickYMin = (s8)p_buf[index + 10];
p_wpd->extConfig.u.cl.unk_0x16 = (s8)p_buf[index + 9];
p_wpd->extConfig.u.cl.unk_0x14 = (s8)p_buf[index + 10];
p_wpd->extConfig.u.cl.rStickYCenter = (s8)p_buf[index + 11];
p_wpd->extConfig.u.cl.triggerLZero = p_buf[index + 12];
p_wpd->extConfig.u.cl.triggerRZero = p_buf[index + 13];
DEBUGPrint("CL: X = %d, X max = %d, X min = %d\n", p_wpd->extConfig.u.cl.lStickXCenter, p_wpd->extConfig.u.cl.lStickXMax,
p_wpd->extConfig.u.cl.lStickXMin);
DEBUGPrint("CL: Y = %d, Y max = %d, Y min = %d\n", p_wpd->extConfig.u.cl.lStickYCenter, p_wpd->extConfig.u.cl.lStickYMax,
p_wpd->extConfig.u.cl.lStickYMin);
DEBUGPrint("CR: X = %d, X max = %d, X min = %d\n", p_wpd->extConfig.u.cl.rStickXCenter, p_wpd->extConfig.u.cl.rStickXMax,
p_wpd->extConfig.u.cl.rStickXMin);
DEBUGPrint("CR: Y = %d, Y max = %d, Y min = %d\n", p_wpd->extConfig.u.cl.rStickYCenter, p_wpd->extConfig.u.cl.rStickYMax,
p_wpd->extConfig.u.cl.rStickYMin);
DEBUGPrint("CL: X = %d, X max = %d, X min = %d\n", p_wpd->extConfig.u.cl.lStickXCenter, p_wpd->extConfig.u.cl.unk_0x04,
p_wpd->extConfig.u.cl.unk_0x02);
DEBUGPrint("CL: Y = %d, Y max = %d, Y min = %d\n", p_wpd->extConfig.u.cl.lStickYCenter, p_wpd->extConfig.u.cl.unk_0x0A,
p_wpd->extConfig.u.cl.unk_0x08);
DEBUGPrint("CR: X = %d, X max = %d, X min = %d\n", p_wpd->extConfig.u.cl.rStickXCenter, p_wpd->extConfig.u.cl.unk_0x10,
p_wpd->extConfig.u.cl.unk_0x0E);
DEBUGPrint("CR: Y = %d, Y max = %d, Y min = %d\n", p_wpd->extConfig.u.cl.rStickYCenter, p_wpd->extConfig.u.cl.unk_0x16,
p_wpd->extConfig.u.cl.unk_0x14);
DEBUGPrint("LR: L = %d, R = %d\n", p_wpd->extConfig.u.cl.triggerLZero, p_wpd->extConfig.u.cl.triggerRZero);
break;
}
@@ -547,9 +547,9 @@ static void getGameInfo(s32 chan, s32 result, u8 index) {
if (p_info->checksum == sum) {
memcpy(&p_wpd->gameInfo, p_buf, sizeof(WPADMEMGameInfo));
p_wpd->gameInfoStatus[index] = WPAD_ERR_NONE;
p_wpd->unk_0x38[index] = WPAD_ERR_NONE;
} else {
p_wpd->gameInfoStatus[index] = WPAD_ERR_INVALID;
p_wpd->unk_0x38[index] = WPAD_ERR_INVALID;
}
}
}

View File

@@ -17,9 +17,9 @@ typedef struct NWC24FLHeader {
u32 version; // 0x04
u32 infoCount; // 0x08
u32 registeredCount; // 0x0C
u32 confirmedBits[4]; // 0x10
u32 pad_0x20[7]; // unused
u32 listFlags; // 0x3C
u32 unk_0x10[4];
u32 unk_0x20[7];
u32 unk_0x3C;
NWC24UserId friendIds[NWC24_FRIEND_INFO_MAX]; // 0x40
} NWC24FLHeader;

View File

@@ -73,15 +73,15 @@ typedef struct NWC24MsgObjPrivate {
};
u32 raw;
} msgBoardFlags; // 0xCC
NWC24Data extraData; // 0xD0
NWC24Data unk_0xD0;
NWC24Data faceData; // 0xD8
NWC24Data altName; // 0xE0
u32 textSize; // 0xE4
u32 dwcId; // 0xEC
u32 iconNew; // 0xF0
u32 pad_0xF4;
u32 pad_0xF8;
u32 pad_0xFC;
u32 unk_0xF4;
u32 unk_0xF8;
u32 unk_0xFC;
} NWC24MsgObjPrivate;
#ifdef __cplusplus

View File

@@ -26,9 +26,9 @@ extern struct NWC24Work {
u8 configData[1024]; // 0x1300
u8 sendMbcHeader[128]; // 0x1700
u8 recvMbcHeader[128]; // 0x1780
u8 mbcEntry[256]; // 0x1800
u8 unk_0x1700[128]; // 0x1700
u8 unk_0x1780[128]; // 0x1780
u8 unk_0x1800[256]; // 0x1800
u8 base64Work[256]; // 0x1900
u8 unk_0x1A00[4096]; // 0x1A00

View File

@@ -62,7 +62,7 @@ typedef struct _CDBRecordKey {
} CDBRecordKey;
typedef struct _CDBRecord {
u32 database; // 0x00
u32 unk_0x00;
void* cryptBuf; // 0x04
CDBRecordKey key; // 0x08
void* file; // 0x38

View File

@@ -58,7 +58,7 @@ void CDBRecordInstanceInit(CDBRecordFile* recordFile, CDBRecord* record, int typ
recordFile->used = 1;
OSUnlockMutex((OSMutex*)recordFile);
recordFile->allocFlag = type;
recordFile->database = record->database;
recordFile->database = record->unk_0x00;
CDBAttrInit(&recordFile->attr);
CDBRecordKeyCopy(&recordFile->key, &record->key);
}
@@ -73,7 +73,7 @@ BOOL CDBRecordInstanceIsUsed(CDBRecordFile* recordFile) {
void CDBRecordInitDescriptor(CDBRecord* record, CDBDatabase* database, CDBRecordKey* key) {
CDBLock();
record->database = (u32)database;
record->unk_0x00 = (u32)database;
CDBRecordKeyCopy(&record->key, key);
record->cryptBuf = NULL;
record->file = NULL;
@@ -95,7 +95,7 @@ CDBErr CDBRecordCreateAtOnce(CDBRecord* record, CDBDatabase* database, const cha
CDBRecordKeyInit(&key, epoch, gameCode, makerCode, 0, fileType, CDB_FS_LOCATION_NAND);
CDBLock();
record->database = (u32)database;
record->unk_0x00 = (u32)database;
CDBRecordKeyCopy(&record->key, &key);
record->cryptBuf = NULL;
record->file = NULL;
@@ -128,7 +128,7 @@ CDBErr CDBRecordOpen_(CDBRecord* record) {
CDBDatabase* database;
CDBRecordDatabaseState* instance;
database = (CDBDatabase*)record->database;
database = (CDBDatabase*)record->unk_0x00;
instance = database->instance;
record->cryptBuf = NULL;
if (instance == NULL) {
@@ -292,7 +292,7 @@ CDBErr CDBRecordWrite_(CDBRecord* record, void* buffer, u32 size) {
CDBErr result;
CDBRecordDatabaseState* instance;
database = (CDBDatabase*)record->database;
database = (CDBDatabase*)record->unk_0x00;
instance = database->instance;
recordFile = record->file;
if (record->key.location == CDB_FS_LOCATION_SD) {
@@ -393,67 +393,6 @@ CDBErr CDBRecordGetDataSize(CDBRecord* record, u32* size) {
return err;
}
CDBErr CDBRecordReduceFileSize(CDBRecord* record, u32 newFileSize) {
CDBRecordFile* recordFile;
CDBErr err;
u32 fileSize;
recordFile = record->file;
if (recordFile == NULL) {
CDBReportError("can't reduce file size of the record ; the record is closed\n");
return CDB_ERROR_27;
}
if ((recordFile->allocFlag & 2) == 0) {
CDBReportError("can't reduce file size of the record ; the record is opened as READONLY\n");
return CDB_ERROR_27;
}
CDBAttrGetFileSize(&recordFile->attr, &fileSize);
if (newFileSize > fileSize) {
CDBReportError("can't reduce file size of the record ; file size must be over %d bytes\n", fileSize);
return CDB_ERROR_26;
}
CDBAttrSetFileSize(&recordFile->attr, newFileSize);
recordFile->attr.dirty = TRUE;
err = CDBRecordFileWriteAttrBuf(record);
if (err != CDB_ERROR_OK) {
return err;
}
return CDB_ERROR_OK;
}
CDBErr CDBRecordReduceDataSize(CDBRecord* record, u32 newDataSize) {
CDBRecordFile* recordFile;
CDBErr err = CDB_ERROR_OK;
u32 dataSize;
recordFile = record->file;
if (recordFile == NULL) {
CDBReportError("can't reduce data size of the record ; the record is closed\n");
return CDB_ERROR_27;
}
if ((recordFile->allocFlag & 2) == 0) {
CDBReportError("can't reduce data size of the record ; the record is opened as READONLY\n");
return CDB_ERROR_27;
}
if (!CDBRecordBelongedDBOpenedAsRW(record)) {
CDBReportError("can't reduce data size of the record; permission denied\n");
return CDB_ERROR_ACCESS_DENIED;
}
err = CDBRecordFileGetDataSize(record, &dataSize);
if (err != CDB_ERROR_OK) {
return err;
}
if (newDataSize < dataSize) {
CDBAttrSetFileSize(&recordFile->attr, newDataSize);
recordFile->attr.dirty = TRUE;
}
err = CDBRecordFileWriteAttrBuf(record);
if (err != CDB_ERROR_OK) {
return err;
}
return CDB_ERROR_OK;
}
CDBErr CDBRecordRemove(CDBRecord* record) {
CDBErr err;
CDBLock();
@@ -491,50 +430,6 @@ void CDBRecordGetTypeForce(CDBRecord* record, char* type) {
CDBUnlock();
}
CDBErr CDBRecordSetFileType(CDBRecord* record, const char* fileType) {
CDBRecordDatabaseState* instance;
CDBRecordFile* recordFile;
CDBErr err;
instance = ((CDBDatabase*)record->database)->instance;
recordFile = record->file;
if ((instance->openFlags & 2) == 0) {
CDBReportError("can't set file type of the record; the database is opened as READONLY\n");
return CDB_ERROR_26;
}
if (recordFile == NULL) {
CDBReportError("can't set file type of the record ; the record is closed\n");
return CDB_ERROR_27;
}
if ((recordFile->allocFlag & 2) == 0) {
CDBReportError("can't set file type of the record ; the record is opened as READONLY\n");
return CDB_ERROR_27;
}
if (record->key.location != CDB_FS_LOCATION_NAND) {
CDBReportError("can't set file type of the record ; the record must exsist on NAND\n");
return CDB_ERROR_26;
}
CDBLock();
strcpy(CDBKeyStrType(record->key.keyString), fileType);
CDBAttrSetKeyStr(&recordFile->attr, &record->key);
err = CDBRecordFileWriteAttrBuf(record);
CDBUnlock();
return err;
}
CDBErr CDBRecordGetFileType(CDBRecord* record, char* fileType) {
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get file type of the record ; the record is closed\n");
err = CDB_ERROR_27;
} else {
CDBConvKeyStrToType(record->key.keyString, fileType);
}
CDBUnlock();
return err;
}
void CDBRecordGetGameCodeForce(CDBRecord* record, char* gameCode) {
u32 value;
CDBLock();
@@ -543,122 +438,12 @@ void CDBRecordGetGameCodeForce(CDBRecord* record, char* gameCode) {
CDBUnlock();
}
CDBErr CDBRecordGetGameCode(CDBRecord* record, u32* gameCode) {
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get game code of the record ; the record is closed\n");
err = CDB_ERROR_27;
} else {
CDBConvKeyStrToGameCode(record->key.keyString, gameCode);
}
CDBUnlock();
return err;
}
CDBErr CDBRecordGetMakerCode(CDBRecord* record, u32* makerCode) {
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get maker code of the record ; the record is closed\n");
err = CDB_ERROR_27;
} else {
CDBConvKeyStrToMakerCode(record->key.keyString, makerCode);
}
CDBUnlock();
return err;
}
CDBErr CDBRecordGetModifiedTime(CDBRecord* record, u32* modifiedTime) {
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get modified time of the record; the record is closed\n");
err = CDB_ERROR_27;
} else {
*modifiedTime = ((CDBRecordFile*)record->file)->attr.buf.lastModifiedDate;
}
CDBUnlock();
return err;
}
CDBErr CDBRecordGetModifiedCount(CDBRecord* record, u32* modifiedCount) {
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get modified count of the record; the record is closed\n");
err = CDB_ERROR_27;
} else {
CDBAttrGetModifiedCount(&((CDBRecordFile*)record->file)->attr, modifiedCount);
}
CDBUnlock();
return err;
}
void CDBRecordGetKeyForce(CDBRecord* record, CDBRecordKey* key) {
CDBLock();
CDBRecordKeyCopy(key, &record->key);
CDBUnlock();
}
CDBErr CDBRecordSetName(CDBRecord* record, const char* name, const char* keyword) {
CDBRecordDatabaseState* instance;
CDBRecordFile* recordFile;
CDBErr err;
instance = ((CDBDatabase*)record->database)->instance;
recordFile = record->file;
if ((instance->openFlags & 2) == 0) {
CDBReportError("can't set a name of the record; the database is opened as READONLY\n");
return CDB_ERROR_26;
}
if (!CDBRecordBelongedDBOpenedAsRW(record)) {
CDBReportError("can't add keyword to the record; permission denied\n");
return CDB_ERROR_ACCESS_DENIED;
}
if (recordFile == NULL) {
CDBReportError("can't set a name of the record; the record is closed\n");
return CDB_ERROR_27;
}
if ((recordFile->allocFlag & 2) == 0) {
CDBReportError("can't set a name of the record; the record is opened as READONLY\n");
return CDB_ERROR_27;
}
CDBLock();
strncpy(recordFile->attr.buf.desc, name, CDB_ATTR_BUF_MAX_DESC_LEN);
recordFile->attr.buf.descLength = strlen(name);
recordFile->attr.dirty = TRUE;
err = CDBRecordFileWriteAttrBuf(record);
CDBUnlock();
return err;
}
CDBErr CDBRecordGetKeyword(CDBRecord* record, char* keyword) {
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get keyword from the record; the record is closed\n");
err = CDB_ERROR_27;
} else {
strcpy(keyword, ((CDBRecordFile*)record->file)->attr.buf.desc);
}
CDBUnlock();
return err;
}
CDBErr CDBRecordGetKey(CDBRecord* record, CDBRecordKey* key) {
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get key from the record; the record is closed\n");
err = CDB_ERROR_27;
} else {
CDBRecordKeyCopy(key, &record->key);
}
CDBUnlock();
return err;
}
void CDBRecordGetCalendarTimeForce(CDBRecord* record, int* year, int* month, int* day, int* hour, int* min, int* sec) {
char epochString[64];
CDBDate epoch;
@@ -669,23 +454,6 @@ void CDBRecordGetCalendarTimeForce(CDBRecord* record, int* year, int* month, int
CDBUnlock();
}
CDBErr CDBRecordGetCalendarTime(CDBRecord* record, int* year, int* month, int* day, int* hour, int* min, int* sec) {
char epochString[64];
CDBDate epoch;
CDBErr err = CDB_ERROR_OK;
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get calender time from the record; the record is closed\n");
err = CDB_ERROR_27;
} else {
CDBConvKeyStrToEpochStr(record->key.keyString, epochString);
CDBConvEpochStrToEpochValue(epochString, &epoch);
CDBConvEpochValueToDate(epoch, year, month, day, hour, min, sec);
}
CDBUnlock();
return err;
}
CDBErr CDBRecordGetId(CDBRecord* record, CDBId* id) {
CDBErr err = CDB_ERROR_OK;
CDBRecordFile* recordFile;
@@ -740,7 +508,7 @@ CDBErr CDBRecordUpdateModifiedDate(CDBRecord* record) {
ticks = OSGetTime();
modifiedDate = ticks / (OS_BUS_CLOCK / 4);
recordFile = record->file;
if ((((CDBRecordDatabaseState*)((CDBDatabase*)record->database)->instance)->openFlags & 2) == 0) {
if ((((CDBRecordDatabaseState*)((CDBDatabase*)record->unk_0x00)->instance)->openFlags & 2) == 0) {
CDBReportError("can't set modified time of the record; the database is opened as READONLY\n");
return CDB_ERROR_26;
}
@@ -764,27 +532,6 @@ CDBErr CDBRecordUpdateModifiedDate(CDBRecord* record) {
return CDB_ERROR_OK;
}
CDBErr CDBRecordDuplicate(CDBRecord* record, CDBRecord* newRecord) {
CDBRecordFile* recordFile;
CDBErr err;
if (record->key.location != CDB_FS_LOCATION_NAND && record->key.location != CDB_FS_LOCATION_SD) {
OSPanic(__FILE__, __LINE__, "CDBRecordDuplicate invalud location\n");
return CDB_ERROR_1;
}
recordFile = record->file;
if (recordFile == NULL) {
return CDB_ERROR_27;
}
CDBLock();
CDBRecordKeyCopy(&newRecord->key, &record->key);
newRecord->file = NULL;
newRecord->database = record->database;
err = CDBRecordFileCreateBlank(newRecord);
CDBUnlock();
return err;
}
CDBErr CDBRecordBackupToSD(CDBRecord* record) {
CDBErr err;
CDBLock();
@@ -823,7 +570,7 @@ CDBErr CDBRecordBackupToSD_(CDBRecord* record) {
CDBRecordKeyCopy(&localRecord.key, &record->key);
localRecord.file = NULL;
localRecord.key.location = CDB_FS_LOCATION_SD;
localRecord.database = record->database;
localRecord.unk_0x00 = record->unk_0x00;
err = CDBRecordFileCreateBlank(&localRecord);
if (err != CDB_ERROR_OK) {
CDBLock();
@@ -867,7 +614,7 @@ CDBErr CDBRecordBackupToSD_(CDBRecord* record) {
CDBLock();
recordFile = localRecord.file;
CDBRecordKeyCopy(&record->key, &localRecord.key);
record->database = localRecord.database;
record->unk_0x00 = localRecord.unk_0x00;
record->file = localRecord.file;
record->cryptBuf = localRecord.cryptBuf;
CDBRecordKeyCopy(&recordFile->key, &localRecord.key);
@@ -948,7 +695,8 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
}
{
CDBErr result;
CDBRecordFile* tempFile = record->file;
CDBRecordFile* tempFile;
tempFile = record->file;
if ((s32)tempFile == 0) {
result = CDB_ERROR_27;
} else if (tempFile->allocFlag == 1) {
@@ -1077,7 +825,7 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
CDBErr CDBRecordDecrypt(CDBRecord* record, void* buffer, u32 size, u32* dataSize, CDBRecordKey* key) {
CDBErr status;
s32 fileOffset;
int fileOffset;
CDBRecordFile* recordFile;
u32 fileDataSize;
u32 fileSize;
@@ -1212,32 +960,3 @@ CDBErr CDBRecordDecrypt(CDBRecord* record, void* buffer, u32 size, u32* dataSize
}
return CDB_ERROR_OK;
}
CDBErr CDBRecordPrivateChangeOwner(CDBRecord* record, u64 newWiiId) {
CDBRecordFile* recordFile;
char fullPath[256];
char newPath[256];
CDBErr err;
u64 preWiiId;
u64 recordWiiId;
CDBReportError("CDBRecordPrivateChangeOwner\n");
recordFile = record->file;
if (recordFile == NULL) {
return CDB_ERROR_27;
}
preWiiId = CDBGetWiiId();
recordWiiId = record->key.wiiId;
OSReport(" i_pre-wiiid = %lX\n", preWiiId);
OSReport(" record-wiiid = %lX\n", recordWiiId);
CDBConvKeyToFullPath(&record->key, fullPath);
record->key.wiiId = newWiiId;
CDBConvKeyToFullPath(&record->key, newPath);
OSReport("path =%s\n", fullPath);
OSReport("path2=%s\n", newPath);
CDBLock();
err = CDBAttrSetWiiId(&recordFile->attr, newWiiId);
CDBUnlock();
return err;
}

View File

@@ -169,11 +169,11 @@ static const u32 AESiDecryptTable[] = {
};
#define ROTATE(x,n) (((x) << (n)) | ((x) >> (32 - (n))))
#define ENCRYPT(a,b,c,d) (((ROTATE(AESiEncryptTable[((b)>>16)&255],16) ^ ROTATE(AESiEncryptTable[(a)>>24],24)) ^ AESiEncryptTable[(d)&255]) ^ ROTATE(AESiEncryptTable[((c)>>8)&255],8))
#define DECRYPT(a,b,c,d) (((ROTATE(AESiDecryptTable[((b)>>16)&255],16) ^ AESiDecryptTable[(d)&255]) ^ ROTATE(AESiDecryptTable[(a)>>24],24)) ^ ROTATE(AESiDecryptTable[((c)>>8)&255],8))
#define SUBSTITUTE(table,a,b,c,d) ((((u32)table[(a)>>24]<<24) | table[(d)&255]) | (((u32)table[((b)>>16)&255]<<16) | ((u32)table[((c)>>8)&255]<<8)))
#define ENCRYPT(a,b,c,d) (ROTATE(AESiEncryptTable[(a)>>24],24) ^ ROTATE(AESiEncryptTable[((b)>>16)&255],16) ^ ROTATE(AESiEncryptTable[((c)>>8)&255],8) ^ AESiEncryptTable[(d)&255])
#define DECRYPT(a,b,c,d) (ROTATE(AESiDecryptTable[(a)>>24],24) ^ ROTATE(AESiDecryptTable[((b)>>16)&255],16) ^ ROTATE(AESiDecryptTable[((c)>>8)&255],8) ^ AESiDecryptTable[(d)&255])
#define SUBSTITUTE(table,a,b,c,d) (((u32)table[(a)>>24]<<24) | ((u32)table[((b)>>16)&255]<<16) | ((u32)table[((c)>>8)&255]<<8) | table[(d)&255])
#define SUBSTITUTE_XOR(table,a,b,c,d) (((((u32)table[(a)>>24]<<24) ^ table[(d)&255]) ^ ((u32)table[((c)>>8)&255]<<8)) ^ ((u32)table[((b)>>16)&255]<<16))
#define SUBSTITUTE_XOR(table,a,b,c,d) (((u32)table[(a)>>24]<<24) ^ ((u32)table[((b)>>16)&255]<<16) ^ ((u32)table[((c)>>8)&255]<<8) ^ table[(d)&255])
void AESiEncryptBlock(AESContext* context, u32* output, const u32* input) {
u32 rounds = context->rounds;
@@ -197,9 +197,8 @@ void AESiEncryptBlock(AESContext* context, u32* output, const u32* input) {
void AESiDecryptBlock(AESContext* context, u32* output, const u32* input) {
u32 rounds=context->rounds;
u32* key=context->keys;
u32* key=context->keys + rounds*4;
u32 a,b,c,d;
key += rounds*4;
if (context->needsTransform) {
u32 round;
for (round=1; round<context->rounds; ++round) {
@@ -210,9 +209,9 @@ void AESiDecryptBlock(AESContext* context, u32* output, const u32* input) {
u32 twice=DOUBLE_BYTES(value);
u32 four=DOUBLE_BYTES(twice);
u32 eight=DOUBLE_BYTES(four)^value;
u32 mixed=(ROTATE(eight,8) ^ (eight ^ four));
mixed=(ROTATE(mixed,8) ^ (mixed ^ twice));
mixed=(ROTATE(mixed,8) ^ (mixed ^ value));
u32 mixed=eight ^ (four ^ ROTATE(eight,8));
mixed ^= twice ^ ROTATE(mixed,8);
mixed ^= value ^ ROTATE(mixed,8);
keys[word]=mixed;
}
}

View File

@@ -68,14 +68,8 @@ void NETMD5GetDigest(NETMD5Context* context, void* digest) {
memset(context, 0, sizeof(*context));
}
static inline u32 rotateSum(u32 state, const u32* word, u32 constant, int shift) {
// Each rotation half reads its own byte-reversed message word.
u32 right = __lwbrx((void*)word, 0);
u32 left = __lwbrx((void*)word, 0);
return ((state + (constant + left)) << shift) | ((constant + (state + right)) >> (32 - shift));
}
#define STEP(a, b, c, d, f, word, n) ((a) = (b) + rotateSum((a) + (f), word, *constant, n))
#define ROTATE(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
#define STEP(a, b, c, d, f, word, n) ((a) += (f), (a) = (b) + ROTATE(__lwbrx(0, (int)(word)) + (*constant + (a)), n))
static void ProcessBlock(NETMD5Context* context) {
static u32 constants[64] = {0xD76AA478, 0xE8C7B756, 0x242070DB, 0xC1BDCEEE, 0xF57C0FAF, 0x4787C62A, 0xA8304613, 0xFD469501, 0x698098D8, 0x8B44F7AF, 0xFFFF5BB1, 0x895CD7BE, 0x6B901122, 0xFD987193, 0xA679438E, 0x49B40821, 0xF61E2562, 0xC040B340, 0x265E5A51, 0xE9B6C7AA, 0xD62F105D, 0x02441453, 0xD8A1E681, 0xE7D3FBC8, 0x21E1CDE6, 0xC33707D6, 0xF4D50D87, 0x455A14ED, 0xA9E3E905, 0xFCEFA3F8, 0x676F02D9, 0x8D2A4C8A, 0xFFFA3942, 0x8771F681, 0x6D9D6122, 0xFDE5380C, 0xA4BEEA44, 0x4BDECFA9, 0xF6BB4B60, 0xBEBFBC70, 0x289B7EC6, 0xEAA127FA, 0xD4EF3085, 0x04881D05, 0xD9D4D039, 0xE6DB99E5, 0x1FA27CF8, 0xC4AC5665, 0xF4292244, 0x432AFF97, 0xAB9423A7, 0xFC93A039, 0x655B59C3, 0x8F0CCC92, 0xFFEFF47D, 0x85845DD1, 0x6FA87E4F, 0xFE2CE6E0, 0xA3014314, 0x4E0811A1, 0xF7537E82, 0xBD3AF235, 0x2AD7D2BB, 0xEB86D391};
@@ -89,13 +83,13 @@ static void ProcessBlock(NETMD5Context* context) {
block = context->buffer32;
word = block;
constant = constants;
for (round = 0; round < 4; ++round) {
STEP(a,b,c,d,(b & c) | (~b & d),word++,7); ++constant;
STEP(d,a,b,c,(a & b) | (~a & c),word++,12); ++constant;
STEP(c,d,a,b,(d & a) | (~d & b),word++,17); ++constant;
STEP(b,c,d,a,(c & d) | (~c & a),word++,22); ++constant;
}
index = indices;
for (round = 0; round < 4; ++round) {
STEP(a,b,c,d,(b & c) | (~b & d),word,7); ++word; ++constant;
STEP(d,a,b,c,(a & b) | (~a & c),word,12); ++word; ++constant;
STEP(c,d,a,b,(d & a) | (~d & b),word,17); ++word; ++constant;
STEP(b,c,d,a,(c & d) | (~c & a),word,22); ++word; ++constant;
}
for (round = 0; round < 4; ++round) {
STEP(a,b,c,d,(b & d) | (c & ~d),block + *index,5); ++index; ++constant;
STEP(d,a,b,c,(a & c) | (b & ~c),block + *index,9); ++index; ++constant;

View File

@@ -548,7 +548,7 @@ NWC24Err NWC24DumpDlTask(NWC24DlTask* dlTask) {
NWC24Err NWC24IterateDlTask(NWC24DlId* dlIterateId, BOOL begin) {
DlTaskListHeader* entriesHeader;
const NWC24Work* work;
NWC24Work* work;
u16 taskId;
u16 maxTaskCount;
DlTaskListHeader* header;

View File

@@ -27,7 +27,7 @@ static NWC24Err GetCachedFLHeader(NWC24FLHeader** header);
static ChkHostNameError CheckHostName(const char* hostName, u32 hostNameLength);
static inline NWC24Err CheckFriendInfo(const NWC24FriendInfo* friendInfo);
static u32 GetConfirmedBit(u32 index) {
static u32 GetUnkFlag(u32 index) {
NWC24Err result;
NWC24FLHeader* header;
u32 data;
@@ -37,11 +37,11 @@ static u32 GetConfirmedBit(u32 index) {
return result;
}
data = header->confirmedBits[index >> 5] >> (index & 0x1f) & 1;
data = header->unk_0x10[index >> 5] >> (index & 0x1f) & 1;
return (NWC24Err)data;
}
static NWC24Err SetConfirmedBit(u32 index, int flag) {
static NWC24Err SetUnkFlag(u32 index, int flag) {
NWC24Err result;
NWC24FLHeader* header;
@@ -50,11 +50,11 @@ static NWC24Err SetConfirmedBit(u32 index, int flag) {
return result;
}
header->confirmedBits[index >> 5] = ~(1 << (index & 0x1f)) & header->confirmedBits[index >> 5] | flag << (index & 0x1f);
header->unk_0x10[index >> 5] = ~(1 << (index & 0x1f)) & header->unk_0x10[index >> 5] | flag << (index & 0x1f);
return NWC24_OK;
}
static NWC24Err SetListFlag(int flag) {
static NWC24Err SetUnkFlag2(int flag) {
NWC24Err result;
NWC24FLHeader* header;
@@ -63,7 +63,7 @@ static NWC24Err SetListFlag(int flag) {
return result;
}
header->listFlags |= flag;
header->unk_0x3C |= flag;
return NWC24_OK;
}
@@ -101,7 +101,7 @@ NWC24Err NWC24ReadFriendInfo(NWC24FriendInfo* info, u32 index) {
Mail_memset(&info->addr.mailAddr[sizeof(NWC24UserId)], 0, sizeof(NWC24UserMailAddr) - sizeof(NWC24UserId));
}
result = GetConfirmedBit(index);
result = GetUnkFlag(index);
if (result == 1) {
info->attr.status = NWC24_FRIENDSTATUS_CONFIRMED;
}
@@ -189,9 +189,9 @@ NWC24Err NWC24WriteFriendInfo(const NWC24FriendInfo* friendInfo, u32 index) {
tmpFriendAddr = (NWC24FriendAddr*)&friendInfo->addr;
}
SetListFlag(1);
SetUnkFlag2(1);
result = SetConfirmedBit(index, 0);
result = SetUnkFlag(index, 0);
if (result != NWC24_OK) {
return result;
}
@@ -347,7 +347,7 @@ NWC24Err NWC24DeleteFriendInfo(u32 index) {
if (resultWrite == NWC24_OK) {
header->friendIds[index] = 0;
header->registeredCount--;
result = SetConfirmedBit(index, 0);
result = SetUnkFlag(index, 0);
if (result == NWC24_OK) {
NWC24FSeek(&file, 0, NWC24_SEEK_BEG);
resultWrite = NWC24FWrite(header, sizeof(NWC24FLHeader), &file);
@@ -374,8 +374,8 @@ NWC24Err NWC24SwapFriendInfos(u32 index1, u32 index2) {
u32 fileOffset1;
u32 fileOffset2;
int confirmedBit1;
int confirmedBit2;
int friendUnkFlag1;
int friendUnkFlag2;
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool()) {
return NWC24_ERR_LIB_NOT_OPENED;
@@ -429,10 +429,10 @@ NWC24Err NWC24SwapFriendInfos(u32 index1, u32 index2) {
header->friendIds[index2] = tmp;
// Swap some flag
confirmedBit1 = GetConfirmedBit(index1);
confirmedBit2 = GetConfirmedBit(index2);
SetConfirmedBit(index1, confirmedBit2);
SetConfirmedBit(index2, confirmedBit1);
friendUnkFlag1 = GetUnkFlag(index1);
friendUnkFlag2 = GetUnkFlag(index2);
SetUnkFlag(index1, friendUnkFlag2);
SetUnkFlag(index2, friendUnkFlag1);
// Write new header
NWC24FSeek(&file, 0, NWC24_SEEK_BEG);
@@ -629,10 +629,10 @@ NWC24Err NWC24iCreateFriendList() {
header->version = FRIEND_LIST_VERSION;
header->infoCount = NWC24_FRIEND_INFO_MAX;
header->registeredCount = 0;
header->confirmedBits[0] = 0;
header->confirmedBits[1] = 0;
header->confirmedBits[2] = 0;
header->confirmedBits[3] = 0;
header->unk_0x10[0] = 0;
header->unk_0x10[1] = 0;
header->unk_0x10[2] = 0;
header->unk_0x10[3] = 0;
result = NWC24FOpen(&file, FLFilePath, NWC24_OPEN_WRITE);
if (result != NWC24_OK) {

View File

@@ -170,7 +170,7 @@ NWC24Err NWC24GetMsgObj(NWC24MsgObj* msg, NWC24MBoxType type, u32 id) {
u32 count = 0;
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool())
return NWC24_ERR_LIB_NOT_OPENED;
entry = (MBCEntry*)NWC24WorkP->mbcEntry;
entry = (MBCEntry*)NWC24WorkP->unk_0x1800;
memset(entry, 0, sizeof(*entry));
if (id == 0)
return NWC24_ERR_HIDDEN;
@@ -251,7 +251,7 @@ NWC24Err NWC24GetMsgIdList(NWC24MBoxType type, u32* ids, u32 maxLength) {
MBCEntry* entry;
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool())
return NWC24_ERR_LIB_NOT_OPENED;
entry = (MBCEntry*)NWC24WorkP->mbcEntry;
entry = (MBCEntry*)NWC24WorkP->unk_0x1800;
err = GetCachedMBCHeader(type, &header);
if (err != NWC24_OK)
return err;
@@ -307,11 +307,11 @@ NWC24Err NWC24iOpenMBox(void) {
NWC24File recvFile, sendFile;
char* path = NWC24WorkP->pathWork;
NWC24Err err;
Mail_memset(NWC24WorkP->sendMbcHeader, 0, 128);
Mail_memset(NWC24WorkP->unk_0x1700, 0, 128);
err = GetCachedMBCHeader(NWC24_MBOX_TYPE_SEND, &header);
if (err != NWC24_OK)
return err;
Mail_memset(NWC24WorkP->recvMbcHeader, 0, 128);
Mail_memset(NWC24WorkP->unk_0x1780, 0, 128);
err = GetCachedMBCHeader(NWC24_MBOX_TYPE_RECV, &header);
if (err != NWC24_OK)
return err;
@@ -340,11 +340,11 @@ NWC24Err NWC24iInitMBox(void) {
NWC24File recvFile, sendFile;
NWC24Err recvResult, sendResult, err, sendStatus;
char* path = NWC24WorkP->pathWork;
Mail_memset(NWC24WorkP->sendMbcHeader, 0, 128);
Mail_memset(NWC24WorkP->unk_0x1700, 0, 128);
sendResult = CreateCtrlFile(NWC24_MBOX_TYPE_SEND, FALSE);
if (sendResult < 0)
return sendResult;
Mail_memset(NWC24WorkP->recvMbcHeader, 0, 128);
Mail_memset(NWC24WorkP->unk_0x1780, 0, 128);
recvResult = CreateCtrlFile(NWC24_MBOX_TYPE_RECV, FALSE);
if (recvResult < 0)
return recvResult;
@@ -616,11 +616,11 @@ static NWC24Err CreateCtrlFile(NWC24MBoxType type, BOOL force) {
err = MakeCtrlPath(path, type);
if (err != NWC24_OK)
return err;
entry = (MBCEntry*)NWC24WorkP->mbcEntry;
entry = (MBCEntry*)NWC24WorkP->unk_0x1800;
if (type == NWC24_MBOX_TYPE_SEND)
header = (MBCHeader*)NWC24WorkP->sendMbcHeader;
header = (MBCHeader*)NWC24WorkP->unk_0x1700;
else if (type == NWC24_MBOX_TYPE_RECV)
header = (MBCHeader*)NWC24WorkP->recvMbcHeader;
header = (MBCHeader*)NWC24WorkP->unk_0x1780;
else
return NWC24_ERR_INVALID_VALUE;
result = err;
@@ -676,7 +676,7 @@ static NWC24Err DeleteMsg(NWC24MBoxType type, u32 id, BOOL protect) {
NWC24Err err, deleteResult, closeResult;
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool())
return NWC24_ERR_LIB_NOT_OPENED;
entry = (MBCEntry*)NWC24WorkP->mbcEntry;
entry = (MBCEntry*)NWC24WorkP->unk_0x1800;
err = GetCachedMBCHeader(type, &header);
if (err != NWC24_OK)
return err;
@@ -754,7 +754,7 @@ static NWC24Err DuplicationCheck(MBCHeader* header, const NWC24MsgObjPrivate* ms
NWC24Err clearResult, deleteResult;
if (type == NWC24_MBOX_TYPE_SEND)
return NWC24_OK;
entry = (MBCEntry*)NWC24WorkP->mbcEntry;
entry = (MBCEntry*)NWC24WorkP->unk_0x1800;
for (offset = 128; offset < header->fileSize; offset += 128) {
if (count >= header->numMessages)
break;
@@ -809,9 +809,9 @@ static NWC24Err GetCachedMBCHeader(NWC24MBoxType type, MBCHeader** header) {
char* path;
NWC24Err err = NWC24_OK, closeResult;
if (type == NWC24_MBOX_TYPE_SEND)
*header = (MBCHeader*)NWC24WorkP->sendMbcHeader;
*header = (MBCHeader*)NWC24WorkP->unk_0x1700;
else if (type == NWC24_MBOX_TYPE_RECV)
*header = (MBCHeader*)NWC24WorkP->recvMbcHeader;
*header = (MBCHeader*)NWC24WorkP->unk_0x1780;
else {
*header = NULL;
return NWC24_ERR_INVALID_VALUE;
@@ -874,7 +874,7 @@ static NWC24Err InitMBCHeader(MBCHeader* header, NWC24MBoxType type) {
static NWC24Err AddMBCEntry(MBCHeader* header, const NWC24MsgObjPrivate* msg, NWC24File* file) {
u32 offset = header->freeOffset;
MBCEntry* entry = (MBCEntry*)NWC24WorkP->mbcEntry;
MBCEntry* entry = (MBCEntry*)NWC24WorkP->unk_0x1800;
u32 next;
NWC24Err err;
if (offset == 0)
@@ -906,7 +906,7 @@ static NWC24Err AddMBCEntry(MBCHeader* header, const NWC24MsgObjPrivate* msg, NW
}
static NWC24Err ClearMBCEntry(MBCHeader* header, NWC24File* file, u32 offset) {
MBCEntry* entry = (MBCEntry*)NWC24WorkP->mbcEntry;
MBCEntry* entry = (MBCEntry*)NWC24WorkP->unk_0x1800;
NWC24Err err = NWC24FSeek(file, offset, NWC24_SEEK_BEG);
if (err != NWC24_OK)
return err;

View File

@@ -243,11 +243,11 @@ static inline NWC24Err WriteMBDelayField(NWC24MsgObjPrivate* msg) {
static inline NWC24Err WriteExtraFields(NWC24MsgObjPrivate* msg) {
NWC24Err err;
if (msg->extraData.size == 0)
if (msg->unk_0xD0.size == 0)
return NWC24_OK;
err = NWC24FWrite(msg->extraData.ptr, msg->extraData.size, m_pFile);
err = NWC24FWrite(msg->unk_0xD0.ptr, msg->unk_0xD0.size, m_pFile);
if (err == NWC24_OK)
msg->length += msg->extraData.size;
msg->length += msg->unk_0xD0.size;
return err;
}

View File

@@ -77,7 +77,7 @@ NWC24Err NWC24InitMsgObj(NWC24MsgObj* msg, NWC24MsgType type) {
NWC24Data_Init(&msgObj->toData);
NWC24Data_Init(&msgObj->unk_0x50);
NWC24Data_Init(&msgObj->unk_0x58);
NWC24Data_Init(&msgObj->extraData);
NWC24Data_Init(&msgObj->unk_0xD0);
NWC24Data_Init(&msgObj->faceData);
NWC24Data_Init(&msgObj->altName);

View File

@@ -242,63 +242,14 @@ BOOL BS2IsDiagDisc() { return (u8)(*(u8 *)OSPhysicalToCached(OS_ADDR_BOOT_INFO)
extern vu32 BS2VideoMode;
extern vu32 __DVDLayoutFormat;
asm void Run(u32 entryPoint, void *start, u32 blockCount, u32 argument) {
// clang-format off
#ifdef __MWERKS__
nofralloc
mtctr r5
mtlr r3
li r0, 0
li r2, 0
li r3, 0
li r5, 0
li r7, 0
li r8, 0
li r9, 0
li r10, 0
li r11, 0
li r12, 0
li r13, 0
li r14, 0
li r15, 0
li r16, 0
li r17, 0
li r18, 0
li r19, 0
li r20, 0
li r21, 0
li r22, 0
li r23, 0
li r24, 0
li r25, 0
li r26, 0
li r27, 0
li r28, 0
li r29, 0
li r30, 0
li r31, 0
// The application stack is fixed; it is unrelated to the formatter.
lis r1, 0x8160
ori r1, r1, 0
li r6, 0
b Run_loop_entry
Run_loop:
dcbz r4, r0
dcbf r4, r0
addi r4, r4, 0x20
bdnz Run_loop
b Run_done
Run_done:
li r4, 0
blr
Run_loop_entry:
b Run_loop
#endif
// clang-format on
void Run(u32 entryPoint, void *start, u32 blockCount, u32 argument) {
u8 *block = start;
for (; blockCount != 0; --blockCount) {
__dcbz(block, 0);
__dcbf(block, 0);
block += 32;
}
((void (*)(u32))entryPoint)(argument);
}
BOOL BS2GetLockedTitles(ESTitleId *pTitleIds, u32 *count) {
@@ -852,7 +803,7 @@ void BS2StartGCGame() {
OSTime time;
StartingGame = TRUE;
while (CoverBlock.state != DVD_STATE_IDLE) {
while (DVDGetCommandBlockStatus(&CoverBlock) != DVD_STATE_IDLE) {
}
soundMode = SCGetSoundMode();
@@ -1845,24 +1796,21 @@ invalidRvlRegion:
State = BS2_STT_RESET_SYSTEM;
break;
}
if (GamePartition != 0) {
State = BS2_STT_37;
} else {
if (GamePartition == 0) {
State = BS2_STT_54;
break;
}
case 0x25: {
u32 partitionOffset = (u32)((DVDPartitionInfo *)GamePartition)->partition;
State = BS2_STT_37;
case 0x25:
if (BS2BootFromCache != 0) {
BS2Report("Open partition from cache.dat\n");
NandPending = 1;
BS2NANDDivideReadAsync(&BS2CacheFileInfo, &PartitionParams.tmd, 0x4a00, BS2NANDCallback, &BS2NandBlock);
} else
DVDOpenPartitionAsync(&Block, &PartitionParams.tmd, partitionOffset, BS2DVDCallback);
DVDOpenPartitionAsync(&Block, &PartitionParams.tmd, (u32)((DVDPartitionInfo *)GamePartition)->partition, BS2DVDCallback);
PartitionOpen = 1;
State = BS2_STT_38;
break;
}
case 0x26: {
status = CheckBS2CommandStatus();
if (status == 0)
@@ -1889,16 +1837,13 @@ invalidRvlRegion:
titlePrefix = titleCode >> 0x18;
titleCharacters[3] = (u8)titleCode;
titleCharacters[0] = (char)(titleCode >> 0x18);
switch (titlePrefix) {
case 'D':
case 'R':
case 'S':
case 'T':
if (titlePrefix < 'R') {
if (titlePrefix == 'D')
goto check_title_region;
} else if (titlePrefix < 'U')
goto check_title_region;
default:
regionMatches = TRUE;
goto title_region_checked;
}
regionMatches = TRUE;
goto title_region_checked;
{
check_title_region:
if (titleCharacters[3] == 0x41) {
@@ -2056,8 +2001,8 @@ invalidRvlRegion:
if (status == 0)
OSPanic("BS2Mach.c", 0x12c8, "BS2 ERROR >>> Cannnot alloc 0x%08x from MEMAllocator", bannerFile.length);
BannerLength = bannerFile.length;
BannerBuffer = BannerAllocation + 32 - BannerAllocation % 32;
BS2Report("BannerBufferAddr : %08X\n", BannerBuffer);
BannerBuffer = OSRoundDown32B(BannerAllocation) + 32;
BS2Report("BannerBufferAddr : %08X\n");
} else {
if ((BannerBuffer != 0) && (BannerLength != 0)) {
if (BannerLength < ((bannerFile.length + 0x1fU) & 0xffffffe0))

View File

@@ -64,13 +64,13 @@ void SimpleWavePlayer::wavePacketCallback(WavePacketCallbackStatus status, WaveP
return;
}
if (self->mbFillInCallback) {
if (self->unk_0xB5) {
MakeWave(player, packet, self);
}
}
SimpleWavePlayer::SimpleWavePlayer() : mSetupParam(1, nw4r::snd::SAMPLE_FORMAT_PCM_S16, 32000, 1.0f, 1) {
mbFillInCallback = true;
unk_0xB5 = true;
unk_0xB0 = false;
mIsSetData = false;
mIsPlaying = false;
@@ -196,7 +196,7 @@ void SimpleWavePlayer::stop() {
void SimpleWavePlayer::update() {
if (mIsPlaying) {
if (!mbFillInCallback) {
if (!unk_0xB5) {
for (int i = 0; i < 3; i++) {
if (mWavePackets[i].GetAppendFlag()) {
continue;

View File

@@ -53,7 +53,7 @@ void AudioFrameCallback() {
for (i = 0; i < AX_VOICE_MAX; i++) {
VoiceInfo* currVoice = &Voices[i];
if (currVoice->getAXVPB() == NULL && currVoice->getUpdateFlag() != 2) {
if (currVoice->getAXVPB() == NULL && currVoice->getUnk_0x0C() != 2) {
continue;
}
@@ -108,7 +108,7 @@ void AudioFrameCallback() {
currVoice->setState(0);
currVoice->setUnk_0x08(0);
}
currVoice->setUpdateFlag(0);
currVoice->setUnk_0x0C(0);
}
return;
}
@@ -370,7 +370,7 @@ clean_up:
}
Voices[axVoiceBuf[i]->index].setAXVPB(axVoiceBuf[i]);
Voices[axVoiceBuf[i]->index].setState(1);
Voices[axVoiceBuf[i]->index].setUpdateFlag(1);
Voices[axVoiceBuf[i]->index].setUnk_0x0C(1);
}
if (handle != NULL) {
for (u32 i = 0; i < chanCount; i++) {
@@ -397,7 +397,7 @@ bool AxAdpcmHandle::setVolume(f32 newVolume) {
mix.vR = newVolume * mpVoices[i]->getMix()->vR;
AXSetVoiceMix(mpVoices[i]->getAXVPB(), &mix);
mpVoices[i]->setUpdateFlag(1);
mpVoices[i]->setUnk_0x0C(1);
a = true;
}
return a;
@@ -416,7 +416,7 @@ void AxAdpcmSimplePlayer::stop(AxAdpcmHandle* handle) {
}
handle->getVoice(i)->setState(7);
handle->getVoice(i)->setUpdateFlag(1);
handle->getVoice(i)->setUnk_0x0C(1);
if (handle->getVoice(i)->getUnk_0x08() != 0) {
handle->getVoice(i)->setUnk_0x08(0);
}
@@ -440,8 +440,8 @@ void AxAdpcmSimplePlayer::setVolume(AxAdpcmHandle* handle, f32 volume) {
void AxAdpcmSimplePlayer::calc() {
for (int i = 0; i < AX_VOICE_MAX; i++) {
if (Voices[i].getUpdateFlag() == 1) {
Voices[i].setUpdateFlag(2);
if (Voices[i].getUnk_0x0C() == 1) {
Voices[i].setUnk_0x0C(2);
}
}
}

View File

@@ -7207,7 +7207,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
u32 cmpLow;
struct {
CHANSVmObjType operandTypes[2];
double floatLiteral;
u64 floatBits;
CHANSVmObjHdr copies[2];
CHANSVmObjHdr load;
CHANSVmObjHdr operand;
@@ -7291,8 +7291,8 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
case CHANS_VM_OP_LOAD_FLOAT: {
opSize = 9;
operandBuf = VmGetOperand(vm, 1, 9);
memcpy(&scratch.floatLiteral, operandBuf, 8);
result = CHANSVmSetFloat(vm, &pVm->accumulator, scratch.floatLiteral);
memcpy(&scratch.floatBits, operandBuf, 8);
result = CHANSVmSetFloat(vm, &pVm->accumulator, *(double*)&scratch.floatBits);
break;
}
@@ -7441,7 +7441,8 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
}
if (leftOp == vmNull || rightOp == vmNull) {
return CHANS_VM_ERR_RESULT_TYPE;
result = CHANS_VM_ERR_RESULT_TYPE;
break;
}
result = opFunc(vm, convTypeIdx, &pVm->accumulator, leftOp, rightOp);
@@ -7716,27 +7717,30 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
CHANSVmObjHdr* pAcc;
CHANSVmExecutionCtx* ctx;
CHANSVmModule* dbg;
CHANSVmErr loadResult;
opSize = 3;
operandBuf = VmGetOperand(vm, 1, 3);
if (operandBuf == vmNull) {
return CHANS_VM_ERR_CODE_RANGE;
}
pAcc = &pVm->accumulator;
loadResult = CHANSVmDeleteObject(vm, pAcc);
if (loadResult == CHANS_VM_OK) {
result = CHANSVmDeleteObject(vm, pAcc);
if (result == CHANS_VM_OK) {
imm16Val = VM_READ_BE_U16(operandBuf, 0);
ctx = pVm->pActiveCtx;
dbg = ctx->pDbg;
if (imm16Val >= dbg->stringCount || dbg->pStringTbl[imm16Val].pStringData == vmNull) {
loadResult = CHANS_VM_ERR_LOAD_STRING_CONST;
} else {
pAcc->type = CHANS_VM_OBJ_TYPE_STRING;
pAcc->hasData = vmTrue;
pAcc->value.wstring_v = (vmWStringObjVal*)&ctx->pDbg->pStringTbl[imm16Val];
if (imm16Val < dbg->stringCount) {
if (dbg->pStringTbl[imm16Val].pStringData != vmNull) {
goto load_str_ok;
}
}
}
result = loadResult;
result = CHANS_VM_ERR_LOAD_STRING_CONST;
break;
load_str_ok:
pAcc->type = CHANS_VM_OBJ_TYPE_STRING;
pAcc->hasData = vmTrue;
pAcc->value.wstring_v = (vmWStringObjVal*)&ctx->pDbg->pStringTbl[imm16Val];
break;
}
@@ -7769,8 +7773,8 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
arrayIdx = (u32)stackPtr->value.int_v;
goto set_index_ok;
case CHANS_VM_OBJ_TYPE_FLOAT: {
double stackFloat = stackPtr->value.float_v;
if (stackFloat >= 0.0 && stackFloat <= 4294967294.0) {
double stackFloat = *(double*)stackPtr;
if (stackFloat <= 4294967294.0 && 0.0 <= stackFloat) {
arrayIdx = (u32)stackFloat;
goto set_index_ok;
}
@@ -7881,7 +7885,8 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
computedAddr += pVm->pActiveCtx->pc + 5;
}
if (computedAddr < 1 || computedAddr >= pVm->pActiveCtx->pDbg->codeSize) {
return CHANS_VM_ERR_CODE_RANGE;
result = CHANS_VM_ERR_CODE_RANGE;
break;
}
pVm->pActiveCtx->pc = computedAddr;
opSize = 0;
@@ -7929,7 +7934,8 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
computedAddr += pVm->pActiveCtx->pc + 4;
}
if (computedAddr < 1 || computedAddr >= pVm->pActiveCtx->pDbg->codeSize) {
return CHANS_VM_ERR_CODE_RANGE;
result = CHANS_VM_ERR_CODE_RANGE;
break;
}
pVm->pActiveCtx->pc = computedAddr;
opSize = 0;
@@ -7954,13 +7960,11 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
}
case CHANS_VM_OP_DELETE_INDIRECT: {
CHANSVmObjHdr* accumulator = &pVm->accumulator;
CHANSVmErr deleteResult = CHANS_VM_ERR_DELETE_INDIRECT;
if (accumulator->type == CHANS_VM_TYPE_INDEX_REF) {
foundObj = VmGetArrayElement(vm, accumulator, accumulator->value.data.len, vmFalse);
deleteResult = VmDeleteCommon(vm, foundObj);
result = CHANS_VM_ERR_DELETE_INDIRECT;
if (pVm->accumulator.type == CHANS_VM_TYPE_INDEX_REF) {
foundObj = VmGetArrayElement(vm, &pVm->accumulator, *((u32*)&pVm->accumulator.value + 1), vmFalse);
result = VmDeleteCommon(vm, foundObj);
}
result = deleteResult;
break;
}
@@ -8004,27 +8008,34 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
if (pVm->pActiveCtx->stackDepth != 0 && pVm->pObjStackTopBuf + sizeof(CHANSVmObjHdr) <= pVm->pHeapEnd) {
CHANSVmObjHdr* stackTop = (CHANSVmObjHdr*)pVm->pObjStackTopBuf;
isTypeMatch = 0;
if (stackTop->type == pVm->accumulator.type) {
if (pVm->accumulator.type == stackTop->type) {
switch (stackTop->type) {
case CHANS_VM_OBJ_TYPE_INTEGER: {
isTypeMatch = stackTop->value.int_v == pVm->accumulator.value.int_v;
u32 low1 = *(u32*)stackTop;
u32 low2 = *(u32*)&pVm->accumulator;
u32 high1 = *((u32*)stackTop + 1);
u32 high2 = *((u32*)&pVm->accumulator + 1);
u32 xor1 = low1 ^ low2;
u32 xor2 = high1 ^ high2;
isTypeMatch = !(xor1 | xor2);
goto end_branch_check;
}
case CHANS_VM_OBJ_TYPE_FLOAT: {
isTypeMatch = stackTop->value.float_v == pVm->accumulator.value.float_v;
double stackFloat = stackTop->value.float_v;
double accFloat = pVm->accumulator.value.float_v;
isTypeMatch = stackFloat == accFloat ? 1 : 0;
goto end_branch_check;
}
case CHANS_VM_OBJ_TYPE_STRING: {
u32 len1, len2;
const vmWStringObjVal* accumulatorString = pVm->accumulator.value.wstring_v;
const vmWStringObjVal* stackString = stackTop->value.wstring_v;
CHANSVmObjHdr* stackObj = (CHANSVmObjHdr*)pVm->pObjStackTopBuf;
u32 strEqual;
isTypeMatch = 0;
len1 = stackString->len;
len2 = accumulatorString->len;
len1 = stackObj->value.wstring_v->len;
len2 = pVm->accumulator.value.wstring_v->len;
if (len1 == len2) {
strEqual = 0;
if (len1 == 0 || memcmp(stackString->spData, accumulatorString->spData, len1) == 0) {
if (len1 == 0 || memcmp(stackObj->value.wstring_v->spData, pVm->accumulator.value.wstring_v->spData, len1) == 0) {
strEqual = 1;
}
if (strEqual) {

View File

@@ -16,7 +16,7 @@ namespace ipl {
namespace cs {
namespace savedata {
struct data {
char sMountPath[MAX_PATH_LENGTH + sizeof(wchar_t)]; // 0x00
char unk_0x00[MAX_PATH_LENGTH + sizeof(wchar_t)]; // 0x00
char sPath[MAX_PATH_LENGTH + sizeof(wchar_t)]; // 0x42
u8 flag; // 0x84
u8* pData; // 0x88
@@ -67,7 +67,7 @@ namespace ipl {
data* data = static_cast<savedata::data*>(*hdr->value.ptr_v);
if (data->pData == NULL && data->size == 0) {
if (data->sMountPath[0] == 0) {
if (data->unk_0x00[0] == 0) {
error = load_nand_(vm, data, heap, offset, size, 0x20);
} else {
error = load_vf_(vm, data, heap, offset, size, 0x20);
@@ -127,7 +127,7 @@ namespace ipl {
}
}
if (data->sMountPath[0] == '\0') {
if (data->unk_0x00[0] == '\0') {
error = load_nand_(vm, data, csHeap, 0, size, -0x20);
} else {
error = load_vf_(vm, data, csHeap, 0, size, -0x20);
@@ -591,7 +591,7 @@ namespace ipl {
memset(data, 0, sizeof(savedata::data));
memset(temp, 0, sizeof(temp));
if (arg1 != NULL) {
util::utf16_to_ascii(data->sMountPath, temp, MAX_PATH_LENGTH, arg0);
util::utf16_to_ascii(data->unk_0x00, temp, MAX_PATH_LENGTH, arg0);
memset(temp, 0, sizeof(temp));
util::utf16_to_ascii(data->sPath, temp, MAX_PATH_LENGTH, arg1);
} else {

View File

@@ -1179,10 +1179,10 @@ namespace ipl {
return;
}
switch (mState) {
case STATE_NORMAL:
switch (mMode) {
case 0:
if (mState != STATE_NORMAL || mMode != 0) {
return;
}
if (!mpFriendCache->isThere(buttonNo + mPage * BTN_MAX)) {
return;
}
@@ -1240,8 +1240,6 @@ namespace ipl {
snd::getSystem()->startSEwithPos("WIPL_SE_CH_HOLD", mDrag.mPos.x);
mState = STATE_DRAG;
}
}
}
void Address::start_drag_point_event(const char* paneName, controller::Interface* con) {
@@ -1427,7 +1425,10 @@ namespace ipl {
if (con->downTrg(controller::BTN_INTERACT)) {
Button* button = static_cast<Button*>(System::getScene(SCENE_BUTTON));
if (mState == STATE_COVER_NORMAL || mState == STATE_NORMAL) {
if (mState != STATE_COVER_NORMAL && mState != STATE_NORMAL) {
break;
}
if (Button::cmpButtonName(paneName, Button::BTN_EXIT) == 0) {
MailAddressSelect* mailAddrSel = static_cast<MailAddressSelect*>(System::getScene(SCENE_MAIL_ADDRESS_SELECT));
button->animation(Button::IDANIM_SELECT_CALENDAR_EXIT);
@@ -1476,7 +1477,7 @@ namespace ipl {
snd::getSystem()->startSE("WIPL_SE_FL_PAGE_DEC");
onPreviousPage();
}
}
break;
}
// fallthrough
}
@@ -1782,15 +1783,13 @@ namespace ipl {
nw4r::math::VEC3 baseTrans = mpLayout->FindPaneByName("N_base_move")->GetTranslate();
math::VEC2 pos = System::getControllerManager()->getController(mDrag.mChan)->getDpdProjectionPos();
nw4r::lyt::TextBox* textBox = static_cast<nw4r::lyt::TextBox*>(mpLayout->FindPaneByName("T_name_move"));
const u16* name = mpFriendCache->getInfo(mDrag.mButton + mDrag.mPage * BTN_MAX).attr.name;
f32 width = 0.0f;
if (textBox != NULL) {
const u16* name = mpFriendCache->getInfo(mDrag.mButton + mDrag.mPage * BTN_MAX).attr.name;
if (name != NULL) {
textBox->GetFont()->GetWidth();
for (; *name != 0; name++) {
width += textBox->GetFont()->GetCharWidth(*name);
}
if (textBox != NULL && name != NULL) {
textBox->GetFont()->GetWidth();
for (; *name != 0; name++) {
width += textBox->GetFont()->GetCharWidth(*name);
}
}
width += 0.01f;
@@ -1947,10 +1946,11 @@ namespace ipl {
}
void FriendListCache::update(u32 index, const wchar_t* name, u64 fdId) {
mInfos[index].attr.fdId = fdId;
memset(mInfos[index].attr.name, 0, sizeof(mInfos[index].attr.name));
wcsncpy((wchar_t*)getInfo(index).attr.name, name, 10);
System::getNwc24Manager()->updateFriendInfo(&getInfo(index), index);
NWC24FriendInfo* info = &mInfos[index];
info->attr.fdId = fdId;
memset(info->attr.name, 0, sizeof(info->attr.name));
wcsncpy((wchar_t*)info->attr.name, name, 10);
System::getNwc24Manager()->updateFriendInfo(info, index);
}
void FriendListCache::del(u32 index) {

View File

@@ -521,8 +521,7 @@ void ipl::scene::AddressEdit::create() {
set_textbox(textPane, friendText);
textPane = (mpCodeLayout)
->getNW4RLyt()->GetRootPane()->FindPaneByName("T_frnd_crd_00", true);
friendText = mString.mDisplayText;
set_textbox(textPane, friendText);
set_textbox(textPane, mString.mDisplayText);
mState = 0;
break;
}
@@ -2780,7 +2779,7 @@ void ipl::scene::AddressEdit::set_err_msg(wchar_t* outErrMsg, u32 outErrMsgLen,
swprintf(nwc24ErrStr, sizeof(nwc24ErrStr) / sizeof(wchar_t), L"%06d\n", errorCode);
wcsncat(outErrMsg, nwc24ErrStr, outErrMsgLen - wcslen(outErrMsg));
u32 messageId;
u32 messageId = MESG_ERROR_NWC24_SERVER;
switch (nwc24Err) {
case NWC24_ERR_NETWORK:
messageId = MESG_ERROR_NWC24_NETWORK;
@@ -2866,7 +2865,10 @@ void ipl::scene::AddressEdit::get_friendinfo() {
memcpy(&ipl::scene::sFriendInfo, &mpFriendCache->getInfo(mSelectedFriend),
sizeof(ipl::scene::sFriendInfo));
mString.setName(reinterpret_cast<const wchar_t*>(ipl::scene::sFriendInfo.attr.name));
set_textbox(mpCodeLayout->getNW4RLyt()->GetRootPane()->FindPaneByName("T_name_00", true), mString.mName);
const wchar_t* name = mString.mName;
nw4r::lyt::Pane* namePane =
mpCodeLayout->getNW4RLyt()->GetRootPane()->FindPaneByName("T_name_00", true);
set_textbox(namePane, name);
wchar_t wiiNo[0x100];
wchar_t email[0x102];
@@ -2879,7 +2881,10 @@ void ipl::scene::AddressEdit::get_friendinfo() {
ipl::utility::CharacterCode::ANSIToUTF16(email, reinterpret_cast<const u8*>(&ipl::scene::sFriendInfo.addr), 0x102);
mString.setEMail(email);
}
set_textbox(mpCodeLayout->getNW4RLyt()->GetRootPane()->FindPaneByName("T_frnd_crd_00", true), mString.mDisplayText);
const wchar_t* displayText = mString.mDisplayText;
nw4r::lyt::Pane* friendCodePane =
mpCodeLayout->getNW4RLyt()->GetRootPane()->FindPaneByName("T_frnd_crd_00", true);
set_textbox(friendCodePane, displayText);
memcpy(&mCreateID, &ipl::scene::sFriendInfo.attr.fdId, sizeof(mCreateID));
}

View File

@@ -674,8 +674,7 @@ namespace ipl {
if (foundLangGroup) {
nw4r::lyt::Group* group = layout->FindGroupByName(langGroup);
nw4r::lyt::Group* const& groupView = group;
for (nw4r::lyt::PaneLinkList::Iterator it = groupView->GetPaneList().GetBeginIter(); it != groupView->GetPaneList().GetEndIter(); it++) {
for (nw4r::lyt::PaneLinkList::Iterator it = group->GetPaneList().GetBeginIter(); it != group->GetPaneList().GetEndIter(); it++) {
it->mTarget->SetVisible(true);
}
} else {
@@ -686,8 +685,7 @@ namespace ipl {
}
if (strcmp(scModuleData.langGroupLookup[region][i], langCodeBuf[scLangLookup[region][i]]) == 0) {
nw4r::lyt::Group* group = layout->FindGroupByName(scModuleData.langGroupLookup[region][i]);
nw4r::lyt::Group* const& groupView = group;
for (nw4r::lyt::PaneLinkList::Iterator it = groupView->GetPaneList().GetBeginIter(); it != groupView->GetPaneList().GetEndIter(); it++) {
for (nw4r::lyt::PaneLinkList::Iterator it = group->GetPaneList().GetBeginIter(); it != group->GetPaneList().GetEndIter(); it++) {
it->mTarget->SetVisible(true);
}
break;

View File

@@ -1,5 +1,3 @@
#define IPL_CHANNEL_SELECT_CPP
#include <decomp/ide.h>
#include "iplSceneUI.h"
@@ -45,7 +43,8 @@ namespace ipl {
return r;
}
inline f32 HermiteIntp<f32>::get() const {
template <>
f32 HermiteIntp<f32>::get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
f32 r = (mStart * (1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
@@ -330,8 +329,8 @@ namespace ipl {
setSceneParentFlags(SCN_PARENTFLAG_DRAW | SCN_PARENTFLAG_CALC);
mOrthoTrans = math::VEC3(0.0f, 0.0f, 0.0f);
mOrthoScale = math::VEC2(1.0f, 1.0f);
unk_0xD8 = math::VEC3(0.0f, 0.0f, 0.0f);
unk_0xE4 = math::VEC2(1.0f, 1.0f);
nw4r::ut::Rect proj4x3;
System::getProjectionRect4x3(&proj4x3);
@@ -648,7 +647,7 @@ namespace ipl {
void ChannelSelect::draw() {
if (mState != STATE_INACTIVE && System::getSceneManager()->onDrawLayer(scene::DRAW_LAYER_DEFAULT)) {
if (mState == STATE_NORMAL_FADE_ZOOM || mState == STATE_NORMAL_DONE_FADE_ZOOM || mState == STATE_NORMAL_RESTART) {
utility::Graphics::setOrthoTransAndScale(mOrthoTrans, mOrthoScale);
utility::Graphics::setOrthoTransAndScale(unk_0xD8, unk_0xE4);
}
utility::Graphics::setOrtho();
@@ -1845,7 +1844,7 @@ namespace ipl {
initChanZoomParam(myVec, 1);
setChanZoomOrtho();
if (System::getChannelManager()->isDiskChannelReady()) {
if (System::getChannelManager()->isUnk_0x1B81()) {
if (System::getBS2Manager()->getIPLState() == bs2::IPL_STATE_RVL_GAME ||
System::getBS2Manager()->getIPLState() == bs2::IPL_STATE_DISK_UPDATE) {
if (mspDiskID != NULL) {
@@ -1857,7 +1856,7 @@ namespace ipl {
if (strncmp(diskID, mspDiskID, 4) == 0) {
if (strncmp(diskMaker, mspDiskMaker, 2) == 0) {
System::getChannelManager()->setDiskChannelReady(false);
System::getChannelManager()->setUnk_0x1B81(false);
}
}
}
@@ -1910,10 +1909,10 @@ namespace ipl {
u16 efbHeight;
if (mState == STATE_NORMAL_FADE_ZOOM || mState == STATE_NORMAL_DONE_FADE_ZOOM || mState == STATE_NORMAL_RESTART) {
nw4r::math::MTX44 mtx;
f32 right = mOrthoTrans.x + projRect.right / mOrthoScale.x;
f32 left = mOrthoTrans.x + projRect.left / mOrthoScale.x;
f32 bottom = mOrthoTrans.y - projRect.bottom / mOrthoScale.y;
f32 top = mOrthoTrans.y - projRect.top / mOrthoScale.y;
f32 right = unk_0xD8.x + projRect.right / unk_0xE4.x;
f32 left = unk_0xD8.x + projRect.left / unk_0xE4.x;
f32 bottom = unk_0xD8.y - projRect.bottom / unk_0xE4.y;
f32 top = unk_0xD8.y - projRect.top / unk_0xE4.y;
MTXOrtho(mtx, top, bottom, left, right, -100.0f, 100.0f);
nw4r::math::VEC4 vec4_in(vec.x, vec.y, 0.0f, 1.0f);
nw4r::math::VEC4 vec4;
@@ -1921,10 +1920,10 @@ namespace ipl {
fbWidth = rMode->fbWidth;
efbHeight = rMode->efbHeight;
f32 projectionWidth = projRect.GetWidth();
scissorX = ((1.0f + vec4.x) * fbWidth / 2) - ((mChanThumbOff_X * mOrthoScale.x) * (fbWidth / projectionWidth));
scissorY = (efbHeight - ((1.0f + vec4.y) * efbHeight / 2)) - (mChanThumbOff_Y * mOrthoScale.y);
scissorWidth = 2.0f * (mChanThumbOff_X * mOrthoScale.x) * (fbWidth / projectionWidth);
scissorHeight = 2.0f * (mChanThumbOff_Y * mOrthoScale.y);
scissorX = ((1.0f + vec4.x) * fbWidth / 2) - ((mChanThumbOff_X * unk_0xE4.x) * (fbWidth / projectionWidth));
scissorY = (efbHeight - ((1.0f + vec4.y) * efbHeight / 2)) - (mChanThumbOff_Y * unk_0xE4.y);
scissorWidth = 2.0f * (mChanThumbOff_X * unk_0xE4.x) * (fbWidth / projectionWidth);
scissorHeight = 2.0f * (mChanThumbOff_Y * unk_0xE4.y);
} else {
fbWidth = rMode->fbWidth;
efbHeight = rMode->efbHeight;
@@ -2003,8 +2002,8 @@ namespace ipl {
nw4r::ut::Rect projRect;
System::getProjectionRect(&projRect);
mOrthoTrans = math::VEC3((frames[0].x + frames[1].x) / 2, (frames[0].y + frames[2].y) / 2, 0.0f);
mOrthoScale = math::VEC2(projRect.GetWidth() / (frames[1].x - frames[0].x), projRect.GetHeight() / (frames[0].y - frames[2].y));
unk_0xD8 = math::VEC3((frames[0].x + frames[1].x) / 2, (frames[0].y + frames[2].y) / 2, 0.0f);
unk_0xE4 = math::VEC2(projRect.GetWidth() / (frames[1].x - frames[0].x), projRect.GetHeight() / (frames[0].y - frames[2].y));
}
int ChannelSelect::isInChannelPaneNames(const char* name) const {

View File

@@ -467,7 +467,7 @@ namespace ipl {
mpDiskBnrLayout->calc();
} else {
calcModuleChannel();
System::getChannelManager()->setDiskChannelReady(false);
System::getChannelManager()->setUnk_0x1B81(false);
}
if ((mState == STATE_NORMAL || mState == STATE_WAIT_TMD || mState == STATE_PREPARE_BOOT || mState == STATE_BOOT_SCENE) && !unk_0x90 &&
@@ -1220,7 +1220,7 @@ namespace ipl {
#pragma ppc_iro_level 0
void ChannelTitle::calcNormalParentalDialog() {
if (mChanSceneID == SCENE_DISK_CHANNEL &&
(System::getBS2Manager()->getIPLState() != bs2::IPL_STATE_RVL_GAME || System::getChannelManager()->isDiskChannelReady())) {
(System::getBS2Manager()->getIPLState() != bs2::IPL_STATE_RVL_GAME || System::getChannelManager()->isUnk_0x1B81())) {
mParentalState = PARENTAL_STATE_FAILED;
}
@@ -2064,7 +2064,7 @@ namespace ipl {
break;
}
case DISK_STATE_WII_DISK_IDLE: {
if (BS2State != bs2::IPL_STATE_RVL_GAME || System::getChannelManager()->isDiskChannelReady()) {
if (BS2State != bs2::IPL_STATE_RVL_GAME || System::getChannelManager()->isUnk_0x1B81()) {
mDiskState = DISK_STATE_EJECT;
mpDiskBnrAnims[DISK_ANIM_GRP_ALL][DISK_ANIM_DISK_EJECT]->play();
mpDiskBnrLayout->GetRootPane()->SetVisible(true);

View File

@@ -237,7 +237,10 @@ bool MemoryCardManager::isIconValidate(u8 slot, s16 index) {
bool MemoryCardManager::isBannerEnable(u8 slot, s16 index) {
CardIcons* icons = reinterpret_cast<CardIcons*>(memorycard::getIconStateArray());
return icons[slot][mFile[slot][index].fileNo].bannerEnable != 0;
u32 file = mFile[slot][index].fileNo;
memorycard::IconState* icon = &icons[slot][file];
u8 enabled = icon->bannerEnable;
return enabled != 0;
}
void MemoryCardManager::update_icon_anm() {

View File

@@ -1341,11 +1341,13 @@ namespace ipl {
wchar_t* titleName = System::getChannelManager()->getTitleName(
page, channelIndex, 0);
memcpy(titleNames + *titleCount * 0x2a, titleName, 0x2a);
++*titleCount;
u32 nextTitleCount = *titleCount + 1;
*titleCount = nextTitleCount;
if (bytes >= secondUsage[0] && blocks >= secondUsage[1]) {
return true;
if (bytes < secondUsage[0] || blocks < secondUsage[1]) {
continue;
}
return true;
}
}
}

View File

@@ -3,10 +3,6 @@
#define IPL_SDMEMORY_DIALOG_STATE_ACCESSOR
#define IPL_SDMEMORY_COMPLETION_PCT_ACCESSOR
#define IPL_CHANNEL_TITLE_NOVTABLE
#include "math/iplInterporation.h"
#undef IPL_CHANNEL_TITLE_NOVTABLE
#include "scene/sdChannelTitle/iplSDChannelTitle.h"
#include "scene/sdChannelSelect/iplSDChannelSelect.h"
#include "system/iplSystem.h"
@@ -1558,5 +1554,15 @@ void SDChannelTitle::startResetting() {
snd::getSystem()->resetAllSound();
}
extern "C" void iplSDChannelTitle_onTitleButtonEvent(SDTitleButtonEventHandler* handler, u32 component,
u32 event, const controller::Interface* controller) {
handler->onEventDerived(component, event, controller);
}
extern "C" void iplSDChannelTitle_onTitlePaneEvent(SDTitlePaneEventHandler* handler, u32 component,
u32 event, const controller::Interface* controller) {
handler->onEvent(component, event, const_cast<controller::Interface*>(controller));
}
}
}

View File

@@ -462,6 +462,7 @@ namespace ipl {
directPagePath = "index03.html";
break;
case 7:
default:
directPagePath = "index01.html";
break;
}
@@ -1379,34 +1380,30 @@ namespace ipl {
return;
}
// One pointer, overwritten by the standard-buffer fetch, so the
// browser `this` and standardBuffer share a callee-saved reg.
void* held = surface->GetBrowserThread();
if (held == NULL) {
ext_ead::www::BrowserThread* browser = surface->GetBrowserThread();
if (browser == NULL) {
return;
}
if (static_cast<ext_ead::www::BrowserThread*>(held)->GetTextureBuffer(0, NULL) == NULL) {
if (browser->GetTextureBuffer(0, NULL) == NULL) {
return;
}
ext_ead::www::BrowserWindow* browserWindow =
static_cast<ext_ead::www::BrowserWindow*>(static_cast<ext_ead::www::BrowserThread*>(held)->mpBrowserWindows[0]);
if ((browserWindow == NULL ? 0 : browserWindow->unk_0x2C4[3]) != 0) {
static_cast<ext_ead::www::BrowserWindow*>(browser->mpBrowserWindows[0]);
if ((browserWindow != NULL ? browserWindow->unk_0x2C4[3] : 0) != 0) {
unk_0x91C[2] = 1;
mState = 0;
browserWindow = static_cast<ext_ead::www::BrowserWindow*>(static_cast<ext_ead::www::BrowserThread*>(held)->mpBrowserWindows[0]);
browserWindow = static_cast<ext_ead::www::BrowserWindow*>(browser->mpBrowserWindows[0]);
if (browserWindow != NULL) {
browserWindow->unk_0x2C4[3] = 0;
}
www::trasition::ScrollState scrollState = www::trasition::GetScrollState();
if (scrollState == www::trasition::SCROLL_LEFT) {
browserScrollDirection = 1;
} else {
browserScrollDirection = scrollState == www::trasition::SCROLL_RIGHT ? -1 : 0;
}
browserScrollDirection = scrollState == www::trasition::SCROLL_LEFT
? 1
: (scrollState == www::trasition::SCROLL_RIGHT ? -1 : 0);
www::trasition::ResetScrollState();
void* changedWideBuffer = static_cast<ext_ead::www::BrowserThread*>(held)->GetTextureBuffer(1, NULL);
void* changedStandardBuffer = static_cast<ext_ead::www::BrowserThread*>(held)->GetTextureBuffer(0, NULL);
void* changedWideBuffer = browser->GetTextureBuffer(1, NULL);
void* changedStandardBuffer = browser->GetTextureBuffer(0, NULL);
OSReport("changed %p %p\n", changedStandardBuffer, changedWideBuffer);
ext_ead::www::Heap::reportLeaHeap();
}
@@ -1419,9 +1416,8 @@ namespace ipl {
WWWRect* standardRect;
WWWRect* wideRect;
void* wideBuffer = static_cast<ext_ead::www::BrowserThread*>(held)->GetTextureBuffer(1, &wideRect);
held = static_cast<ext_ead::www::BrowserThread*>(held)->GetTextureBuffer(0, &standardRect);
void* standardBuffer = held;
void* wideBuffer = browser->GetTextureBuffer(1, &wideRect);
void* standardBuffer = browser->GetTextureBuffer(0, &standardRect);
nw4r::ut::Rect projection4x3;
System::getProjectionRect4x3(&projection4x3);
int screenWidth = abs(static_cast<int>(projection4x3.GetWidth()));
@@ -1448,33 +1444,33 @@ namespace ipl {
int wideWidth = abs(static_cast<int>(projection16x9.GetWidth()));
int wideHeight = abs(static_cast<int>(projection16x9.GetHeight()));
f32 wideLeft = -wideWidth / 2;
f32 wideTopL = wideHeight / 2;
f32 wideTop = wideHeight / 2;
f32 wideRight = wideWidth / 2;
f32 wideTopR = wideHeight / 2;
nw4r::ut::Rect leftSide(wideLeft, wideTopL,
nw4r::ut::Rect leftSide(wideLeft, wideTop,
wideLeft + sideDescriptor->textureHeader->width,
wideTopL - sideDescriptor->textureHeader->height);
wideTop - sideDescriptor->textureHeader->height);
nw4r::ut::Rect rightSide(wideRight - sideDescriptor->textureHeader->width,
wideTopR, wideRight, wideTopR - sideDescriptor->textureHeader->height);
wideTop, wideRight, wideTop - sideDescriptor->textureHeader->height);
if (browserScrollDirection != 0) {
void* wideMaterial =
nw4r::lyt::Material* wideMaterial =
mpChangeLayout->FindPaneByName("N_Tra0")->FindMaterialByName("Tex0");
nw4r::lyt::Material* firstStandardMaterial =
mpChangeLayout->FindPaneByName("N_Tra0")->FindMaterialByName("Tex1");
nw4r::lyt::Material* secondStandardMaterial =
mpChangeLayout->FindPaneByName("N_Tra0")->FindMaterialByName("Tex2");
static_cast<nw4r::lyt::Material*>(wideMaterial)->SetTexture(0, wideTexture);
wideMaterial->SetTexture(0, wideTexture);
firstStandardMaterial->SetTexture(0, standardTexture);
secondStandardMaterial->SetTexture(0, standardTexture);
mpChangeLayout->FindPaneByName("N_Tra0")->SetVisible(true);
if (browserScrollDirection == 1) {
wideMaterial = mpSecondAnimation;
static_cast<utility::FrameController*>(wideMaterial)->initFrame();
static_cast<utility::FrameController*>(wideMaterial)->restart();
utility::FrameController* animation = mpSecondAnimation;
animation->initFrame();
animation->restart();
} else {
wideMaterial = mpFirstAnimation;
static_cast<utility::FrameController*>(wideMaterial)->initFrame();
static_cast<utility::FrameController*>(wideMaterial)->restart();
utility::FrameController* animation = mpFirstAnimation;
animation->initFrame();
animation->restart();
}
mpChangeLayout->calc();
browserScrollDirection = 0;
@@ -1514,44 +1510,13 @@ namespace ipl {
}
if (mpWiiSettingFlag->smthMsgData >= 2 && mpWiiSettingFlag->smthMsgData <= 7) {
GXRenderModeObj* pRmode = System::getRenderModeObj();
GXRenderModeObj renderMode;
volatile GXRenderModeObj* srcMode = pRmode;
volatile GXRenderModeObj* dstMode = &renderMode;
int n = 12;
u8* src;
u8* dst = &renderMode.aa;
src = &pRmode->aa;
dstMode->viTVmode = srcMode->viTVmode;
dstMode->fbWidth = srcMode->fbWidth;
dstMode->efbHeight = srcMode->efbHeight;
dstMode->xfbHeight = srcMode->xfbHeight;
dstMode->viXOrigin = srcMode->viXOrigin;
dstMode->viYOrigin = srcMode->viYOrigin;
dstMode->viWidth = srcMode->viWidth;
dstMode->viHeight = srcMode->viHeight;
dstMode->xFBmode = srcMode->xFBmode;
dstMode->field_rendering = srcMode->field_rendering;
dstMode->aa = srcMode->aa;
for (; n != 0; n--) {
dst[1] = src[1];
dst[2] = src[2];
src += 2;
dst += 2;
}
dstMode->vfilter[0] = srcMode->vfilter[0];
dstMode->vfilter[1] = srcMode->vfilter[1];
dstMode->vfilter[2] = srcMode->vfilter[2];
dstMode->vfilter[3] = srcMode->vfilter[3];
dstMode->vfilter[4] = srcMode->vfilter[4];
dstMode->vfilter[5] = srcMode->vfilter[5];
dstMode->vfilter[6] = srcMode->vfilter[6];
GXRenderModeObj renderMode = *System::getRenderModeObj();
u32 left;
u32 top;
u32 width;
u32 height;
GXGetScissor(&left, &top, &width, &height);
GXSetScissor(0, dstMode->efbHeight / 2 - 0xA4, dstMode->fbWidth, 0x132);
GXSetScissor(0, renderMode.efbHeight / 2 - 0xA4, renderMode.fbWidth, 0x132);
mpMainLayout->draw();
GXSetScissor(left, top, width, height);
}
@@ -1641,10 +1606,10 @@ namespace ipl {
OSReport("initKeyboard formId:%d\n", mpWiiSettingData->data[0x11]);
memset(unk_0x938, 0, sizeof(unk_0x938));
int stringLimit;
keyboard::Manager::KeyboardType keyboardType = keyboard::Manager::LETTER;
int rowLimit;
int invalidInput = 0;
keyboard::Manager::KeyboardType keyboardType = keyboard::Manager::LETTER;
int rowLimit = 0;
int stringLimit = 0;
int productArea = static_cast<s8>(SCGetProductArea());
switch (mpWiiSettingData->data[0x11]) {
@@ -1746,16 +1711,14 @@ namespace ipl {
}
if (productArea == 11) {
void* systemDic = System::getKeyboard()->getZiSystemDic();
void* oemDic = System::getKeyboard()->getZiOemDic();
System::getKeyboard()->memoFrm()->setZiDictionary(oemDic, systemDic);
System::getKeyboard()->memoFrm()->setZiDictionary(System::getKeyboard()->getZiOemDic(), System::getKeyboard()->getZiSystemDic());
}
keyboard::Manager::KeyboardSetting setting;
setting.rowLimit = rowLimit;
setting.type = keyboardType;
setting.wcString = reinterpret_cast<const wchar_t*>(unk_0x938);
setting.stringLimit = stringLimit;
setting.type = keyboardType;
setting.rowLimit = rowLimit;
System::getKeyboard()->start(0, setting);
if (invalidInput != 0) {
@@ -1775,6 +1738,7 @@ namespace ipl {
if (mKeyboardState.pressOK) {
onTextInputOK();
u8 formId = mpWiiSettingData->data[0x11];
formText = NULL;
switch (formId) {
case 1:
formText = mpStringBuffer->nickname;
@@ -1845,8 +1809,7 @@ namespace ipl {
memcpy(mpStringBuffer->asterisks, mpStringBuffer->securityKey, sizeof(mpStringBuffer->securityKey));
mpStringBuffer->asterisks[0x41] = 0;
while (mpStringBuffer->asterisks[index] != 0) {
mpStringBuffer->asterisks[index] = '*';
index++;
mpStringBuffer->asterisks[index++] = '*';
}
if (index > 0x20) {
mpStringBuffer->asterisks[0x20] = '\n';
@@ -1858,6 +1821,7 @@ namespace ipl {
}
} else {
u8 formId = mpWiiSettingData->data[0x11];
formText = NULL;
switch (formId) {
case 1:
formText = mpStringBuffer->nickname;

View File

@@ -30,7 +30,7 @@ namespace ipl {
SettingSelect::SettingSelect(EGG::Heap* heap, int arg)
: Base(heap), ::gui::EventHandler(), mState(STATE_WAIT_BUTTON_FADE_IN), mPrevState(STATE_WAIT_BUTTON_FADE_IN), mSettingArg(arg),
mpLayout(NULL), mpLayoutFile(NULL), mpGui(NULL), mPendingSceneId(0), mExitSeqStep(0) {
mpLayout(NULL), mpLayoutFile(NULL), mpGui(NULL), unk_0x90(0), unk_0x94(0) {
setSceneParentFlags(SCN_PARENTFLAG_CALC | SCN_PARENTFLAG_DRAW);
}
@@ -222,7 +222,7 @@ namespace ipl {
void SettingSelect::stt_1st_fadeout() {
if (is_stopped_all_anm()) {
if (mPendingSceneId != 0) {
if (unk_0x90 != 0) {
System::getFader()->fadeOut();
CHANGE_STATE(STATE_WAIT_BLACK_OUT);
} else {
@@ -247,7 +247,7 @@ namespace ipl {
void SettingSelect::stt_2nd_fadeout() {
if (is_stopped_all_anm()) {
if (mPendingSceneId != 0) {
if (unk_0x90 != 0) {
CHANGE_STATE(STATE_WAIT_CHILD);
reset_gui();
} else {
@@ -309,7 +309,7 @@ namespace ipl {
case STATE_1ST_NORMAL: {
System::getChannelManager()->refreshAsync();
System::getFader()->fadeOut();
mPendingSceneId = SCENE_BOARD;
unk_0x90 = 4;
reserveAllSceneDestruction(SCENE_BOARD, NULL);
@@ -369,8 +369,8 @@ namespace ipl {
int backAnim = -1;
int inAnim = -1;
switch (mPendingSceneId) {
case SCENE_MEMORY: {
switch (unk_0x90) {
case 13: {
#ifndef KOREAN_BUILD
backAnim = ANIM_WII_SAVE_DATA_BACK;
inAnim = ANIM_GC_SAVE_DATA_IN;
@@ -380,12 +380,12 @@ namespace ipl {
#endif
break;
}
case SCENE_MEMORY_CARD: {
case 14: {
backAnim = ANIM_GC_SAVE_DATA_BACK;
inAnim = ANIM_WII_SAVE_DATA_IN;
break;
}
case SCENE_CHANNEL_EDIT: {
case 12: {
backAnim = ANIM_CHANNEL_BACK;
inAnim = ANIM_SAVE_DATA_IN;
if (mSettingArg == SettingSelectArg::ARG_START_SAVE_DATA) {
@@ -404,14 +404,14 @@ namespace ipl {
void SettingSelect::stt_wait_child_anm() {
if (is_stopped_all_anm()) {
switch (mPendingSceneId) {
case SCENE_CHANNEL_EDIT: {
switch (unk_0x90) {
case 12: {
static_cast<SettingButton*>(System::getScene(SCENE_SETTING_BUTTON))->showWii();
CHANGE_STATE(STATE_2ND_NORMAL);
break;
}
case SCENE_MEMORY:
case SCENE_MEMORY_CARD: {
case 13:
case 14: {
static_cast<SettingButton*>(System::getScene(SCENE_SETTING_BUTTON))->showWii();
#ifndef KOREAN_BUILD
CHANGE_STATE(STATE_3RD_NORMAL);
@@ -422,7 +422,7 @@ namespace ipl {
}
}
mPendingSceneId = 0;
unk_0x90 = 0;
}
}
@@ -587,7 +587,7 @@ namespace ipl {
break;
}
case BTN_SETTING: {
mPendingSceneId = SCENE_SETTING;
unk_0x90 = 18;
flashAnim = ANIM_SETTING_FLASH;
outAnim = ANIM_DATA_MANAGE_OUT;
reserveAllSceneDestruction(SCENE_SETTING, (void*)Setting::ARG_NORMAL_PAGE);
@@ -596,7 +596,7 @@ namespace ipl {
}
case BTN_SAVEDATA: {
#ifdef KOREAN_BUILD
mPendingSceneId = SCENE_MEMORY;
unk_0x90 = 13;
#endif
flashAnim = ANIM_SAVE_DATA_FLASH;
outAnim = ANIM_CHANNEL_OUT;
@@ -611,7 +611,7 @@ namespace ipl {
break;
}
case BTN_CHANNEL: {
mPendingSceneId = SCENE_CHANNEL_EDIT;
unk_0x90 = 12;
flashAnim = ANIM_CHANNEL_FLASH;
outAnim = ANIM_SAVE_DATA_OUT;
createChildScene(SCENE_CHANNEL_EDIT, this, NULL);
@@ -623,7 +623,7 @@ namespace ipl {
break;
}
case BTN_WII_SAVE: {
mPendingSceneId = SCENE_MEMORY;
unk_0x90 = 13;
flashAnim = ANIM_WII_SAVE_DATA_FLASH;
outAnim = ANIM_GC_SAVE_DATA_OUT;
createChildScene(SCENE_MEMORY, this, NULL);
@@ -632,7 +632,7 @@ namespace ipl {
break;
}
case BTN_GC_SAVE: {
mPendingSceneId = SCENE_MEMORY_CARD;
unk_0x90 = 14;
flashAnim = ANIM_GC_SAVE_DATA_FLASH;
outAnim = ANIM_WII_SAVE_DATA_OUT;
createChildScene(SCENE_MEMORY_CARD, this, NULL);
@@ -689,7 +689,7 @@ namespace ipl {
}
void SettingSelect::calc_exit_sequence() {
switch (mExitSeqStep) {
switch (unk_0x94) {
case 0: {
prepare_exit_abort();
break;
@@ -720,13 +720,13 @@ namespace ipl {
System::getBS2Manager()->abort();
System::stopReceiveSchedule();
mExitSeqStep = 1;
unk_0x94 = 1;
}
}
void SettingSelect::wait_decide_se() {
if (!snd::getSystem()->isSEActive("WIPL_SE_DECIDE")) {
mExitSeqStep = 2;
unk_0x94 = 2;
}
}
@@ -734,7 +734,7 @@ namespace ipl {
__WPADReconnect(TRUE);
snd::getSystem()->stopAllSound(20);
System::getFader()->fadeOut();
mExitSeqStep = 3;
unk_0x94 = 3;
}
void SettingSelect::finish_exit_reboot() {

View File

@@ -91,7 +91,7 @@ namespace ipl {
extern "C" const u32 scLangLookup__Q23ipl7channel[][16];
Manager::Manager(EGG::Heap* heap)
: mpHeap(heap), mState(INIT), mbCanRefresh(0), mbDiskChannelReady(false), mbSetDiskBannerInfo(false), mPrevNandResult(NAND_RESULT_OK),
: mpHeap(heap), mState(INIT), mbCanRefresh(0), unk_0x1B81(false), mbSetDiskBannerInfo(false), mPrevNandResult(NAND_RESULT_OK),
mbLoadedChJump(false) {
mpLockedMsgFile = NULL;
@@ -951,7 +951,7 @@ namespace ipl {
int state = System::getBS2Manager()->getIPLState();
if (state == bs2::IPL_STATE_RVL_GAME && mBS2State != bs2::IPL_STATE_RVL_GAME) {
mbSetDiskBannerInfo = setDiskBannerInfo(false);
mbDiskChannelReady = true;
unk_0x1B81 = true;
} else if (state != bs2::IPL_STATE_RVL_GAME && state != mBS2State) {
setDiskBannerInfo(true);
}
@@ -1076,7 +1076,7 @@ namespace ipl {
ARCFileInfo readFile;
if (unk) {
mbDiskChannelReady = false;
unk_0x1B81 = false;
}
int diskPage, diskIndex;

View File

@@ -46,17 +46,17 @@ namespace ipl {
}
if (mButton != 0) {
if (down(BTN_INTERACT)) {
mDecideHoldCount++;
unk_0x08++;
} else {
mDecideHoldCount = 0;
unk_0x08 = 0;
mButton = 0;
}
} else {
mDecideHoldCount = 0;
unk_0x08 = 0;
}
} else {
mButton = 0;
mDecideHoldCount = 0;
unk_0x08 = 0;
}
switch (mRumbleType) {
@@ -109,7 +109,7 @@ namespace ipl {
return NULL;
}
int ipl::controller::Base::decide() const {
return mDecideHoldCount == 5;
return unk_0x08 == 5;
}
int ipl::controller::Base::rumble(int type) {
int ret = FALSE;
@@ -130,44 +130,44 @@ namespace ipl {
}
void ipl::controller::Revolution::read() {
if (!isValidDpd()) {
mpKpadStatus->pos.y = 1.0f / 0.0f;
mpKpadStatus->pos.x = 1.0f / 0.0f;
mpKpadStatus->speed = 0.0f;
mpKpadStatus->vec.y = 0.0f;
mpKpadStatus->vec.x = 0.0f;
unk_0x20->pos.y = 1.0f / 0.0f;
unk_0x20->pos.x = 1.0f / 0.0f;
unk_0x20->speed = 0.0f;
unk_0x20->vec.y = 0.0f;
unk_0x20->vec.x = 0.0f;
}
mbWasPinching = mbPinching;
unk_0x1E = unk_0x1D;
if (isValidBtn()) {
if (mbWasPinching == 0) {
if (unk_0x1E == 0) {
if (down(0x800) && down(0x400)) {
mbPinching = 1;
unk_0x1D = 1;
}
} else if (!down(0x800) || !down(0x400)) {
mbPinching = 0;
unk_0x1D = 0;
}
} else {
mbPinching = 0;
unk_0x1D = 0;
}
Base::read();
}
bool ipl::controller::Revolution::isValidDpd() const {
if (mbForceInvalid != 0) {
if (unk_0x1C != 0) {
return false;
}
return (mpKpadStatus->wpad_err == 0 || mpKpadStatus->wpad_err == -7) && mpKpadStatus->dpd_valid_fg != 0;
return (unk_0x20->wpad_err == 0 || unk_0x20->wpad_err == -7) && unk_0x20->dpd_valid_fg != 0;
}
bool ipl::controller::Revolution::isValidBtn() const {
u8 val = mpKpadStatus->wpad_err;
u8 val = unk_0x20->wpad_err;
return (u8)(val + 7) <= 7 && ((1 << (val + 7)) & 0xA1) != 0;
}
bool ipl::controller::Revolution::down(u32 mButton) const {
bool ret = false;
if (isValidBtn()) {
if (mpKpadStatus->hold & (mButton & 0xFFFF)) {
if (unk_0x20->hold & (mButton & 0xFFFF)) {
ret = true;
}
}
@@ -177,7 +177,7 @@ namespace ipl {
ipl::math::VEC2 ipl::controller::Revolution::getDpdProjectionPos() const {
math::VEC2 ret;
Vec2 dest;
Vec2 src = {mpKpadStatus->pos.x, mpKpadStatus->pos.y};
Vec2 src = {unk_0x20->pos.x, unk_0x20->pos.y};
nw4r::ut::Rect nw4r_rect; // constructor shouldn't be inlined
Rect kpad_rect;
@@ -216,9 +216,9 @@ namespace ipl {
y = fy;
}
ipl::controller::Classic::Classic(int arg0, KPADStatus& arg1) : Revolution(arg0, arg1) {
mClassicCursorPos.x = 0.01f;
mClassicCursorPos.y = 0.01f;
mClassicCursorTimer = 0;
unk_0x24.x = 0.01f;
unk_0x24.y = 0.01f;
unk_0x2C = 0;
}
ipl::controller::Base::~Base() {
}
@@ -230,32 +230,32 @@ namespace ipl {
}
void ipl::controller::Classic::read() {
if (!Revolution::isValidDpd()) {
math::VEC2 lstick(mpKpadStatus->ex_status.cl.lstick.x, mpKpadStatus->ex_status.cl.lstick.y);
math::VEC2 lstick(unk_0x20->ex_status.cl.lstick.x, unk_0x20->ex_status.cl.lstick.y);
if (lstick.x * lstick.x + lstick.y * lstick.y > 0.0036f) {
mClassicCursorPos.x = math::abs_clamp(mClassicCursorPos.x + mpKpadStatus->ex_status.cl.lstick.x * 0.05f, 1.8f);
mClassicCursorPos.y = math::abs_clamp(mClassicCursorPos.y - mpKpadStatus->ex_status.cl.lstick.y * 0.05f, 1.2f);
unk_0x24.x = math::abs_clamp(unk_0x24.x + unk_0x20->ex_status.cl.lstick.x * 0.05f, 1.8f);
unk_0x24.y = math::abs_clamp(unk_0x24.y - unk_0x20->ex_status.cl.lstick.y * 0.05f, 1.2f);
}
math::VEC2 rstick = math::VEC2(mpKpadStatus->ex_status.cl.rstick.x, mpKpadStatus->ex_status.cl.rstick.y);
math::VEC2 rstick = math::VEC2(unk_0x20->ex_status.cl.rstick.x, unk_0x20->ex_status.cl.rstick.y);
if (getClassicHoldFlag() != 0 || lstick.x * lstick.x + lstick.y * lstick.y > 0.0036f ||
rstick.x * rstick.x + rstick.y * rstick.y > 0.0036f) {
mClassicCursorTimer = 180;
unk_0x2C = 180;
}
if (--mClassicCursorTimer < 0) {
mClassicCursorTimer = 0;
if (--unk_0x2C < 0) {
unk_0x2C = 0;
}
} else {
mClassicCursorPos.y = 0.01f;
mClassicCursorPos.x = 0.01f;
mClassicCursorTimer = 0;
unk_0x24.y = 0.01f;
unk_0x24.x = 0.01f;
unk_0x2C = 0;
}
Revolution::read();
}
int ipl::controller::Classic::getClassicHoldFlag() const {
return mpKpadStatus->ex_status.cl.hold;
return unk_0x20->ex_status.cl.hold;
}
template <>
f32 ipl::math::abs_clamp<f32>(const f32& x, const f32& y) {
@@ -270,7 +270,7 @@ namespace ipl {
ipl::math::VEC2 ipl::controller::Classic::getHorizon() const {
math::VEC2 ret;
if (Revolution::isValidDpd()) {
ret.set(mpKpadStatus->horizon.x, mpKpadStatus->horizon.y);
ret.set(unk_0x20->horizon.x, unk_0x20->horizon.y);
} else {
ret.x = 1.0f;
ret.y = -0.2679492f;
@@ -280,9 +280,9 @@ namespace ipl {
ipl::math::VEC2 ipl::controller::Classic::getDpdPos() const {
math::VEC2 ret;
if (Revolution::isValidDpd()) {
ret.set(mpKpadStatus->pos.x, mpKpadStatus->pos.y);
} else if (mClassicCursorTimer != 0) {
ret = mClassicCursorPos;
ret.set(unk_0x20->pos.x, unk_0x20->pos.y);
} else if (unk_0x2C != 0) {
ret = unk_0x24;
} else {
ret.x = (1.0f / 0.0f);
ret.y = (1.0f / 0.0f);
@@ -296,9 +296,9 @@ namespace ipl {
ipl::math::VEC2 ipl::controller::Classic::getDpdProjectionPos() const {
math::VEC2 ret;
if (Revolution::isValidDpd()) {
ret.set(mpKpadStatus->pos.x, mpKpadStatus->pos.y);
} else if (mClassicCursorTimer != 0) {
ret = mClassicCursorPos;
ret.set(unk_0x20->pos.x, unk_0x20->pos.y);
} else if (unk_0x2C != 0) {
ret = unk_0x24;
} else {
ret.set(1.0f / 0.0f, 1.0f / 0.0f);
}
@@ -454,7 +454,7 @@ void ipl::controller::Master::setForceInvalid(bool flag) {
return -1;
}
void ipl::controller::Base::setForceInvalid(bool flag) {
mbForceInvalid = flag;
unk_0x1C = flag;
}
int ipl::controller::Base::getType() const {
return mType;
@@ -463,65 +463,65 @@ void ipl::controller::Master::setForceInvalid(bool flag) {
return mChan;
}
KPADStatus* ipl::controller::Revolution::getKPADStatus() const {
return mpKpadStatus;
return unk_0x20;
}
f32 ipl::controller::Revolution::getDpdDistance() const {
return mpKpadStatus->dist;
return unk_0x20->dist;
}
int ipl::controller::Revolution::getReleaseFlag() const {
return mpKpadStatus->release;
return unk_0x20->release;
}
int ipl::controller::Revolution::getTrigFlag() const {
return mpKpadStatus->trig;
return unk_0x20->trig;
}
int ipl::controller::Revolution::getHoldFlag() const {
return mpKpadStatus->hold;
return unk_0x20->hold;
}
int ipl::controller::Revolution::pinchOffTrg() const {
int ret = 0;
if (isValidBtn() && mbPinching == 0 && mbWasPinching != 0) {
if (isValidBtn() && unk_0x1D == 0 && unk_0x1E != 0) {
ret = 1;
}
return ret;
}
int ipl::controller::Revolution::pinch() const {
int ret = 0;
if (isValidBtn() && mbPinching != 0) {
if (isValidBtn() && unk_0x1D != 0) {
ret = 1;
}
return ret;
}
int ipl::controller::Revolution::pinchTrg() const {
int ret = 0;
if (isValidBtn() && mbPinching != 0 && mbWasPinching == 0) {
if (isValidBtn() && unk_0x1D != 0 && unk_0x1E == 0) {
ret = 1;
}
return ret;
}
bool ipl::controller::Revolution::repeat(u32 button) const {
return down(button) && (mpKpadStatus->hold & 0x80000000) != 0;
return down(button) && (unk_0x20->hold & 0x80000000) != 0;
}
BOOL ipl::controller::Classic::isValidDpdClassic() const {
return mClassicCursorTimer != 0;
return unk_0x2C != 0;
}
bool ipl::controller::Classic::isValidDpd() const {
if (mbForceInvalid != 0) {
if (unk_0x1C != 0) {
return false;
}
return (Revolution::isValidDpd() != 0) || (mClassicCursorTimer != 0);
return (Revolution::isValidDpd() != 0) || (unk_0x2C != 0);
}
int ipl::controller::Classic::getClassicReleaseFlag() const {
return mpKpadStatus->ex_status.cl.release;
return unk_0x20->ex_status.cl.release;
}
int ipl::controller::Classic::getClassicTrigFlag() const {
return mpKpadStatus->ex_status.cl.trig;
return unk_0x20->ex_status.cl.trig;
}
bool ipl::controller::Classic::upTrg(u32 button) const {
bool ret = false;
if (isValidBtn()) {
bool pressed = true;
KPADStatus* status = mpKpadStatus;
KPADStatus* status = unk_0x20;
if ((status->release & (button & 0xFFFF)) == 0) {
if ((status->ex_status.cl.release & (button >> 16)) == 0) {
pressed = false;
@@ -537,7 +537,7 @@ void ipl::controller::Master::setForceInvalid(bool flag) {
bool ret = false;
if (isValidBtn()) {
bool pressed = true;
KPADStatus* status = mpKpadStatus;
KPADStatus* status = unk_0x20;
if ((status->trig & (button & 0xFFFF)) == 0) {
if ((status->ex_status.cl.trig & (button >> 16)) == 0) {
pressed = false;
@@ -553,8 +553,8 @@ void ipl::controller::Master::setForceInvalid(bool flag) {
bool ret = false;
if (isValidBtn()) {
bool pressed = true;
if ((mpKpadStatus->hold & (button & 0xFFFF)) == 0) {
if ((mpKpadStatus->ex_status.cl.hold & (button >> 16)) == 0) {
if ((unk_0x20->hold & (button & 0xFFFF)) == 0) {
if ((unk_0x20->ex_status.cl.hold & (button >> 16)) == 0) {
pressed = false;
}
}
@@ -565,15 +565,15 @@ void ipl::controller::Master::setForceInvalid(bool flag) {
return ret;
}
ipl::math::VEC2 ipl::controller::Revolution::getHorizon() const {
return math::VEC2(mpKpadStatus->horizon.x, mpKpadStatus->horizon.y);
return math::VEC2(unk_0x20->horizon.x, unk_0x20->horizon.y);
}
ipl::math::VEC2 ipl::controller::Revolution::getDpdPos() const {
return math::VEC2(mpKpadStatus->pos.x, mpKpadStatus->pos.y);
return math::VEC2(unk_0x20->pos.x, unk_0x20->pos.y);
}
bool ipl::controller::Revolution::upTrg(u32 button) const {
bool ret = false;
if (isValidBtn()) {
if (mpKpadStatus->release & (button & 0xFFFF)) {
if (unk_0x20->release & (button & 0xFFFF)) {
ret = true;
}
}
@@ -582,7 +582,7 @@ void ipl::controller::Master::setForceInvalid(bool flag) {
bool ipl::controller::Revolution::downTrg(u32 button) const {
bool ret = false;
if (isValidBtn()) {
if (mpKpadStatus->trig & (button & 0xFFFF)) {
if (unk_0x20->trig & (button & 0xFFFF)) {
ret = true;
}
}

View File

@@ -152,9 +152,9 @@ namespace ipl {
}
Revolution::Revolution(int chan, int type, KPADStatus& status) : Base(chan, type, status) {
mbPinching = 0;
mbWasPinching = 0;
mpKpadStatus = &status;
unk_0x1D = 0;
unk_0x1E = 0;
unk_0x20 = &status;
}
Interface* Manager::getMasterController() {

View File

@@ -931,15 +931,17 @@ void CArGBAOdh::cdj_c_makeHeader(SArCDJ_OdhMaster* master, u32 size) {
}
s32 CArGBAOdh::cdj_c_colorConv(SArCDJ_OdhMaster* master, u8* sourceData, int format) {
u32 paddedWidth;
u16 width;
u16 height;
u8* workPlane;
u8* cbPlane;
int sourceStride;
u8* crPlane;
u8* cbPlane;
u16* dimensions;
int rowIndex;
int sourceStride;
int i;
u16 dimension;
u16 paddedDimensions[2];
dimensions = &master->width;
@@ -950,11 +952,11 @@ s32 CArGBAOdh::cdj_c_colorConv(SArCDJ_OdhMaster* master, u8* sourceData, int for
height = dimensions[1];
for (i = 0; i < 2; i++) {
u16 remainder = dimensions[i] & 7;
if (remainder != 0) {
paddedDimensions[i] = (dimensions[i] + 8) - remainder;
dimension = dimensions[i];
if ((dimension & 7) != 0) {
paddedDimensions[i] = (dimension + 8) - (dimension & 7);
} else {
paddedDimensions[i] = dimensions[i];
paddedDimensions[i] = dimension;
}
}
@@ -970,12 +972,13 @@ s32 CArGBAOdh::cdj_c_colorConv(SArCDJ_OdhMaster* master, u8* sourceData, int for
}
}
paddedWidth = paddedDimensions[0];
for (rowIndex = 0; rowIndex < (s32)height; rowIndex++) {
LineConv11(sourceData + (rowIndex & 3) * 8 + rowIndex / 4 * sourceStride, workPlane, cbPlane, crPlane,
dimensions[0], dimensions[1], (const long*)gArConvPlttTbl, format);
workPlane += paddedDimensions[0];
cbPlane += paddedDimensions[0];
crPlane += paddedDimensions[0];
workPlane += paddedWidth;
cbPlane += paddedWidth;
crPlane += paddedWidth;
}
return 0;
@@ -1359,10 +1362,12 @@ s32 CArGBAOdh::cdj_d_initializeDecompressOdh(SArCDJ_OdhMaster* master, u8* workB
}
s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int workSize) {
int blockStride;
int workBufferSize = workSize;
u8 xSampling;
u8 coefficientIndex;
u16 blockWidth;
int blockRowStride;
int planeOffset;
u32 sourceLimit = srcSize;
int statusOrOffset;
@@ -1375,6 +1380,8 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
blockWidth = master->blocksWide;
blockRowSize = (u32)blockWidth * 0x38;
rowStride = (u32)blockWidth << 3;
blockRowStride = blockRowSize * 2;
blockStride = (u32)blockWidth << 4;
do {
xSampling = master->xSampling;
if ((xSampling == 1U) && (master->ySampling == 1U)) {
@@ -1405,9 +1412,9 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
coefficientIndex = odh_natural_order[naturalIndex];
master->coefficients[coefficientIndex] = master->dcCoefficients[naturalIndex];
}
statusOrOffset = (u32)master->blockX * 8 +
(u32)master->blocksWide * ((u32)master->blockY << 6) +
(u32)master->blocksHigh * ((u32)master->blocksWide << 6);
statusOrOffset = ((u32)master->blockY << 6) * (u32)master->blocksWide +
((u32)master->blocksHigh * ((u32)master->blocksWide << 6) +
(u32)master->blockX * 8);
if (statusOrOffset + blockRowSize + 8 > workBufferSize) {
statusOrOffset = -0x7ffffffa;
goto finishBlock;
@@ -1447,14 +1454,14 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
}
planeOffset = (u32)master->blockX * 0x10 +
(u32)master->blocksWide * ((u32)master->blockY << 6) * 2;
requiredBlockEnd = planeOffset + (blockRowSize * 2) + 8;
requiredBlockEnd = planeOffset + blockRowStride + 8;
if (requiredBlockEnd > workBufferSize) {
statusOrOffset = -0x7ffffffa;
goto finishBlock;
}
idct_fast
(range_limit,master->quantizationTables,master->coefficients,master->workBuffer + planeOffset
, ((u32)blockWidth << 4));
,blockStride);
statusOrOffset = huffmanDecoder
(master->dcCoefficients, &master->luminanceRequest, (u16**)hufftreePtr.tables, 0, sourceLimit);
master->chrominanceRequest.bitstream = master->luminanceRequest.bitstream;
@@ -1470,7 +1477,7 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
}
idct_fast
(range_limit,master->quantizationTables,master->coefficients,
(u8*)((u32)planeOffset + (u32)master->workBuffer) + 8, ((u32)blockWidth << 4));
planeOffset + master->workBuffer + 8,blockStride);
statusOrOffset = huffmanDecoder
(master->dcCoefficients, &master->chrominanceRequest, (u16**)(hufftreePtr.tables + 2), 1, sourceLimit);
if (statusOrOffset != 0) return statusOrOffset;
@@ -1536,7 +1543,7 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
coefficientIndex = odh_natural_order[naturalIndex];
master->coefficients[coefficientIndex] = master->dcCoefficients[naturalIndex];
}
planeOffset += (u32)master->blocksWide << 6;
planeOffset = planeOffset + (u32)master->blocksWide * 0x40;
if (planeOffset + blockRowSize + 8 > workBufferSize) {
statusOrOffset = -0x7ffffffa;
goto finishBlock;
@@ -1593,14 +1600,14 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
}
planeOffset = (u32)master->blockX * 0x10 +
(u32)master->blocksWide * ((u32)master->blockY << 6) * 4;
requiredBlockEnd = planeOffset + (blockRowSize * 2) + 8;
requiredBlockEnd = planeOffset + blockRowStride + 8;
if (requiredBlockEnd > workBufferSize) {
statusOrOffset = -0x7ffffffa;
goto finishBlock;
}
idct_fast
(range_limit,master->quantizationTables,master->coefficients,master->workBuffer + planeOffset
, ((u32)blockWidth << 4));
,blockStride);
statusOrOffset = huffmanDecoder
(master->dcCoefficients, &master->luminanceRequest, (u16**)hufftreePtr.tables, 0, sourceLimit);
if (statusOrOffset != 0) return statusOrOffset;
@@ -1611,13 +1618,13 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
}
int nextOffset = planeOffset + 8;
planeOffset = nextOffset;
if (nextOffset + (blockRowSize * 2) + 8 > workBufferSize) {
if (nextOffset + blockRowStride + 8 > workBufferSize) {
statusOrOffset = -0x7ffffffa;
goto finishBlock;
}
idct_fast
(range_limit,master->quantizationTables,master->coefficients,master->workBuffer + nextOffset
, ((u32)blockWidth << 4));
,blockStride);
statusOrOffset = huffmanDecoder
(master->dcCoefficients, &master->luminanceRequest, (u16**)hufftreePtr.tables, 0, sourceLimit);
if (statusOrOffset != 0) return statusOrOffset;
@@ -1626,16 +1633,15 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
coefficientIndex = odh_natural_order[naturalIndex];
master->coefficients[coefficientIndex] = master->dcCoefficients[naturalIndex];
}
// Store the updated plane in requiredBlockEnd so MWCC keeps it in r15.
requiredBlockEnd = planeOffset + (u32)master->blocksWide * 0x80 + -8;
planeOffset = requiredBlockEnd + (blockRowSize * 2) + 8;
if (planeOffset > workBufferSize) {
planeOffset = planeOffset + (u32)master->blocksWide * 0x80 + -8;
requiredBlockEnd = planeOffset + blockRowStride + 8;
if (requiredBlockEnd > workBufferSize) {
statusOrOffset = -0x7ffffffa;
goto finishBlock;
}
idct_fast
(range_limit,master->quantizationTables,master->coefficients,master->workBuffer + requiredBlockEnd
, ((u32)blockWidth << 4));
(range_limit,master->quantizationTables,master->coefficients,master->workBuffer + planeOffset
,blockStride);
statusOrOffset = huffmanDecoder
(master->dcCoefficients, &master->luminanceRequest, (u16**)hufftreePtr.tables, 0, sourceLimit);
master->chrominanceRequest.bitstream = master->luminanceRequest.bitstream;
@@ -1645,13 +1651,13 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
coefficientIndex = odh_natural_order[naturalIndex];
master->coefficients[coefficientIndex] = master->dcCoefficients[naturalIndex];
}
if (planeOffset + 8 > workBufferSize) {
if (requiredBlockEnd + 8 > workBufferSize) {
statusOrOffset = -0x7ffffffa;
goto finishBlock;
}
idct_fast
(range_limit,master->quantizationTables,master->coefficients,
(u8*)((u32)requiredBlockEnd + (u32)master->workBuffer) + 8, ((u32)blockWidth << 4));
planeOffset + master->workBuffer + 8,blockStride);
statusOrOffset = huffmanDecoder
(master->dcCoefficients, &master->chrominanceRequest, (u16**)(hufftreePtr.tables + 2), 1, sourceLimit);
if (statusOrOffset != 0) return statusOrOffset;
@@ -1690,9 +1696,9 @@ s32 CArGBAOdh::cdj_d_decompressLoop(SArCDJ_OdhMaster* master, int srcSize, int w
(range_limit,master->quantizationTables + 64,master->coefficients,master->workBuffer + statusOrOffset,
rowStride);
}
int nextBlockX = master->blockX + 1;
master->blockX = nextBlockX;
if ((u16)nextBlockX == master->blocksWide) {
blockX = master->blockX + 1;
master->blockX = blockX;
if (blockX == master->blocksWide) {
master->blockX = 0;
master->blockY = master->blockY + 1;
}

View File

@@ -884,187 +884,172 @@ namespace ipl {
return ret;
}
static inline void verifySavedataZD(EGG::Heap* heap, ESTitleId titleId, NANDFileInfo* fileInfo) {
char path[NAND_MAX_PATH];
s32 ret;
u8* saveData = NULL;
BOOL fileOpen = FALSE;
BOOL deleteSaveData = FALSE;
sprintf(path, "/title/%08x/%08x/data/%s", (u32)((titleId & 0x00FFFFFFFFFFFFFFULL) >> 32), (u32)(titleId & 0x00FFFFFFFFFFFFFFULL), "zeldaTp.dat");
if (!ESMisc::ChangeUid(titleId)) {
OSReport("%s::%s: ChangeUid failed\n", __FILE__, __FUNCTION__);
ESMisc::DeleteTitle(heap, titleId);
} else {
ret = NANDPrivateOpen(path, fileInfo, NAND_ACCESS_READ);
if (ret == NAND_RESULT_NOEXISTS) {
OSReport("%s::%s: Does not exist %s: %d\n", __FILE__, __FUNCTION__, path, ret);
} else if (ret != NAND_RESULT_OK) {
OSReport("%s::%s: Open save data file failed: %d\n", __FILE__, __FUNCTION__, ret);
} else {
fileOpen = TRUE;
saveData = (u8*)heap->alloc(0x4000, -DEFAULT_ALIGN);
if (saveData == NULL) {
OSReport("%s::%s: Alloc failed: %d\n", __FILE__, __FUNCTION__, -2);
} else {
memset(saveData, 0, 0x4000);
ret = NANDRead(fileInfo, saveData, 0x4000);
if (ret < 0) {
OSReport("%s::%s: Read file failed: %d\n", __FILE__, __FUNCTION__, ret);
goto cleanup;
} else if (ret != 0x4000) {
OSReport("%s::%s: File size is not correct: %d\n", __FILE__, __FUNCTION__, ret);
deleteSaveData = TRUE;
} else {
u32 offset = 8;
u32 j = 0;
BOOL valid = FALSE;
while (j < 3) {
u8* block = saveData + offset;
if (!checkForNullTermination((char*)block + 0x4e, 8) ||
!checkForNullTermination((char*)block + 0x58, 8) ||
!checkForNullTermination((char*)block + 0x72, 8) ||
!checkForNullTermination((char*)block + 0x8e, 8) ||
!checkForNullTermination((char*)block + 0x1b4, 0x11) ||
!checkForNullTermination((char*)block + 0x1c5, 0x11)) {
goto verify_failed;
}
j++;
offset += 0xa94;
}
offset = 0x2008;
j = 0;
while (j < 3) {
u8* block = saveData + offset;
if (!checkForNullTermination((char*)block + 0x4e, 8) ||
!checkForNullTermination((char*)block + 0x58, 8) ||
!checkForNullTermination((char*)block + 0x72, 8) ||
!checkForNullTermination((char*)block + 0x8e, 8) ||
!checkForNullTermination((char*)block + 0x1b4, 0x11) ||
!checkForNullTermination((char*)block + 0x1c5, 0x11)) {
goto verify_failed;
}
j++;
offset += 0xa94;
}
valid = TRUE;
verify_failed:
if (!valid) {
OSReport("%s::%s: Verify failed for %016llx\n", __FILE__, __FUNCTION__,
titleId);
deleteSaveData = TRUE;
}
}
NANDClose(fileInfo);
fileOpen = FALSE;
if (deleteSaveData) {
ESMisc::DeleteSavedata(titleId, heap);
}
}
}
}
cleanup:
if (saveData != NULL) {
heap->free(saveData);
}
if (fileOpen) {
NANDClose(fileInfo);
}
ESMisc::ChangeUid(SYSMENU_TITLE_ID);
}
static inline s32 DeleteTicketsForce(EGG::Heap* heap, ESTitleId titleId, u8* ticketViews, u32* ticketViewCount) {
ESTicketView* ticketViewList = NULL;
s32 ret;
memset(ticketViews, 0, OSRoundUp32B(sizeof(ESTicketView)));
ret = ES_GetTicketViews(titleId, NULL, ticketViewCount);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: ES_GetTicketViews failed: %d for %016llx\n", __FILE__, __FUNCTION__, ret, titleId);
goto cleanup;
}
if (*ticketViewCount == 0) {
return ret;
}
ticketViewList = (ESTicketView*)heap->alloc(*ticketViewCount * OSRoundUp32B(sizeof(ESTicketView)), -DEFAULT_ALIGN);
ret = ES_GetTicketViews(titleId, ticketViewList, ticketViewCount);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: ES_GetTicketViews failed: %d for %016llx\n", __FILE__, __FUNCTION__, ret, titleId);
goto cleanup;
}
for (u32 j = 0; j < *ticketViewCount; j++) {
memcpy(ticketViews, (u8*)ticketViewList + j * sizeof(ESTicketView), sizeof(ESTicketView));
ret = ES_DeleteTicket((ESTicketView*)ticketViews);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: ES_DeleteTicket failed: %d for %016llx\n", __FILE__, __FUNCTION__, ret,
((ESTicketView*)ticketViews)->ticketId);
}
}
cleanup:
if (ticketViewList != NULL) {
heap->free(ticketViewList);
}
return ret;
}
static inline s32 InitSavedata(EGG::Heap* heap) {
u8 ticketViews[OSRoundUp32B(sizeof(ESTicketView))] ALIGN32;
NANDFileInfo fileInfo ALIGN32;
u32 ticketViewCount;
ESTitleId* titleIds = NULL;
void ESMisc::DeleteUnauthorizedData(EGG::Heap* heap) {
u32 titleCount = 0;
ESTitleId* titleIds = NULL;
char path[88];
NANDFileInfo fileInfo ALIGN32;
u8 ticketViews[0xe0] ALIGN32;
u32 ticketViewCount;
ESTicketView* ticketViewList;
s32 ret = ES_ListTitlesOnCard(NULL, &titleCount);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: Failed to ES_ListTitlesOnCard1: %d\n", __FILE__, __FUNCTION__, ret);
goto cleanup;
}
titleIds = (ESTitleId*)heap->alloc(OSRoundUp32B(titleCount * sizeof(ESTitleId)), -DEFAULT_ALIGN);
if (ret == ES_ERR_OK) {
titleIds = (ESTitleId*)heap->alloc(OSRoundUp32B(titleCount * sizeof(ESTitleId)), -DEFAULT_ALIGN);
if (titleIds == NULL) {
OSReport("%s::%s: Unable to allocate\n", __FILE__, __FUNCTION__);
goto cleanup;
}
OSReport("%s::%s: Unable to allocate\n", __FILE__, "InitSavedata");
} else {
ret = ES_ListTitlesOnCard(titleIds, &titleCount);
if (ret == ES_ERR_OK) {
ret = ES_ListTitlesOnCard(titleIds, &titleCount);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: Failed to ES_ListTitlesOnCard2: %d\n", __FILE__, __FUNCTION__, ret);
goto cleanup;
}
u32 titleIdOffset = 0;
for (u32 i = 0; i < titleCount; i++) {
u32 titleIdHi = *(u32*)((u8*)titleIds + titleIdOffset);
u32 titleIdLo = *(u32*)((u8*)titleIds + titleIdOffset + 4);
{
u8* ticketScratch = ticketViews;
for (u32 i = 0; i < titleCount; i++) {
if ((titleIds[i] & 0xFFFFFFFFFFFFFF00ULL) == 0x00010000525A4400ULL) {
verifySavedataZD(heap, titleIds[i], &fileInfo);
continue;
if ((titleIdLo & 0xffffff00) == 0x525a4400 && titleIdHi == 0x10000) {
u8* saveData = NULL;
BOOL fileOpen = FALSE;
BOOL deleteSaveData = FALSE;
sprintf(path - 8, "/title/%08x/%08x/data/%s", titleIdHi & 0xffffff, titleIdLo, "zeldaTp.dat");
if (!ChangeUid(((ESTitleId)titleIdHi << 32) | titleIdLo)) {
OSReport("%s::%s: ChangeUid failed\n", __FILE__, "verifySavedataZD");
DeleteTitle(heap, ((ESTitleId)titleIdHi << 32) | titleIdLo);
} else {
ret = NANDPrivateOpen(path - 8, (NANDFileInfo*)((u8*)&fileInfo - 0x20), NAND_ACCESS_READ);
if (ret == NAND_RESULT_NOEXISTS) {
OSReport("%s::%s: Does not exist %s: %d\n", __FILE__, "verifySavedataZD", path - 8, ret);
} else if (ret != NAND_RESULT_OK) {
OSReport("%s::%s: Open save data file failed: %d\n", __FILE__, "verifySavedataZD", ret);
} else {
fileOpen = TRUE;
saveData = (u8*)heap->alloc(0x4000, -DEFAULT_ALIGN);
if (saveData == NULL) {
OSReport("%s::%s: Alloc failed: %d\n", __FILE__, "verifySavedataZD", -2);
} else {
memset(saveData, 0, 0x4000);
ret = NANDRead((NANDFileInfo*)((u8*)&fileInfo - 0x20), saveData, 0x4000);
if (ret < 0) {
OSReport("%s::%s: Read file failed: %d\n", __FILE__, "verifySavedataZD", ret);
} else if (ret != 0x4000) {
OSReport("%s::%s: File size is not correct: %d\n", __FILE__, "verifySavedataZD", ret);
deleteSaveData = TRUE;
} else {
u32 offset = 8;
u32 j = 0;
BOOL valid = FALSE;
while (j < 3) {
u8* block = saveData + offset;
if (!checkForNullTermination((char*)block + 0x4e, 8) ||
!checkForNullTermination((char*)block + 0x58, 8) ||
!checkForNullTermination((char*)block + 0x72, 8) ||
!checkForNullTermination((char*)block + 0x8e, 8) ||
!checkForNullTermination((char*)block + 0x1b4, 0x11) ||
!checkForNullTermination((char*)block + 0x1c5, 0x11)) {
goto verify_failed;
}
j++;
offset += 0xa94;
}
offset = 0x2008;
j = 0;
while (j < 3) {
u8* block = saveData + offset;
if (!checkForNullTermination((char*)block + 0x4e, 8) ||
!checkForNullTermination((char*)block + 0x58, 8) ||
!checkForNullTermination((char*)block + 0x72, 8) ||
!checkForNullTermination((char*)block + 0x8e, 8) ||
!checkForNullTermination((char*)block + 0x1b4, 0x11) ||
!checkForNullTermination((char*)block + 0x1c5, 0x11)) {
goto verify_failed;
}
j++;
offset += 0xa94;
}
valid = TRUE;
verify_failed:
if (!valid) {
OSReport("%s::%s: Verify failed for %016llx\n", __FILE__, "verifySavedataZD",
((ESTitleId)titleIdHi << 32) | titleIdLo);
deleteSaveData = TRUE;
}
}
NANDClose((NANDFileInfo*)((u8*)&fileInfo - 0x20));
fileOpen = FALSE;
if (deleteSaveData) {
DeleteSavedata(((ESTitleId)titleIdHi << 32) | titleIdLo, heap);
}
}
}
}
switch (titleIds[i]) {
case 0x0001000844495343ULL:
case 0x000100014A4F4449ULL:
case 0x0001000148415858ULL:
case 0x0001000844564458ULL:
case 0x000100084449534BULL:
ES_DeleteTitle(titleIds[i]);
DeleteTicketsForce(heap, titleIds[i], ticketScratch, &ticketViewCount);
break;
if (saveData != NULL) {
heap->free(saveData);
}
if (fileOpen) {
NANDClose((NANDFileInfo*)((u8*)&fileInfo - 0x20));
}
ChangeUid(SYSMENU_TITLE_ID);
continue;
}
if ((((ESTitleId)titleIdHi << 32) | titleIdLo) == 0x0001000844495343ULL ||
((((ESTitleId)titleIdHi << 32) | titleIdLo) < 0x0001000844495343ULL &&
((((ESTitleId)titleIdHi << 32) | titleIdLo) == 0x000100014a4f4449ULL ||
((((ESTitleId)titleIdHi << 32) | titleIdLo) > 0x000100014a4f4449ULL &&
(((ESTitleId)titleIdHi << 32) | titleIdLo) == 0x0001000148415858ULL))) ||
((((ESTitleId)titleIdHi << 32) | titleIdLo) > 0x0001000844495343ULL &&
((((ESTitleId)titleIdHi << 32) | titleIdLo) == 0x0001000844564458ULL ||
((((ESTitleId)titleIdHi << 32) | titleIdLo) > 0x0001000844564458ULL &&
(((ESTitleId)titleIdHi << 32) | titleIdLo) == 0x000100084449534bULL)))) {
ESTitleId titleId = *(ESTitleId*)((u8*)titleIds + titleIdOffset);
ES_DeleteTitle(titleId);
ticketViewList = NULL;
memset(ticketViews, 0, sizeof(ticketViews));
ret = ES_GetTicketViews(titleId, NULL, &ticketViewCount);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: ES_GetTicketViews failed: %d for %016llx\n", __FILE__, "DeleteTicketsForce", ret, titleId);
} else if (ticketViewCount != 0) {
ticketViewList = (ESTicketView*)heap->alloc(ticketViewCount * 0xe0, -DEFAULT_ALIGN);
ret = ES_GetTicketViews(titleId, ticketViewList, &ticketViewCount);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: ES_GetTicketViews failed: %d for %016llx\n", __FILE__, "DeleteTicketsForce", ret, titleId);
} else {
for (u32 j = 0; j < ticketViewCount; j++) {
memcpy(ticketViews, (u8*)ticketViewList + j * sizeof(ESTicketView), 0xd8);
ret = ES_DeleteTicket((ESTicketView*)ticketViews);
if (ret != ES_ERR_OK) {
OSReport("%s::%s: ES_DeleteTicket failed: %d for %016llx\n", __FILE__, "DeleteTicketsForce", ret,
((ESTicketView*)ticketViews)->ticketId);
}
}
}
}
if (ticketViewList != NULL) {
heap->free(ticketViewList);
}
}
titleIdOffset += 8;
}
} else {
OSReport("%s::%s: Failed to ES_ListTitlesOnCard2: %d\n", __FILE__, "InitSavedata", ret);
}
}
} else {
OSReport("%s::%s: Failed to ES_ListTitlesOnCard1: %d\n", __FILE__, "InitSavedata", ret);
}
cleanup:
if (titleIds != NULL) {
heap->free(titleIds);
}
return ret;
}
s32 ESMisc::DeleteUnauthorizedData(EGG::Heap* heap) {
return InitSavedata(heap);
return;
}
BOOL checkForNullTermination(char* str, u32 len) {

View File

@@ -29,26 +29,3 @@ Additional Decrypt correction: restored 0x3E800 size limit, actual seek/read err
Remaining: CDBCryptBuffer 99.97479%, 119/119 instructions, three pool offsets; CDBRecordEncrypt 97.19014%, register allocation and one instruction; CDBRecordDecrypt 99.96789%, stack placement.
The four forced field accessors end with CDBUnlock and do not produce a CDBErr result. Their void declarations are gated by CDB_RECORD_IMPLEMENTATION, preserving all other translation units and avoiding fall-through non-void definitions.
## w1008/cdb leaf — dead-fn fossil + Encrypt coloring (worker w1008)
SOLVED — link-deadstrip fossil mechanism: orig .data's fossil literals (0x398-0x9be)
come from ~15 dead functions whose code mwldeppc stripped at link. Added all dead
fns (CDBRecordGetFileSize through CDBRecordPrivateChangeOwner) as GLOBAL fns in
fossil-emission order; global (not static) emits standalone code AND auto-inlines
at use sites. .data content byte-identical (orig has 2B reconstruction tail pad).
Verified at DOL level: fossil strings land at exact expected vaddrs.
SOLVED — Encrypt +0x40 code gap: `err = CDBRecordGetFileSize(record, &fileSize)`
calls the dead fn which auto-inlines, reproducing orig's expanded block.
`(s32)ptr == 0` → `cmpwi r0,0` required (== NULL gives cmplw). 284/284 insns
identical, 0 stream diffs.
WALL — CDBRecordEncrypt 57 byte diffs, pure callee-reg coloring on identical
web structure. Orig packs {key+err}→r24, {tempFile+fileOffset}→r31, pool→r25,
args→r26-29; mine packs {tempFile+err}→r24, {key+fileOffset}→r29, pool→r31,
args→r25-28. Equal-cost packings (tie-break). ~18 probes all neutral/regressed:
recordFile/err/tempFile/fileOffset decl order+scope+init forms, per-block vs
shared `result`, single-web fileOffset (-69), fn-scope tempFile, `register`,
err dead-init (emits, +4B/831), u32/s32 types, decl+init forms.
DOL-verified: the entire DOL diff vs orig = exactly these 57 bytes.

View File

@@ -1,41 +0,0 @@
# CHANSVm load-constant error preservation
Baseline: 449529d92405f8f7fda610660c7794914a81dfe6. Scope: CHANSVm.c only; no linking classifications or headers changed.
## Retained correction
LOAD_STRING_CONST must preserve a failure from CHANSVmDeleteObject. The original object tests the deletion return and branches directly to the local result merge when it is nonzero. The load-string error is selected only after deletion succeeds and the constant index is out of range or has no string payload. The prior C instead overwrote every deletion error with CHANS_VM_ERR_LOAD_STRING_CONST.
A native destructor that returns false is a concrete error-producing path through CHANSVmDeleteObject; this distinction is observable, not merely a compiler-scheduling preference.
The new local loadResult preserves that error, keeps constant validation and installation inside the successful-deletion block, and merges the result afterward. Target and rebuilt blocks have the same instruction count and control-flow destinations; remaining operand differences are registers. No strings, data layout, or generated jump-table destinations changed.
## Measurements
- All 233 target functions have compiled C implementations; this is not a claim that all are exact or independently behavior-proven.
- Instruction-exact functions: 221/233 -> 221/233; every objdiff-exact function also passes ctxdiff.
- Unit decompiled/fuzzy: 99.364426% -> 99.383840%.
- Exact code: 37608/53564 bytes -> 37608/53564 bytes (70.211334%).
- Exact data: 6904/6904 bytes -> 6904/6904 bytes (100%).
- CHANSVmStep: 96.466080% -> 96.673584%; 1253/1253 instructions; ctxdiff differing positions 314 -> 297.
- Per-function score regressions relative to the fresh baseline report: zero.
- The unit remains NonMatching/unlinked; no link flags were changed.
## Attempts
1. Read previous round/wave logs and recent local trials; establish live baseline and run pool_diff first: 125 strings identical.
2. Replace the load-string shared error/goto path with a typed local error result and successful-deletion-only constant validation. Retained: correct error behavior, higher fuzzy score, unchanged exact code/data.
3. Separately tried consolidating GET_PROPERTY_NAME's local found flag and removing two unused array-index assignments. Rejected and restored completely: Step shrank to 1249 instructions and data dropped to 2232/6904. This unrelated trial is absent from the final source.
## Validation
- Full 43U build passed with the assigned wibo wrapper and WIBO_SJIS_MISSING_IMPORTS=1.
- DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d.
- pool_diff: 125/125 identical strings.
- .data: 4672/4672 bytes identical; all 352 canonical relocations identical.
- .rodata: 1432/1432 bytes identical; all 258 canonical relocations identical.
- All 233 functions compared with ctxdiff/odiff: 221 exact; no falsely exact objdiff functions.
- git diff --check passed.
- Source-extracted host C harness passed six load-constant cases: missing operand; deletion failure with valid index; deletion failure with invalid index; invalid index after successful deletion; null payload; successful installation. The harness stubs surrounding VM dependencies and checks C behavior only; no Wii runtime execution is claimed.
Source is paused after this focused candidate for parent review. The remaining 12 functions are still non-exact.

View File

@@ -1,49 +0,0 @@
# CHANSVm opcode error-path reconstruction
Baseline: 2f399716. This is a separate structural-reconstruction candidate; it preserves the preceding LOAD_STRING_CONST behavior fix. Only CHANSVm.c changed apart from this log. No headers, linking flags, remote branches, or original assets were changed.
## Retained changes and target evidence
- Failed binary-operand conversion returns CHANS_VM_ERR_RESULT_TYPE directly. Target Step relative +0x410 selects the error and +0x414 returns through +0x1364.
- Invalid GET_PROPERTY_NAME and JUMP destinations return CHANS_VM_ERR_CODE_RANGE directly. Target error tails are +0xd90/+0xd94 and +0xefc/+0xf00, respectively, both ending at +0x1364.
- DELETE_INDIRECT has a typed accumulator and a local deletion result, and reads the index through value.data.len rather than an offset-based u32 pointer cast. SET_INDEX elsewhere in the same function establishes this field as the index-reference index. The target holds the opcode-local result until the merge at +0xfb0, then assigns the common interpreter status. The rebuilt +0xf80 through +0xfb4 block is instruction-identical to the target.
These preserve existing C behavior. Unlike the preceding deletion-error fix, no new behavioral defect is claimed.
## Measurements
- Exact functions: 221/233 -> 221/233. Every previously exact function remains instruction-exact, not merely objdiff-exact.
- Decompiled/fuzzy unit: 99.383840% -> 99.406320%.
- CHANSVmStep: 96.673584% -> 96.913800%; 1253/1253 instructions; differing positions 297 -> 285.
- Exact code: unchanged, 37608/53564 bytes (70.211334%).
- Exact data: unchanged, 6904/6904 bytes (100%).
- Per-function score regressions: zero.
- Unit remains NonMatching/unlinked; twelve functions remain non-exact.
## Rejected investigations
All rejected source changes were restored, and no register forcing or declaration-order sweep was used.
- GET_PROPERTY_NAME output-state separation: a local found flag, initialized flag, shared index/output, and inline helper. These produced 1251-1253 instructions but moved generated data-table destinations; rejected.
- Direct result-type-table accesses, an explicit zero-count normalization/pretested loop, and indexed operand-type enumeration: 1254-1257 instructions; generated data-table destinations moved; rejected.
- Internal linkage for result-type or constant-header tables, individually and together, did not change those results; restored.
- CASE strict-comparison result separation, case-local match state, byte-sized operand types, and indexed operand enumeration: improved some local structure but introduced an operand-type spill and 1254-1255 instructions; generated tables moved; rejected.
- Direct exceptional returns alone: retained for combination, 96.697525%, data 100%.
- Typed DELETE_INDIRECT and local result alone: retained for combination, 96.889860%, data 100%.
- Combined direct returns and typed deletion result: accepted candidate, 96.913800%, data 100%.
- A first combination script used an obsolete substring end offset and did not compile; restored, corrected, and rerun. No source from the malformed attempt remains.
- Adding strict-comparison restructuring to the retained combination still produced 1254 instructions and data regression; rejected.
## Validation
- Full 43U build passed with the assigned wrapper and WIBO_SJIS_MISSING_IMPORTS=1.
- DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d.
- pool_diff: 125/125 strings identical.
- .data: 4672/4672 raw bytes and 352/352 canonical relocations identical.
- .rodata: 1432/1432 raw bytes and 258/258 canonical relocations identical.
- All 233 target functions compared: 221 instruction-exact; zero falsely exact objdiff functions; zero per-function score regressions from 2f399716.
- Narrow-string-reference audit: all 233 functions analyzed, 40 arguments checked, no candidates/errors/skips.
- Source-extracted host C tests: four DELETE_INDIRECT cases passed (wrong type, successful deletion, deletion failure, and null element forwarding), including exact unsigned index forwarding. The six prior LOAD_STRING_CONST cases also passed unchanged. These stub surrounding VM dependencies and are not Wii runtime tests.
- git diff --check passed.
The focused candidate is paused for independent parent review.

View File

@@ -1,52 +0,0 @@
# CHANSVm typed comparison reconstruction
Baseline: ec75ddb0. This candidate is separate from the accepted load-string and opcode-error-path work. Those commits and their logs are unchanged. Only CHANSVm.c and this log changed; no headers, linking classifications, metadata, or original assets changed.
## Retained reconstruction
- LOAD_FLOAT copies the eight-byte literal into a double scratch member and passes that value directly. This replaces a u64 temporary followed by a double-pointer reinterpretation. Scratch alignment, member offsets, and emitted code are unchanged.
- SET_INDEX reads the floating operand through its union member and checks its lower bound before its upper bound, matching the target's comparison order. The accepted interval remains [0, 4294967294], with NaN and infinities rejected.
- Strict integer equality uses the declared 64-bit integer values rather than four offset-based u32 loads and manual XOR/OR expressions.
- Strict floating equality uses the declared floating values directly.
- Strict string equality uses named, read-only payload pointers rather than recreating a header pointer. The stack operand is consistently first in the outer type comparison, following the target.
This is structural/type reconstruction, not a newly discovered behavior fix. No register forcing, declaration sweep, or alignment padding was introduced.
## Target evidence
After rebuilding, the integer-comparison block (Step instructions 1093-1102), floating-comparison block (1103-1108), string-comparison block (1109-1128), and floating-index block (703-712) have the same instructions, control flow, constants, and memory offsets as the target after register names are normalized. This comparison is advisory: register differences remain, and Step is not exact.
The floating range's instruction forms now use the target's lower-bound-first order. Integer equality emits the same target ten-instruction two-word equality sequence naturally from the 64-bit value comparison. LOAD_FLOAT retains its original eight-byte copy and call sequence without a pointer reinterpretation.
## Measurements
- Instruction-exact functions: 221/233 -> 221/233; no previously exact function regressed.
- Unit Decompiled/fuzzy: 99.406320% -> 99.413185%.
- Step: 96.913800% -> 96.987230%; 1253/1253 instructions; differing positions 285 -> 276.
- Exact code: unchanged at 37608/53564 bytes (70.211334%).
- Exact data: unchanged at 6904/6904 bytes (100%).
- Per-function score regressions: zero.
- Unit remains NonMatching/unlinked, with twelve non-exact functions.
## Attempts
- Direct 64-bit equality alone: Step 96.933760%, data 100%; retained for combination.
- Typed integer/float/string comparison paths: 96.971270%, data 100%; retained.
- Those typed paths plus a separate strict-comparison local error result: 1254 instructions, table relocations moved; rejected.
- Floating index member access alone preserves the typed-comparison score. Lower-bound-first range checking raises it to 96.983240%, data 100%; retained.
- A union literal temporary produced the same code; simplified to a direct double member instead, also with identical code.
- Stack-first type comparison raises Step to 96.987230% with unchanged data; retained.
## Verification
- Full 43U build passed with the assigned wrapper and WIBO_SJIS_MISSING_IMPORTS=1.
- DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d.
- pool_diff: all 125 strings identical.
- .data: 4672/4672 raw bytes and 352/352 canonical relocations identical.
- .rodata: 1432/1432 raw bytes and 258/258 canonical relocations identical.
- All 233 functions checked with ctxdiff/odiff: 221 instruction-exact; no falsely exact objdiff functions.
- Literal-reference audit: 233 functions analyzed, 40 resolvable call-string arguments checked, no candidates/errors/skips.
- Source-extracted host C harnesses passed 20 strict-comparison cases, nine floating-index-bound cases, and eight floating-literal bit patterns. Coverage includes signed integer extremes, differing high words, signed zero, NaN, infinities, strings, references, deletion errors, and literal payload preservation. They stub surrounding dependencies and do not constitute Wii runtime execution.
- git diff --check passed.
Source is paused for independent parent verification.

Some files were not shown because too many files have changed in this diff Show More