Compare commits

..

1 Commits

Author SHA1 Message Date
coah
f7d1a7f211 cleanup(iplController): name decide/pinch/kpad/classic fields
unk_0x08 -> mDecideHoldCount
unk_0x1C -> mbForceInvalid
unk_0x1D -> mbPinching
unk_0x1E -> mbWasPinching
unk_0x20 -> mpKpadStatus
unk_0x24 -> mClassicCursorPos
unk_0x2C -> mClassicCursorTimer

Also update iplControllerManager ctor inits for Base fields.

Matching 100% before/after; DOL sha1 unchanged.
2026-10-02 14:09:29 -05:00
393 changed files with 8884 additions and 71573 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

@@ -95,15 +95,11 @@ AOSS_810BDF18 = .bss:0x810BDF18; // type:object size:0x6A0
AOSS_810BE5B8 = .bss:0x810BE5B8; // type:object size:0x280
AOSS_810BE838 = .bss:0x810BE838; // type:object size:0x68
AOSS_810BE8A0 = .bss:0x810BE8A0; // type:object size:0x400
gAtermIpConfig = .bss:0x810BECA0; // type:object size:0x7C4 data:4byte
gAtermIfConfig = .bss:0x810BF464; // type:object size:0x15E
ATERM_810BECA0 = .bss:0x810BECA0; // type:object size:0x924 data:4byte
ATERM_810BF5C4 = .bss:0x810BF5C4; // type:object size:0x24
ATERM_810BF5E8 = .bss:0x810BF5E8; // type:object size:0x258
gAtermConfigurationResult = .bss:0x810BF840; // type:object size:0xE8
gAtermAssociationRequest = .bss:0x810BF928; // type:object size:0x10
gAtermPacketBuffer = .bss:0x810BF938; // type:object size:0x800
gAtermDecodedResponse = .bss:0x810C0138; // type:object size:0x800 data:2byte
gAtermSession = .bss:0x810C0938; // type:object size:0x20
ATERM_810BF840 = .bss:0x810BF840; // type:object size:0x900
ATERM_810C0140 = .bss:0x810C0140; // type:object size:0x818 data:2byte
AtermThread = .bss:0x810C0958; // type:object size:0x318 scope:local align:32
Voices = .bss:0x810C0C80; // type:object size:0x1800 data:4byte
sZeroMem = .bss:0x810C2480; // type:object size:0x100 data:byte
@@ -118,9 +114,7 @@ ziStringColorRightDestructorRecord = .bss:0x810C65CC; // type:object size:0xC da
underlateColorDestructorRecord = .bss:0x810C65D8; // type:object size:0xC data:4byte
unInputedWCharColorSpaceDestructorRecord = .bss:0x810C65E4; // type:object size:0xC data:4byte
ElementBuffer__Q39textinput8tistring6WithZi = .bss:0x810C65F0; // type:object size:0x200 data:2byte
CandidatesBuffer__Q39textinput8tistring6WithZi = .bss:0x810C67F0; // type:object size:0x200 data:2byte
ElementWorkBuffer__Q39textinput8tistring6WithZi = .bss:0x810C69F0; // type:object size:0x200 data:2byte
PredictionBuffer__Q39textinput8tistring6WithZi = .bss:0x810C6BF0; // type:object size:0x200 data:2byte
CandidatesBuffer__Q39textinput8tistring6WithZi = .bss:0x810C67F0; // type:object size:0x600 data:2byte
CandidatedWord__Q39textinput8tistring6WithZi = .bss:0x810C6DF0; // type:object size:0x1400 data:2byte
LatestWord__Q39textinput8tistring6WithZi = .bss:0x810C81F0; // type:object size:0x80 data:2byte
snWidthTable__Q29textinput10textdrawer = .bss:0x810C8270; // type:object size:0x580 data:4byte
@@ -13910,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
@@ -16049,7 +16038,7 @@ mscClockPaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DCA8; // type:objec
@23740 = .data:0x8164DE49; // type:object size:0x1B scope:local data:string
scPaneName_N_GCIcon = .data:0x8164DE64; // type:object size:0x9 data:string
scPaneName_N_DiscUpdateIcon = .data:0x8164DE6D; // type:object size:0x11 data:string
@24295 = .data:0x8164DE80; // type:object size:0x1C scope:local
updateDiskState_jumptable = .data:0x8164DE80; // type:object size:0x1C scope:local
scSE_WSD_SELECT = .data:0x8164DE9C; // type:object size:0xB data:string
@24254 = .data:0x8164DEA7; // type:object size:0x10 scope:local data:string
@24282 = .data:0x8164DEB7; // type:object size:0x12 scope:local data:string
@@ -17176,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
@@ -17206,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
@@ -17265,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
@@ -18112,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
@@ -22427,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
@@ -23281,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

@@ -648,7 +648,7 @@ config.libs = [
Object(Matching, "system/iplDialogWindow.cpp"),
Object(Matching, "system/iplHomeButtonMenu.cpp"),
Object(Matching, "system/iplNandSDWorker.cpp"),
Object(Matching, "system/iplKeyboard.cpp"),
Object(Equivalent, "system/iplKeyboard.cpp"),
Object(Matching, "system/iplErrorHandler.cpp"),
Object(Matching, "system/iplResetHandler.cpp"),
Object(Matching, "system/iplWarningHandler.cpp"),
@@ -727,7 +727,7 @@ config.libs = [
]
),
IPLSection("address", [
Object(Matching, "scene/address/iplAddress.cpp"),
Object(NonMatching, "scene/address/iplAddress.cpp"),
Object(Matching, "scene/address/iplAddressAddSel.cpp"),
Object(NonMatching, "scene/address/iplAddressEdit.cpp"),
]
@@ -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", [
@@ -879,7 +879,7 @@ config.libs = [
Object(NonMatching, "scene/setting/AOSSLink.c"),
Object(Matching, "scene/setting/iplRakuRakuThread.cpp"),
Object(NonMatching, "scene/setting/AOSS.c", extra_cflags=["-O4,p", "-inline off"]),
Object(NonMatching, "scene/setting/ATERM.c", extra_cflags=["-O4,p", "-inline on"]),
Object(NonMatching, "scene/setting/ATERM.c", extra_cflags=["-O4,p", "-inline off"]),
]
),
IPLSection("settingSelect", [
@@ -908,7 +908,7 @@ config.libs = [
),
# it decides to do fast optimization for this one
IPLSection("keyboard", [
Object(Matching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiCellPhone.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiCandidateBox.cpp", extra_cflags=["-O4,p"]),
@@ -982,7 +982,7 @@ config.libs = [
),
ZI8Lib("zi8clib", [
Object(Matching, "clib/zaddress.c"),
Object(Matching, "clib/zconvert.c"),
Object(NonMatching, "clib/zconvert.c"),
Object(NonMatching, "clib/zi81key.c"),
Object(NonMatching, "clib/zi8alpha.c"),
Object(Matching, "clib/zi8alts.c"),
@@ -997,7 +997,7 @@ config.libs = [
Object(Matching, "clib/zi8is.c"),
Object(NonMatching, "clib/zi8match.c"),
Object(Matching, "clib/zi8misc.c"),
Object(Matching, "clib/zi8pud2.c"),
Object(NonMatching, "clib/zi8pud2.c"),
Object(Matching, "clib/Zi8punct.c"),
Object(Matching, "clib/zi8space.c"),
Object(NonMatching, "clib/zi8uwd.c"),
@@ -1043,7 +1043,7 @@ config.libs = [
RevoEXLib("net", [
Object(Matching, "net/nettime.c"),
Object(Matching, "net/crc.c"),
Object(Matching, "net/md5.c"),
Object(NonMatching, "net/md5.c"),
Object(Matching, "net/sha1.c"),
Object(Matching, "net/hmac.c"),
Object(Matching, "net/neterrorcode.c"),
@@ -1081,9 +1081,9 @@ config.libs = [
Object(Matching, "nwc24/NWC24Parser.c"),
Object(Matching, "nwc24/NWC24MsgCommit.c"),
Object(Matching, "nwc24/NWC24MsgRead.c"),
Object(Matching, "nwc24/NWC24MsgSubject.c"),
Object(NonMatching, "nwc24/NWC24MsgSubject.c"),
Object(Matching, "nwc24/NWC24Schedule.c"),
Object(Matching, "nwc24/NWC24DateParser.c"),
Object(NonMatching, "nwc24/NWC24DateParser.c"),
Object(Matching, "nwc24/NWC24FriendList.c"),
Object(Matching, "nwc24/NWC24SecretFList.c"),
Object(Matching, "nwc24/NWC24UserId.c"),
@@ -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"),
]
@@ -1691,7 +1691,7 @@ config.libs = [
Object(Matching, "fa/pdm_bpb.c"),
Object(Matching, "fa/pdm_disk.c"),
Object(NonMatching, "fa/pdm_partition.c"),
Object(Matching, "fa/pf_cache.c"),
Object(NonMatching, "fa/pf_cache.c"),
Object(Matching, "fa/pf_cluster.c"),
Object(Matching, "fa/pf_dir.c"),
Object(Matching, "fa/pf_entry.c"),
@@ -1826,7 +1826,7 @@ config.libs = [
Object(Matching, "fa/pfs_unmount.c"),
Object(Matching, "fa/pf_stub_unicode.c"),
Object(Matching, "fa/api/FAAttach.c"),
Object(NonMatching, "fa/api/FAAttach.c"),
Object(Matching, "fa/api/FABuffering.c"),
Object(Matching, "fa/api/FACreate.c"),
Object(Matching, "fa/api/FACreatedir.c"),
@@ -1908,7 +1908,7 @@ config.libs = [
[
Object(Matching, "core/eggAllocator.cpp"),
Object(Matching, "core/eggAudioArcPlayerMgr.cpp"),
Object(Matching, "core/eggAudioExpMgr.cpp"),
Object(Equivalent, "core/eggAudioExpMgr.cpp"),
Object(Matching, "core/eggAudioFxMgr.cpp"),
Object(Matching, "core/eggAudioMgr.cpp"),
Object(Matching, "core/eggAudioHeapMgr.cpp"),
@@ -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

@@ -24,7 +24,7 @@ typedef struct BS2UpdateHeader {
typedef struct BS2UpdateEntry {
// Update Meta Data
vu32 type; // 0x00
u32 type; // 0x00
u32 attr; // 0x04
u32 size; // 0x08
u32 depend; // 0x0C

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

@@ -7,7 +7,7 @@ namespace ipl {
namespace memorycard {
typedef struct FileInfo {
u16 fileNo; // 0x00
volatile u16 size; // 0x02
u16 size; // 0x02
u8 canCopy; // 0x04
u8 canMove; // 0x05
u16 unk_0x06; // 0x06
@@ -28,7 +28,7 @@ namespace ipl {
} CardState; // 0x14
typedef struct IconState {
volatile u8 bannerEnable; // 0x00
u8 bannerEnable; // 0x00
u8 unk_0x01; // 0x01
u8 unk_0x02; // 0x02
u8 bannerType; // 0x03

View File

@@ -142,6 +142,9 @@ namespace textinput {
// TODO enum?
int getInputType() const;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void resetHoldingButton();
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#if defined(MYTIMANAGER_IMPLEMENTATION) && defined(TI_CELLPHONE_IMPLEMENTATION)

View File

@@ -69,9 +69,6 @@
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data) override;
virtual bool updateInput(input::HKBManager& hkbManager) override;
#endif
#if defined(TI_CELLPHONE_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void resetHoldingButton();
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
@@ -98,6 +95,7 @@
virtual void changeSpaceKeyTop(const PaneNameToCharCode* keys);
void setUpperCaseJP(bool enabled);
void setLangKeyActive(bool enabled);
void resetHoldingButton();
private:
bool mbLineFeedButton;

View File

@@ -74,16 +74,8 @@ namespace textinput {
virtual void onEvent(GUIComponent& comp, u32 event, void* data) {} // 0x0C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setLatestEventCtrlNo(int ctrlNo);
#else
virtual void setLatestEventCtrlNo(int ctrlNo) { muLatestEventCtrlNo = ctrlNo; } // 0x10
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual int getLatestEventCtrlNo();
#else
virtual int getLatestEventCtrlNo() { return muLatestEventCtrlNo; } // 0x14
#endif
protected:
int muLatestEventCtrlNo; // 0x04
@@ -117,11 +109,7 @@ namespace textinput {
: GUIInterface(), mbInitialize(false), mDraggingButton(0xFFFF), mID(id), mbTriggerTarget(false), mpManager(NULL), mpListener(NULL) {
init();
}
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual ~GUIComponent();
#else
virtual ~GUIComponent() {} // 0x08
#endif
virtual u32 getID() { return mID; } // 0x20
@@ -158,11 +146,7 @@ namespace textinput {
}
virtual bool isTriggerTarget() { return mbTriggerTarget; } // 0x48
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setTriggerTarget(bool bEnable);
#else
virtual void setTriggerTarget(bool bEnable) { mbTriggerTarget = bEnable; } // 0x4C
#endif
void setParentManager(GUIManager* manager) { mpManager = manager; }
GUIManager* getParentManager() { return mpManager; }

View File

@@ -47,11 +47,7 @@ namespace textinput {
#else
virtual Language getLanguage() const { return meLanguage; }
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void update();
#else
virtual void update() {}
#endif
#else
virtual Language getLanguage() const;
virtual void update();

View File

@@ -64,11 +64,7 @@ namespace textinput {
virtual void setWCString(const wchar_t* string);
virtual void setLanguage(Language language);
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual Language getLanguage() const;
#else
virtual Language getLanguage() const { return meLanguage; }
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
Language getLanguageForMemo() const { return meLanguage; }
#endif
@@ -133,18 +129,10 @@ namespace textinput {
virtual const InputForm* getInputForm() const { return mpInputForm; }
virtual keyboard::hwkey::HWKeyboard* getHWKeyboard() { return mpHWKeyboard; }
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual const keyboard::hwkey::HWKeyboard* getHWKeyboard() const;
#else
virtual const keyboard::hwkey::HWKeyboard* getHWKeyboard() const { return mpHWKeyboard; }
#endif
virtual keyboard::pctype::LayoutByNW4R* getPCKeyboard() { return mpPCKeyboard; }
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual const keyboard::pctype::LayoutByNW4R* getPCKeyboard() const;
#else
virtual const keyboard::pctype::LayoutByNW4R* getPCKeyboard() const { return mpPCKeyboard; }
#endif
virtual keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() { return mpCellPhoneKeyboard; }
virtual const keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() const { return mpCellPhoneKeyboard; }
@@ -161,11 +149,7 @@ namespace textinput {
virtual const candidatebox::LayoutByNW4R* getCandidateBox() const { return mpCandidateBox; }
virtual toolbar::LayoutByNW4R* getToolBar() { return mpToolBar; }
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual const toolbar::LayoutByNW4R* getToolBar() const;
#else
virtual const toolbar::LayoutByNW4R* getToolBar() const { return mpToolBar; }
#endif
#ifdef TIMANAGER_IMPLEMENTATION
virtual void* getPredictLanguageSelectDialog();

View File

@@ -36,11 +36,7 @@ namespace textinput {
virtual void onTiEvent(gui::PaneComponent* paneComponent, u32 event, Input* input) = 0; // 0x18
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setEventObserver(EventObserver *event);
#else
virtual void setEventObserver(EventObserver *event) { mpEventObserver = event; } // 0x1C
#endif
protected:
EventObserver* mpEventObserver; // 0x08
@@ -101,19 +97,25 @@ namespace textinput {
virtual void calc(); // 0x0C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void onAnmEvent(AnmPaneEvent);
virtual void onAnmEvent(AnmPaneEvent) {}
#else
virtual void onAnmEvent(AnmPaneEvent paneEvent);
#endif // 0x10
virtual void changeAnimation(u32 id); // 0x14
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isInAnimation();
virtual bool isInAnimation() { return mpCurrentAnim != NULL; }
#else
virtual bool isInAnimation();
#endif // 0x18
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual Anim* searchAnimation(u32 id);
virtual Anim* searchAnimation(u32 id) {
for (Anim* animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, NULL)); animation != NULL;
animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, animation))) {
if (animation->muID == id) return animation;
}
return NULL;
}
#else
virtual Anim* searchAnimation(u32 id);
#endif // 0x1C
@@ -245,22 +247,14 @@ namespace textinput {
virtual bool updateInput(int point, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data); // 0x20
virtual bool updateInput(input::HKBManager& hkbManager); // 0x24
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual TiLayout* getLayout();
#else
virtual TiLayout* getLayout() { return mpLayout; } // 0x28
#endif
virtual nw4r::lyt::Pane* getPane(const char* paneName); // 0x2C
virtual const nw4r::lyt::Pane* getPane(const char* paneName) const; // 0x30
virtual u32 getFlightDuration(int point, const char* paneName); // 0x34
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setAnimOn(bool flag);
#else
virtual void setAnimOn(bool flag) { mbAnimOn = flag; } // 0x38
#endif
virtual void drawPane(const char* paneName); // 0x3C
@@ -288,16 +282,8 @@ namespace textinput {
virtual AnmPane* searchAnmPane(const char* paneName); // 0x60
virtual AnmPane* searchAnmPane(wchar_t ch); // 0x64
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual nw4r::ut::List& getAnmPaneList();
#else
virtual nw4r::ut::List& getAnmPaneList() { return mAnmPanes; } // 0x68
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual gui::PaneManager* getPaneManager();
#else
virtual gui::PaneManager* getPaneManager() { return mpPaneManager; } // 0x6C
#endif
virtual void AdjustPaneMtx(Mtx& mtx, const nw4r::lyt::DrawInfo& drawInfo, const nw4r::math::MTX34& mGlobalMtx); // 0x70

View File

@@ -191,11 +191,7 @@ namespace textinput {
#endif
virtual ~Base();
virtual void create(MEMAllocator* allocator);
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void init();
#else
virtual inline void init();
#endif
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual int getType();
@@ -227,9 +223,6 @@ namespace textinput {
virtual void updateFixMode();
protected:
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
inline void initializeKeyState();
#endif
State mState;
const LanguageData* mpInitialLanguageData;
KeyState mKeyState;
@@ -308,8 +301,6 @@ namespace textinput {
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mpKeyboardEventHandler(NULL),
mShiftButton(1, this, this), mCapsButton(0, this, this), mModePanel(2, this, this) {}
#elif defined(TI_PC_KEYBOARD_IMPLEMENTATION)
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName);
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
@@ -361,15 +352,6 @@ namespace textinput {
UIModePanel mModePanel;
};
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: LayoutByNW4R(manager, accessor, observer, layoutName) {}
virtual ~Sample() {}
};
#endif
class AnmPane : public nw4rmanager::AnmPane {
public:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : nw4rmanager::AnmPane(pane, observer), mAnimation(0) {}

View File

@@ -14,17 +14,9 @@ namespace textinput {
Base(Manager* manager) : mQwerty(true), meLanguage(USA), mpAllocator(NULL), mpManager(manager) {}
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void create(MEMAllocator* allocator);
#else
virtual void create(MEMAllocator* allocator) { mpAllocator = allocator; }
#endif
virtual void init() {}
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isQwerty() const;
#else
virtual bool isQwerty() const { return mQwerty; }
#endif
virtual void setQwerty(bool qwerty);
virtual void setLanguage(Language language) { meLanguage = language; }
virtual Language getLanguage() const { return meLanguage; }

View File

@@ -39,9 +39,7 @@ public:
};
static u16 ElementBuffer[0x100];
static u16 CandidatesBuffer[0x100];
static u16 ElementWorkBuffer[0x100];
static u16 PredictionBuffer[0x100];
static u16 CandidatesBuffer[0x300];
static u16 CandidatedWord[0xa00];
static u16 LatestWord[0x40];

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

@@ -141,9 +141,6 @@ namespace ipl {
void init(nw4r::lyt::Pane* pane);
void set(u64 fdId);
void reset();
#ifdef IPL_ADDRESS_MATCHING
nigaoe::Object* getPortrait() const { return mpNigaoe; }
#endif
static void create_callback(nigaoe::Object* object, void* work);

View File

@@ -12,7 +12,6 @@
namespace ipl {
namespace scene {
extern "C" BOOL push_button_queue(void*, const void*);
class ButtonEventHandlerBase;
class OptOutButtonEventHandlerBase;
class SDMenuEventHandlerBase;
@@ -315,7 +314,6 @@ namespace ipl {
}
protected:
friend BOOL push_button_queue(void*, const void*);
typedef struct Command {
enum {
TYPE_ANIM = 0,

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

@@ -62,17 +62,17 @@ namespace ipl {
void start_left_event(const char* paneName);
void start_trig_event(const char* paneName);
typedef struct CmdEntry {
typedef struct Unk {
int command; // 0x00
u32 msgID; // 0x04
} CmdEntry;
} Unk;
CmdEntry mCmdQueue[64];
Unk unk_0x64[64];
int mQueueCapacity;
int mQueueCount;
int mQueueRead;
int mQueueWrite;
int unk_0x264;
int unk_0x268;
int unk_0x26C;
int unk_0x270;
int mSettingArg; // 0x274

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

@@ -65,7 +65,7 @@ namespace ipl {
STATE_FINISHED,
};
volatile bool mbDoneProcess; // 0x00
bool mbDoneProcess; // 0x00
int mCDBResult; // 0x04
int mPrevFreeSize; // 0x08

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

@@ -33,7 +33,7 @@ namespace ipl {
u64 titleId; // 0x10
bool threadTerminated; // 0x18
bool unk_0x19;
bool mbHasNewMessage; // 0x1A
bool unk_0x1A;
EGG::ExpHeap* getHeap() { return heap; }
} CSData;

View File

@@ -60,9 +60,9 @@ namespace ipl {
int mMessageID; // 0x08
int mArg2;
int mArg3;
char mArg1[4];
int unk_0x0C;
int unk_0x10;
char unk_0x14[4];
u8* mpArcData; // 0x18
u32 mArcSize; // 0x1C

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

@@ -139,7 +139,7 @@ namespace ipl {
bool received() { return mbReviecedMsg; }
void prepNextReceive() { mbReviecedMsg = false; }
volatile bool isReceivingIdle() { return mbReceiving == false; }
volatile bool isUnk0xA31() { return unk_0xA31 == false; }
BOOL isAppDlEnableLock(u32 appId) {
utility::autoMutexLock lock(mAutoLock);
@@ -175,9 +175,9 @@ namespace ipl {
OSMutex mAutoLock; // 0xA18
bool mbReviecedMsg;
bool mbReceiving;
bool unk_0xA31;
bool mbReceivePaused; // 0xA32
bool mbNewTitleTblReady;
bool unk_0xA33;
static Arg smArg;

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

@@ -21,12 +21,6 @@ namespace EGG {
virtual void initialize(IAudioMgr::Arg* arg);
};
class ExpAudioMgr : public SimpleAudioMgr, public AudioFxMgr {
public:
ExpAudioMgr();
virtual ~ExpAudioMgr();
};
} // namespace EGG
#endif // EGG_AUDIO_EXP_MGR_H

View File

@@ -29,10 +29,4 @@ namespace EGG {
mHeap.SaveState();
}
ExpAudioMgr::ExpAudioMgr() {
}
ExpAudioMgr::~ExpAudioMgr() {
}
} // namespace EGG

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

@@ -88,7 +88,7 @@ namespace nw4r {
PaneList& GetChildList() { return mChildList; }
const math::VEC3& GetTranslate() { return mTranslate; }
#if defined(IPL_SDMEMORY_SET_TRANSLATE_OUT_OF_LINE) || defined(IPL_ADDRESS_MATCHING)
#ifdef IPL_SDMEMORY_SET_TRANSLATE_OUT_OF_LINE
void SetTranslate(const math::VEC3& translate);
#else
void SetTranslate(const math::VEC3& translate) { mTranslate = translate; }

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

@@ -1,35 +1,79 @@
#include <stddef.h>
#include <tmc_jpeg_internal.h>
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_init_buff_thumbnail(register TMCCJPEGDecWork* work, register u8* dst, register u8* src) {
nofralloc
lwz r0, 4(r5)
cmpwi r0, 0
bne _init_buff_thumbnail_have_src1
li r3, -1
blr
_init_buff_thumbnail_have_src1:
lwz r0, 8(r5)
cmpwi r0, 0
bne _init_buff_thumbnail_have_src2
li r3, -1
blr
_init_buff_thumbnail_have_src2:
lwz r7, 0(r5)
li r0, 0
stw r7, 0x18(r4)
lwz r6, 4(r5)
stw r6, 0x1c(r4)
lwz r6, 8(r5)
stw r6, 0x20(r4)
lwz r6, 0xc(r5)
stw r6, 0x24(r4)
lwz r5, 0x10(r5)
stw r5, 0x28(r4)
stw r7, 8(r4)
lwz r6, 0x674(r3)
lwz r5, 0x66c(r3)
add r5, r6, r5
stw r5, 0xc(r4)
lwz r6, 0x670(r3)
li r3, 0
add r5, r5, r6
stw r0, 0x20(r4)
subi r0, r5, 0x22
stw r5, 0x10(r4)
stw r0, 0x14(r4)
blr
}
#else
s32 TMCJPEGDEC_init_buff_thumbnail(TMCCJPEGDecWork* work, u8* dst, u8* src) {
TMCCJPEGDecWork* buffer = (TMCCJPEGDecWork*)dst;
const TMCCJPEGDecInitParam* input = (const TMCCJPEGDecInitParam*)(src - offsetof(TMCCJPEGDecInitParam, pBuf2));
s32 endAddress;
u8* start;
const TMCCJPEGDecExifData* exif = (const TMCCJPEGDecExifData*)work;
u32* src32;
u32* dst32;
u32 tmp;
if (input->buf2Size == 0) {
src32 = (u32*)src;
dst32 = (u32*)dst;
if (src32[1] == 0) {
return -1;
}
if (input->dataSize == 0) {
if (src32[2] == 0) {
return -1;
}
start = input->pBuf2;
buffer->pBufOrg = start;
buffer->bufLen = input->buf2Size;
buffer->remaining = input->dataSize;
buffer->pCallback = input->pCallback;
buffer->pCbCtx = input->pContext;
buffer->pBufStart = start;
buffer->pBufCur = exif->thumbnailData + exif->thumbnailOffset;
endAddress = exif->thumbnailLength;
endAddress = (u32)buffer->pBufCur + endAddress;
buffer->remaining = 0;
buffer->pBufEnd = (u8*)endAddress;
buffer->pBufMark = (u8*)((u32)endAddress - 0x22);
tmp = src32[0];
dst32[6] = src32[0];
dst32[7] = src32[1];
dst32[8] = src32[2];
dst32[9] = src32[3];
dst32[10] = src32[4];
dst32[2] = tmp;
dst32[3] = work->thumbHuffSize[2] + work->thumbHuffSize[0];
dst32[4] = work->thumbHuffSize[1] + dst32[3];
dst32[5] = dst32[4] - 0x22;
dst32[8] = 0;
return 0;
}
#endif
s32 TMCJPEGDEC_init_buff(TMCCJPEGDecWork* work) {
work->bitBuf = 0;

View File

@@ -28,36 +28,36 @@ static s32 scalingClampU8(s32 value) {
void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
s32 tmp[64];
s32* dst;
s32 d;
s32 t;
s32 done;
s32 iter;
s32 i;
s32 y;
s32 e;
s32 b2;
s32 b1;
s32 b3;
s32 b4;
s32 b5;
s32 b6;
s32 b7;
s32 n;
s32 v;
s32 m;
s32 a;
s32 done;
s32 d;
s32 z;
s32 v;
s32 o;
s32 p;
s32 p_part;
s32 m_part;
s32 t;
s32 u;
s32 r;
s32 o;
s32 x;
s32 n;
s32 y;
s32 x_factor;
s32 z_factor;
s32 iter;
s32 m_part;
s32 q;
s32 w;
s32 e;
s32 b3;
s32 x;
s32 b1;
r = (zigzag >> 4) * 8;
dst = tmp;
@@ -93,19 +93,17 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
} else {
s32 oddLowSum;
s32 oddHighSum;
s32 oddLowDifference;
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;
@@ -227,7 +225,7 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
s32 tmp[64];
s32* dst;
s32 a;
s32 done;
s32 iter;
s32 d;
s32 b1;
@@ -239,14 +237,14 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
s32 b7;
s32 v;
s32 r;
s32 done;
s32 a;
s32 i;
s32 m;
s32 n;
s32 o;
s32 x;
s32 q;
s32 e;
s32 y;
s32 u;
s32 w;
s32 p;
@@ -256,7 +254,7 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
s32 z_factor;
s32 m_part;
s32 p_part;
s32 y;
s32 e;
if (zigzag == 0x11) {
s32 val;

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

@@ -106,43 +106,192 @@ s32 TMCJPEGDEC_decompmcu(u32 maxMCU, u32 mcuCount, TMCCJPEGDecWork* work, void*
return 0;
}
static inline void initZigzag(TMCCJPEGDecWork* work) {
const u8* zigzag = TMCJPEGDEC_Zigzag_data;
s32 i;
work->restartInterval = 0;
work->scanCount = 0;
for (i = 0; i < 64; i++) {
work->zigzagData[i] = *zigzag++ << 2;
}
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_imagestart(register TMCCJPEGDecWork* work) {
nofralloc
stwu r1, -0x20(r1)
mflr r0
lis r8, TMCJPEGDEC_Zigzag_data@ha
li r4, 0
stw r0, 0x24(r1)
li r0, 4
addi r8, r8, TMCJPEGDEC_Zigzag_data@l
li r7, 0
stw r31, 0x1c(r1)
mr r31, r3
sth r4, 0x181a(r3)
stb r4, 0x181c(r3)
mtctr r0
_imagestart_loop:
lbz r6, 0(r8)
add r9, r3, r7
lbz r5, 1(r8)
addi r7, r7, 8
rlwinm r6, r6, 2, 0x18, 0x1d
lbz r4, 2(r8)
stb r6, 0x458(r9)
rlwinm r5, r5, 2, 0x18, 0x1d
rlwinm r6, r4, 2, 0x18, 0x1d
lbz r0, 3(r8)
stb r5, 0x459(r9)
rlwinm r5, r0, 2, 0x18, 0x1d
lbz r4, 4(r8)
stb r6, 0x45a(r9)
rlwinm r6, r4, 2, 0x18, 0x1d
lbz r4, 6(r8)
stb r5, 0x45b(r9)
lbz r0, 5(r8)
rlwinm r4, r4, 2, 0x18, 0x1d
stb r6, 0x45c(r9)
rlwinm r5, r0, 2, 0x18, 0x1d
lbz r0, 7(r8)
stb r5, 0x45d(r9)
lbz r6, 8(r8)
rlwinm r0, r0, 2, 0x18, 0x1d
stb r4, 0x45e(r9)
lbz r5, 9(r8)
rlwinm r6, r6, 2, 0x18, 0x1d
stb r0, 0x45f(r9)
add r9, r3, r7
lbz r4, 0xa(r8)
rlwinm r5, r5, 2, 0x18, 0x1d
stb r6, 0x458(r9)
addi r7, r7, 8
rlwinm r6, r4, 2, 0x18, 0x1d
lbz r0, 0xb(r8)
stb r5, 0x459(r9)
rlwinm r5, r0, 2, 0x18, 0x1d
lbz r4, 0xc(r8)
stb r6, 0x45a(r9)
rlwinm r6, r4, 2, 0x18, 0x1d
lbz r4, 0xe(r8)
stb r5, 0x45b(r9)
lbz r0, 0xd(r8)
rlwinm r4, r4, 2, 0x18, 0x1d
stb r6, 0x45c(r9)
rlwinm r5, r0, 2, 0x18, 0x1d
lbz r0, 0xf(r8)
stb r5, 0x45d(r9)
addi r8, r8, 0x10
rlwinm r0, r0, 2, 0x18, 0x1d
stb r4, 0x45e(r9)
stb r0, 0x45f(r9)
bdnz _imagestart_loop
mr r4, r31
addi r3, r1, 8
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _imagestart_have_marker
b _imagestart_return
_imagestart_have_marker:
lhz r0, 8(r1)
cmplwi r0, 0xffd8
beq _imagestart_parse
li r3, -0x20
b _imagestart_return
_imagestart_parse:
li r0, 0
mr r4, r31
sth r0, 8(r1)
addi r3, r1, 8
bl TMCJPEGDEC_parse_para
cmpwi r3, 0
bge _imagestart_check_sof
b _imagestart_return
_imagestart_check_sof:
lhz r0, 8(r1)
cmplwi r0, 0xffc0
beq _imagestart_parse_sof
li r3, -0x10
b _imagestart_return
_imagestart_parse_sof:
mr r3, r31
bl TMCJPEGDEC_parse_sof
srawi r0, r3, 0x1f
and r3, r3, r0
_imagestart_return:
lwz r0, 0x24(r1)
lwz r31, 0x1c(r1)
mtlr r0
addi r1, r1, 0x20
blr
}
#else
s32 TMCJPEGDEC_imagestart(TMCCJPEGDecWork* work) {
u16 marker;
s32 r;
initZigzag(work);
u32 off;
u8* p;
int i;
const u8* zigzag;
zigzag = TMCJPEGDEC_Zigzag_data;
work->restartInterval = 0;
work->scanCount = 0;
off = 0;
i = 4;
do {
p = (u8*)work + off;
off += 8;
p[0x458] = (zigzag[0] & 0x3F) << 2;
p[0x459] = (zigzag[1] & 0x3F) << 2;
p[0x45a] = (zigzag[2] & 0x3F) << 2;
p[0x45b] = (zigzag[3] & 0x3F) << 2;
p[0x45c] = (zigzag[4] & 0x3F) << 2;
p[0x45e] = (zigzag[6] & 0x3F) << 2;
p[0x45d] = (zigzag[5] & 0x3F) << 2;
p[0x45f] = (zigzag[7] & 0x3F) << 2;
p = (u8*)work + off;
off += 8;
p[0x458] = (zigzag[8] & 0x3F) << 2;
p[0x459] = (zigzag[9] & 0x3F) << 2;
p[0x45a] = (zigzag[10] & 0x3F) << 2;
p[0x45b] = (zigzag[11] & 0x3F) << 2;
p[0x45c] = (zigzag[12] & 0x3F) << 2;
p[0x45d] = (zigzag[13] & 0x3F) << 2;
p[0x45e] = (zigzag[14] & 0x3F) << 2;
p[0x45f] = (zigzag[15] & 0x3F) << 2;
zigzag += 16;
} while (--i != 0);
r = TMCJPEGDEC_get_wbyte(&marker, work);
if (r < 0) {
return r;
}
if (marker != 0xFFD8) {
return -0x20;
}
marker = 0;
r = TMCJPEGDEC_parse_para(&marker, work);
if (r < 0) {
return r;
}
if (marker != 0xFFC0) {
return -0x10;
}
r = TMCJPEGDEC_parse_sof(work);
if (r < 0) {
return r;
}
return 0;
}
#endif
s32 TMCJPEGDEC_imageend(TMCCJPEGDecWork* work) {
if (work->pState->unk_0x21 == 1)
@@ -634,85 +783,266 @@ s32 TMCJPEGDEC_restart_interval(TMCCJPEGDecWork* work, u32 maxMCU, u32 mcuCount)
}
#endif
static inline s32 skipSegmentData(u16 length, TMCCJPEGDecWork* work) {
s32 result = TMCJPEGDEC_move_ptr(length, work);
if (result < 0) {
return result;
}
return 0;
}
#ifdef __MWERKS__
static asm s32 TMCJPEGDEC_parse_para(register u16* marker, register TMCCJPEGDecWork* work) {
nofralloc
static inline s32 parseApplication(TMCCJPEGDecWork* work) {
u16 length;
s32 result = TMCJPEGDEC_get_wbyte(&length, work);
if (result < 0) {
return result;
}
if (length < 2) {
return -0x45;
}
length -= 2;
result = skipSegmentData(length, work);
if (result < 0) {
return result;
}
return 0;
}
stwu r1, -0x30(r1)
mflr r0
stw r0, 0x34(r1)
stmw r26, 0x18(r1)
mr r28, r3
mr r29, r4
li r31, 0
lis r26, 1
li r27, 1
lhz r30, 0(r3)
static inline s32 parseRestartInterval(TMCCJPEGDecWork* work) {
u16 length;
s32 result = TMCJPEGDEC_get_wbyte(&length, work);
if (result < 0) {
return result;
}
if (length != 4) {
return -0x42;
}
result = TMCJPEGDEC_get_wbyte(&length, work);
if (result < 0) {
return result;
}
work->restartInterval = length;
return 0;
}
_parse_para_loop:
mr r4, r29
addi r3, r1, 0x12
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_para_marker_loaded
cmpwi r3, -0x90
bne _parse_para_return
lhz r0, 0x12(r1)
cmplwi r0, 0xffd9
bne _parse_para_return
li r3, 0
b _parse_para_marker_loaded
b _parse_para_return
static inline s32 parseNumberOfLines(TMCCJPEGDecWork* work) {
u16 length;
s32 result = TMCJPEGDEC_get_wbyte(&length, work);
if (result < 0) {
return result;
}
if (length != 4) {
return -0x43;
}
result = TMCJPEGDEC_get_wbyte(&length, work);
if (result < 0) {
return result;
}
work->frameHeight = length;
return 0;
}
_parse_para_marker_loaded:
lhz r0, 0x12(r1)
b _parse_para_marker_condition
static inline s32 parseComment(TMCCJPEGDecWork* work) {
u16 length;
s32 result = TMCJPEGDEC_get_wbyte(&length, work);
if (result < 0) {
return result;
}
if (length < 2) {
return -0x44;
}
length -= 2;
result = skipSegmentData(length, work);
if (result < 0) {
return result;
}
return 0;
}
_parse_para_marker_byte:
mr r4, r29
addi r3, r1, 8
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_para_marker_byte_loaded
b _parse_para_return
_parse_para_marker_byte_loaded:
lbz r0, 8(r1)
ori r0, r0, 0xff00
sth r0, 0x12(r1)
_parse_para_marker_condition:
clrlwi r4, r0, 0x10
cmplwi r4, 0xffff
beq _parse_para_marker_byte
cmplwi r4, 0xffe0
blt _parse_para_switch
cmplwi r4, 0xffef
bgt _parse_para_switch
mr r4, r29
addi r3, r1, 0x10
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_para_app_length
b _parse_para_check_result
_parse_para_app_length:
lhz r3, 0x10(r1)
cmplwi r3, 2
bge _parse_para_app_move
li r3, -0x45
b _parse_para_check_result
_parse_para_app_move:
addi r0, r3, -2
mr r4, r29
sth r0, 0x10(r1)
clrlwi r3, r0, 0x10
bl TMCJPEGDEC_move_ptr
srawi r0, r3, 0x1f
and r3, r3, r0
srawi r0, r3, 0x1f
and r3, r3, r0
b _parse_para_check_result
_parse_para_switch:
addi r0, r26, -0x27
cmpw r4, r0
beq _parse_para_eoi
bge _parse_para_switch_ge_ffc2
addi r0, r26, -0x3e
cmpw r4, r0
beq _parse_para_sos
bge _parse_para_switch_ge_ffc4
addi r0, r26, -0x40
cmpw r4, r0
beq _parse_para_sof
b _parse_para_unknown
_parse_para_switch_ge_ffc4:
addi r0, r26, -0x3c
cmpw r4, r0
beq _parse_para_dht
b _parse_para_unknown
_parse_para_switch_ge_ffc2:
addi r0, r26, -0x23
cmpw r4, r0
beq _parse_para_dri
bge _parse_para_switch_ge_ffdc
addi r0, r26, -0x25
cmpw r4, r0
beq _parse_para_dqt
bge _parse_para_dnl
b _parse_para_com_marker
_parse_para_switch_ge_ffdc:
addi r0, r26, -2
cmpw r4, r0
beq _parse_para_com
b _parse_para_unknown
_parse_para_dht:
mr r3, r30
mr r4, r29
bl TMCJPEGDEC_parse_dht
b _parse_para_check_result
_parse_para_dqt:
mr r3, r29
bl TMCJPEGDEC_parse_dqt
b _parse_para_check_result
_parse_para_dri:
mr r4, r29
addi r3, r1, 0xe
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_para_dri_length
b _parse_para_check_result
_parse_para_dri_length:
lhz r0, 0xe(r1)
cmplwi r0, 4
beq _parse_para_dri_value
li r3, -0x42
b _parse_para_check_result
_parse_para_dri_value:
mr r4, r29
addi r3, r1, 0xe
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_para_dri_store
b _parse_para_check_result
_parse_para_dri_store:
lhz r0, 0xe(r1)
li r3, 0
sth r0, 0x181a(r29)
b _parse_para_check_result
_parse_para_dnl:
mr r4, r29
addi r3, r1, 0xc
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_para_dnl_length
b _parse_para_check_result
_parse_para_dnl_length:
lhz r0, 0xc(r1)
cmplwi r0, 4
beq _parse_para_dnl_value
li r3, -0x43
b _parse_para_check_result
_parse_para_dnl_value:
mr r4, r29
addi r3, r1, 0xc
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_para_dnl_store
b _parse_para_check_result
_parse_para_dnl_store:
lhz r0, 0xc(r1)
li r3, 0
sth r0, 0x17f2(r29)
b _parse_para_check_result
_parse_para_com:
mr r4, r29
addi r3, r1, 0xa
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_para_com_length
b _parse_para_check_result
_parse_para_com_length:
lhz r3, 0xa(r1)
cmplwi r3, 2
bge _parse_para_com_move
li r3, -0x44
b _parse_para_check_result
_parse_para_com_move:
addi r0, r3, -2
mr r4, r29
sth r0, 0xa(r1)
clrlwi r3, r0, 0x10
bl TMCJPEGDEC_move_ptr
srawi r0, r3, 0x1f
and r3, r3, r0
srawi r0, r3, 0x1f
and r3, r3, r0
b _parse_para_check_result
_parse_para_sof:
li r31, 1
b _parse_para_check_result
_parse_para_sos:
li r31, 1
b _parse_para_check_result
_parse_para_com_marker:
li r31, 1
b _parse_para_check_result
_parse_para_eoi:
stb r27, 0x181c(r29)
li r31, 1
b _parse_para_check_result
_parse_para_unknown:
li r3, -0x2f
_parse_para_check_result:
cmpwi r3, 0
bge _parse_para_keep_going
li r31, 1
_parse_para_keep_going:
cmpwi r31, 0
beq _parse_para_loop
lhz r0, 0x12(r1)
sth r0, 0(r28)
_parse_para_return:
lmw r26, 0x18(r1)
lwz r0, 0x34(r1)
mtlr r0
addi r1, r1, 0x30
blr
}
#else
static s32 TMCJPEGDEC_parse_para(u16* marker, TMCCJPEGDecWork* work) {
u8 byte;
u16 local;
u16 appSize;
u16 driSize;
u16 dnlSize;
u16 comSize;
s32 result;
u32 keepGoing = 0;
@@ -737,7 +1067,18 @@ static s32 TMCJPEGDEC_parse_para(u16* marker, TMCCJPEGDecWork* work) {
}
if (local >= 0xFFE0 && local <= 0xFFEF) {
result = parseApplication(work);
result = TMCJPEGDEC_get_wbyte(&appSize, work);
if (result < 0) {
goto _check;
}
if (appSize < 2) {
result = -0x45;
goto _check;
}
appSize -= 2;
result = TMCJPEGDEC_move_ptr(appSize, work);
result = result & (result >> 31);
result = result & (result >> 31);
} else {
switch ((s32)local) {
case 0xFFC4: {
@@ -749,15 +1090,48 @@ static s32 TMCJPEGDEC_parse_para(u16* marker, TMCCJPEGDecWork* work) {
break;
}
case 0xFFDD: {
result = parseRestartInterval(work);
result = TMCJPEGDEC_get_wbyte(&driSize, work);
if (result >= 0) {
if (driSize != 4) {
result = -0x42;
} else {
result = TMCJPEGDEC_get_wbyte(&driSize, work);
if (result < 0) {
goto _check;
}
work->restartInterval = driSize;
result = 0;
}
}
break;
}
case 0xFFDC: {
result = parseNumberOfLines(work);
result = TMCJPEGDEC_get_wbyte(&dnlSize, work);
if (result >= 0) {
if (dnlSize != 4) {
result = -0x43;
} else {
result = TMCJPEGDEC_get_wbyte(&dnlSize, work);
if (result >= 0) {
work->frameHeight = dnlSize;
result = 0;
}
}
}
break;
}
case 0xFFFE: {
result = parseComment(work);
result = TMCJPEGDEC_get_wbyte(&comSize, work);
if (result >= 0) {
if (comSize < 2) {
result = -0x44;
} else {
comSize -= 2;
result = TMCJPEGDEC_move_ptr(comSize, work);
result = result & result >> 31;
result = result & result >> 31;
}
}
break;
}
case 0xFFC0: {
@@ -784,6 +1158,7 @@ static s32 TMCJPEGDEC_parse_para(u16* marker, TMCCJPEGDecWork* work) {
}
}
_check:
if (result < 0) {
keepGoing = 1;
}
@@ -792,6 +1167,7 @@ static s32 TMCJPEGDEC_parse_para(u16* marker, TMCCJPEGDecWork* work) {
*marker = local;
return result;
}
#endif
#ifdef __MWERKS__
static asm s32 TMCJPEGDEC_parse_dht(register s32 first, register TMCCJPEGDecWork* work) {
@@ -1583,19 +1959,167 @@ static s32 TMCJPEGDEC_parse_sof(TMCCJPEGDecWork* work) {
}
#endif
#ifdef __MWERKS__
static asm s32 TMCJPEGDEC_parse_sos(register TMCCJPEGDecWork* work) {
nofralloc
stwu r1, -0x30(r1)
mflr r0
stw r0, 0x34(r1)
stmw r27, 0x1c(r1)
mr r28, r3
addi r30, r3, 0x2c
addi r29, r3, 0x58
addi r3, r1, 0xa
mr r4, r28
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_sos_have_length
b _parse_sos_return
_parse_sos_have_length:
lhz r0, 0xa(r1)
cmplwi r0, 2
bge _parse_sos_have_count
li r3, -0x51
b _parse_sos_return
_parse_sos_have_count:
mr r4, r28
addi r3, r1, 8
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_sos_store_count
b _parse_sos_return
_parse_sos_store_count:
lbz r3, 8(r1)
cmplwi r3, 4
stb r3, 0x180b(r28)
bgt _parse_sos_bad_count
lbz r0, 0x180a(r28)
cmplw r3, r0
beq _parse_sos_count_valid
_parse_sos_bad_count:
li r3, -0x51
b _parse_sos_return
_parse_sos_count_valid:
li r31, 0
b _parse_sos_loop_condition
_parse_sos_loop:
mr r4, r28
addi r3, r1, 8
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_sos_have_component
b _parse_sos_return
_parse_sos_have_component:
lbz r0, 0x180a(r28)
li r5, 0
lbz r4, 8(r1)
mtctr r0
cmpwi r0, 0
ble _parse_sos_bad_component
_parse_sos_find_component:
add r3, r30, r5
lbz r0, 0x14(r3)
cmpw r4, r0
bne _parse_sos_next_component
stbx r5, r30, r31
add r27, r30, r31
b _parse_sos_found_component
_parse_sos_next_component:
addi r5, r5, 1
bdnz _parse_sos_find_component
_parse_sos_bad_component:
li r3, -0x51
b _parse_sos_return
_parse_sos_found_component:
mr r4, r28
addi r3, r1, 8
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_sos_have_tables
b _parse_sos_return
_parse_sos_have_tables:
lbz r0, 8(r1)
srawi r5, r0, 4
clrlwi r6, r0, 0x1c
cmpwi r5, 1
bgt _parse_sos_bad_tables
cmpwi r6, 1
ble _parse_sos_tables_valid
_parse_sos_bad_tables:
li r3, -0x51
b _parse_sos_return
_parse_sos_tables_valid:
lbz r0, 0(r27)
add r3, r29, r5
add r4, r30, r0
stb r5, 0x1c(r4)
lbz r0, 0(r27)
add r4, r30, r0
stb r6, 0x20(r4)
lbz r0, 0x1794(r3)
cmplwi r0, 1
beq _parse_sos_ac_valid
li r3, -0x40
b _parse_sos_return
_parse_sos_ac_valid:
add r3, r29, r6
lbz r0, 0x1796(r3)
cmplwi r0, 1
beq _parse_sos_quant_valid
li r3, -0x40
b _parse_sos_return
_parse_sos_quant_valid:
lbz r0, 0x18(r27)
add r3, r29, r0
lbz r0, 0x1790(r3)
cmplwi r0, 1
beq _parse_sos_next
li r3, -0x41
b _parse_sos_return
_parse_sos_next:
addi r31, r31, 1
_parse_sos_loop_condition:
lbz r0, 0x180b(r28)
cmpw r31, r0
blt _parse_sos_loop
mr r4, r28
li r3, 3
bl TMCJPEGDEC_move_ptr
srawi r0, r3, 0x1f
and r3, r3, r0
_parse_sos_return:
lmw r27, 0x1c(r1)
lwz r0, 0x34(r1)
mtlr r0
addi r1, r1, 0x30
blr
}
#else
static s32 TMCJPEGDEC_parse_sos(TMCCJPEGDecWork* work) {
typedef struct {
u8 map[4];
u32 dcPredict[4];
u8 id[4];
u8 quantTable[4];
u8 dcTable[4];
u8 acTable[4];
} TMCComponentInfo;
s32 idx;
TMCComponentInfo* components;
u8* compPtr;
TMCUnknownInfo* scalePtr;
TMCComponentInfo* mapPtr;
u8* mapPtr;
s32 dcTbl;
s32 acTbl;
@@ -1606,7 +2130,7 @@ static s32 TMCJPEGDEC_parse_sos(TMCCJPEGDecWork* work) {
s32 ci;
u8 scanByte;
components = (TMCComponentInfo*)work->compMap;
compPtr = (u8*)work->compMap;
scalePtr = (TMCUnknownInfo*)&work->scaleFlag;
r = TMCJPEGDEC_get_wbyte(&len, work);
@@ -1622,12 +2146,12 @@ static s32 TMCJPEGDEC_parse_sos(TMCCJPEGDecWork* work) {
return r;
}
work->scanCompCount = scanByte;
if (work->scanCompCount > 4 || work->scanCompCount != work->compCount) {
if (scanByte > 4 || scanByte != work->compCount) {
return -0x51;
}
work->scanCompCount = scanByte;
for (idx = 0; idx < (s32)work->scanCompCount; idx++) {
r = TMCJPEGDEC_get_byte(&scanByte, work);
if (r < 0) {
@@ -1635,15 +2159,18 @@ static s32 TMCJPEGDEC_parse_sos(TMCCJPEGDecWork* work) {
}
for (ci = 0; ci < (s32)work->compCount; ci++) {
if ((s32)scanByte == (s32)components->id[ci]) {
components->map[idx] = ci;
mapPtr = (TMCComponentInfo*)&components->map[idx];
goto componentFound;
if ((s32)compPtr[ci + 0x14] == (s32)scanByte) {
compPtr[idx] = ci;
mapPtr = compPtr + idx;
break;
}
}
return -0x51;
componentFound:
// TODO: This isn't right...
if (ci >= (s32)work->compCount) {
return -0x51;
}
r = TMCJPEGDEC_get_byte(&scanByte, work);
if (r < 0) {
return r;
@@ -1656,8 +2183,8 @@ componentFound:
return -0x51;
}
components->dcTable[mapPtr->map[0]] = dcTbl;
components->acTable[mapPtr->map[0]] = acTbl;
compPtr[*mapPtr + 0x1c] = dcTbl;
compPtr[*mapPtr + 0x20] = acTbl;
if (scalePtr->dcTblFlag[dcTbl] != 1) {
return -0x40;
@@ -1667,17 +2194,15 @@ componentFound:
return -0x40;
}
if (scalePtr->quantTblFlag[mapPtr->quantTable[0]] != 1) {
if (scalePtr->quantTblFlag[mapPtr[0x18]] != 1) {
return -0x41;
}
}
moveResult = TMCJPEGDEC_move_ptr(3, work);
if (moveResult < 0) {
return moveResult;
}
return 0;
return moveResult & (moveResult >> 31);
}
#endif
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_err_restart(register TMCCJPEGDecWork* work) {

View File

@@ -4,21 +4,219 @@ extern void* memset(void* dest, int value, unsigned long size);
static s32 TMCJPEGDEC_vl_decode_rc(u32* huff_tbl, u8* huff_sym, TMCCJPEGDecWork* work);
static inline s32 readCoefficientBits(TMCCJPEGDecWork* work, s32 count) {
u32 range = 1UL << count;
u32 mask = range - 1;
s32 value;
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_decode_iquant_rc(register s32* block, register u8* conv_row_ptr, register u32* dc_predict_row_ptr, register TMCCJPEGDecWork* work) {
nofralloc
value = work->bitCount - count;
work->bitCount = value;
value = (work->bitBuf >> value) & mask;
if (range >> 1 > (u32)value) {
value -= mask;
}
return value;
stwu r1, -0x40(r1)
mflr r0
stw r0, 0x44(r1)
stmw r21, 0x14(r1)
mr r22, r3
mr r23, r4
mr r25, r5
mr r24, r6
lwz r0, 4(r6)
lwz r21, 0x498(r6)
cmpwi r0, 8
bgt _decode_iquant_rc_have_dc_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_have_dc_bits
b _decode_iquant_rc_return
_decode_iquant_rc_have_dc_bits:
lwz r4, 4(r24)
lwz r3, 0(r24)
addi r0, r4, -8
srw r0, r3, r0
rlwinm r0, r0, 2, 0x16, 0x1d
lhzx r5, r21, r0
cmpwi r5, 0
beq _decode_iquant_rc_decode_dc
add r3, r21, r0
subf r0, r5, r4
lhz r21, 2(r3)
stw r0, 4(r24)
b _decode_iquant_rc_have_dc_value
_decode_iquant_rc_decode_dc:
lwz r3, 0x49c(r24)
mr r5, r24
lwz r4, 0x4a0(r24)
bl TMCJPEGDEC_vl_decode_rc
cmpwi r3, 0
mr r21, r3
bge _decode_iquant_rc_have_dc_value
b _decode_iquant_rc_return
_decode_iquant_rc_have_dc_value:
cmpwi r21, 0
beq _decode_iquant_rc_store_dc
lwz r0, 4(r24)
cmpw r0, r21
bgt _decode_iquant_rc_read_dc_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_read_dc_bits
b _decode_iquant_rc_return
_decode_iquant_rc_read_dc_bits:
lwz r0, 4(r24)
li r4, 1
lwz r3, 0(r24)
slw r6, r4, r21
subf r4, r21, r0
addi r5, r6, -1
srwi r0, r6, 1
srw r3, r3, r4
stw r4, 4(r24)
and r3, r5, r3
cmplw r0, r3
ble _decode_iquant_rc_store_dc_bits
subf r3, r5, r3
_decode_iquant_rc_store_dc_bits:
lwz r0, 0(r25)
add r0, r0, r3
stw r0, 0(r25)
_decode_iquant_rc_store_dc:
lwz r5, 0(r25)
addi r3, r22, 4
lwz r0, 0(r23)
li r4, 0
mullw r0, r5, r0
stw r0, 0(r22)
lwz r30, 0x4a8(r24)
lwz r26, 0x4ac(r24)
lwz r25, 0x4b0(r24)
lwz r27, 0x1834(r24)
lwz r5, 0x1838(r24)
bl memset
lis r21, TMCJPEGDEC_Zigzag_data@ha
li r28, 1
addi r21, r21, TMCJPEGDEC_Zigzag_data@l
li r31, 1
_decode_iquant_rc_ac_loop:
lwz r0, 4(r24)
cmpwi r0, 8
bgt _decode_iquant_rc_have_ac_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_have_ac_bits
b _decode_iquant_rc_return
_decode_iquant_rc_have_ac_bits:
lwz r4, 4(r24)
lwz r3, 0(r24)
addi r0, r4, -8
srw r0, r3, r0
rlwinm r0, r0, 2, 0x16, 0x1d
add r3, r30, r0
lhzx r0, r30, r0
cmpwi r0, 0
beq _decode_iquant_rc_decode_ac
lhz r3, 2(r3)
subf r0, r0, r4
stw r0, 4(r24)
b _decode_iquant_rc_have_ac_value
_decode_iquant_rc_decode_ac:
mr r3, r26
mr r4, r25
mr r5, r24
bl TMCJPEGDEC_vl_decode_rc
cmpwi r3, 0
bge _decode_iquant_rc_have_ac_value
b _decode_iquant_rc_return
_decode_iquant_rc_have_ac_value:
clrlwi. r29, r3, 0x1c
beq _decode_iquant_rc_no_ac_bits
lwz r0, 4(r24)
srawi r3, r3, 4
add r28, r28, r3
cmpw r0, r29
bgt _decode_iquant_rc_read_ac_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_read_ac_bits
b _decode_iquant_rc_return
_decode_iquant_rc_read_ac_bits:
cmpw r28, r27
ble _decode_iquant_rc_store_ac
lwz r0, 4(r24)
cmpwi r28, 0x40
subf r0, r29, r0
stw r0, 4(r24)
blt _decode_iquant_rc_increment
li r3, -0x64
b _decode_iquant_rc_return
_decode_iquant_rc_increment:
addi r28, r28, 1
b _decode_iquant_rc_loop_check
_decode_iquant_rc_store_ac:
lwz r0, 4(r24)
slw r6, r31, r29
lwz r3, 0(r24)
addi r5, r6, -1
subf r4, r29, r0
srwi r0, r6, 1
srw r3, r3, r4
stw r4, 4(r24)
and r4, r5, r3
cmplw r0, r4
ble _decode_iquant_rc_have_extra
subf r4, r5, r4
_decode_iquant_rc_have_extra:
cmpwi r28, 0x40
blt _decode_iquant_rc_store_coeff
li r3, -0x64
b _decode_iquant_rc_return
_decode_iquant_rc_store_coeff:
lbzx r0, r21, r28
addi r28, r28, 1
slwi r3, r0, 2
lwzx r0, r23, r3
mullw r0, r4, r0
stwx r0, r22, r3
b _decode_iquant_rc_loop_check
_decode_iquant_rc_no_ac_bits:
cmpwi r3, 0
bne _decode_iquant_rc_zrl
li r3, 0
b _decode_iquant_rc_return
_decode_iquant_rc_zrl:
addi r28, r28, 0x10
_decode_iquant_rc_loop_check:
cmpwi r28, 0x40
blt _decode_iquant_rc_ac_loop
li r3, 0
_decode_iquant_rc_return:
lmw r21, 0x14(r1)
lwz r0, 0x44(r1)
mtlr r0
addi r1, r1, 0x40
blr
}
#else
s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_row_ptr, TMCCJPEGDecWork* work) {
const u8* zztbl;
u16* ac_fast;
s32 t;
s32 idx;
@@ -33,6 +231,7 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
s32 blk_mul;
s32 bit_pos;
u32 bit_data;
u16* dcf;
s32* conv_row;
@@ -49,7 +248,7 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
tmp = (work->bitBuf >> (bit_pos - 8) & 0xFF) << 2;
val = dcf[tmp >> 1];
if (val != 0) {
tmp = dcf[(tmp >> 1) + 1];
tmp = *(u16*)((u8*)dcf + tmp + 2);
work->bitCount -= val;
val = tmp;
} else {
@@ -65,7 +264,16 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
return r;
}
}
extra = readCoefficientBits(work, val);
tmp = 1UL << val;
bit_pos = work->bitCount - val;
work->bitCount = bit_pos;
bit_data = work->bitBuf;
extra = tmp - 1;
extra = extra & (bit_data >> bit_pos);
if (tmp >> 1 > (u32)extra) {
extra -= (tmp - 1);
}
dc_predict_row_ptr[0] += extra;
}
@@ -77,8 +285,9 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
blk_size = work->blockSize;
blk_mul = work->blockSizeMul;
memset(block + 1, 0, blk_mul);
memset((u8*)block + 4, 0, blk_mul);
zztbl = TMCJPEGDEC_Zigzag_data;
idx = 1;
do {
if (work->bitCount <= 8) {
@@ -88,7 +297,7 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
}
{
u16* ac_entry = &ac_fast[(work->bitBuf >> (work->bitCount - 8) & 0xFF) * 2];
u16* ac_entry = (u16*)((u8*)ac_fast + ((work->bitBuf >> (work->bitCount - 8) & 0xFF) << 2));
val = *ac_entry;
if (val != 0) {
tmp = val;
@@ -119,12 +328,21 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
}
idx++;
} else {
extra = readCoefficientBits(work, t);
bit_pos = work->bitCount - t;
work->bitCount = bit_pos;
bit_data = work->bitBuf;
tmp = 1UL << t;
extra = tmp - 1;
extra = extra & (bit_data >> bit_pos);
if (tmp >> 1 > extra) {
extra -= tmp - 1;
}
if (idx >= 64) {
return TMCC_ERROR_OVERFLOW;
}
block[TMCJPEGDEC_Zigzag_data[idx]] = extra * conv_row[TMCJPEGDEC_Zigzag_data[idx]];
*(s32*)((u8*)block + zztbl[idx] * 4) = extra * conv_row[zztbl[idx]];
idx++;
}
} else {
@@ -137,6 +355,7 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
return 0;
}
#endif
static s32 TMCJPEGDEC_vl_decode_rc(u32* huff_tbl, u8* huff_sym, TMCCJPEGDecWork* work) {
s32 bit_pos;

View File

@@ -167,28 +167,28 @@ s32 TMCJPEGDEC_set_converterRGB565(TMCCJPEGDecWork* work) {
static void TMCJPEGDEC_converterYUV411toRGB565(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileRow;
s32 lumaSkip;
s32 cbValue;
s32 blue;
TMCCJPEGDecState* state;
s32 lumaSkip;
u32 tileWidth;
s32 crValue;
s32 width;
s32 height;
s32 chromaSkip;
u8* cb;
u8* texture;
u8* luminance;
u8* cb;
s32 chromaSkip;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u8 value;
u32 tileWidth;
s32 greenOffset;
s32 redOffset;
s32 red;
s32 tileRow;
s32 blueOffset;
u8 value;
s32 red;
s32 greenOffset;
s32 green;
luminance = work->convBuf + 4;
@@ -284,9 +284,7 @@ static void TMCJPEGDEC_converterYUV411toRGB565edge(TMCCJPEGDecWork* work, s32 x,
s32 yEnd = y + height;
s32 lumaSkip = 32 - width;
s32 chromaSkip = lumaSkip >> 2;
s32 redOffset;
s32 blueOffset;
s32 greenOffset;
s32 redOffset, greenOffset, blueOffset;
ASSERTLINE((x & 3) == 0, __LINE__);
for (; y < yEnd; y++) {
s32 tileRow = (y >> 2) * tileWidth;
@@ -324,11 +322,11 @@ static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32
s32 chromaSkip;
s32 width;
s32 blue;
u16* output;
s32 lumaSkip;
s32 red;
s32 tileRow;
s32 lumaSkip;
s32 redOffset;
u16* output;
u32 tileWidth;
u8* texture;
TMCCJPEGDecState* state;
s32 crValue;
@@ -340,7 +338,7 @@ static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32
s32 cbValue;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 green;
@@ -477,22 +475,22 @@ static void TMCJPEGDEC_converterYUV420toRGB565(TMCCJPEGDecWork* work, s32 x, s32
s32 width;
s32 redOffset;
s32 green;
s32 tileRow;
s32 lumaSkip;
u32 tileWidth;
u8* texture;
s32 chromaSkip;
s32 height;
u8* texture;
s32 yEnd;
u8* luminance;
s32 crValue;
s32 value;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 cbValue;
s32 column;
u8* cr;
s32 greenOffset;
s32 tileRow;
s32 cbValue;
s32 lumaSkip;
s32 blueOffset;
s32 red;
TMCCJPEGDecState* state;
@@ -565,23 +563,26 @@ static void TMCJPEGDEC_converterYUV420toRGB565(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
u16* output;
s32 yEnd;
s8 crValue;
s32 tileRow;
u8* texture;
u8* luminance;
s32 width;
s8* cb;
s8 crValue;
s32 width;
s8* cr;
s8 cbValue;
s32 column;
s32 xEnd;
s8 cbValue;
s32 yEnd;
s32 red;
s32 blue;
u32 tileWidth;
s32 height;
TMCCJPEGDecState* state;
s32 green;
s32 lumaSkip;
u32 tileWidth;
s32 chromaSkip;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
@@ -618,18 +619,16 @@ static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x,
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
s32 value = *luminance++;
s32 red = value + redOffset;
s32 blue = value + blueOffset;
s32 green = value + greenOffset;
if ((blue | red | green) >> 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 = *luminance++;
red = blue + redOffset;
green = blue + greenOffset;
blue = blue + blueOffset;
if ((blue | red | green) >> 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);
}
luminance += lumaSkip;
if (y & 1) {
@@ -817,11 +816,15 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
u8* luminance;
u8* cb;
u8* cr;
s32 value;
s32 column;
s32 xEnd;
s32 cbValue;
s32 yEnd;
u32 tileWidth;
s32 green;
s32 blue;
s32 red;
s32 height;
luminance = work->convBuf + 4;
@@ -841,19 +844,17 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
for (column = x; column < xEnd; column++) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
{
s32 value = *luminance++;
s32 green = value + (-(cbValue * 88 + crValue * 183) >> 8);
s32 red = value + ((crValue * 359) >> 8);
s32 blue = value + ((cbValue * 454) >> 8);
if ((red | green | blue) >> 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));
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);
}
luminance += rowSkip;
cb += rowSkip;

View File

@@ -179,7 +179,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 yEnd;
s32 tileWidth;
s32 blueOffset;
s32 greenOffset;
u16* output;
s32 tileRow;
s32 lumaSkip;
s8 crValue;
@@ -188,7 +188,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 cbValue;
u8 value;
s32 row;
u16* output;
s32 greenOffset;
s32 redOffset;
s32 blue;
@@ -285,9 +285,9 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 chromaSkip;
s32 tileRow;
s32 lumaSkip;
s32 xEnd;
u8* texture;
TMCCJPEGDecState* state;
u8* luminance;
@@ -296,15 +296,15 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 height;
u8* cr;
s32 column;
s32 xEnd;
s32 lumaSkip;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
u16* output;
s32 cbValue;
s8 crValue;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 chromaSkip;
s32 blue;
s32 red;
s32 green;
@@ -366,11 +366,11 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
u16* output;
s32 cbValue;
s32 tileRow;
TMCCJPEGDecState* state;
s32 lumaSkip;
s32 cbValue;
s32 tileWidth;
TMCCJPEGDecState* state;
u16* output;
u8* texture;
s32 width;
s32 height;
@@ -381,8 +381,8 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 column;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
s32 tileRow;
s32 greenOffset;
s32 blueOffset;
s32 value;
@@ -441,21 +441,21 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
s32 blue;
u16* output;
s32 tileRow;
s32 lumaSkip;
s32 xEnd;
u8* cr;
TMCCJPEGDecState* state;
u8* texture;
s32 tileWidth;
u8* luminance;
s32 width;
s32 height;
u8* cb;
u8* cr;
u8* texture;
s32 column;
s32 xEnd;
s32 chromaSkip;
s32 yEnd;
s32 tileWidth;
s32 tileRow;
s32 cbValue;
s32 crValue;
s32 redOffset;
@@ -463,8 +463,8 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 blueOffset;
s32 value;
s32 red;
s32 lumaSkip;
s32 green;
s32 blue;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
@@ -517,27 +517,27 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
s8 crValue;
s32 lumaSkip;
u16* output;
TMCCJPEGDecState* state;
s32 tileRow;
s8 crValue;
s32 chromaSkip;
u8* luminance;
TMCCJPEGDecState* state;
u8* texture;
s32 width;
s32 height;
s32 green;
s32 blue;
u8* luminance;
u8* cb;
u8* cr;
s32 lumaSkip;
s32 yEnd;
s32 xEnd;
s32 value;
s32 column;
s32 xEnd;
s32 yEnd;
u8* cr;
s32 greenOffset;
s32 tileWidth;
s32 redOffset;
s32 greenOffset;
u8* texture;
u8* cb;
u16* output;
s32 blueOffset;
s32 red;
s32 cbValue;
@@ -641,9 +641,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 xEnd = x + width;
s32 lumaSkip = 16 - width;
s32 chromaSkip = lumaSkip >> 1;
s32 redOffset;
s32 blueOffset;
s32 greenOffset;
s32 redOffset, greenOffset, blueOffset;
ASSERTLINE((x & 1) == 0, __LINE__);
for (; y < yEnd; y++) {
u16* output = (u16*)(texture + ((y & 3) << 3));
@@ -658,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;
@@ -770,7 +768,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileRow;
s32 lumaSkip;
s32 blue;
u8* texture;
u8* luminance;
@@ -785,14 +783,14 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 greenOffset;
s32 yEnd;
s32 cbValue;
s32 tileWidth;
s32 tileRow;
s32 blueOffset;
s32 red;
s8 crValue;
u8 value;
s32 green;
s32 redOffset;
s32 lumaSkip;
s32 tileWidth;
luminance = work->convBuf + 4;
cb = work->convBuf + 132;

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;
@@ -267,20 +267,20 @@ struct __zi8_work_data_s {
ziU8 unk_0x140C[4];
ziU32 formats; // 0x1410
ziU8 unk_0x1414[4];
ziU8 formatCount;
ziU8 unk_0x1418;
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
ziU8 unk_0x1760[4]; // 0x1760
ziU8* groupPtr; // 0x1764
ziU8* unk_0x1764; // 0x1764
ziU8 unk_0x1768;
ziU8 unk_0x1769[0x81];
ziU16 matchOffset; // 0x17EA
ziU16 unk_0x17EA;
ziU8 unk_0x17EC;
ziU8 unk_0x17ED[3];
ziU8* dawgGroup; // 0x17F0
@@ -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

@@ -1,20 +1,5 @@
#include <zi8clib/zitypes.h>
typedef struct {
ziU8 countOnly;
ziU8 maxWordLength;
ziU8 lookupMode;
ziU8 suffixOnly;
ziU8 controls[8];
ziU32 maxCount;
ziU16 capacity;
ziU8 minWordLength;
ziU8 flags;
ziU16 candidateCapacity;
ziU8 checkOnly;
ziU8 reserved;
} ZiCandidateOptions;
const ziWChar Zi8PunctTable[40] = {
0xFF0C, 0x3002, 0x3001, 0xFF1A, 0xFF1F, 0xFF01, 0x3005, 0x2026,
0x2015, 0xFF1B, 0xFF0E, 0x30FB, 0x201C, 0x201D, 0xFF08, 0xFF09,
@@ -23,8 +8,8 @@ const ziWChar Zi8PunctTable[40] = {
0xFFE1, 0x20AC, 0x203B, 0xFF20, 0x0000,
};
ziU32 Zi8Punctuation(ziGetParam* param, ziPtr options ZI_NEED_WORK) {
ziS32 limit = ((ZiCandidateOptions*)options)->capacity - 1;
ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
ziS32 limit = ((ziU16*)__zi8_work_data)[8] - 1;
ziS32 count = 0;
ziU8 i = 0;
ziU16 fc = param->firstCandidate;
@@ -36,7 +21,7 @@ ziU32 Zi8Punctuation(ziGetParam* param, ziPtr options ZI_NEED_WORK) {
}
if (fc == 0) {
count++;
if (((ZiCandidateOptions*)options)->countOnly == 0) {
if (ZI_WORK->unk_0x00 == 0) {
param->candidates[i++] = Zi8PunctTable[j];
if ((param->context & 0x10) != 0) {
param->candidates[i++] = 0x20;
@@ -48,7 +33,7 @@ ziU32 Zi8Punctuation(ziGetParam* param, ziPtr options ZI_NEED_WORK) {
break;
}
} else {
if (count >= (ziS32)((ZiCandidateOptions*)options)->maxCount) {
if (count >= (ziS32)ZI_WORK->unk_0x0C) {
return count;
}
}
@@ -57,7 +42,7 @@ ziU32 Zi8Punctuation(ziGetParam* param, ziPtr options ZI_NEED_WORK) {
}
j++;
}
if (((ZiCandidateOptions*)options)->countOnly == 0) {
if (ZI_WORK->unk_0x00 == 0) {
param->letters = count;
}
return count;

View File

@@ -1,8 +1,3 @@
#include <zi8clib/zitypes.h>
#undef ZI_NEED_WORK
#define ZI_NEED_WORK , struct __zi8_work_data_s* __zi8_work_data
#undef ZI_WORK
#define ZI_WORK __zi8_work_data
#include <zi8clib/zconvert.h>
#include <zi8clib/zierror.h>
@@ -28,7 +23,7 @@ typedef struct ziConversionTable {
} ziConversionTable;
const ziConversionTables Zi8CvrtTables = {0};
ziU16 Zi8GetTableCount(ziU8, ziU8 ZI_NEED_WORK);
ziU32 Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2UserKey(ziChar, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
@@ -42,7 +37,7 @@ ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
return 0;
}
if (Zi8GetTableCount(language, 6, __zi8_work_data) != 0) {
table = (ziU8*)Zi8GetTableAddress(language, 6, __zi8_work_data);
table = Zi8GetTableAddress(language, 6, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6A4, __zi8_work_data);
return 0;
@@ -82,7 +77,7 @@ ziChar Zi8ConvertWC2UC(ziWChar character, ziU8 language ZI_NEED_WORK) {
return 0;
}
if (Zi8GetTableCount(language, 7, __zi8_work_data) != 0) {
table = (ziConversionTable*)Zi8GetTableAddress(language, 7, __zi8_work_data);
table = Zi8GetTableAddress(language, 7, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6AE, __zi8_work_data);
return 0;
@@ -142,7 +137,7 @@ ziWChar Zi8ConvertUC2Key(ziChar character, ziU8 language ZI_NEED_WORK) {
if (ZI_WORK->userKeys[language] != 0)
return Zi8ConvertUC2UserKey(character, language, __zi8_work_data);
if (Zi8GetTableCount(language, 8, __zi8_work_data) != 0) {
table = (ziConversionTable*)Zi8GetTableAddress(language, 8, __zi8_work_data);
table = Zi8GetTableAddress(language, 8, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6B8, __zi8_work_data);
return 0;

View File

@@ -15,6 +15,28 @@ typedef struct {
typedef struct { ziU8 keyLow; ziU8 keyHigh; ziU8 code; ziU8 flags; } Zi8AltSoundRecord;
typedef struct {
ziU8 language;
ziU8 getMode;
ziU8 subLanguage;
ziU8 context;
ziU8 getOptions;
ziWChar* elements;
ziU8 elementCount;
ziWChar* currentWord;
ziU8 wordCharCount;
ziWChar* candidates;
ziU8 maxCandidates;
ziU16 firstCandidate;
ziU8 wordCandidates;
ziU8 count;
ziU8 letters;
ziU8* scratch;
ziPtr workspace;
} Zi8OneKeyParam;
typedef struct {
ziU8 countOnly;
ziU8 maxSpellingLength;
@@ -181,15 +203,15 @@ const ziWChar zi8PYfinalSpelling[64][4] = {
const unsigned long long Zi8SOpinyinArray = 0x0303010705000000ULL;
extern ziU16 Zi8Ord2Ord(ziU16, ziPtr);
extern Zi8UInt Zi8Ord2Ord(ziU16, ziPtr);
extern ziU8 Zi8LangSupported(ziU8, ziPtr);
extern ziU16 Zi8GetTableCount(ziU8,ziU8,ziPtr);
extern ziU32 Zi8GetTableAddress(ziU8,ziU8,ziPtr);
extern void Zi8Memset(ziU8*,ziU32,ziS32);
extern ziU8 _Zi8GetCandidates(ziGetParam*,ziPtr);
extern void Zi8InitDupWordBuf(ziPtr);
extern ziU32 Zi8GetPInfo(ziU32,ziWChar *,ziU8,ziPtr);
extern ziU32 Zi8GetZInfo(ziU32,ziWChar *,ziU8,ziPtr);
extern Zi8UInt Zi8GetTableAddress(ziU8,ziU8,ziPtr);
extern void Zi8Memset();
extern int _Zi8GetCandidates();
extern void Zi8InitDupWordBuf();
extern ziU16 Zi8GetPInfo(ziU16,ziWChar *,ziU8,ziPtr);
extern ziU16 Zi8GetZInfo(ziU16,ziWChar *,ziU8,ziPtr);
extern ziBool Zi8IsDupWordW(ziWChar *,ziU8,ziPtr);
extern ziU8 Zi8GetFormatVersion(ziU8,ziPtr);
extern ziU16 Zi8Uni2Ord(ziWChar,ziPtr);
@@ -197,10 +219,10 @@ extern ziU16 Zi8GetPCode(ziU8 *,ziU8 *);
extern ziU8 Zi8MatchOEMdata(ziWChar *,ziU8,ziU8,ziWChar *,ziU16,ziU8,ziU8,ziPtr);
extern ziU8 Zi8MatchPUDdata(ziWChar *,ziU8,ziU8,ziWChar *,ziU16,ziU8,ziU8,ziPtr);
extern ziWChar Zi8Ord2Uni(ziU16,ziPtr);
extern ziU32 Zi8GetZHuwdPtr(ziU32*,ziU16*,ziPtr);
extern ziU8 Zi8GetPyPhonetic(ziWChar*,ziU8,ziU16*,ziU16*,ziU8*,ziU16*,ziU16*,ziPtr);
extern ziU8 Zi8GetBpmfPhonetic(ziWChar*,ziU8,ziU16*,ziU16*,ziU16*,ziU16*,ziPtr);
extern ziU8 _Zi8CheckCandidates(ziGetParam*,ziPtr);
extern Zi8UInt Zi8GetZHuwdPtr(ziU8 **,ziU16 *,ziPtr);
extern int Zi8GetPyPhonetic();
extern ziU8 Zi8GetBpmfPhonetic();
extern int _Zi8CheckCandidates();
Zi8UInt Zi8SpellingZY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
{
@@ -289,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;
@@ -440,15 +462,15 @@ BACKWARD_SEARCH:
goto BINARY_SEARCH;
}
}
static Zi8UInt Zi8SetFindCand(ziU8 *foundCandidates,ziU16 ordinal,ziPtr work)
static Zi8UInt Zi8SetFindCand(ziU8 *foundCandidates,Zi8UInt ordinal,ziPtr work)
{
Zi8UInt result;
ordinal = Zi8Ord2Ord(ordinal,work);
result = (ziU8)((1 << ((int)ordinal % 8)) &
foundCandidates[(int)ordinal / 8]);
foundCandidates[(int)ordinal / 8] |=
1 << ((int)ordinal % 8);
result = (ziU8)((1 << ((int)(ordinal & 0xffff) % 8)) &
foundCandidates[(int)(ordinal & 0xffff) / 8]);
foundCandidates[(int)(ordinal & 0xffff) / 8] |=
1 << ((int)(ordinal & 0xffff) % 8);
return result;
}
@@ -484,7 +506,7 @@ LAB_return_false:
return 0;
}
ziU32 Zi8Get1KeyPressSpelling(ziGetParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
{
ziU8 candidateCount;
ziBool exactLength;
@@ -509,18 +531,18 @@ ziU32 Zi8Get1KeyPressSpelling(ziGetParam *params,Zi8OneKeyOptions *options,Zi8On
ziU16 *output;
ziU8 *savedSearchOrder;
ziU16 spellingBuffer[8];
ziGetParam searchParams;
Zi8OneKeyParam searchParams;
candidateCount = 0;
totalCandidates = 0;
optionsMask = params->getOptions;
params->count = 0;
params->letters = 0;
params->completion = 0;
optionsMask = optionsMask & ~0x10;
optionsMask = optionsMask & ~0x20;
optionsMask = optionsMask & ~0x40;
if (options->maxSpellingLength == '\0') {
params->letters = 0;
params->count = 0;
Zi8LogError(100,work);
return 0;
}
@@ -798,7 +820,7 @@ ziU32 Zi8Get1KeyPressSpelling(ziGetParam *params,Zi8OneKeyOptions *options,Zi8On
savedSearchCount = work->searchOrderCount;
convertedInput = false;
savedSearchFlags = work->searchFlags;
Zi8Memset((ziU8*)&searchParams,0,0x2c);
Zi8Memset(&searchParams,0,0x2c);
searchParams.getMode = 0;
searchParams.subLanguage = 0x80;
searchParams.context = 1;
@@ -896,7 +918,7 @@ ziU32 Zi8Get1KeyPressSpelling(ziGetParam *params,Zi8OneKeyOptions *options,Zi8On
work->searchFlags = savedSearchFlags;
work->searchOrder = savedSearchOrder;
work->searchOrderCount = savedSearchCount;
params->letters = searchParams.letters;
params->count = searchParams.count;
work->spellingOnly = 0;
if (convertedInput) {
if (params->getMode == '\x03') {
@@ -915,7 +937,7 @@ ziU32 Zi8Get1KeyPressSpelling(ziGetParam *params,Zi8OneKeyOptions *options,Zi8On
}
}
if ((options->countOnly == '\0') && (params->getMode == '\x03')) {
for (tableIndex = 0; tableIndex < params->letters;) {
for (tableIndex = 0; tableIndex < params->count;) {
while (*output != 0) {
if (*output != 0x27) {
*output++ |= 0xf300;
@@ -1000,12 +1022,12 @@ nextSpelling:
}
}
finishSpelling:
params->letters = candidateCount;
params->count = candidateCount;
Zi8LogError(100,work);
return totalCandidates;
}
ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
{
ziU16 wordBuffer [64];
ziU16 spelling [8];
@@ -1024,7 +1046,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
ziU8 *phraseEntries;
ziU16 *currentWord;
ziU8 *entryCursor;
ziU32 userEntriesAddress;
ziU8 *userEntries;
int duplicateIndex;
ziU16 alternateCount;
ziU16 ordinalCount;
@@ -1126,8 +1148,8 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
}
languageMask = languageMask << 4;
remaining = params->firstCandidate;
params->count = 0;
params->letters = 0;
params->completion = 0;
inputLength = params->elementCount;
if (inputLength != 0) {
while (inputLength != 0) {
@@ -1249,7 +1271,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
tableCursor = Zi8GetTableCount(1,9,work);
}
if (8 < inputLimit) {
params->count = 0;
params->wordCandidates = 0;
goto finishCandidates;
}
for (index = 0; index < (int)(Zi8UInt)inputLimit; index++) {
@@ -1305,7 +1327,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
}
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;
}
@@ -1335,7 +1357,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
output[outputIndex++] = candidateCharacter;
}
if (candidateCount >= params->maxCandidates || outputIndex > outputLimit) {
params->count = candidateCount;
params->wordCandidates = candidateCount;
goto finishCandidates;
}
} else {
@@ -1374,7 +1396,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
}
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;
}
@@ -1404,7 +1426,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
output[outputIndex++] = candidateCharacter;
}
if (candidateCount >= params->maxCandidates || outputIndex > outputLimit) {
params->count = candidateCount;
params->wordCandidates = candidateCount;
goto finishCandidates;
}
} else {
@@ -1497,7 +1519,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
}
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;
}
@@ -1525,7 +1547,7 @@ ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8
output[outputIndex++] = firstOrdinal;
}
if (candidateCount >= params->maxCandidates || outputIndex > outputLimit) {
params->count = candidateCount;
params->wordCandidates = candidateCount;
goto finishCandidates;
}
} else {
@@ -1546,7 +1568,7 @@ nextPhrase:
else {
finishPhrases:
if (params->wordCharCount != '\0') {
params->count = candidateCount;
params->wordCandidates = candidateCount;
}
}
if ((options->countOnly == '\0') && (tableCursor != 0)) {
@@ -1579,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;
@@ -1607,11 +1629,11 @@ nextSortedOrdinal:
;
}
}
if ((options->countOnly == '\0') && (ziU8)Zi8GetZHuwdPtr(&userEntriesAddress,&userCount,work) != 0)
if ((options->countOnly == '\0') && Zi8GetZHuwdPtr(&userEntries,&userCount,work) != 0)
{
for (phraseOrdinal = 0; phraseOrdinal < userCount;) {
if ((params->elementCount == '\0') || ((((ziU8*)userEntriesAddress)[1] & 0x80) != 0)) {
userOrdinal = (ziU16)(((ziU8*)userEntriesAddress)[1] & 0x7f) << 8 | (ziU16)((ziU8*)userEntriesAddress)[2];
if ((params->elementCount == '\0') || ((userEntries[1] & 0x80) != 0)) {
userOrdinal = (userEntries[1] & 0x7f) << 8 | (ziU16)userEntries[2];
phraseTable = syllableTable + (Zi8UInt)userOrdinal * 0xc;
if (((*phraseTable & languageMask) != 0) &&
((characterSetTable == 0 || ((characterSet & characterSetTable[(Zi8UInt)userOrdinal]) != 0)))) {
@@ -1632,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;
@@ -1655,7 +1677,7 @@ nextSortedOrdinal:
}
nextUserOrdinal:
phraseOrdinal++;
userEntriesAddress = userEntriesAddress + 3;
userEntries = userEntries + 3;
}
}
phraseTable = syllableTable;
@@ -1688,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;
}
@@ -1716,14 +1738,15 @@ nextOrdinal:
}
finishCandidates:
if ((emitWords) && (outputIndex != 0)) {
output[outputIndex++] = 0;
output[outputIndex] = 0;
outputIndex++;
}
params->letters = candidateCount;
params->count = candidateCount;
Zi8LogError(100,work);
return totalCandidates;
}
ziBool Zi8ZHCheckSpelling(ziWChar *input,ziWChar *spelling,ziU8 inputLength,ziPtr work)
Zi8UInt Zi8ZHCheckSpelling(ziU16 *input,ziU16 *spelling,Zi8UInt inputLength,char *work)
{
int index;
ziU8 result;
@@ -1738,11 +1761,11 @@ ziBool Zi8ZHCheckSpelling(ziWChar *input,ziWChar *spelling,ziU8 inputLength,ziPt
int syllableStart;
int syllableLength;
Zi8UInt tableOffset;
ziWChar candidateBuffer [16];
ziU16 phoneticCodes [16];
ziU16 phoneticMasks [16];
ziU8 candidateBuffer [32];
ziU8 phoneticCodes [32];
ziU8 phoneticMasks [32];
ziU16 convertedSpelling [64];
ziGetParam getParam;
Zi8OneKeyParam getParam;
ziU8 maskLow;
ziU8 codeLow;
ziU8 maskHigh;
@@ -1783,7 +1806,7 @@ ziBool Zi8ZHCheckSpelling(ziWChar *input,ziWChar *spelling,ziU8 inputLength,ziPt
}
index = 0;
syllableStart = index;
for (; index < (int)inputLength; index = index + 1) {
for (; index < (int)(inputLength & 0xff); index = index + 1) {
switch (spelling[index]) {
case 0xf331:
toneMask = 1;
@@ -1854,7 +1877,7 @@ nextInputCharacter:
}
else {
if ((input[index] == 0x27) || (input[index] == 0xf360)) {
if (index < (int)inputLength) {
if (index < (int)(inputLength & 0xff)) {
convertedSpelling[index] = input[index] = spelling[index];
}
else {
@@ -1896,7 +1919,7 @@ nextInputCharacter:
getParam.elementCount = (ziU8)index;
getParam.currentWord = 0;
getParam.wordCharCount = 0;
getParam.candidates = candidateBuffer;
getParam.candidates = (ziWChar *)candidateBuffer;
getParam.maxCandidates = 1;
getParam.firstCandidate = 0;
if ((ziU8)_Zi8CheckCandidates(&getParam,work) != 0) {

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

@@ -351,7 +351,6 @@ int Zi8AlphaGetCandidates(ziGetParam* parameters, ziPtr optionData, ziPtr workDa
int candidateCount;
ziU8 *keyLayout;
ziU8 *keyLayoutCursor;
ziPtr workspace;
ziU16 prefixTableFlags;
ziU16 prefixVowelFlags;
ziU8 prefixMode;
@@ -407,7 +406,6 @@ int Zi8AlphaGetCandidates(ziGetParam* parameters, ziPtr optionData, ziPtr workDa
contextEnabled = 0;
keyLayoutCount = 0;
keyLayout = 0;
workspace = workData;
phoneticInput = 0;
phoneticSeparator = 0;
if ((((((language == 0x7c) || (language == 0x7d)) || (language == 0x7b)) ||
@@ -922,8 +920,9 @@ selectDictionary:
if ((((wordLength == 0) && (*punctuationCursor != 0)) && (dictionaryExact != 0)) &&
((((ZiAlphaWork*)workData)->singleCharacter != 0 && (parameters->elementCount == 2)))) {
*wordCursor = ((ZiAlphaWork*)workData)->singleCharacter;
wordCursor[1] = *punctuationCursor;
punctuationCursor = punctuationCursor + 1;
wordCursor[2] = 0;
wordCursor[1] = *punctuationCursor++;
wordLength = 2;
}
if (((apostropheIndex != 0) && (wordLength != 0)) && (elementCount == parameters->elementCount)) {
@@ -1006,7 +1005,7 @@ filterVowelCandidate:
case 3:
case 7:
while( ZI8_TRUE ) {
wordLength = Zi8MatchUWDdata(elements,elementCount,
wordLength = Zi8MatchUWDdata(elements,elementCount & 0xff,
parameters->currentWord,parameters->wordCharCount,
language,wordCursor,wordCapacity & 0xffff,dictionaryExact,
dictionaryStatus[dictionaryKind] & 0xff,workData);
@@ -1017,8 +1016,8 @@ filterVowelCandidate:
case 4:
case 8:
if (elementCount != 0) {
wordLength = Zi8MatchOEMdata(elements,elementCount,language,wordCursor,
wordCapacity,dictionaryExact,
wordLength = Zi8MatchOEMdata(elements,elementCount & 0xff,language,wordCursor,
wordCapacity & 0xffff,dictionaryExact,
dictionaryStatus[dictionaryKind] & 0xff,workData);
}
break;
@@ -1069,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)))))) {
@@ -1085,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)) ||
@@ -1140,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;
}
@@ -1195,9 +1194,7 @@ checkKeyLayout:
break;
}
emitCandidate:
if (firstCandidate != 0) {
--firstCandidate;
} else {
if (firstCandidate == 0) {
if (((ZiAlphaOptions*)optionData)->countOnly != '\0') {
if (((ZiAlphaOptions*)optionData)->suffixOnly != '\0') {
if ((int)((ZiAlphaOptions*)optionData)->shortestWord > (int)(wordLength + prefixCount)) {
@@ -1207,17 +1204,20 @@ emitCandidate:
((ZiAlphaOptions*)optionData)->longestWord = wordLength + prefixCount;
}
}
if (++candidateCount >= ((ZiAlphaOptions*)optionData)->maxResults) goto finishCandidates;
candidateCount = candidateCount + 1;
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;
}
@@ -1326,7 +1326,8 @@ emitCandidate:
wordCursor = wordCursor + wordLength;
wordCapacity = wordCapacity - wordLength;
}
if (++candidateCount >= (int)(unsigned int)parameters->maxCandidates) {
candidateCount = candidateCount + 1;
if ((int)(unsigned int)parameters->maxCandidates <= candidateCount) {
prefixCount = 0;
goto finishCandidates;
}
@@ -1358,12 +1359,15 @@ emitCandidate:
}
}
}
else {
firstCandidate = firstCandidate - 1;
}
}
}
}
}
retryDictionary:;
} while (dictionaryIndex != 0);
} while (dictionaryKind != 0);
}
finishDictionaryPass:;
}
@@ -1372,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;
@@ -1398,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;
@@ -1418,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)))) {
@@ -1437,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))
@@ -1568,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

@@ -133,16 +133,16 @@ typedef struct {
ziU8 phonetics[11];
} ZiChineseRecord;
extern ziU32 Zi8GetTableAddress(ziU8 language, ziU8 table, ziPtr work);
extern ziPtr Zi8GetTableAddress(ziU8 language, ziU8 table, ziPtr work);
extern ziU16 Zi8GetTableCount(ziU8 language, ziU8 table, ziPtr work);
extern ziU8 Zi8IsDupWChar(ziWChar character, ziPtr work);
extern ziU8 Zi8IsDupWordW(ziWChar* word, ziU8 length, ziPtr work);
extern ziWChar Zi8Ord2Uni(ziU16 ordinal, ziPtr work);
extern ziU8 Zi8MatchPhonetic(ziPtr phonetics, ziU8* records,
ziPtr indexTable, ziU16 indexCount, ziU32 dictionary,
ziU8* record, ziU16* mask, ziU16* match,
ziU16* length, ziU8** matchedRecord,
ziU8** matchedString, ziU8 wordMode, ziU8 partial,
extern ziU8 Zi8MatchPhonetic(ziU8* phonetics, ZiChineseRecord* records,
ziPtr indexTable, ziU16 indexCount, ziPtr dictionary,
ZiChineseRecord* record, ziU16* mask, ziU16* match,
ziU16* length, ZiChineseRecord** matchedRecord,
int* matchedIndex, ziU8 wordMode, ziU8 partial,
ziU8 oneCharacter, ziU16 excludedMask,
ziU16 excludedMatch, ziU8 charset, ziU8 options,
ziU16 ordinal, ziU16* tone, ziU8 spellingOnly,
@@ -160,13 +160,13 @@ extern const ziU8 zi8CangjieCodes[25];
extern const ziWChar ziPuncts[4];
extern const ziWChar ziTones[4];
const ziWChar zi8tones[4];
extern ziU32 Zi8GetZHuwdPtr(ziU32* entries, ziU16* count, ziPtr work);
extern ziU8 Zi8GetZHuwdPtr(ziU8** entries, ziU16* count, ziPtr work);
extern ziBool Zi8IsComponent(ziWChar character, ziPtr work);
extern ziBool Zi8IsCharacter(ziWChar character, ziPtr work);
extern ziU8 Zi8MatchOEMdata(ziWChar* currentWord, ziU8 length, ziU8 language,
ziWChar* output, ziU16 capacity, ziU8 mode, ziU8 next, ziPtr work);
extern ziU16 Zi8Uni2Ord(ziWChar character, ziPtr work);
extern ziU16 Zi8GetPCode(ziU8* table, ziU8* record);
extern int Zi8GetPCode(ziU8* table, ziU8* record);
extern ziU16 Zi8MatchAltSound(ziPtr table, ziU16 count, ziPtr phonetics,
ziU16 ordinal, ziU16 mask, ziU16 value, ziU8 flags, ziPtr work);
extern ziU32 Zi8SecMatchChar(ziPtr record, ziU8* dictionary, ziMatchParam* match, ziU16* code, ziPtr work);
@@ -199,7 +199,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
ziU8 matchMode;
int index;
ziWChar* currentWord;
ziU32 userEntriesAddress;
ziU8* userEntries;
ziU16 ordinalIndex;
ziU16 tableIndex;
ziU16 phraseOrdinal;
@@ -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 {
@@ -614,10 +614,10 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
case 56: case 59:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 60: case 63:
case 52: case 55:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->bANDp) ordinalIndex = 0xF9FF;
break;
case 52: case 55:
case 60: case 63:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->gANDk) ordinalIndex = 0xF9FF;
break;
case 38:
@@ -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);
@@ -755,8 +755,8 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
componentOrdinals = (ziU8*)Zi8GetTableAddress(1, 7, work);
componentTable = componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
componentCursor += 8;
componentIndex = componentCount - 1;
--componentCount;
componentIndex = componentCount;
alternateCharacter = 0;
phoneticRetry = 1;
}
@@ -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;
}
}
@@ -1299,16 +1299,16 @@ context_word_lookup:
if (emitWords) {
++emittedCount;
outputIndex += emittedWords;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) {
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)) {
@@ -1336,7 +1336,7 @@ dictionary_search:
Zi8GetFormatVersion(1, work) >= 8) {
lastCharHigh = (request->currentWord[request->wordCharCount - 1] >> 8) & 0xFF;
lastCharLow = request->currentWord[request->wordCharCount - 1];
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 28, work);
phoneticGroups = Zi8GetTableAddress(1, 28, work);
rangeCount = Zi8GetTableCount(1, 28, work);
rangeIndex = 0;
while (rangeIndex < rangeCount) {
@@ -1384,7 +1384,7 @@ numeric_setup:
default: ordinalCount = 0; break;
}
}
if (ordinalCount) ordinalTable = (ziU8*)Zi8GetTableAddress(1, 29, work);
if (ordinalCount) ordinalTable = Zi8GetTableAddress(1, 29, work);
}
if (!request->elementCount && (getMode == 7 || getMode == 8 || getMode == 9)) {
resultFallback = 0;
@@ -1434,8 +1434,8 @@ candidate_dictionary_search:
if (emitWords) {
++emittedCount;
output[outputIndex++] = character;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) goto engine_finish;
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) goto engine_finish;
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) goto engine_finish;
}
@@ -1451,7 +1451,7 @@ character_range_start:
firstOrdinal = 0;
rangeIndex = Zi8GetTableCount(1, 16, work);
if (Zi8GetFormatVersion(1, work) >= 4 && rangeIndex && elements[0] != 0xEF00) {
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 16, work);
phoneticGroups = Zi8GetTableAddress(1, 16, work);
rangeIndex = 0;
rangeCount = 0;
switch (phase) {
@@ -1612,9 +1612,9 @@ phonetic_ordinal_search:
record = records + phraseOrdinal * 12;
candidateCount = 0;
phoneticGroups = 0;
if (!Zi8MatchPhonetic(phoneticTable, records, alternateTable, alternateCount,
(ziU32)phraseTable, record, match.phon, match.phon2,
&candidateCount, &record, &phoneticGroups,
if (!Zi8MatchPhonetic(phoneticTable, (ZiChineseRecord*)records, alternateTable, alternateCount,
phraseTable, (ZiChineseRecord*)record, match.phon, match.phon2,
&candidateCount, (ZiChineseRecord**)&record, (int*)&phoneticGroups,
0, 1, match.nCand, phoneticMask, phoneticMatch, charset, requireFull,
phraseOrdinal, &candidateOrdinal, 0, work)) continue;
if (charsetTable) {
@@ -1676,8 +1676,8 @@ tone_candidates:
if (emitWords) {
++emittedCount;
output[outputIndex++] = character;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) goto engine_finish;
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) goto engine_finish;
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) goto engine_finish;
} else if (totalResults >= options->maxResults) goto engine_finish;
@@ -1752,12 +1752,12 @@ 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)) &&
(ziU8)Zi8GetZHuwdPtr(&userEntriesAddress, &userCount, work) && (getMode != 0 || match.nSeg <= 1)) {
Zi8GetZHuwdPtr(&userEntries, &userCount, work) && (getMode != 0 || match.nSeg <= 1)) {
userIndex = 0;
while (userIndex < userCount) {
candidateOrdinal = (ziU16)(((ziU8*)userEntriesAddress)[1] & 0x7F) << 8 | ((ziU8*)userEntriesAddress)[2];
candidateOrdinal = (ziU16)(userEntries[1] & 0x7F) << 8 | userEntries[2];
record = records + candidateOrdinal * 12;
if (!(record[0] & charset)) goto user_character_next;
character = ((ziU16)record[6] << 8) + record[7];
@@ -1792,7 +1792,7 @@ user_character_search:
(ziU8)Zi8SecMatchChar(record, componentTable, &match, 0, work)) candidateStatus = 1;
break;
case 1: case 2:
if (request->elementCount && !(((ziU8*)userEntriesAddress)[1] & 0x80)) candidateStatus = 0;
if (request->elementCount && !(userEntries[1] & 0x80)) candidateStatus = 0;
else {
candidateStatus = (match.first & (ziU16)Zi8GetPCode(phoneticTable, record)) == match.first2;
if (!candidateStatus && (record[0] & 0x80) && !requireFull &&
@@ -1827,7 +1827,7 @@ user_character_search:
}
user_character_next:
++userIndex;
userEntriesAddress += 3;
userEntries += 3;
}
}
if (!prefixLookup) goto phonetic_alt_continue;
@@ -1912,7 +1912,7 @@ cangjie_components:
Zi8GetTableCount(1, 16, work) && elements[0] != 0xEF00 && getMode != 5) {
rangeIndex = 0;
rangeCount = 0;
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 16, work);
phoneticGroups = Zi8GetTableAddress(1, 16, work);
switch (phase) {
case 0: rangeIndex = 0; rangeCount = 2; phase = 1; break;
case 1:
@@ -2052,7 +2052,7 @@ component_record_next:
if (getMode != 5) {
while (exactPhrase) {
while (match.count) {
if ((candidateCount -= 1) == 0xFFFF) goto frequency_range_retry;
if (!candidateCount--) goto frequency_range_retry;
if (match.arrD[0] == (record[0] & match.arr1[0]) &&
(ziU8)Zi8SecMatchChar(record, componentTable, &match, &candidateOrdinal, work)) goto frequency_accept;
record += 12;
@@ -2199,7 +2199,7 @@ phonetic_main:
if (Zi8GetFormatVersion(1, work) >= 4) rangeCount = Zi8GetTableCount(1, 23, work);
else rangeCount = 0;
if (rangeCount && match.nCand == 2 && emitWords) {
frequencyCursor = (ziU8*)Zi8GetTableAddress(1, 24, work);
frequencyCursor = Zi8GetTableAddress(1, 24, work);
frequencyEntry = frequencyCursor;
duplicateIndex = Zi8GetTableCount(1, 24, work);
if (!duplicateIndex) isFirstCandidate = 1;
@@ -2298,7 +2298,7 @@ phonetic_pair_next:
alternateCursor += 4;
}
phonetic_group_next:
ordinalIndex += 1;
++ordinalIndex;
frequencyCursor += 5;
}
}
@@ -2323,9 +2323,9 @@ phonetic_ordinals:
candidateCount = recordCount;
phoneticGroups = 0;
while (emittedCount < request->maxCandidates && candidateCount) {
if (!Zi8MatchPhonetic(phoneticTable, records, alternateTable, alternateCount,
(ziU32)phraseTable, record, match.phon, match.phon2,
&candidateCount, &record, &phoneticGroups,
if (!Zi8MatchPhonetic(phoneticTable, (ZiChineseRecord*)records, alternateTable, alternateCount,
phraseTable, (ZiChineseRecord*)record, match.phon, match.phon2,
&candidateCount, (ZiChineseRecord**)&record, (int*)&phoneticGroups,
emitWords, singleCharacterPass, match.nCand, phoneticMask, phoneticMatch, charset,
requireFull, recordCount, &candidateOrdinal, filteringMode, work)) break;
ordinalIndex = recordCount - candidateCount - 1;
@@ -2446,7 +2446,7 @@ engine_finish:
return totalResults;
filtered_search:
userIndex = Zi8GetTableCount(1, 31, work);
frequencyTable = (ziU8*)Zi8GetTableAddress(1, 31, work);
frequencyTable = Zi8GetTableAddress(1, 31, work);
for (; userIndex; --userIndex) {
index = frequencyTable[0] & 15;
if (!(*frequencyTable++ & charset)) goto filtered_next;
@@ -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;
@@ -2608,10 +2608,10 @@ static int Zi8NewMatchPhonetic(ziGetParam* request, ZiChineseRecord* records,
ziU8* phonetics;
int totalResults;
int emittedCharacters;
ziU8* matchedRecord;
ZiChineseRecord* matchedRecord;
ziU8* phoneticGroups;
ziU8* candidateGroups;
ziU8* matchedString;
int matchedIndex;
int capacity;
ziU8* groupCandidates;
ziU16 phoneticCount;
@@ -2645,20 +2645,20 @@ static int Zi8NewMatchPhonetic(ziGetParam* request, ZiChineseRecord* records,
if ((mask & 7) == 7) {
stopAfterTone = match & 7;
}
phoneticOffsets = (ziU16*)Zi8GetTableAddress(1, 13, work);
ordinalTable = (ziU16*)Zi8GetTableAddress(1, 14, work);
phoneticOffsets = Zi8GetTableAddress(1, 13, work);
ordinalTable = Zi8GetTableAddress(1, 14, work);
if (pinyin) {
phonetics = (ziU8*)Zi8GetTableAddress(1, 3, work);
phonetics = Zi8GetTableAddress(1, 3, work);
phoneticCount = Zi8GetTableCount(1, 3, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 17, work);
phoneticGroups = Zi8GetTableAddress(1, 17, work);
groupCount = Zi8GetTableCount(1, 17, work);
candidateGroups = (ziU8*)Zi8GetTableAddress(1, 18, work);
candidateGroups = Zi8GetTableAddress(1, 18, work);
} else {
phonetics = (ziU8*)Zi8GetTableAddress(1, 4, work);
phonetics = Zi8GetTableAddress(1, 4, work);
phoneticCount = Zi8GetTableCount(1, 4, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 19, work);
phoneticGroups = Zi8GetTableAddress(1, 19, work);
groupCount = Zi8GetTableCount(1, 19, work);
candidateGroups = (ziU8*)Zi8GetTableAddress(1, 20, work);
candidateGroups = Zi8GetTableAddress(1, 20, work);
}
if (groupCount) {
@@ -2782,12 +2782,12 @@ next_group_candidate:
}
}
if (stopAfterTone) {
matchedRecord = (ziU8*)(records + character);
matchedRecord = records + character;
matchedLength = 0;
matchedString = 0;
if (!Zi8MatchPhonetic(phonetics, (ziU8*)records, indexTable, indexCount,
(ziU32)dictionary, matchedRecord, &mask, &match,
&matchedLength, &matchedRecord, &matchedString,
matchedIndex = 0;
if (!Zi8MatchPhonetic(phonetics, records, indexTable, indexCount,
dictionary, matchedRecord, &mask, &match,
&matchedLength, &matchedRecord, &matchedIndex,
wordMode, 1, 1, excludedMask, excludedMatch,
charset, request->getOptions & 0x40, character,
&matchedTone, 0, work)) {

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;
}
}
@@ -184,36 +184,36 @@ unsigned int Zi8MatchROMdata1(ziWChar *elements, ziU8 count, ziU8 language, ziWC
result = 0;
if (status == 0) {
ZI_WORK->groupPtr = (ziU8*)group;
if (ZI_WORK->groupPtr == 0) {
ZI_WORK->unk_0x1764 = (ziU8*)group;
if (ZI_WORK->unk_0x1764 == 0) {
if (Zi8GetTableSize(language & 0xff,0xb,ZI_WORK) != 0) {
ZI_WORK->groupPtr = (ziU8*)(tableAddress = Zi8GetTableAddress(language & 0xff,0xb,ZI_WORK));
ZI_WORK->unk_0x1764 = (ziU8*)(tableAddress = Zi8GetTableAddress(language & 0xff,0xb,ZI_WORK));
}
}
if (ZI_WORK->groupPtr != 0) {
for (; (*ZI_WORK->groupPtr != 0xff && ((groupIndex & 0xff) != 0));
if (ZI_WORK->unk_0x1764 != 0) {
for (; (*ZI_WORK->unk_0x1764 != 0xff && ((groupIndex & 0xff) != 0));
groupIndex = groupIndex - 1) {
while (*ZI_WORK->groupPtr != 0xff) {
ZI_WORK->groupPtr += 2;
while (*ZI_WORK->unk_0x1764 != 0xff) {
ZI_WORK->unk_0x1764 += 2;
}
ZI_WORK->groupPtr++;
ZI_WORK->unk_0x1764++;
}
}
}
if (ZI_WORK->groupPtr == 0) {
if (ZI_WORK->unk_0x1764 == 0) {
result = Zi8MatchROMdata0(elements,count,language & 0xff,output,capacity & 0xffff,
mode & 0xff,status & 0xff,0,1,acceptPrefix,0,&ZI_WORK->dawgCtx,
ZI_WORK->unk_0x1760,ZI_WORK);
}
else {
while (*ZI_WORK->groupPtr != 0xff) {
while (*ZI_WORK->unk_0x1764 != 0xff) {
result = Zi8MatchROMdata0(elements,count,language & 0xff,output,
capacity & 0xffff,mode & 0xff,status & 0xff,
*ZI_WORK->groupPtr,
ZI_WORK->groupPtr[1],acceptPrefix,0,
*ZI_WORK->unk_0x1764,
ZI_WORK->unk_0x1764[1],acceptPrefix,0,
&ZI_WORK->dawgCtx,ZI_WORK->unk_0x1760,ZI_WORK);
if ((result & 0xff) != 0) break;
ZI_WORK->groupPtr += 2;
ZI_WORK->unk_0x1764 += 2;
status = 0;
}
}
@@ -230,31 +230,31 @@ unsigned int Zi8MatchROMdata2(ziWChar* elements, ziU8 count, ziU8 language,
if (reservedMode != 0) return 0;
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;
ZI_WORK->unk_0x17EA = 0;
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:
ZI_WORK->maxCnt = 1;
result = Zi8MatchROMdata1(elements + ZI_WORK->matchOffset,
count - ZI_WORK->matchOffset, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
result = Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA,
count - ZI_WORK->unk_0x17EA, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], capacity,
mode, status, ZI_WORK->unk_0x1768, (char*)group,
acceptPrefix, ZI_WORK);
if ((ziU8)result != 0) {
for (index = (ziU8)(ZI_WORK->matchOffset + result); index != 0; index--) {
for (index = (ziU8)(ZI_WORK->unk_0x17EA + result); index != 0; index--) {
output[index - 1] = ZI_WORK->unk_0x17F4[index - 1];
}
result = (ziU8)(result + ZI_WORK->matchOffset);
result = (ziU8)(result + ZI_WORK->unk_0x17EA);
} else {
if (status != 0 || count == 1) goto finish_segments;
if (mode == 1 && ZI_WORK->unk_0x1768 == 0 &&
(ziU8)Zi8MatchROMdata1(elements + ZI_WORK->matchOffset,
count - ZI_WORK->matchOffset, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
(ziU8)Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA,
count - ZI_WORK->unk_0x17EA, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], capacity,
0, status, ZI_WORK->unk_0x1768, (char*)group,
acceptPrefix, ZI_WORK) != 0) goto finish_segments;
if ((Zi8GetTableCount(language, 0x1f, ZI_WORK) & 4) == 0) {
@@ -264,23 +264,23 @@ search_segment:
}
if (ZI_WORK->maxCnt > capacity) goto finish_segments;
for (index = ZI_WORK->maxCnt; index != 0; index--) {
result = Zi8MatchROMdata1(elements + ZI_WORK->matchOffset, index, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
result = Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA, index, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], capacity,
1, 0, ZI_WORK->unk_0x1768, (char*)group,
acceptPrefix, ZI_WORK);
if ((ziU8)result != 0) {
ZI_WORK->matchOffset += (ziU8)result;
if (ZI_WORK->matchOffset == count) return 0;
ZI_WORK->unk_0x17EA += (ziU8)result;
if (ZI_WORK->unk_0x17EA == 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++) {
for (index = 0; index < ZI_WORK->unk_0x17EA; 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;
}
@@ -51,10 +51,10 @@ ziBool Zi8ZHsetZYfuzzyPairs(ziFuzzyZYPairs pairs ZI_NEED_WORK) {
ziBool Zi8SetLatinSearchOrder(ziU8* searchArray, ziU8 searchSize ZI_NEED_WORK) {
if (searchArray == 0 || *searchArray == 0) {
ZI_WORK->formats = (ziU32)Zi8SOdefaultArray;
ZI_WORK->formatCount = 9;
ZI_WORK->unk_0x1418 = 9;
} else {
ZI_WORK->formats = (ziU32)searchArray;
ZI_WORK->formatCount = searchSize;
ZI_WORK->unk_0x1418 = searchSize;
}
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);
@@ -62,7 +62,7 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
return 1;
}
ziU8 Zi8IsZicorpSignature(ziU16* p, ziU16 len ZI_NEED_WORK) {
ziU8 Zi8IsZicorpSignature(ziU16* p, ziU16 len) {
if ((ziU16)len > 6 && p[0] == 0x7A && p[1] == 0x69 && p[2] == 0x63 &&
p[3] == 0x6F && p[4] == 0x72 && p[5] == 0x70) {
return 1;

View File

@@ -254,7 +254,7 @@ ziBool Zi8PriMatchNextComp(ziU8* node, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8
return 0;
}
ziBool Zi8SecMatchComp(ziPtr nodeAddress, ziMatchParam* matchAddress, ziPtr dictionaryAddress ZI_NEED_WORK) {
ziBool Zi8SecMatchComp(ziPtr nodeAddress, ziMatchParam* matchAddress, ziPtr dictionaryAddress) {
int chainIndex;
ziU16 matchCode;
ziU16 targetCode;
@@ -506,7 +506,7 @@ pinyin_initial:
convertedCount = Zi8PinyinInitials[value];
if (convertedCount != 0) {
if (outputIndex == 0) {
*resultCount += 1;
*resultCount = *resultCount + 1;
}
result++;
initial[outputIndex] = 0x7E00;
@@ -526,7 +526,7 @@ pinyin_initial:
value = *current;
if (value != 0x68 && value != 0xF368) goto scan_final;
if (outputIndex == 0) {
*resultCount += 1;
*resultCount = *resultCount + 1;
}
final[outputIndex] += 0x200;
*bestInitial = initial[0];
@@ -567,7 +567,7 @@ scan_final:
value -= 0xF361;
if (value > 0x19) {
if (outputIndex == 0) {
*resultCount += 1;
*resultCount = *resultCount + 1;
}
goto finish_final;
}
@@ -577,7 +577,7 @@ scan_final:
pinyin[index] = (ziU8)value + 1;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) == 0) goto try_final_extension;
if (outputIndex == 0) {
*resultCount += 1;
*resultCount = *resultCount + 1;
}
current++;
index++;
@@ -592,7 +592,7 @@ try_final_extension:
pinyin[index + 1] = 0xFF;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (outputIndex == 0) {
*resultCount += 1;
*resultCount = *resultCount + 1;
}
pinyin[index + 1] = 0;
current++;
@@ -615,7 +615,7 @@ try_final_extension:
finish_final:
if ((index > 3) && (count != 0) && (((value = *current) == 0x27) || (value == 0xF360) || (value == 0x20))) {
if (outputIndex == 0) {
*resultCount += 1;
*resultCount = *resultCount + 1;
}
current++;
count--;
@@ -705,10 +705,11 @@ finish_final:
}
}
}
if (++outputIndex > 0xf) break;
outputIndex++;
if (outputIndex > 0xf) break;
}
if ((result > 1) && (text[*resultCount - 1] >= 0xF341) && (text[*resultCount - 1] <= 0xF35A)) {
*resultCount -= 1;
*resultCount = *resultCount - 1;
}
return result;
@@ -742,9 +743,9 @@ check_row:
return 0;
}
ziU8 Zi8GetBpmfPhonetic(ziWChar* text, ziU8 count, ziU16* initial, ziU16* final, ziU16* bestInitial, ziU16* bestFinal ZI_NEED_WORK) {
ziS32 Zi8GetBpmfPhonetic(ziWChar* text, ziU8 count, ziU16* initial, ziU16* final, ziU16* bestInitial, ziU16* bestFinal ZI_NEED_WORK) {
ziU16 value;
ziU8 resultCount = 0;
ziU32 resultCount = 0;
Zi8LogError(0x64, ZI_WORK);
if (count == 0) {

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

@@ -17,7 +17,7 @@ typedef struct ziPudHeader {
ziU8 options[4];
ziPudSection sections[1];
} ziPudHeader;
ziU8 Zi8_8147FD7C(ziWChar*, ziU8, ziU8, ziWChar*, ziU16, ziU8, ziU8 ZI_NEED_WORK);
ziU32 Zi8_8147FD7C(ziWChar*, ziU8, ziU8, ziWChar*, ziU16, ziU8, ziU8 ZI_NEED_WORK);
ziU32 ZiIsPhoneticChar(ziWChar character) {
if ((character < 0xF305 || character > 0xF329) && (character < 0xF361 || character > 0xF37A)) return 0;
@@ -56,11 +56,8 @@ ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option, struct __zi8_work_data_s* __zi8_work_da
Zi8LogError(100, __zi8_work_data);
return previous;
}
ziU8 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziWChar* spelling, ziU16 spellingCapacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
struct {
int fallback;
ziPtr workspace;
} match;
ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziWChar* spelling, ziU16 spellingCapacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
int fallback = 0;
ziU8* bytePattern;
ziWChar folded;
ziPudSection* section;
@@ -71,8 +68,6 @@ ziU8 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
ziU32 entrySize;
ziPudHeader* table;
ziU8* byteOutput;
match.workspace = __zi8_work_data;
match.fallback = 0;
if (!(ZI_WORK->pudCount <= 16 && ZI_WORK->pudCount != 0 && ZI_WORK->pudTable[ZI_WORK->pudCount - 1] != 0)) {
Zi8LogError(0x4B0, __zi8_work_data);
return 0;
@@ -93,8 +88,8 @@ ziU8 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
Zi8LogError(0x4F6, __zi8_work_data);
return 0;
}
ZI_WORK->unk_0x314 = ((ziU16)section->count[0] << 8) + (ziU16)section->count[1];
ZI_WORK->unk_0x310 = (ziU32)table + (((ziU16)section->offset[0] << 8) + (ziU16)section->offset[1]);
ZI_WORK->unk_0x314 = section->count[0] * 0x100 + section->count[1];
ZI_WORK->unk_0x310 = (ziU32)table + section->offset[0] * 0x100 + section->offset[1];
ZI_WORK->unk_0x318 = 0;
}
for (;;) {
@@ -107,7 +102,7 @@ ziU8 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++;
@@ -131,11 +126,11 @@ 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:
if (match.fallback) {
if (fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
@@ -169,7 +164,7 @@ matched:
}
if (length == 1 && complete != 0 && continuation == 0) {
complete = 0;
match.fallback = 1;
fallback = 1;
ZI_WORK->unk_0x318 = 0;
} else {
ZI_WORK->unk_0x310 = 0;
@@ -179,12 +174,12 @@ matched:
}
}
}
ziU8 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation, struct __zi8_work_data_s* __zi8_work_data) {
ziU8 result;
ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation, struct __zi8_work_data_s* __zi8_work_data) {
ziU32 result;
if (continuation == 0) __zi8_work_data->pudCount = 1;
for (;;) {
result = Zi8_8147FD7C(pattern, length, language, output, capacity, complete, continuation, __zi8_work_data);
if (result != 0) break;
if ((ziU8)result != 0) break;
if (++__zi8_work_data->pudCount <= 16) {
continuation = 0;
} else {
@@ -194,6 +189,6 @@ ziU8 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* outp
}
return result;
}
ziU8 Zi8_8147FD7C(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziU32 Zi8_8147FD7C(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
return Zi8MatchPUDdata_ZHS(pattern, length, language, output, capacity, 0, 0, complete, continuation, __zi8_work_data);
}

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

@@ -1,13 +1,13 @@
#include <zi8clib/zitypes.h>
ziU16 Zi8GetVersion(ziPtr __zi8_work_data) {
ziU16 Zi8GetVersion() {
return 1802;
}
ziU16 Zi8GetBuildID(ziPtr __zi8_work_data) {
ziU16 Zi8GetBuildID() {
return 41;
}
ziU16 Zi8GetOEMID(ziPtr __zi8_work_data) {
ziU16 Zi8GetOEMID() {
return 249;
}

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

@@ -46,7 +46,7 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
ziU8* data;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziU32 savedFormats = ZI_WORK->formats;
ziU8 savedCount = ZI_WORK->formatCount;
ziU8 savedCount = ZI_WORK->unk_0x1418;
ziSearchState search = {0};
Zi8LogError(100, __zi8_work_data);
if (word == 0 || *word == 0) {
@@ -75,20 +75,20 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
request.firstCandidate = 0;
ZI_WORK->formats = (ziU32)formats;
if (ZI_WORK->unk_0x1C[0] == 2) {
ZI_WORK->formatCount = 0;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 1;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 2;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 3;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 4;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 5;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 6;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 7;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 8;
} else if (ZI_WORK->unk_0x1C[0] != 0) ZI_WORK->formatCount = 2;
else ZI_WORK->formatCount = 1;
ZI_WORK->unk_0x1418 = 0;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 1;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 2;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 3;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 4;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 5;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 6;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 7;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 8;
} else if (ZI_WORK->unk_0x1C[0] != 0) ZI_WORK->unk_0x1418 = 2;
else ZI_WORK->unk_0x1418 = 1;
count = Zi8GetCandidatesOrCount(&request, &search, __zi8_work_data);
ZI_WORK->formats = savedFormats;
ZI_WORK->formatCount = savedCount;
ZI_WORK->unk_0x1418 = savedCount;
if (count != 0) return 1;
}
if (language != 1) {

View File

@@ -11,15 +11,15 @@ typedef struct {
ziU8 characterLow;
} ZiKoreanKeyEntry;
ziU16 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_WORK) {
ziU32 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_WORK) {
ziU32 value;
ziU16 count;
ziU16 i;
ziU32 i;
count = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
for (i = 0; i < count; i++) {
value = (ziU16)(((ziU16)table[(i << 3) + i + 7] << 8) |
table[(i << 3) + i + 8]);
for (i = 0; (ziU16)i < count; i++) {
value = (ziU16)(((ziU16)table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 7] << 8) |
table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 8]);
if (value == key) {
Zi8LogError(0x64, ZI_WORK);
return i;
@@ -119,19 +119,28 @@ ziU32 Zi8_814833F0(const ziGetParam* param, ziU16 key ZI_NEED_WORK) {
ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
ziU8* inserted ZI_NEED_WORK) {
ziU8* tableA;
ziU8* tableB;
ZiKoreanKeyEntry* entry;
ziS32 compactIndex;
ziU16 tableCount;
ziU32 j = 0;
ziU8 candidateIndex = 0;
ziU8 matched = 0;
ziBool matches;
ziU8 keys[5] = {0};
struct {
ziBool matches;
ziU8 candidateIndex;
ziU16 tableCount;
ziS32 compactIndex;
ZiKoreanKeyEntry* entry;
ziU8* tableB;
ziU8* tableA;
union {
ziU32 firstWord;
ziU8 bytes[5];
} keys;
} filter;
ziU32 j;
ziS32 i;
ziS32 candidate;
ziU8 matched;
j = 0;
filter.candidateIndex = 0;
matched = 0;
filter.keys.bytes[4] = filter.keys.firstWord = 0;
Zi8LogError(0x64, ZI_WORK);
if (param->elementCount == 0) {
if (*remaining >= *count) {
@@ -157,40 +166,40 @@ ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
return 0;
}
tableA = (ziU8*)Zi8GetTableAddress(param->language, 9, ZI_WORK);
tableB = (ziU8*)Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (tableA == 0) {
filter.tableA = (ziU8*)Zi8GetTableAddress(param->language, 9, ZI_WORK);
filter.tableB = (ziU8*)Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (filter.tableA == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
return 0;
} else if (tableB == 0) {
} else if (filter.tableB == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
return 0;
} else {
tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, keys);
filter.tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, filter.keys.bytes);
i = 0;
while (i < tableCount && matched < *count) {
matches = ZI8_TRUE;
entry = (ZiKoreanKeyEntry*)&tableA[(i << 3) + i];
while (i < filter.tableCount && matched < *count) {
filter.matches = ZI8_TRUE;
filter.entry = (ZiKoreanKeyEntry*)&filter.tableA[(i << 3) + i];
j = 0;
if (param->elementCount > 1) {
for (j = 0; (int)(j & 0xFF) < (int)param->elementCount / 2; j++) {
if (keys[j & 0xFF] != entry->keyBytes[j & 0xFF]) {
matches = ZI8_FALSE;
if (filter.keys.bytes[j & 0xFF] != filter.entry->keyBytes[j & 0xFF]) {
filter.matches = ZI8_FALSE;
break;
}
}
}
if (matches && (param->elementCount % 2) != 0 &&
((keys[j & 0xFF] & 0xF0) != (entry->keyBytes[j & 0xFF] & 0xF0))) {
matches = ZI8_FALSE;
if (filter.matches && (param->elementCount % 2) != 0 &&
((filter.keys.bytes[j & 0xFF] & 0xF0) != (filter.entry->keyBytes[j & 0xFF] & 0xF0))) {
filter.matches = ZI8_FALSE;
}
if (matches) {
for (candidateIndex = 0; candidateIndex < *count; candidateIndex++) {
if (param->candidates[candidateIndex] ==
(((ziU16)((ZiKoreanKeyEntry*)tableA)[i].characterHigh << 8) | (ziU16)((ZiKoreanKeyEntry*)tableA)[i].characterLow)) {
if (filter.matches) {
for (filter.candidateIndex = 0; filter.candidateIndex < *count; filter.candidateIndex++) {
if (param->candidates[filter.candidateIndex] ==
(((ziU16)((ZiKoreanKeyEntry*)filter.tableA)[i].characterHigh << 8) | (ziU16)((ZiKoreanKeyEntry*)filter.tableA)[i].characterLow)) {
matched++;
param->candidates[candidateIndex] &= 0x7FFF;
param->candidates[filter.candidateIndex] &= 0x7FFF;
break;
}
}
@@ -216,10 +225,10 @@ ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
}
*remaining = 0;
} else {
for (compactIndex = 0; compactIndex < *count; compactIndex++) {
if ((param->candidates[compactIndex] & 0x8000) == 0) {
param->candidates[compactIndex] |= 0x8000;
Zi8_81483308(param, param->candidates[compactIndex], inserted, ZI_WORK);
for (filter.compactIndex = 0; filter.compactIndex < *count; filter.compactIndex++) {
if ((param->candidates[filter.compactIndex] & 0x8000) == 0) {
param->candidates[filter.compactIndex] |= 0x8000;
Zi8_81483308(param, param->candidates[filter.compactIndex], inserted, ZI_WORK);
}
}
*remaining = *remaining - matched;
@@ -278,7 +287,8 @@ ziU32 Zi8GetKOcandidates(ziGetParam* param, ZiKoreanCandidateOptions* options ZI
search.resultCount = 0;
search.packedKeys.firstWord = 0;
search.packedKeys.bytes[4] = 0;
search.wordIndex = search.remainingLetters = 0;
search.remainingLetters = 0;
search.wordIndex = 0;
search.candidateCount = 0;
search.keyByte = 0;
search.remainingCandidates = param->firstCandidate;
@@ -299,12 +309,11 @@ 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);
if (param->wordCharCount == 0) goto scan_key_table;
{
if (param->wordCharCount != 0) {
if (((search.keyIndex = Zi8_8148302C(param->currentWord[0], keyTable, ZI_WORK)) != 0xFFFF) &&
((((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->keyBytes[4] & 8) != 0)) {
search.wordOffset = ((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->childLow |
@@ -356,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 {
@@ -386,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 {
@@ -426,10 +435,9 @@ 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;
}
scan_key_table:
if (param->elementCount > 9) {
param->letters = 0;
return 0;

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

@@ -21,7 +21,6 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
ziWChar bestFinal;
ziWChar previousInitial;
ziWChar previousFinal;
ziBool hasComponent;
ziU8 elementCount;
ziU8 elementIndex;
ziU8 stroke;
@@ -44,7 +43,6 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
stroke = 0;
contextMask = 0x20;
Zi8Memset(match,0,0x1ee);
hasComponent = 0;
nibbles = 0;
elementIndex = 0;
elementCount = request->elementCount;
@@ -60,15 +58,13 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
}
if (elementCount != 0) {
element = request->elements[0];
match->comp = element;
match->comp = element = request->elements[0];
if (Zi8IsComponent(element,__zi8_work_data) != 0) {
elementIndex++;
hasComponent = 1;
buffers.component = (ziU8*)Zi8GetTableAddress(1,2,__zi8_work_data);
buffers.componentIndex = (ziU8*)Zi8GetTableAddress(1,6,__zi8_work_data);
buffers.componentIndex += (element - 0xef10) * 2;
match->field22 = ((buffers.componentIndex[1] & 0x3f) << 8) + *buffers.componentIndex;
match->field22 = (((ziU16)buffers.componentIndex[1] & 0x3f) << 8) + *buffers.componentIndex;
buffers.component += (ziU32)match->field22 * 8;
switch(*buffers.component & 0xf) {
case 0:
@@ -223,14 +219,13 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
Zi8Memcpy((ziU8 (*)[12])match->segs1 + match->nSeg,buffers.masks,0xc);
Zi8Memcpy((ziU8 (*)[12])match->segsD + match->nSeg,buffers.strokes,0xc);
match->nSeg++;
if (stroke != 0xff || elementIndex >= elementCount || match->nSeg >= 0x10) break;
if (stroke != 0xff || elementIndex >= elementCount || match->nSeg >= 0x10) goto complete;
Zi8Memset(buffers.masks,0,0xc);
Zi8Memset(buffers.strokes,0,0xc);
buffers.masks[0] = match->arr1[0] & 0xf0;
buffers.strokes[0] = match->arrD[0] & 0xf0;
nibbles = 1;
} while (1);
return 1;
}
match->length = nibbles;
if (elementCount != 0) {
@@ -244,18 +239,20 @@ 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;
final = 0;
bestFinal = bestInitial = 0;
previousFinal = previousInitial = 0;
bestInitial = 0;
bestFinal = 0;
previousInitial = 0;
previousFinal = 0;
buffers.phoneticInput = request->elements;
match->nCand = 0;
request->completion = request->elementCount;
request->count = request->elementCount;
phoneticLength = 1;
for (index = 0; index < elementCount;) {
for (index = 0; index < elementCount; index++) {
stroke = Zi8GetBpmfPhonetic(buffers.phoneticInput,phoneticLength,&initial,&final,&bestInitial,&bestFinal,
__zi8_work_data);
if (stroke != 0) {
@@ -283,18 +280,19 @@ savePhonetic:
}
if (buffers.phoneticInput[phoneticLength - 1] == 0xF360) {
match->nCand--;
bestInitial = initial = previousInitial;
bestFinal = final = previousFinal;
bestInitial = previousInitial;
bestFinal = previousFinal;
final = bestFinal;
initial = bestInitial;
goto savePhonetic;
}
if (match->nCand == 1) {
request->completion = phoneticLength - 1;
request->count = phoneticLength - 1;
}
buffers.phoneticInput = buffers.phoneticInput + phoneticLength - 1;
phoneticLength = 0;
index--;
}
index++;
phoneticLength++;
}
if (elementCount != 0) {
@@ -308,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;
@@ -333,5 +331,6 @@ savePhonetic:
}
}
}
complete:
return 1;
}

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

@@ -242,25 +242,61 @@ L_2b0:
blr
}
void _CNTCACHEDeleteTitle() {
char* token = strtok(NULL, scCntCacheSpaceNl);
while (token != NULL) {
ESTitleId titleId;
int removable;
errno = 0;
titleId = strtoull(token, NULL, 16);
if (errno == 0 && (u32)ES_TITLE_TYPE(titleId) != 1) {
removable = _CNTCACHEIsTitleRemovable(titleId);
if (removable == 1) {
ES_DeleteTitle(titleId);
} else if (removable == 0) {
ES_DeleteTitleContent(titleId);
}
}
token = strtok(NULL, scCntCacheSpaceNl);
}
asm void _CNTCACHEDeleteTitle() {
stwu r1, -0x20(r1)
mflr r0
li r3, 0
la r4, scCntCacheSpaceNl
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
stw r29, 0x14(r1)
stw r28, 0x10(r1)
bl strtok
li r30, 0
li r31, -1
b L_370
L_304:
stw r30, errno(r0)
li r4, 0
li r5, 0x10
bl strtoull
lwz r0, errno(r0)
mr r28, r4
mr r29, r3
cmpwi r0, 0
bne L_364
and r0, r3, r31
cmplwi r0, 1
beq L_364
bl _CNTCACHEIsTitleRemovable
cmpwi r3, 1
bne L_350
mr r4, r28
mr r3, r29
bl ES_DeleteTitle
b L_364
L_350:
cmpwi r3, 0
bne L_364
mr r4, r28
mr r3, r29
bl ES_DeleteTitleContent
L_364:
li r3, 0
la r4, scCntCacheSpaceNl
bl strtok
L_370:
cmpwi r3, 0
bne L_304
lwz r0, 0x24(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
lwz r28, 0x10(r1)
mtlr r0
addi r1, r1, 0x20
blr
}
asm int _CNTCACHEIsTitleRemovable(ESTitleId titleId) {

View File

@@ -6,6 +6,11 @@ typedef struct FA_NAND_ATTACH {
u32 size;
} FA_NAND_ATTACH;
typedef struct FA_ATTACH_REQUEST {
FADrvTbl* table;
u32 count;
} FA_ATTACH_REQUEST;
FADisk* gOpenDisk[26];
FAPartition* gOpenPartition[26];
typedef struct FA_DISK_INIT {
@@ -29,13 +34,13 @@ static struct {
} drvInitFunc = {diskInitTbl, 3};
extern s32 pdm_open_disk(FA_DISK_INIT* table, FADisk** disk);
extern s32 pdm_open_partition(FADisk* disk, u32 index, FAPartition** partition);
extern s32 pfstub_attach(FADrvTbl** drives, const void* nand_data);
extern s32 pfstub_attach(FA_ATTACH_REQUEST* request, FA_NAND_ATTACH* nand);
extern s32 pfd_sddrv_is_media_insert(void);
extern s32 pfd_mscdrv_is_media_insert(FADisk* disk);
extern s32 pfd_mscdrv_is_media_insert(void);
FAError FAAttach(u32 device, char* nand_path, u32 nand_size, FADrvTbl* table) {
FADisk* disk;
FADrvTbl* drives[2];
FA_ATTACH_REQUEST request;
FA_NAND_ATTACH nand;
s32 error;
s32 index;
@@ -60,16 +65,16 @@ FAError FAAttach(u32 device, char* nand_path, u32 nand_size, FADrvTbl* table) {
return -1;
}
}
drives[0] = table;
drives[1] = NULL;
request.table = table;
request.count = 0;
if (device == 2) {
memcpy(nand.path, nand_path, 78);
nand.size = nand_size;
}
if (device == 2) {
error = pfstub_attach(drives, &nand);
error = pfstub_attach(&request, &nand);
} else {
error = pfstub_attach(drives, NULL);
error = pfstub_attach(&request, NULL);
}
if (error != 0) {
return -1;
@@ -80,11 +85,11 @@ FAError FAAttach(u32 device, char* nand_path, u32 nand_size, FADrvTbl* table) {
gOpenPartition[index] = table->pPart;
if (device == 0) {
if (pfd_sddrv_is_media_insert()) {
drives[0]->stat |= 0x10;
request.table->stat |= 0x10;
}
} else if (device == 1) {
if (pfd_mscdrv_is_media_insert(disk)) {
drives[0]->stat |= 0x10;
if (pfd_mscdrv_is_media_insert()) {
request.table->stat |= 0x10;
}
}
} else {

View File

@@ -3,7 +3,7 @@
static FAEjectCallback g_detach_func;
static FAInsertCallback g_attach_func;
extern s32 uhf_msc_is_media_insert(FADisk* disk);
extern s32 uhf_msc_is_media_insert(void);
s32 pfd_mscdrv_registar_callback(FAInsertCallback insert, FAEjectCallback eject) {
g_attach_func = insert;
@@ -11,6 +11,6 @@ s32 pfd_mscdrv_registar_callback(FAInsertCallback insert, FAEjectCallback eject)
return 0;
}
s32 pfd_mscdrv_is_media_insert(FADisk* disk) {
return uhf_msc_is_media_insert(disk);
s32 pfd_mscdrv_is_media_insert(void) {
return uhf_msc_is_media_insert();
}

View File

@@ -318,58 +318,58 @@ s32 pfd_sddrv_init(FADisk* disk) {
}
if ((pfd_sddrv_flags(&g_pfd_sddrv_info) & 1) != 0) {
OSReport("INFO SD Card driver is already initialize. pfd_sddrv_init()\n");
if (disk != g_pfd_sddrv_info.disk) {
return -44;
if (disk == g_pfd_sddrv_info.disk) {
return 0;
}
return -44;
}
if ((g_pfd_sddrv_info.flags & 4) == 0) {
g_pfd_sddrv_info.bytes_per_sector = 0x200;
pf_memset(&g_pfd_sddev, 0, 0x28);
sd_result = ISD_InitCard();
if (sd_result != 0) {
OSReport("ERR:Failed to init SD Card Driver in pfd_sddrv_init()\n");
return -40;
}
g_pfd_sddrv_info.flags |= 4;
}
pf_memset(&g_pfd_sddev, 0, 0x28);
device = &g_pfd_sddev.device;
sd_result = ISD_MountCard(0, &device);
if (sd_result != 0) {
OSReport("ERR SD card can not mount [ret = 0x%x]. pfd_sddrv_init()\n", sd_result);
return -41;
}
sd_result = ISD_GetDeviceStatus(device, &status);
if (sd_result != 0) {
OSReport("ERR Failed to get sd card status. [ret = 0x%x]\n", sd_result);
return 21;
}
if ((status & 1) != 0) {
g_pfd_sddrv_info.media_inserted = 1;
}
g_pfd_sddrv_info.device = device;
if (g_pfd_sddrv_info.media_inserted != 0) {
g_event = 2;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_removal_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
} else {
if ((g_pfd_sddrv_info.flags & 4) == 0) {
g_pfd_sddrv_info.bytes_per_sector = 0x200;
pf_memset(&g_pfd_sddev, 0, 0x28);
sd_result = ISD_InitCard();
if (sd_result != 0) {
OSReport("ERR:Failed to init SD Card Driver in pfd_sddrv_init()\n");
return -40;
}
g_pfd_sddrv_info.flags |= 4;
}
pf_memset(&g_pfd_sddev, 0, 0x28);
device = &g_pfd_sddev.device;
sd_result = ISD_MountCard(0, &device);
g_event = 1;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_inter_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR SD card can not mount [ret = 0x%x]. pfd_sddrv_init()\n", sd_result);
return -41;
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
sd_result = ISD_GetDeviceStatus(device, &status);
if (sd_result != 0) {
OSReport("ERR Failed to get sd card status. [ret = 0x%x]\n", sd_result);
return 21;
}
if ((status & 1) != 0) {
g_pfd_sddrv_info.media_inserted = 1;
}
g_pfd_sddrv_info.device = device;
if (g_pfd_sddrv_info.media_inserted != 0) {
g_event = 2;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_removal_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
} else {
g_event = 1;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_inter_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
}
g_pfd_sddrv_info.disk = disk;
g_pfd_sddrv_info.flags |= 1;
}
g_pfd_sddrv_info.disk = disk;
g_pfd_sddrv_info.flags |= 1;
return 0;
}
@@ -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;
@@ -1361,20 +1360,19 @@ s32 pfd_sddrv_store_fat32_bpb_buf(PFD_SDDRV_FORMAT_DATA* format_data, u8* sector
static s32 pfd_sddrv_store_fat32_reserved_buf(u8* sector_buffer) {
PFD_SDDRV_RESERVED_BOOT_SECTOR* reserved_boot_sector;
s32 result = -30;
if (sector_buffer != 0) {
pf_memset(sector_buffer, 0, 0x200);
reserved_boot_sector = (PFD_SDDRV_RESERVED_BOOT_SECTOR*)sector_buffer;
if (((u32)reserved_boot_sector->signature.bytes & 1) != 0) {
reserved_boot_sector->signature.bytes[0] = 0x55;
reserved_boot_sector->signature.bytes[1] = 0xaa;
} else {
reserved_boot_sector->signature.value = 0x55aa;
}
result = 0;
if (sector_buffer == 0) {
return -30;
}
return result;
pf_memset(sector_buffer, 0, 0x200);
reserved_boot_sector = (PFD_SDDRV_RESERVED_BOOT_SECTOR*)sector_buffer;
if (((u32)reserved_boot_sector->signature.bytes & 1) != 0) {
reserved_boot_sector->signature.bytes[0] = 0x55;
reserved_boot_sector->signature.bytes[1] = 0xaa;
} else {
reserved_boot_sector->signature.value = 0x55aa;
}
return 0;
}
s32 pfd_sddrv_build_fat32_mbr_bpb(u32 total_sectors) {

View File

@@ -1,32 +1,25 @@
#include <private/fa/pdm.h>
#include <revolution/types.h>
#define MBR_WORD(buf, offset) \
((pf_u32)(buf)[offset] + ((pf_u32)(buf)[(offset) + 1] << 8) + \
((pf_u32)(buf)[(offset) + 2] << 16) + ((pf_u32)(buf)[(offset) + 3] << 24))
#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_u32* p_start;
pf_u32* p_count;
pf_s16 index;
pf_u32 start[4];
pf_u32 count[4];
pf_u32* p_start;
pf_u32* p_count;
*p_is_mbr = 0;
if (buf[510] != 0x55 || buf[511] != 0xAA) { return 2; }
p_start = start;
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 {
@@ -78,20 +71,15 @@ pf_bool pdm_part_is_boot_sector(pf_u8* buf) {
return is_boot;
}
static inline pf_u32 read_relative_start_sector(pf_u32 base, const pf_u8* buf, pf_u32 offset) {
return base + (buf[offset] + ((unsigned int)buf[offset + 1] << 8) +
((unsigned int)buf[offset + 2] << 16) + ((unsigned int)buf[offset + 3] << 24));
}
pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
pf_u32 part_index = 0;
pf_u32 requested = p_part->part_id;
pf_u32 start[4];
pf_u32 count[4];
pf_u32 part_index = 0;
pf_u32 sector;
pf_u32 base;
pf_u16 index;
pf_u16 extended_index;
pf_u32 base;
pf_u32 sector;
pf_u32 length;
pf_bool is_mbr;
pf_u32 success;
@@ -124,14 +112,14 @@ 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 = read_relative_start_sector(sector, buf, 454);
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 = read_relative_start_sector(base, buf, 470);
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);

View File

@@ -550,6 +550,15 @@ pf_s32 PFCACHE_DoWriteSector(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf
#pragma dont_inline reset
static inline pf_u32 PFCACHE_RecordPageEndOverlap(PF_CACHE_PAGE* p_page, pf_u32 end_sector, pf_u32* p_num_success, pf_u32* p_num_rest_sector) {
pf_u32 last_sector = end_sector - 1;
pf_u32 num_overlap = end_sector - p_page->sector;
*p_num_success += num_overlap;
*p_num_rest_sector -= num_overlap;
p_page->stat |= 2;
return last_sector;
}
pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf_u8* p_buf, pf_u32 sector,
pf_u32 num_sector, pf_u32* p_num_success) {
PF_CACHE_PAGE* p_page = PF_NULL;
@@ -557,6 +566,8 @@ pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE**
pf_u32 num_rest_sector = num_sector;
pf_u8* p_sbuf;
pf_u8* p_ebuf;
pf_u32 num_overlap;
pf_u32 last_sector;
*p_num_success = 0;
do {
if (p_page == PF_NULL) {
@@ -606,10 +617,10 @@ pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE**
(p_page->sector + p_page->size) >= (sector + num_sector)) {
pf_memcpy(p_page->buffer, (pf_u8*)&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector],
(sector + num_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= p_page->size - ((p_page->sector + p_page->size) - (sector + num_sector));
*p_num_success += p_page->size - ((p_page->sector + p_page->size) - (sector + num_sector));
p_page->stat |= 2;
p_ebuf = &p_page->buffer[(p_page->size - ((p_page->sector + p_page->size) - (sector + num_sector)) - 1) << p_vol->bpb.log2_bytes_per_sector];
num_overlap = num_sector;
num_overlap += sector;
last_sector = PFCACHE_RecordPageEndOverlap(p_page, num_overlap, p_num_success, &num_rest_sector);
p_ebuf = &p_page->buffer[(last_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector];
p_page->p_mod_sbuf = p_page->buffer;
if (p_page->p_mod_ebuf == NULL || p_page->p_mod_ebuf < p_ebuf) {
p_page->p_mod_ebuf = p_ebuf;

View File

@@ -1,12 +1,12 @@
#include <revolution/fa/pf_stub.h>
s32 pfstub_attach(FADrvTbl** drives, const void* nand_data) {
s32 pfstub_attach(FADrvTbl* drives, u32 mode) {
PF_STUB_MESSAGE message;
message.operation = 27;
message.object = drives;
message.callback = NULL;
message.data = nand_data;
message.data = (void*)mode;
if (pfstub_com_massage(&message) == -1) {
return -1;
}

View File

@@ -557,14 +557,18 @@ 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[(u32)callbackArg].device) {
if (callback->callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[index].device) {
return;
}
switch (success) {
@@ -575,12 +579,13 @@ 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) {
s32 index;
u32 ofs;
u8 ledBits;
u32 index;
BOOL interrupts;
USBKBDErr result;
if (!kbdInitialized) {
@@ -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;
@@ -571,14 +578,8 @@ static inline f32 clamp_acc_value(f32 value, f32 limit) {
}
static inline void smooth_acc_value(KPADInside* kpad, f32 value, f32* result) {
f32 amount;
f32 delta;
delta = value - *result;
if (delta < 0.0f) {
amount = -delta;
} else {
amount = delta;
}
f32 delta = value - *result;
f32 amount = delta < 0.0f ? -delta : delta;
if (amount >= kpad->value9C) {
amount = 1.0f;
} else {
@@ -618,16 +619,12 @@ static void read_kpad_acc(KPADInside* kpad, KPADSample* status) {
kpad->status.acc_speed = (f32)sqrt(previous.z * previous.z + (previous.x * previous.x + previous.y * previous.y));
calc_acc_horizon(kpad);
calc_acc_vertical(kpad);
if (status->error == 0 && status->device == 1) {
if (status->dataFormat == 4) {
goto read_extension_acceleration;
}
if (status->dataFormat == 5) {
goto read_extension_acceleration;
}
if (status->error != 0 || status->device != 1) {
return;
}
if (status->dataFormat != 4 && status->dataFormat != 5) {
return;
}
return;
read_extension_acceleration:
{
Vec extensionPrevious;
raw.x = clamp_acc_value((f32)-(s32)status->extension.fs.accX * kpad->value4E8, kp_fs_acc_max);
@@ -791,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;
@@ -819,7 +822,7 @@ static s8 select_1obj_first(KPADInside* kpad) {
return -1;
}
}
} while (++object < kpad->dpdState.candidates);
} while (++object < end);
return 0;
}
@@ -949,20 +952,15 @@ static void calc_dpd_variable(KPADInside* kpad, s8 valid) {
f32 dx;
f32 next;
dx = value - kpad->status.dist;
if (dx < 0.0f) {
magnitude = -dx;
} else {
magnitude = dx;
}
magnitude = dx < 0.0f ? -dx : dx;
if (magnitude >= kpad->value94) {
magnitude = 1.0f;
} else {
magnitude /= kpad->value94;
magnitude = magnitude / kpad->value94;
magnitude *= magnitude;
magnitude *= magnitude;
}
magnitude *= kpad->value98;
next = magnitude * dx;
next = magnitude * kpad->value98 * dx;
kpad->status.dist_vec = next;
if (next < 0.0f) {
kpad->status.dist_speed = -next;
@@ -973,15 +971,12 @@ static void calc_dpd_variable(KPADInside* kpad, s8 valid) {
}
}
{
f32 midpointFactor = 0.5f;
f32 scaleX = midpointFactor * (kpad->dpdState.candidates[0].x + kpad->dpdState.candidates[1].x);
f32 scaleY = midpointFactor * (kpad->dpdState.candidates[0].y + kpad->dpdState.candidates[1].y);
f32 rotatedX = kpad->dpdObjectDirection.x * kpad->horizonTangent.x + kpad->dpdObjectDirection.y * kpad->horizonTangent.y;
f32 rotatedX = kpad->horizonTangent.x * kpad->dpdObjectDirection.x + kpad->horizonTangent.y * kpad->dpdObjectDirection.y;
f32 rotatedY = -kpad->dpdObjectDirection.y * kpad->horizonTangent.x + kpad->dpdObjectDirection.x * kpad->horizonTangent.y;
f32 transformedX = rotatedX * scaleX - rotatedY * scaleY;
f32 transformedY = rotatedY * scaleX + rotatedX * scaleY;
delta.x = kpad->sensorBarScale * (kpad->sensorBarCenter.x - transformedX);
delta.y = kpad->sensorBarScale * (kpad->sensorBarCenter.y - transformedY);
f32 scaleX = 0.5f * (kpad->dpdState.candidates[0].x + kpad->dpdState.candidates[1].x);
f32 scaleY = 0.5f * (kpad->dpdState.candidates[0].y + kpad->dpdState.candidates[1].y);
delta.x = kpad->sensorBarScale * (kpad->sensorBarCenter.x - (rotatedX * scaleX - rotatedY * scaleY));
delta.y = kpad->sensorBarScale * (kpad->sensorBarCenter.y - (rotatedY * scaleX + rotatedX * scaleY));
point.x = -kpad->accelNormal.y * delta.x + kpad->accelNormal.x * delta.y;
point.y = -kpad->accelNormal.x * delta.x - kpad->accelNormal.y * delta.y;
if (kpad->status.dpd_valid_fg == 0) {
@@ -1314,9 +1309,6 @@ static void read_kpad_stick(KPADInside* kpad, KPADSample* status) {
}
s32 KPADRead(s32 chan, KPADStatus* statuses, u32 count) {
u32 changed;
u16 heldButtons;
KPADStatus* output;
KPADInside* kpad = &inside_kpads[chan];
s32 probe;
BOOL interruptState;
@@ -1324,15 +1316,17 @@ s32 KPADRead(s32 chan, KPADStatus* statuses, u32 count) {
u32 ringCount;
s32 start;
s32 sampleIndex;
s32 remaining;
u32 remaining;
u32 remainingSamples;
u32 buttons;
u16 previousButtons;
u32 coreButtons;
u32 changed;
u32 extensionButtons;
u32 coreButtons;
u8 device;
KPADSample latestSample;
KPADSample* sample;
KPADStatus* output;
if (WPADGetStatus() != 3) {
return 0;
}
@@ -1366,19 +1360,19 @@ s32 KPADRead(s32 chan, KPADStatus* statuses, u32 count) {
if (available > count) {
available = count;
}
remaining = available;
kpad->ringCount = 0;
output = statuses + remaining;
start = kpad->ringIndex - available;
if (start < 0) {
start += 16;
}
--output;
{
KPADStatus* copyOutput;
sampleIndex = start;
remaining = available;
copyOutput = statuses + (available - 1);
while (--remaining != 0) {
output--;
*(KPADSample*)output = kpad->ringData[sampleIndex];
copyOutput--;
*(KPADSample*)copyOutput = kpad->ringData[sampleIndex];
sampleIndex++;
if (sampleIndex >= 16) {
sampleIndex = 0;
@@ -1391,7 +1385,7 @@ s32 KPADRead(s32 chan, KPADStatus* statuses, u32 count) {
WPADAccGravityUnit gravity = {1, 1, 1};
WPADAccGravityUnit extensionGravity = {1, 1, 1};
WPADGetAccGravityUnit(chan, WPAD_ACC_GRAVITY_UNIT_CORE, &gravity);
if (gravity.x * gravity.y * gravity.z != 0) {
if (gravity.z * gravity.x * gravity.y != 0) {
kpad->value4DC = 1.0f / gravity.x;
kpad->value4E0 = 1.0f / gravity.y;
kpad->value4E4 = 1.0f / gravity.z;
@@ -1401,7 +1395,7 @@ s32 KPADRead(s32 chan, KPADStatus* statuses, u32 count) {
kpad->value4E4 = 0.01f;
}
WPADGetAccGravityUnit(chan, WPAD_ACC_GRAVITY_UNIT_FS, &extensionGravity);
if (extensionGravity.x * extensionGravity.y * extensionGravity.z != 0) {
if (extensionGravity.z * extensionGravity.x * extensionGravity.y != 0) {
kpad->value4E8 = 1.0f / extensionGravity.x;
kpad->value4EC = 1.0f / extensionGravity.y;
kpad->value4F0 = 1.0f / extensionGravity.z;
@@ -1414,8 +1408,8 @@ s32 KPADRead(s32 chan, KPADStatus* statuses, u32 count) {
output = statuses + available;
--output;
device = 0xFD;
extensionButtons = 0xFFFF;
coreButtons = 0xFFFF;
extensionButtons = 0xFFFF;
buttons = 0xFFFF;
do {
output--;
@@ -1452,20 +1446,18 @@ s32 KPADRead(s32 chan, KPADStatus* statuses, u32 count) {
if (extensionButtons == 0xFFFF) {
extensionButtons = kpad->status.ex_status.cl.hold;
}
buttons = (buttons & 0x9FFF) | (coreButtons & 0x6000);
previousButtons = kpad->status.hold;
heldButtons = (buttons & 0x9FFF) | (coreButtons & 0x6000);
changed = heldButtons ^ previousButtons;
kpad->status.hold = heldButtons;
kpad->status.trig = changed & heldButtons;
changed = previousButtons ^ buttons;
kpad->status.hold = buttons;
kpad->status.trig = changed & buttons;
kpad->status.release = changed & previousButtons;
if (device == 2) {
u16 previousExtensionButtons;
previousExtensionButtons = kpad->status.ex_status.cl.hold;
extensionButtons = (u16)extensionButtons;
kpad->status.ex_status.cl.hold = extensionButtons;
changed = extensionButtons ^ previousExtensionButtons;
previousButtons = kpad->status.ex_status.cl.hold;
kpad->status.ex_status.cl.hold = (u16)extensionButtons;
changed = previousButtons ^ (u16)extensionButtons;
kpad->status.ex_status.cl.trig = changed & extensionButtons;
kpad->status.ex_status.cl.release = changed & previousExtensionButtons;
kpad->status.ex_status.cl.release = changed & previousButtons;
}
calc_button_repeat(kpad, device, ringCount);
remainingSamples = available;
@@ -1510,6 +1502,7 @@ void KPADInit(void) {
f32 zero;
f32 degreesToRadians;
f32 one;
f32* matrix;
u32 i;
s32 chan;
BOOL enabled;
@@ -1520,6 +1513,7 @@ void KPADInit(void) {
one = 1.0f;
zero = 0.0f;
degreesToRadians = 0.017453292f;
matrix = initial_rotation_matrix;
kpad = inside_kpads;
do {
kpad->dpdEnable = 1;
@@ -1547,9 +1541,9 @@ void KPADInit(void) {
}
referenceWidth = referenceWidth < referenceHeight ? referenceWidth : referenceHeight;
initial_rotation_matrix[0] = one;
initial_rotation_matrix[1] = zero;
initial_rotation_matrix[2] = zero;
initial_rotation_matrix[3] = zero;
matrix[1] = zero;
matrix[2] = zero;
matrix[3] = zero;
kpad->sensorBarScale = sensorDistance / referenceWidth;
kpad->value9C = zero;
kpad->value94 = zero;
@@ -1568,18 +1562,18 @@ void KPADInit(void) {
kpad->sensorHeightPending = 1;
kpad->sensorBarPosition = 1;
kpad->freeStyleAccelRotation = 0;
initial_rotation_matrix[4] = zero;
matrix[4] = zero;
rotationElement = (f32)cos(degreesToRadians * sensor_bar_angle_degrees);
initial_rotation_matrix[5] = rotationElement;
matrix[5] = rotationElement;
rotationElement = (f32)-sin(degreesToRadians * sensor_bar_angle_degrees);
initial_rotation_matrix[7] = zero;
initial_rotation_matrix[8] = zero;
initial_rotation_matrix[6] = rotationElement;
matrix[7] = zero;
matrix[8] = zero;
matrix[6] = rotationElement;
rotationElement = (f32)sin(degreesToRadians * sensor_bar_angle_degrees);
initial_rotation_matrix[9] = rotationElement;
matrix[9] = rotationElement;
rotationElement = (f32)cos(degreesToRadians * sensor_bar_angle_degrees);
initial_rotation_matrix[10] = rotationElement;
initial_rotation_matrix[11] = zero;
matrix[10] = rotationElement;
matrix[11] = zero;
{
i = 0;
do {

View File

@@ -64,7 +64,7 @@ struct NUPTitleInfo {
u32 ticketCertificateSize;
void* tmdCertificate;
u32 tmdCertificateSize;
ESTmdView* tmdView;
void* tmdView;
u32 tmdViewSize;
u8 hasTicket;
u8 hasTmd;
@@ -165,7 +165,7 @@ static ESError __nupHttpBufferFlushES(u8* buffer, unsigned long size, unsigned l
return result;
}
static inline char* __nupFindTag(char* response, const char* startTag, const char* endTag,
static inline char* __nupFindTag(char* response, const char* endTag, const char* startTag,
char** value, size_t* length) {
char* start;
char* end;
@@ -188,7 +188,10 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
size_t titleCount;
{
afterEnd = __nupFindTag(response, "<Version>", "</Version>", &start, &valueLength);
const char* versionEndTag = "</Version>";
const char* versionStartTag = "<Version>";
afterEnd = __nupFindTag(response, versionEndTag, versionStartTag,
&start, &valueLength);
if (afterEnd == 0 || valueLength != strlen("1.0") || strncmp(start, "1.0", valueLength) != 0) {
result = -5004;
goto done;
@@ -196,7 +199,10 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
}
{
afterEnd = __nupFindTag(response, "<DeviceId>", "</DeviceId>", &start, &valueLength);
const char* deviceIdEndTag = "</DeviceId>";
const char* deviceIdStartTag = "<DeviceId>";
afterEnd = __nupFindTag(response, deviceIdEndTag, deviceIdStartTag,
&start, &valueLength);
if (afterEnd == 0 || strtoull(start, 0, 10) != deviceId) {
result = -5004;
goto done;
@@ -204,7 +210,10 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
}
{
afterEnd = __nupFindTag(response, "<MessageId>", "</MessageId>", &start, &valueLength);
const char* messageIdEndTag = "</MessageId>";
const char* messageIdStartTag = "<MessageId>";
afterEnd = __nupFindTag(response, messageIdEndTag, messageIdStartTag,
&start, &valueLength);
if (afterEnd == 0 || valueLength != strlen(messageId) || strncmp(start, messageId, valueLength) != 0) {
result = -5004;
goto done;
@@ -212,7 +221,10 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
}
{
afterEnd = __nupFindTag(response, "<ErrorCode>", "</ErrorCode>", &start, &valueLength);
const char* errorCodeEndTag = "</ErrorCode>";
const char* errorCodeStartTag = "<ErrorCode>";
afterEnd = __nupFindTag(response, errorCodeEndTag, errorCodeStartTag,
&start, &valueLength);
if (afterEnd == 0 || valueLength != strlen("0") || strncmp(start, "0", valueLength) != 0) {
result = -5004;
goto done;
@@ -220,7 +232,10 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
}
{
afterEnd = __nupFindTag(response, "<UploadAuditData>", "</UploadAuditData>", &start, &valueLength);
const char* uploadAuditEndTag = "</UploadAuditData>";
const char* uploadAuditStartTag = "<UploadAuditData>";
afterEnd = __nupFindTag(response, uploadAuditEndTag, uploadAuditStartTag,
&start, &valueLength);
if (afterEnd == 0 || valueLength != strlen("0") || (*start != '0' && *start != '1')) {
result = -5004;
goto done;
@@ -233,7 +248,10 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
}
{
afterEnd = __nupFindTag(response, "<ContentPrefixURL>", "</ContentPrefixURL>", &start, &valueLength);
const char* contentPrefixEndTag = "</ContentPrefixURL>";
const char* contentPrefixStartTag = "<ContentPrefixURL>";
afterEnd = __nupFindTag(response, contentPrefixEndTag, contentPrefixStartTag,
&start, &valueLength);
if (afterEnd == 0 || valueLength == 0) {
result = -5004;
goto done;
@@ -248,7 +266,10 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
}
{
afterEnd = __nupFindTag(response, "<UncachedContentPrefixURL>", "</UncachedContentPrefixURL>", &start, &valueLength);
const char* uncachedPrefixEndTag = "</UncachedContentPrefixURL>";
const char* uncachedPrefixStartTag = "<UncachedContentPrefixURL>";
afterEnd = __nupFindTag(response, uncachedPrefixEndTag, uncachedPrefixStartTag,
&start, &valueLength);
if (afterEnd == 0 || valueLength == 0) {
result = -5004;
goto done;
@@ -265,8 +286,14 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
titleCount = 0;
cursor = response;
{
while ((cursor = __nupFindTag(cursor, "<TitleId>", "</TitleId>", &start, &valueLength)) != 0 &&
(cursor = __nupFindTag(cursor, "<Version>", "</Version>", &start, &valueLength)) != 0) {
const char* versionEndTag = "</Version>";
const char* versionStartTag = "<Version>";
const char* titleIdEndTag = "</TitleId>";
const char* titleIdStartTag = "<TitleId>";
while ((cursor = __nupFindTag(cursor, titleIdEndTag, titleIdStartTag,
&start, &valueLength)) != 0 &&
(cursor = __nupFindTag(cursor, versionEndTag, versionStartTag,
&start, &valueLength)) != 0) {
titleCount++;
}
}
@@ -279,13 +306,19 @@ static s32 __nupParseServerInfo(NUPContextInfo* context, char* response, char* m
memset(context->titles, 0, titleCount * sizeof(NUPTitleInfo));
cursor = response;
{
const char* versionEndTag = "</Version>";
const char* versionStartTag = "<Version>";
const char* titleIdEndTag = "</TitleId>";
const char* titleIdStartTag = "<TitleId>";
char* titleStart;
char* versionStart;
size_t titleLength;
size_t versionLength;
char* parsedEnd;
while ((cursor = __nupFindTag(cursor, "<TitleId>", "</TitleId>", &titleStart, &titleLength)) != 0 &&
(cursor = __nupFindTag(cursor, "<Version>", "</Version>", &versionStart, &versionLength)) != 0) {
while ((cursor = __nupFindTag(cursor, titleIdEndTag, titleIdStartTag,
&titleStart, &titleLength)) != 0 &&
(cursor = __nupFindTag(cursor, versionEndTag, versionStartTag,
&versionStart, &versionLength)) != 0) {
unsigned long long titleId = strtoull(titleStart, &parsedEnd, 16);
if (parsedEnd != titleStart + titleLength) {
result = -5004;
@@ -694,7 +727,7 @@ static s32 __nupGetBootVersion(NUPContextInfo* context, ESTitleVersion* title) {
title->hasContent = 1;
result = __nupSetBootTitleVersion(title);
} else {
s32 i;
u32 i;
for (i = 0; i < context->ownedTitleCount; i++) {
if (context->ownedTitleIds[i] == title->titleId) {
break;
@@ -731,16 +764,18 @@ static s32 __nupGetBootVersion(NUPContextInfo* context, ESTitleVersion* title) {
goto done;
}
}
if (title->contentCount < tmdView->head.numContents) {
u32 installedContentCount = title->contentCount;
if (installedContentCount < tmdView->head.numContents) {
goto done;
}
for (i = 0; i < tmdView->head.numContents; i++) {
ESContentId contentId = tmdView->contents[i].cid;
if (!__nupHasInstalledContent(title, contentId, title->contentCount)) {
s32 contentIndex;
for (contentIndex = 0; contentIndex < tmdView->head.numContents; contentIndex++) {
if (!__nupHasInstalledContent(title, tmdView->contents[contentIndex].cid,
installedContentCount)) {
break;
}
}
if (i < tmdView->head.numContents) {
if (contentIndex < tmdView->head.numContents) {
goto done;
}
title->hasContent = 1;
@@ -835,7 +870,7 @@ static s32 __nupGetTmd(NUPTitleInfo* title, char* contentPrefixUrl) {
result = ES_DiGetTmdView((ESTitleMeta*)title->tmd, title->tmdSize, 0,
&title->tmdViewSize);
if (result == 0) {
title->tmdView = (ESTmdView*)nup::__nupMalloc(title->tmdViewSize);
title->tmdView = nup::__nupMalloc(title->tmdViewSize);
if (title->tmdView == 0) {
result = -5000;
} else {
@@ -872,26 +907,23 @@ static s32 __nupGetTitleSize(NUPTitleInfo* title) {
if (title->hasTmd == 0 && title->contentCount == 0) {
title->progressStep += 4;
}
title->progressStep += 5;
title->installedContentSize += 0x4000;
title->progressStep++;
title->installedContentSize += (title->tmdSize + 0x3fff) & 0xffffc000;
title->progressStep++;
title->installedContentSize += 0x8000;
title->progressStep++;
title->installedContentSize += 0x4000;
title->progressStep++;
title->installedContentSize += 0x4000;
title->progressStep++;
for (contentIndex = 0; contentIndex < title->tmdView->head.numContents; contentIndex++) {
ESContentId contentId = title->tmdView->contents[contentIndex].cid;
for (contentIndex = 0; contentIndex < ((ESTmdView*)title->tmdView)->head.numContents; contentIndex++) {
ESCmdView* content = &((ESTmdView*)title->tmdView)->contents[contentIndex];
ESContentId contentId = content->cid;
if (!__nupHasContent(title, contentId) ||
title->titleId == 0x0000000100000001ULL) {
if (title->tmdView->contents[contentIndex].size > 0xffffffefULL) {
if (content->size > 0xffffffefULL) {
result = -0x1394;
break;
}
title->updateContentSize += (title->tmdView->contents[contentIndex].size + 0xf) & 0xfffffffffffffff0ULL;
title->installedContentSize += (title->tmdView->contents[contentIndex].size + 0x3fff) & 0xffffffffffffc000ULL;
title->updateContentSize += (content->size + 0xf) & 0xfffffffffffffff0ULL;
title->installedContentSize += (((ESTmdView*)title->tmdView)->contents[contentIndex].size + 0x3fff) & 0xffffffffffffc000ULL;
title->progressStep++;
}
}

View File

@@ -781,11 +781,114 @@ static ISD_Error sduGetOCR(SDDev* dev, u32* data) {
return ret;
}
#ifdef __MWERKS__
asm ISD_Error ISD_GetCardSize(register SDDev* dev, register u32* outSize, register u32* outSize2, register u32* outSectorSize) {
nofralloc
stwu r1, -0x30(r1)
mflr r0
stw r0, 0x34(r1)
stw r31, 0x2c(r1)
mr r31, r6
stw r30, 0x28(r1)
mr r30, r5
li r5, 0x10
stw r29, 0x24(r1)
mr r29, r4
li r4, 0
stw r28, 0x20(r1)
mr r28, r3
addi r3, r1, 8
bl memset
mr r3, r28
addi r5, r1, 8
li r4, 9
li r6, 0x10
bl ISD_ReadCardRegister
cmpwi r3, 0
beq ISD_GetCardSize_success
b ISD_GetCardSize_return
ISD_GetCardSize_success:
lwz r0, 0x14(r1)
rlwinm. r0, r0, 0xa, 0x1e, 0x1f
beq ISD_GetCardSize_standard
lwz r0, 0xc(r1)
li r5, 0x80
rlwinm r3, r0, 0x18, 0xa, 0x1f
addi r0, r3, 1
slwi r3, r0, 0xa
rlwinm r0, r0, 3, 7, 0x1c
b ISD_GetCardSize_store
ISD_GetCardSize_standard:
lwz r3, 0x10(r1)
li r0, 9
lwz r7, 0xc(r1)
rlwinm r4, r3, 0x18, 0x1c, 0x1f
cmplwi r4, 9
srwi r6, r7, 0x16
rlwimi r6, r3, 0xa, 0x14, 0x15
rlwinm r3, r7, 0x19, 0x1d, 0x1f
blt ISD_GetCardSize_clamp_high
mr r0, r4
ISD_GetCardSize_clamp_high:
cmplwi r0, 0xb
li r4, 0xb
bgt ISD_GetCardSize_clamp_done
mr r4, r0
ISD_GetCardSize_clamp_done:
addi r0, r3, 2
li r5, 1
addi r3, r6, 1
addi r4, r4, -9
slw r0, r5, r0
lwz r6, 8(r1)
mullw r0, r3, r0
slw r3, r5, r4
srwi r5, r6, 0x1f
rlwimi r5, r7, 1, 0x19, 0x1e
mullw r3, r3, r0
addi r5, r5, 1
slwi r0, r3, 9
divwu r0, r0, r5
srw r0, r0, r4
ISD_GetCardSize_store:
cmpwi r29, 0
stw r5, 0x18(r28)
stw r0, 0x1c(r28)
stw r3, 0x20(r28)
beq ISD_GetCardSize_no_outSize
stw r3, 0(r29)
ISD_GetCardSize_no_outSize:
cmpwi r30, 0
beq ISD_GetCardSize_no_outSize2
stw r3, 0(r30)
ISD_GetCardSize_no_outSize2:
cmpwi r31, 0
beq ISD_GetCardSize_success_return
li r0, 0x200
stw r0, 0(r31)
ISD_GetCardSize_success_return:
li r3, 0
ISD_GetCardSize_return:
lwz r0, 0x34(r1)
lwz r31, 0x2c(r1)
lwz r30, 0x28(r1)
lwz r29, 0x24(r1)
lwz r28, 0x20(r1)
mtlr r0
addi r1, r1, 0x30
blr
}
#else
ISD_Error ISD_GetCardSize(SDDev* dev, u32* outSize, u32* outSize2, u32* outSectorSize) {
ISD_Error ret;
u32 eraseBlockCount;
u32 sectorCount;
u32 eraseBlockSize;
u32 out0;
u32 out1;
u32 out2;
u32 resp[4];
memset(resp, 0, sizeof(resp));
@@ -796,33 +899,27 @@ ISD_Error ISD_GetCardSize(SDDev* dev, u32* outSize, u32* outSize2, u32* outSecto
}
if ((resp[3] >> 0x16) & 3) {
eraseBlockSize = 0x80;
sectorCount = (((resp[1] >> 8) & 0x3FFFFF) + 1) * 1024;
eraseBlockCount = ((((resp[1] >> 8) & 0x3FFFFF) + 1) * 8) & 0x01FFFFF8;
out0 = 0x80;
out2 = (((resp[1] >> 8) & 0x3FFFFF) + 1) * 512;
out1 = ((((resp[1] >> 8) & 0x3FFFFF) + 1) * 8) & 0x01FFFFF8;
} else {
u32 readBlockLength = (resp[2] >> 8) & 0xF;
u32 capacity = ((resp[2] & 3) << 10) | (resp[1] >> 22);
u32 blockScale;
u32 sizeMultiplier = (resp[1] >> 7) & 7;
u32 tmp = (((resp[2] >> 8) & 0xF) >= 9 ? ((resp[2] >> 8) & 0xF) : 9);
tmp = tmp <= 11 ? tmp : 11;
readBlockLength = readBlockLength >= 9 ? readBlockLength : 9;
readBlockLength = readBlockLength <= 11 ? readBlockLength : 11;
eraseBlockSize = (((resp[1] & 0x3F) << 1) | (resp[0] >> 31)) + 1;
blockScale = 1 << (readBlockLength - 9);
sectorCount = ((capacity + 1) * (1 << (sizeMultiplier + 2))) * blockScale;
eraseBlockCount = ((sectorCount << 9) / eraseBlockSize) >> (readBlockLength - 9);
out2 = (1 << (tmp - 9)) * (((((resp[1] >> 0x16) & ~0xC00) | ((resp[2] << 10) & 0xC00)) + 1) * (1 << (((resp[1] >> 7) & 7) + 2)));
out0 = (((resp[0] >> 0x1F) & ~0x7E) | ((resp[1] << 1) & 0x7E)) + 1;
out1 = ((out2 << 9) / out0) >> (tmp - 9);
}
dev->SDSectorSize = eraseBlockSize;
dev->SDSectorNum = eraseBlockCount;
dev->SDDevSize = sectorCount;
dev->SDSectorSize = out0;
dev->SDSectorNum = out1;
dev->SDDevSize = out2;
if (outSize != NULL) {
*outSize = sectorCount;
*outSize = out2;
}
if (outSize2 != NULL) {
*outSize2 = sectorCount;
*outSize2 = out2;
}
if (outSectorSize != NULL) {
*outSectorSize = 512;
@@ -830,6 +927,7 @@ ISD_Error ISD_GetCardSize(SDDev* dev, u32* outSize, u32* outSize2, u32* outSecto
return SD_ERROR_SUCCESS;
}
#endif
ISD_Error ISD_RegisterDeviceIntrHandler(SDDev* dev, SDDevIntrCallback intCB, void* arg) {
u32 state;

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

@@ -1260,12 +1260,12 @@ s32 WADBackupEx(u64 titleId, u32 flags, MEMAllocator* allocator, char* path, u32
titleMetaSize = 0;
contentDataSize = 0;
files = 0;
titleMeta = 0;
outputBuffer = 0;
titleMetaBuffer = 0;
titleMeta = 0;
files = 0;
fileCount = 0;
importedSize = 0;
outputBuffer = 0;
encryptionBuffer = 0;
fileDataSize = 0;
installedContentCount = 0;

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 {
@@ -563,17 +563,6 @@ static void WPADiGetScSettings() {
_scSetting = FALSE;
}
static void __reconnect(BOOL exec) {
DEBUGPrint("Reconnect Start!!\n");
BTA_DmSendHciReset();
OSCancelAlarm(&_managerAlarm);
WUDSetHidRecvCallback(NULL);
WUDShutdown(exec);
}
static void WPADiAfh() {
BOOL enabled;
u8* pWifiChannel;
@@ -617,6 +606,550 @@ static void WPADiRumbleMotor(s32 chan, BOOL prevSuccess) {
_rumbleCnt[chan] = _wpdcb[chan]->motorBusy ? _rumbleCnt[chan] + 1 : 0;
}
static void __reconnect(BOOL exec) {
DEBUGPrint("Reconnect Start!!\n");
BTA_DmSendHciReset();
OSCancelAlarm(&_managerAlarm);
WUDSetHidRecvCallback(NULL);
WUDShutdown(exec);
}
#ifdef __MWERKS__
char scWpadManageStrs[0x58] = "Reconnect Start!!\n\0\0\0\0\0\0"
"Check the update of WiFi using channel\n\0"
"WiFi uses channel = %d\n";
extern void _savegpr_19();
extern void _restgpr_19();
static asm void WPADiManageHandler(OSAlarm* pAlarm, OSContext* pContext) {
nofralloc
stwu r1, -0x160(r1)
mflr r0
stw r0, 0x164(r1)
addi r11, r1, 0x160
bl _savegpr_19
lis r28, scWpadVersionStr@ha
addi r28, r28, scWpadVersionStr@l
bl WUDGetStatus
cmpwi r3, 0x3
beq WPADiManageHandler_8AC8
cmpwi r3, 0x2
bne WPADiManageHandler_91D8
lwz r0, _initialized(r0)
cmpwi r0, 0x0
bne WPADiManageHandler_91D8
li r0, 0x1
lis r3, WPADiConnCallback@ha
stw r0, _initialized(r0)
addi r3, r3, WPADiConnCallback@l
bl WUDSetHidConnCallback
lis r3, WPADiRecvCallback@ha
addi r3, r3, WPADiRecvCallback@l
bl WUDSetHidRecvCallback
li r0, 0x32
stw r0, _recCnt(r0)
b WPADiManageHandler_91D8
WPADiManageHandler_8AC8:
lwz r4, _recCnt(r0)
lwz r19, _recFlag(r0)
cntlzw r3, r4
subi r0, r4, 0x1
extrwi r3, r3, 1, 26
cmpwi r19, 0x0
neg r3, r3
andc r0, r0, r3
stw r0, _recCnt(r0)
blt WPADiManageHandler_8B28
cmpwi r0, 0x0
bne WPADiManageHandler_91D8
addi r3, r28, 0xf0
crclr 4*cr1+eq
bl DEBUGPrint
bl BTA_DmSendHciReset
lis r3, _managerAlarm@ha
addi r3, r3, _managerAlarm@l
bl OSCancelAlarm
li r3, 0x0
bl WUDSetHidRecvCallback
mr r3, r19
bl WUDShutdown
b WPADiManageHandler_91D8
WPADiManageHandler_8B28:
lis r24, _wpdcb@ha
li r22, 0x0
addi r24, r24, _wpdcb@l
la r25, _extCnt
la r23, _rumbleCnt
li r29, 0x0
li r30, 0x10
li r31, 0x1
WPADiManageHandler_8B48:
lbz r0, 0x0(r25)
li r21, 0x0
cmplwi r0, 0x5
bne WPADiManageHandler_8D20
lwz r26, 0x0(r24)
lwz r0, 0x8d8(r26)
cmpwi r0, 0x0
beq WPADiManageHandler_8D10
bl OSDisableInterrupts
mr r27, r3
bl OSDisableInterrupts
lbz r4, 0x5ec(r26)
lbz r0, 0x5ed(r26)
subf r0, r4, r0
extsb. r19, r0
bge WPADiManageHandler_8B94
lwz r0, 0x5f4(r26)
add r0, r19, r0
extsb r19, r0
WPADiManageHandler_8B94:
bl OSRestoreInterrupts
cmpwi r19, 0x0
bne WPADiManageHandler_8BB0
mr r3, r27
bl OSRestoreInterrupts
li r0, 0x0
b WPADiManageHandler_8BDC
WPADiManageHandler_8BB0:
lbz r0, 0x5ec(r26)
addi r3, r1, 0xc8
lwz r4, 0x5f0(r26)
li r5, 0x30
extsb r0, r0
mulli r0, r0, 0x30
add r4, r4, r0
bl memcpy
mr r3, r27
bl OSRestoreInterrupts
li r0, 0x1
WPADiManageHandler_8BDC:
cmpwi r0, 0x0
beq WPADiManageHandler_8D10
lwz r0, 0xc8(r1)
cmplwi r0, 0x12
beq WPADiManageHandler_8BFC
lwz r0, 0x840(r26)
cmpwi r0, 0x0
beq WPADiManageHandler_8D10
WPADiManageHandler_8BFC:
lwz r21, 0xc8(r1)
mr r3, r22
lwz r20, 0xcc(r1)
addi r4, r1, 0xf8
lwz r19, 0xd0(r1)
lwz r12, 0xd4(r1)
lwz r11, 0xd8(r1)
lwz r10, 0xdc(r1)
lwz r9, 0xe0(r1)
lwz r8, 0xe4(r1)
lwz r7, 0xe8(r1)
lwz r6, 0xec(r1)
lwz r5, 0xf0(r1)
lwz r0, 0xf4(r1)
stw r21, 0xf8(r1)
stw r20, 0xfc(r1)
stw r19, 0x100(r1)
stw r12, 0x104(r1)
stw r11, 0x108(r1)
stw r10, 0x10c(r1)
stw r9, 0x110(r1)
stw r8, 0x114(r1)
stw r7, 0x118(r1)
stw r6, 0x11c(r1)
stw r5, 0x120(r1)
stw r0, 0x124(r1)
bl WPADiSendData
cmpwi r3, 0x0
bne WPADiManageHandler_8D10
bl OSDisableInterrupts
mr r27, r3
bl OSDisableInterrupts
lbz r4, 0x5ec(r26)
lbz r0, 0x5ed(r26)
subf r0, r4, r0
extsb. r19, r0
bge WPADiManageHandler_8C9C
lwz r0, 0x5f4(r26)
add r0, r19, r0
extsb r19, r0
WPADiManageHandler_8C9C:
bl OSRestoreInterrupts
cmpwi r19, 0x0
bne WPADiManageHandler_8CB4
mr r3, r27
bl OSRestoreInterrupts
b WPADiManageHandler_8D08
WPADiManageHandler_8CB4:
lbz r0, 0x5ec(r26)
li r4, 0x0
lwz r3, 0x5f0(r26)
li r5, 0x30
extsb r0, r0
mulli r0, r0, 0x30
add r3, r3, r0
bl memset
lbz r0, 0x5ec(r26)
mr r3, r27
lwz r4, 0x5f4(r26)
extsb r6, r0
subi r4, r4, 0x1
subf r5, r4, r6
addi r0, r6, 0x1
subf r4, r6, r4
nor r4, r5, r4
srawi r4, r4, 31
andc r0, r0, r4
stb r0, 0x5ec(r26)
bl OSRestoreInterrupts
WPADiManageHandler_8D08:
li r21, 0x1
b WPADiManageHandler_8D14
WPADiManageHandler_8D10:
li r21, 0x0
WPADiManageHandler_8D14:
cmpwi r21, 0x0
beq WPADiManageHandler_8D20
stb r29, 0x0(r25)
WPADiManageHandler_8D20:
cmpwi r21, 0x0
bne WPADiManageHandler_8ED0
lwz r27, 0x0(r24)
lwz r0, 0x8d8(r27)
cmpwi r0, 0x0
beq WPADiManageHandler_8EC8
bl OSDisableInterrupts
mr r26, r3
bl OSDisableInterrupts
lbz r4, 0x160(r27)
lbz r0, 0x161(r27)
subf r0, r4, r0
extsb. r19, r0
bge WPADiManageHandler_8D64
lwz r0, 0x168(r27)
add r0, r19, r0
extsb r19, r0
WPADiManageHandler_8D64:
bl OSRestoreInterrupts
cmpwi r19, 0x0
bne WPADiManageHandler_8D80
mr r3, r26
bl OSRestoreInterrupts
li r0, 0x0
b WPADiManageHandler_8DAC
WPADiManageHandler_8D80:
lbz r0, 0x160(r27)
addi r3, r1, 0x68
lwz r4, 0x164(r27)
li r5, 0x30
extsb r0, r0
mulli r0, r0, 0x30
add r4, r4, r0
bl memcpy
mr r3, r26
bl OSRestoreInterrupts
li r0, 0x1
WPADiManageHandler_8DAC:
cmpwi r0, 0x0
beq WPADiManageHandler_8EC8
lwz r19, 0x68(r1)
mr r3, r22
lwz r20, 0x6c(r1)
addi r4, r1, 0x98
lwz r26, 0x70(r1)
lwz r12, 0x74(r1)
lwz r11, 0x78(r1)
lwz r10, 0x7c(r1)
lwz r9, 0x80(r1)
lwz r8, 0x84(r1)
lwz r7, 0x88(r1)
lwz r6, 0x8c(r1)
lwz r5, 0x90(r1)
lwz r0, 0x94(r1)
stw r19, 0x98(r1)
stw r20, 0x9c(r1)
stw r26, 0xa0(r1)
stw r12, 0xa4(r1)
stw r11, 0xa8(r1)
stw r10, 0xac(r1)
stw r9, 0xb0(r1)
stw r8, 0xb4(r1)
stw r7, 0xb8(r1)
stw r6, 0xbc(r1)
stw r5, 0xc0(r1)
stw r0, 0xc4(r1)
bl WPADiSendData
cmpwi r3, 0x0
bne WPADiManageHandler_8EC8
bl OSDisableInterrupts
mr r26, r3
bl OSDisableInterrupts
lbz r4, 0x160(r27)
lbz r0, 0x161(r27)
subf r0, r4, r0
extsb. r19, r0
bge WPADiManageHandler_8E54
lwz r0, 0x168(r27)
add r0, r19, r0
extsb r19, r0
WPADiManageHandler_8E54:
bl OSRestoreInterrupts
cmpwi r19, 0x0
bne WPADiManageHandler_8E6C
mr r3, r26
bl OSRestoreInterrupts
b WPADiManageHandler_8EC0
WPADiManageHandler_8E6C:
lbz r0, 0x160(r27)
li r4, 0x0
lwz r3, 0x164(r27)
li r5, 0x30
extsb r0, r0
mulli r0, r0, 0x30
add r3, r3, r0
bl memset
lbz r0, 0x160(r27)
mr r3, r26
lwz r4, 0x168(r27)
extsb r6, r0
subi r4, r4, 0x1
subf r5, r4, r6
addi r0, r6, 0x1
subf r4, r6, r4
nor r4, r5, r4
srawi r4, r4, 31
andc r0, r0, r4
stb r0, 0x160(r27)
bl OSRestoreInterrupts
WPADiManageHandler_8EC0:
li r0, 0x1
b WPADiManageHandler_8ECC
WPADiManageHandler_8EC8:
li r0, 0x0
WPADiManageHandler_8ECC:
or r21, r21, r0
WPADiManageHandler_8ED0:
lwz r20, 0x0(r24)
lwz r0, 0x8bc(r20)
cmpwi r0, -0x1
beq WPADiManageHandler_8FD0
cmpwi r21, 0x1
beq WPADiManageHandler_8F18
bl OSDisableInterrupts
lbz r4, 0x160(r20)
lbz r0, 0x161(r20)
subf r0, r4, r0
extsb. r19, r0
bge WPADiManageHandler_8F0C
lwz r0, 0x168(r20)
add r0, r19, r0
extsb r19, r0
WPADiManageHandler_8F0C:
bl OSRestoreInterrupts
cmpwi r19, 0x0
ble WPADiManageHandler_8F24
WPADiManageHandler_8F18:
lwz r3, 0x0(r24)
stw r29, 0x8d0(r3)
b WPADiManageHandler_8FAC
WPADiManageHandler_8F24:
lbz r0, 0x0(r23)
cmplwi r0, 0x5
bne WPADiManageHandler_8FAC
sth r31, 0x22(r1)
mr r3, r22
lwz r5, 0x0(r24)
addi r4, r1, 0x38
stb r29, 0xc(r1)
lwz r12, 0x10(r1)
stw r29, 0x8d0(r5)
lwz r21, 0xc(r1)
lwz r11, 0x14(r1)
lwz r10, 0x18(r1)
lwz r9, 0x1c(r1)
lwz r8, 0x20(r1)
lwz r7, 0x24(r1)
lwz r6, 0x28(r1)
lwz r5, 0x2c(r1)
lwz r0, 0x30(r1)
stw r30, 0x8(r1)
stw r29, 0x34(r1)
stw r30, 0x38(r1)
stw r21, 0x3c(r1)
stw r12, 0x40(r1)
stw r11, 0x44(r1)
stw r10, 0x48(r1)
stw r9, 0x4c(r1)
stw r8, 0x50(r1)
stw r7, 0x54(r1)
stw r6, 0x58(r1)
stw r5, 0x5c(r1)
stw r0, 0x60(r1)
stw r29, 0x64(r1)
bl __SendData
WPADiManageHandler_8FAC:
lwz r3, 0x0(r24)
lwz r0, 0x8d0(r3)
cmpwi r0, 0x0
beq WPADiManageHandler_8FC8
lbz r3, 0x0(r23)
addi r0, r3, 0x1
b WPADiManageHandler_8FCC
WPADiManageHandler_8FC8:
li r0, 0x0
WPADiManageHandler_8FCC:
stb r0, 0x0(r23)
WPADiManageHandler_8FD0:
lbz r0, _checkCnt(r0)
cmplwi r0, 0x5
bne WPADiManageHandler_8FE4
mr r3, r22
bl WPADiCheckContInputs
WPADiManageHandler_8FE4:
lhz r0, _senseCnt(r0)
cmplwi r0, 0xa
bne WPADiManageHandler_8FF8
mr r3, r22
bl WPADiRadioSensitivity
WPADiManageHandler_8FF8:
lbz r3, 0x0(r25)
cmplwi r3, 0x5
addi r0, r3, 0x1
bne WPADiManageHandler_900C
mr r0, r3
WPADiManageHandler_900C:
addi r22, r22, 0x1
stb r0, 0x0(r25)
cmpwi r22, 0x4
addi r25, r25, 0x1
addi r24, r24, 0x4
addi r23, r23, 0x1
blt WPADiManageHandler_8B48
lhz r0, _afhCnt(r0)
cmplwi r0, 0xea60
bne WPADiManageHandler_9090
lis r21, 0x8000
li r4, 0x1
addi r3, r21, 0x31a2
bl DCInvalidateRange
addi r3, r28, 0x108
crclr 4*cr1+eq
bl DEBUGPrint
lbz r3, _afhChannel(r0)
lbz r0, 0x31a2(r21)
extsb r3, r3
cmpw r3, r0
beq WPADiManageHandler_9090
bl OSDisableInterrupts
lbz r0, 0x31a2(r21)
stb r0, _afhChannel(r0)
bl OSRestoreInterrupts
lbz r4, 0x31a2(r21)
addi r3, r28, 0x130
crclr 4*cr1+eq
bl DEBUGPrint
lbz r0, _afhChannel(r0)
extsb r3, r0
bl WUDSetDisableChannel
WPADiManageHandler_9090:
lhz r6, _senseCnt(r0)
lis r3, 0x1
subi r0, r3, 0x15a0
lbz r9, _checkCnt(r0)
subi r4, r6, 0xa
subfic r3, r6, 0xa
nor r3, r4, r3
lhz r10, _afhCnt(r0)
srawi r8, r3, 31
addi r7, r6, 0x1
clrlwi r0, r0, 16
subi r4, r9, 0x5
subfic r3, r9, 0x5
andc r7, r7, r8
nor r5, r4, r3
subf r4, r0, r10
subf r3, r10, r0
lbz r0, _scFlush(r0)
srawi r6, r5, 31
addi r5, r9, 0x1
nor r4, r4, r3
addi r3, r10, 0x1
srawi r4, r4, 31
andc r5, r5, r6
andc r3, r3, r4
cmpwi r0, 0x0
sth r7, _senseCnt(r0)
stb r5, _checkCnt(r0)
sth r3, _afhCnt(r0)
beq WPADiManageHandler_9138
bl SCCheckStatus
cmpwi r3, 0x0
bne WPADiManageHandler_9138
lis r3, _scArray@ha
addi r3, r3, _scArray@l
bl SCSetBtDeviceInfoArray
cmpwi r3, 0x1
bne WPADiManageHandler_9138
li r3, 0x0
bl SCFlushAsync
li r0, 0x0
stb r0, _scFlush(r0)
WPADiManageHandler_9138:
lbz r0, _scSetting(r0)
cmpwi r0, 0x0
beq WPADiManageHandler_91D4
bl SCCheckStatus
cmpwi r3, 0x0
bne WPADiManageHandler_91D4
bl SCGetBtDpdSensibility
clrlwi r0, r3, 24
cmplwi r0, 0x1
bge WPADiManageHandler_9164
li r0, 0x1
WPADiManageHandler_9164:
cmplwi r0, 0x5
ble WPADiManageHandler_9170
li r0, 0x5
WPADiManageHandler_9170:
stb r0, _dpdSensitivity(r0)
bl SCGetWpadSensorBarPosition
clrlwi r3, r3, 24
subi r0, r3, 0x1
cntlzw r0, r0
extrwi r0, r0, 8, 19
stb r0, _sensorBarPos(r0)
bl SCGetWpadMotorMode
clrlwi r3, r3, 24
subi r0, r3, 0x1
cntlzw r0, r0
srwi r0, r0, 5
stw r0, _rumble(r0)
bl SCGetWpadSpeakerVolume
clrlwi. r0, r3, 24
mr r4, r3
bne WPADiManageHandler_91B8
li r4, 0x0
WPADiManageHandler_91B8:
clrlwi r0, r3, 24
cmplwi r0, 0x7f
blt WPADiManageHandler_91C8
li r4, 0x7f
WPADiManageHandler_91C8:
li r0, 0x0
stb r4, _speakerVolume(r0)
stb r0, _scSetting(r0)
WPADiManageHandler_91D4:
bl BTA_HhGetAclQueueInfo
WPADiManageHandler_91D8:
addi r11, r1, 0x160
bl _restgpr_19
lwz r0, 0x164(r1)
mtlr r0
addi r1, r1, 0x160
blr
}
#else
static void WPADiManageHandler(OSAlarm* pAlarm, OSContext* pContext) {
s32 status = WPADGetStatus();
s32 chan;
@@ -635,10 +1168,8 @@ static void WPADiManageHandler(OSAlarm* pAlarm, OSContext* pContext) {
return;
}
_recCnt = _recCnt == 0 ? 0 : _recCnt - 1;
if (_recFlag >= 0) {
if (_recCnt == 0) {
if (--_recCnt <= 0) {
__reconnect(_recFlag);
}
return;
@@ -685,6 +1216,9 @@ static void WPADiManageHandler(OSAlarm* pAlarm, OSContext* pContext) {
BTA_HhGetAclQueueInfo();
}
#endif
static void WPADiManageHandler0(OSAlarm* pAlarm, OSContext* pContext) {
OSSwitchFiberEx((u32)pAlarm, (u32)pContext, 0, 0, WPADiManageHandler, __WPADiManageHandlerStack + sizeof(__WPADiManageHandlerStack));
}
@@ -729,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;
@@ -764,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);
@@ -2158,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: {
@@ -2170,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

@@ -34,7 +34,7 @@ void CDBConvTypeStrToFullPath(char* fullPath, char* yearStr, char* monthStr, cha
void CDBConvFileNameStrToFullPath(char* fullPath, char* yearStr, char* monthStr, char* dayStr, char* hourStr, char* minuteStr, char* codeStr,
char* typeStr, char* fileStr, CDBLocation location, u64* wiiId);
CDBDate CDBConvDirStrToCDBDate(char* yearStr, char* monthStr, char* dayStr, char* hourStr, char* minuteStr);
CDBDate CDBConvDirStrToCDBDate(char* yearStr, char* monthStr, char* dayStr, char* hourStr, char* minuteStr, CDBLocation location, u64* wiiId);
void CDBConvGCStrToGCValue(char* gcStr, u32* gcValue);
void CDBConvGCValueToGCStr(u32 gcValue, char* gcStr);

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