Compare commits

..

1 Commits

Author SHA1 Message Date
coah
87a084da31 cleanup(iplSettingButton): rename Unk ring-buffer placeholders
Unk -> CmdEntry; unk_0x64 -> mCmdQueue; capacity/count/read/write
indices. Byte-identical (DOL sha1 unchanged).
2026-10-02 14:06:01 -05:00
472 changed files with 13088 additions and 87189 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
@@ -16022,8 +16011,8 @@ mscBasePaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC18; // type:object
@17309 = .data:0x8164DC42; // type:object size:0xB scope:local data:string
@17310 = .data:0x8164DC4D; // type:object size:0xB scope:local data:string
@17311 = .data:0x8164DC58; // type:object size:0xB scope:local data:string
mscPicturePaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC64; // type:object size:0x14 data:4byte
mscEdgePaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC78; // type:object size:0x14 data:4byte
mscUnk0PaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC64; // type:object size:0x14 data:4byte
mscUnk1PaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC78; // type:object size:0x14 data:4byte
@17317 = .data:0x8164DC8C; // type:object size:0x9 scope:local data:string
@17318 = .data:0x8164DC95; // type:object size:0x9 scope:local data:string
@17319 = .data:0x8164DC9E; // type:object size:0x9 scope:local data:string
@@ -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,13 +908,13 @@ config.libs = [
),
# it decides to do fast optimization for this one
IPLSection("keyboard", [
Object(Matching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiCellPhone.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"]),
Object(Matching, "keyboard/tiToolBar.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiPredictLang.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiSignWindow.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiSignWindow.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiString.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiAtokString.cpp", extra_cflags=["-O4,p"]), # for 4.3J
Object(NonMatching, "keyboard/tiZiString.cpp", extra_cflags=["-O4,p"]), # for 4.3U and 4.3E
@@ -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"),
@@ -1022,7 +1022,7 @@ config.libs = [
Object(Matching, "cdb/CDBFileSystem.c"),
Object(Matching, "cdb/CDBFileSystemVF.c"),
Object(Matching, "cdb/CDBFileSystemSD.c"),
Object(Matching, "cdb/CDBRecord.c"),
Object(NonMatching, "cdb/CDBRecord.c"),
Object(Matching, "cdb/CDBRecordFile.c"),
Object(Matching, "cdb/CDBRecordKey.c"),
Object(Matching, "cdb/CDBIntArray.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,15 +1081,15 @@ 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"),
Object(Matching, "nwc24/NWC24Time.c"),
Object(Matching, "nwc24/NWC24Ipc.c"),
Object(Matching, "nwc24/NWC24Download.c"),
Object(Equivalent, "nwc24/NWC24Download.c"),
Object(Matching, "nwc24/NWC24CHJump.c"),
Object(Matching, "nwc24/NWC24System.c"),
]
@@ -1218,7 +1218,7 @@ config.libs = [
Object(NonMatching, "texturecvtr/Texture_MCUtoRGB565.c"),
Object(NonMatching, "texturecvtr/Texture_MCUtoRGBA8.c"),
Object(Matching, "b65/iqdec_b65_frv32.c"),
Object(NonMatching, "b65/iqdec_b65_frv32.c"),
]
),
# NW4R
@@ -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"),
]
@@ -1559,7 +1559,7 @@ config.libs = [
]
),
RVLSDKLib("kpad", [
Object(Matching, "kpad/KPAD.c"),
Object(NonMatching, "kpad/KPAD.c"),
]
),
RVLSDKLib("euart", [
@@ -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

@@ -139,13 +139,13 @@ namespace www {
namespace ext_ead {
namespace www {
typedef struct ImeData {
u32 eventType; // 0x00
u32 unk_0x00; // 0x00
u32 imeID; // 0x04
char* text; // 0x08
u32 creationDataA; // 0x0c
u32 creationDataB; // 0x10
u32 creationDataC; // 0x14
u32 creationDataD; // 0x18
u32 unk_0x0C; // 0x0c
u32 unk_0x10; // 0x10
u32 unk_0x14; // 0x14
u32 unk_0x18; // 0x18
u32 maxLength; // 0x1c
ImeData& operator=(const ImeData&);
@@ -177,7 +177,7 @@ namespace ext_ead {
struct {
u32 imeID;
char* str;
u32 updateData;
u32 unk_0x0C;
} updateIme; // ID 4
u32 raw[6];
} data;
@@ -203,12 +203,12 @@ namespace ext_ead {
void CreateImeData(ImeData* data, const WWWIMEData* wwwData);
void DisposeImeData(ImeData* data);
void CommitIme(ImeData* data, const char* text);
void CommitIme(ImeData* data, const char* something);
void CommitImeCmdPacket(const CmdPacket* data);
void UpdateImeCmdPacket(const CmdPacket* data);
static void FlushCallback(WWWRect* rect, int callbackData);
static void FlushCallback(WWWRect* rect, int unk);
u32* GetRaster() { return mpRaster; }
WWWHandle* GetHandle() { return mpBrowserHandle; }
@@ -222,7 +222,7 @@ namespace ext_ead {
bool CheckThreadExit_();
void InitSurface_();
void InitFonts_(const char* fontDirectory);
void InitFonts_(const char* unk);
void SendKeyboardEvent_(u32 btnMask, u32 triggerFlag, u32 releaseFlag, WWWKeySym sym);
WWWKeySym GetKeyboardSym_(u32 input);

View File

@@ -23,7 +23,7 @@ namespace ext_ead {
void SendNotifyEvent(WWWEvent event, WWWHandleEventData* dataHandle);
void ExecuteEvent();
void UpdateTexture();
void* GetTextureBuffer(int pageOffset, bool forUpdate, WWWRect** rectPtrOut);
void* GetTextureBuffer(int a, bool b, WWWRect** rectPtrOut);
void SetWindowSize(int w, int h);
WWWHandlewindow* GetHandleWindow() { return mpWwwWindow; };
@@ -55,11 +55,11 @@ namespace ext_ead {
u32 mRenderingMode; // 0x2AC
public:
int mDisplayPageIndex; // 0x2B0
u32 mDisplayBufferIndices[2]; // 0x2B4
u32 mUpdateBufferIndex; // 0x2BC
u32 mUpdatePageIndex; // 0x2C0
u8 mPageLoadStatus[6]; // 0x2C4
int unk_0x2B0; // 0x2B0
u32 unk_0x2B4[2]; // 0x2B4
u32 unk_0x2BC; // 0x2BC
u32 unk_0x2C0; // 0x2C0
u8 unk_0x2C4[6]; // 0x2C4
};
} // namespace www
} // namespace ext_ead

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

@@ -52,17 +52,17 @@ namespace textinput {
const Manager *mgr() const { return mpManager; }
Manager* mpManager; // 0x10
u8 mbShiftTapPending; // 0x14
u8 field_0x14; // 0x14
#ifdef TIINPUTFORM_IMPLEMENTATION
u8 mbSingleQuoteClosing;
u8 mbDoubleQuoteClosing;
#else
#ifdef TIHWKEYBOARD_IMPLEMENTATION
bool mbSingleQuoteClosing;
bool mbDoubleQuoteClosing;
bool field_0x15;
bool field_0x16;
#else
u8 mbSingleQuoteClosing; // 0x15
u8 mbDoubleQuoteClosing; // 0x16
u8 field_0x15; // 0x15
u8 field_0x16; // 0x16
#endif
#endif
};

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
@@ -129,26 +125,14 @@ namespace textinput {
#ifdef TIHWKEYBOARD_IMPLEMENTATION
EventObserver* getEventObserverForHardware() const { return mpEventObserver; }
#endif
#ifdef TISIGNWINDOW_IMPLEMENTATION
virtual InputForm* getInputForm();
#else
virtual InputForm* getInputForm() { return mpInputForm; }
#endif
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; }
@@ -165,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

@@ -18,7 +18,6 @@ struct LanguageDependency {
class Base : public KeyboardBase {
public:
Base(Manager* manager) : mpAllocator(NULL), mpManager(manager) {}
virtual ~Base();
virtual void create(MEMAllocator*) override;
virtual void init() override;
@@ -46,8 +45,6 @@ class EventHandler;
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mbActive(false), mbInput(false), mpEventHandler(NULL), mpKeyboard(NULL) {}
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator*) override;
virtual void init() override;
@@ -78,9 +75,7 @@ public:
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: LayoutByNW4R(manager, accessor, observer, layoutName) {}
virtual ~Sample() {}
virtual ~Sample();
};
class EventHandler : public nw4rmanager::TiEventHandler {

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

@@ -34,7 +34,7 @@ namespace textinput {
void replaceChar(char* dest, u32 destLen, const char* src, int replaceIdx, char newCh);
bool isAlphabet(wchar_t ch);
f32 hermiteInterporation(f32 time, f32 startTime, f32 startValue, f32 startTangent, f32 endTime, f32 endValue, f32 endTangent);
f32 hermiteInterporation(f32 arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6);
void getProjectionRect4x3(nw4r::ut::Rect* rect);
void getProjectionRect16x9(nw4r::ut::Rect* rect);

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

@@ -113,37 +113,37 @@ namespace ipl {
void init(const T& start, const T& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
T get() const {
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
T r =
(mStart *
(1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))))) -
(mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))));
(1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))))) -
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
r +=
(mStartTangent *
(frame +
((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (2.0f * frame * frame))))) +
(mEndTangent * ((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (frame * frame))));
(var_f27 +
((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
/*f32 maxFrame = mMaxFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
T weightedEnd = mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame))));
T weightedStart = mStart * (1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame)))));
T r = weightedStart - weightedEnd;
/*f32 var_f27 = mMaxFrame;
f32 var_f28 = 1.0f / mMaxFrame;
T sp28 = mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27))));
T sp1C = mStart * (1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
T r = sp1C - sp28;
f32 frameSquared = maxFrame * maxFrame;
f32 scaledCubic = inverseDuration * (inverseDuration * (maxFrame * frameSquared));
f32 tangentContribution =
(mStartTangent * (maxFrame + (scaledCubic - (inverseDuration * (2.0f * maxFrame * maxFrame))))) + (mEndTangent * (scaledCubic - (inverseDuration * frameSquared)));
r = r + tangentContribution;
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
return r;*/
}
@@ -163,28 +163,24 @@ 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 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
f32 r =
(mStart *
(1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))))) -
(mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))));
(1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))))) -
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
r +=
(mStartTangent *
(frame + ((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (2.0f * frame * frame))))) +
(mEndTangent * ((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (frame * frame))));
(var_f27 + ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
}
#endif
protected:
f32 mStart;
@@ -231,35 +227,35 @@ namespace ipl {
}
#else
T get() const {
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
f32 t1t2 =
(inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) - (inverseDuration * (inverseDuration * (3.0f * frame * frame)));
(var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) - (var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)));
T r = (mStart * (1.0f + t1t2)) - (mEnd * t1t2);
f32 frameSquared = frame * frame;
f32 scaledCubic = inverseDuration * (inverseDuration * (frame * frameSquared));
f32 tangentContribution =
(mStartTangent * (frame + (scaledCubic - (inverseDuration * (2.0f * frame * frame))))) + (mEndTangent * (scaledCubic - (inverseDuration * frameSquared)));
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + tangentContribution;
r = r + temp_f3;
return r;
/*f32 maxFrame = mMaxFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
T weightedEnd = mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame))));
T weightedStart = mStart * (1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame)))));
T r = weightedStart - weightedEnd;
/*f32 var_f27 = mMaxFrame;
f32 var_f28 = 1.0f / mMaxFrame;
T sp28 = mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27))));
T sp1C = mStart * (1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
T r = sp1C - sp28;
f32 frameSquared = maxFrame * maxFrame;
f32 scaledCubic = inverseDuration * (inverseDuration * (maxFrame * frameSquared));
f32 tangentContribution =
(mStartTangent * (maxFrame + (scaledCubic - (inverseDuration * (2.0f * maxFrame * maxFrame))))) + (mEndTangent * (scaledCubic - (inverseDuration * frameSquared)));
r = r + tangentContribution;
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
return r;*/
}
#endif
@@ -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

@@ -332,12 +332,12 @@ namespace ipl {
scroller mScroller; // 0x58
picture mPicture; // 0xC8
int mReservedWord;
u8 mReservedByte;
int unk_0xF8;
u8 unk_0xFC;
EGG::Allocator mGUIAlloc; // 0x100
wchar_t mUrlTerminators[6];
wchar_t unk_0x114[6];
u8* mpCmpArcData; // 0x120
u8* mpArcData; // 0x124

View File

@@ -18,11 +18,11 @@ namespace ipl {
class line_collision {
public:
line_collision() : mLeft(0.0f), mRight(0.0f), mY(0.0f) {}
line_collision() : unk_0x00(0.0f), unk_0x04(0.0f), unk_0x08(0.0f) {}
f32 mLeft;
f32 mRight;
f32 mY;
f32 unk_0x00;
f32 unk_0x04;
f32 unk_0x08;
nw4r::ut::Link mLinkList; // 0x0C
};
@@ -31,9 +31,9 @@ namespace ipl {
url_collision();
~url_collision();
int mTagNo;
wchar_t* mpStart;
wchar_t* mpEnd;
int unk_0x00;
wchar_t* unk_0x04;
wchar_t* unk_0x08;
nw4r::ut::Link mLinkList; // 0x0C
nw4r::ut::List mLineCollisions; // 0x14
};
@@ -53,19 +53,19 @@ namespace ipl {
void parse(nw4r::ut::PrintContext<wchar_t>* context);
BOOL is_focused() const;
void select(int tagNo);
void select(int unk);
int get_focused_tagno(int chan) const;
url_collision* get_selected_col();
void get_url(char* urlOut, u32 urlLen);
void setHitYOffset(f32 val) { mHitYOffset = val; }
void setMemoTranslateY(f32 val) { mMemoTranslateY = val; }
void setFocusEnabled(bool val) { mbFocusEnabled = val; }
void setUnk_0x40(f32 val) { unk_0x40 = val; }
void setUnk_0x44(f32 val) { unk_0x44 = val; }
void setUnk_0x53(bool val) { unk_0x53 = val; }
u8 getColorPass() const { return mbColorPass; }
void setColorPass(u8 val) { mbColorPass = val; }
u8 getUnk_0x50() const { return unk_0x50; }
void setUnk_0x50(u8 val) { unk_0x50 = val; }
private:
typedef struct {
@@ -75,14 +75,14 @@ namespace ipl {
con_data mConData[WPAD_MAX_CONTROLLERS]; // 0x00
nw4r::ut::List mUrlCollisions; // 0x34
f32 mHitYOffset;
f32 mMemoTranslateY;
int mCurTagNo;
int mSelectedTagNo;
u8 mbColorPass;
u8 mbInTag;
u8 mbHoverOffset;
u8 mbFocusEnabled;
f32 unk_0x40;
f32 unk_0x44;
int unk_0x48;
int unk_0x4C;
u8 unk_0x50;
u8 unk_0x51;
u8 unk_0x52;
u8 unk_0x53;
};
} // namespace scene
} // namespace ipl

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

@@ -40,7 +40,7 @@ namespace ipl {
void initExtModule(EGG::Heap* workHeap, channel::RsoThread* thread);
int calcExtModule(EGG::ExpHeap* expHeap, bool canStartModule, bool onSceneChange);
int calcExtModule(EGG::ExpHeap* expHeap, bool unk0, bool unk1);
void drawThumbnail();
void drawCursor();
@@ -57,14 +57,14 @@ namespace ipl {
BOOL isDiskChannel() const;
BOOL isValid() const;
void onPoint(int eventFlags);
void onLeft(int eventFlags);
void onPinch(bool pinched);
void onPoint(int unk);
void onLeft(int unk);
void onPinch(bool unk);
void setCursorDecideAnim();
void initCursorAnim(bool resetPointCount);
void initBalloonAnim(bool resetPointCount);
void initCursorAnim(bool unk);
void initBalloonAnim(bool unk);
void FillModuleCount();
@@ -83,15 +83,15 @@ namespace ipl {
void initCursor();
void calcCursor(const nw4r::math::VEC3& vec);
void setCursorAnim(int state) NO_INLINE;
void setCursorAnim(int unk) NO_INLINE;
void calcCursorAnim();
void startCursorAnim(int animationIndex);
void startCursorAnim(int unk);
void initBalloon();
void setBalloonText(const wchar_t* text);
void calcBalloon(const nw4r::math::VEC3& vec);
void setBalloonAnim(int state) NO_INLINE;
void setBalloonAnim(int unk) NO_INLINE;
void calcBalloonAnim();
void clearModuleParam();
@@ -107,7 +107,7 @@ namespace ipl {
}
private:
u8 mListLinkStorage[8];
u8 unk_0x00[8];
EGG::Heap* mpCursorHeap; // 0x08
EGG::Heap* mpBalloonHeap; // 0x0C
@@ -149,22 +149,22 @@ namespace ipl {
layout::Object* mpCursorLayout; // 0x48
layout::Animator* mpCursorAnims[ANIM_CURSOR_MAX]; // 0x4C
int mCursorState;
int mPendingCursorState;
int unk_0x58;
int unk_0x5C;
layout::Object* mpBalloonLayout; // 0x60
layout::Animator* mpBalloonAnim; // 0x64
int mBalloonState;
int mPendingBalloonState;
int mBalloonWaitFrame;
int unk_0x68;
int unk_0x6C;
int unk_0x70;
int mPointCount;
int unk_0x74;
nw4r::lyt::Group* mpNwc24NewGroup; // 0x78
layout::GroupAnimator* mpNwc24NewAnim; // 0x7C
bool mpNwc24NewPlayAnim; // 0x80
int mNewMessageState;
u32 mNewMessageFrame;
int unk_0x84;
u32 unk_0x88;
f32 mThumbWidth; // 0x8C
f32 mThumbHeight; // 0x90
@@ -188,7 +188,7 @@ namespace ipl {
channel::RsoThread* mpModuleThread; // 0xE8
int mExtModuleState; // 0xEC
nand::SharedFile* mpModuleFile; // 0xF0
bool mbModuleFlag;
bool unk_0xF4;
u32 mModuleCount; // 0xF8
u32 mMaxModuleCount; // 0xFC

View File

@@ -76,7 +76,7 @@ namespace ipl {
void appendToChannelList(int page, int index);
void destroyChannelObj(ChannelObj * channelObj);
void sortChannelList(int page);
void sortChannelListByPage(int page, int edgeDirection);
void sortChannelListByPage(int page, int unk);
ChannelObj* searchList(int page, int index) const;
void setupDiskChanObj();
@@ -87,7 +87,7 @@ namespace ipl {
void setChanFrameVisibility();
BOOL isChannelInView(int page, int index) const;
BOOL isChannelInCalc(int page, int index, int currentPage) const;
BOOL isChannelInCalc(int page, int index, int unk2) const;
BOOL isPageCreated(int page) const;
BOOL isPageCreatedAllDone(int page) const;
@@ -108,14 +108,14 @@ namespace ipl {
BOOL prepareRestarting(int page);
void restart(int page, int index);
nw4r::lyt::Pane* getChannelBasePane(int page, int index, int currentPage) const;
nw4r::lyt::Pane* getChannelBasePane(int page, int index, int unk3) const;
const nw4r::lyt::Pane* getChannelBasePane(int index) const;
nw4r::lyt::Pane* getChannelBasePane(int index);
nw4r::math::VEC3 getDispChanTrans(int index) const;
void setChannelScissor(const ChannelObj* channelObj) const;
void initChanZoomParam(const math::VEC3& pos, BOOL zoomOut);
void initChanZoomParam(const math::VEC3& pos, BOOL unk);
void calcChanZoomParam();
void setChanZoomOrtho();
@@ -148,11 +148,11 @@ namespace ipl {
void startResetting();
bool unkBool() {
return !mbWaitForModuleStop || mModuleState == 3;
return !unk_0x185 || unk_0x180 == 3;
}
void setSomething() {
mbModuleSceneChange = true;
mbWaitForModuleStop = 1;
unk_0x185 = 1;
}
enum {
@@ -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
@@ -274,25 +274,25 @@ namespace ipl {
clock mClock; // 0x108
s32 mPrevSDState; // 0x168
EGG::Heap* mpThumbnailHeap;
EGG::Heap* unk_0x16C;
EGG::Heap* mpDiskHeap; // 0x170
EGG::Heap* mpCursorHeap; // 0x174
EGG::Heap* mpBalloonHeap; // 0x178
EGG::Heap* mpChannelObjHeap;
EGG::Heap* unk_0x17C;
int mModuleState;
int unk_0x180;
bool mbModuleSceneChange; // 0x184
bool mbWaitForModuleStop;
bool unk_0x185;
ChannelObj* mpCurrentRsoChanObj; // 0x188
ChannelObj* mpPriorityModuleChanObj;
ChannelObj* unk_0x18C;
EGG::Heap* mpModuleWorkHeap; // 0x190
channel::RsoThread* mpModuleThread; // 0x194
EGG::ExpHeap* mpModuleHeaps[49]; // 0x198
bool mbModuleHeapInUse[49];
bool unk_0x25C[49];
nw4r::math::VEC2 mDragPos; // 0x290
int mConChan; // 0x298
@@ -300,21 +300,21 @@ namespace ipl {
int mMoveOldIndex; // 0x2A0
int mMoveNewPage; // 0x2A4
int mMoveNewIndex; // 0x2A8
int mDragRightScrollFrame;
int mDragLeftScrollFrame;
int mReleaseWaitFrame;
bool mbDragReleased;
int unk_0x2AC;
int unk_0x2B0;
int unk_0x2B4;
bool unk_0x2B8;
nand::File* mpSaveDataFile; // 0x2BC
ChannelObj* mpMovedChanObj;
layout::Object* mpMoveThumbnailLayout;
layout::Animator* mpMoveThumbnailAnim;
ChannelObj* unk_0x2C0;
layout::Object* unk_0x2C4;
layout::Animator* unk_0x2C8;
u32 unused_0x2CC;
static BOOL msInitFlag;
static const char* mscChanPaneNames[CHAN_SCROLL_MAX][MAX_CHANNEL_INDEX];
static const char* mscBasePaneNames[CHAN_SCROLL_MAX];
static const char* mscPicturePaneNames[CHAN_SCROLL_MAX];
static const char* mscEdgePaneNames[CHAN_SCROLL_MAX];
static const char* mscUnk0PaneNames[CHAN_SCROLL_MAX];
static const char* mscUnk1PaneNames[CHAN_SCROLL_MAX];
static const char* mscClockPaneNames[3];
static const char* mscMaskPaneName;

View File

@@ -112,7 +112,7 @@ namespace ipl {
void startChangeChannel(int page, int index);
void reserveNextScene();
void reserveSettingScene(bool skipConfirmation);
void reserveSettingScene(bool unk);
void prepareForBoot1(int sceneID);
void prepareForBoot2(int sceneID);
@@ -318,9 +318,9 @@ namespace ipl {
int mDiskState2; // 0x78
nw4r::math::VEC3 mDispTrans; // 0x7C
u32 mBootWaitFrame;
int mStartButtonState;
bool mbBannerStartPending;
u32 unk_0x88;
int unk_0x8C;
bool unk_0x90;
layout::GroupAnimator* mpGrpAnims[ANIM_GRP_MAX][ANIM_MAX]; // 0x94
layout::Animator* mpChangeAnims[ANIM_MAX]; // 0x1D4
@@ -352,8 +352,8 @@ namespace ipl {
layout::Object* mpDiskBnrLayout; // 0x254
layout::Animator* mpDiskBnrAnims[DISK_ANIM_GRP_MAX][DISK_ANIM_MAX]; // 0x258
undefined reservedAfterDiskAnims[4];
undefined mWiiDiskReady;
undefined unk_0x320[4];
undefined unk_0x324;
nand::LayoutFile* mpGCBannerFile; // 0x328
layout::Object* mpGCBannerLyt; // 0x32C
@@ -371,24 +371,24 @@ namespace ipl {
CsChanTtlButtonEventHandler* mpButtonEvent; // 0x354
utility::Capture* mpCapture; // 0x358
ESTmdView* mpCurTicket; // 0x35C
bool mbTmdReady;
bool unk_0x360;
u16 mCurGameCode; // 0x362
ESTitleId mTmpTitleID; // 0x368
bool mbTmpTitleCleanupDone;
bool mbTicketLimitReady;
bool unk_0x370;
bool unk_0x371;
u32 mLimitType; // 0x374
u32 mTimeLimitRemain; // 0x378
bool mbStartButtonFocusPlayed;
bool unk_0x37C;
int mModuleState; // 0x380
int mModuleType; // 0x384
volatile bool mbModuleSceneChange; // 0x388
bool mbRSODoneCalc; // 0x389
u32 mModuleFrame;
u32 mModuleInterval;
u32 unk_0x38C;
u32 unk_0x390;
nand::SharedFile* mpModuleFile; // 0x394
EGG::ExpHeap* mpRsoExpHeaps[2]; // 0x398
int mCurRsoExpHeap; // 0x39C

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

@@ -187,22 +187,6 @@ namespace ipl {
}
private:
GXTexObj* initBannerTexture(u8 slot, s32 file, void* data) {
GXInitTexObj(&mFileCell[slot][file].banner, data, 0x60, 0x20,
GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, GX_FALSE);
return &mFileCell[slot][file].banner;
}
void initBannerTextureCI(u8 slot, s32 file, void* data) {
GXInitTexObjCI(&mFileCell[slot][file].banner, data, 0x60, 0x20,
GX_TF_C8, GX_CLAMP, GX_CLAMP, GX_FALSE, GX_TLUT0);
}
GXTlutObj* initBannerPalette(u8 slot, s32 file, void* data) {
GXInitTlutObj(&mFileCell[slot][file].bannerTlut, data, GX_TL_RGB5A3, 0x100);
return &mFileCell[slot][file].bannerTlut;
}
u32 unk_0x04; // 0x00004
MCFile mFile[2][0x7F]; // 0x00008
MCFileCell mFileCell[2][0x7F]; // 0x00FE8

View File

@@ -44,7 +44,7 @@ namespace ipl {
#endif
struct SettingAPScanList {
u8 reservedHeader[0x14];
u8 unknown[0x14];
union {
struct {
u16 count;
@@ -180,33 +180,33 @@ namespace ipl {
ARG_SETUP,
ARG_UPDATE,
ARG_INTERNET_PAGE,
ARG_RESUME_SETUP,
ARG_DIRECT_PAGE,
ARG_UNK_5,
ARG_UNK_6,
};
private:
#ifdef IPL_SETTING_IMPLEMENTATION
int mUpdateTiming;
u8 mBrowserStopRequested;
u8 reservedAfterBrowserStop[3];
u8 unk_0x5C;
u8 unk_0x5D[3];
nand::Base* mpWWWLibraryFile;
nand::Base* mpSettingHTMLFile;
nand::Base* mpWWWArchiveFile;
nand::Base* mpFontFile;
nand::Base* mpBackgroundTPLFile;
int mDialogState;
int mAPScanState;
int mEULAState;
int unk_0x74;
int unk_0x78;
int unk_0x7C;
int mProfileIDMode;
int mUSBAPState;
int unk_0x84;
int mAOSSState;
int mRakuState;
int mFuncMsgPending;
int mSafeModeDialogState;
int unk_0x94;
ESTitleId mUpdateTitleId;
u32 mPrepareTick;
u8 mSettingData[0x16];
u8 reservedAfterSettingData[2];
u8 unk_0xBA[2];
nand::LayoutFile* mpSettingLayoutFile;
layout::Object* mpChangeLayout;
layout::Object* mpMainLayout;
@@ -221,25 +221,25 @@ namespace ipl {
APScanThread* mpAPScanThread;
SettingAPScanList mAPScanList;
void* mpMem1BrowserBuffer;
u32 reservedBrowserWord;
u32 unk_0x908;
void* mpMem2BrowserBuffer;
void* mpBrowserStringBuffer;
int mAPScrollOffset;
int mAPAnimationIndex;
u8 mUiStatus[4];
int unk_0x914;
int unk_0x918;
u8 unk_0x91C[4];
ext_ead::www::ImeData* mpBrowserData;
www::wiisetting::WiiData* mpWiiSettingData;
www::wiisetting::WiiFlag* mpWiiSettingFlag;
u8 mActionFrame;
u8 reservedAfterActionFrame[3];
int mSupportCode;
u8 unk_0x92C;
u8 unk_0x92D[3];
int unk_0x930;
www::wiisetting::SetStringBuf* mpStringBuffer;
#ifdef IPL_SETTING_IMPLEMENTATION
wchar_t mInputText[0x101];
wchar_t unk_0x938[0x101];
#else
u8 mInputText[0x202];
u8 unk_0x938[0x202];
#endif
u8 reservedAfterInputText;
u8 unk_0xB3A;
u8 mBrowserCreated;
keyboard::Manager::State mKeyboardState;
int mInitialArgument;
@@ -247,21 +247,21 @@ namespace ipl {
int mProgressiveMode;
int mEuRgb60Mode;
u8 mIsResetAcceptable;
u8 reservedAfterResetFlag[3];
u8 unk_0xB5D[3];
OSMessageQueue mFuncMessageQueue;
OSMessage mFuncMessages[5];
int mScreenModeChangeState;
int unk_0xB94;
int mState;
int mInputDelayFrame;
int unk_0xB9C;
OSTime mCreatePageTime;
u32 mConnectedControllerMask;
u8 mNetSettingResultSent;
u8 reservedAfterNetSettingResult[3];
u8 reservedTail[0x10];
u32 unk_0xBA8;
u8 unk_0xBAC;
u8 unk_0xBAD[3];
u8 unk_0xBB0[0x10];
static void* mem1Buffer_;
static void* mem2Buffer_;
#else
u8 mSettingStorage[0xB68];
u8 unk_0x58[0xB68];
#endif
};

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

@@ -40,8 +40,8 @@ enum {
typedef struct tagSTVRCSettings {
u32 magic; // 0x00
u32 formatVersion;
u32 configurationValid;
u32 unk_0x04;
u32 unk_0x08;
u32 modelMakerID; // 0x0C
u32 modelType; // 0x10
u8 commandMap[TVRC_COMMAND_MAP_MAX]; // 0x14

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

@@ -20,7 +20,7 @@ namespace ipl {
// here to avoid typing in long namespaces constantly :P
enum {
CHANS_VM_ALT_SND_STATE_UNAVAILABLE = 0,
CHANS_VM_ALT_SND_STATE_FALLBACK,
CHANS_VM_ALT_SND_STATE_UNK1,
CHANS_VM_ALT_SND_STATE_PLAY,
};
@@ -32,8 +32,8 @@ namespace ipl {
layout::Animator** anims; // 0x08
u64 titleId; // 0x10
bool threadTerminated; // 0x18
bool isThumbnail;
bool mbHasNewMessage; // 0x1A
bool unk_0x19;
bool unk_0x1A;
EGG::ExpHeap* getHeap() { return heap; }
} CSData;

View File

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

View File

@@ -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

@@ -55,27 +55,27 @@ namespace ipl {
STATE_12,
};
u32 mbDisabledTriggerEnabled;
u32 unk_0x04;
BOOL mbInitialized; // 0x08
nand::SharedFile* mpDBFile; // 0x0C
BOOL mbResetting; // 0x10
s32 mCurrentCommand; // 0x14
u32 mRepeatCount;
u32 mbRepeatCommand;
u32 unk_0x18;
u32 unk_0x1C;
u32 mModelMakerID; // 0x20
u32 mModelType; // 0x24
BOOL mbPrepTVRC; // 0x28
void* mpDatabaseArc; // 0x2C
OSTime mCommandTransitionTime;
OSTime mMuteStartTime;
OSTime mSoundShutupTime;
OSTime mLastCommandTime;
OSTime unk_0x30;
OSTime unk_0x38;
OSTime unk_0x40;
OSTime unk_0x48;
int mCmdMaps[TVRC_COMMAND_MAP_MAX]; // 0x50
u32 mState; // 0x70
OSTick mDisabledTriggerTick;
OSTick unk_0x74;
BOOL mbDisabled; // 0x78
BOOL mbDisabledTriggerPending;
u8 mDisabledTriggerState;
BOOL unk_0x7C;
u8 unk_0x80;
undefined unused_0x81[7];
};
} // namespace ipl

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

@@ -32,8 +32,8 @@ namespace ipl {
void set_arw_param();
int mState; // 0x04
math::VEC2 mPointerPosition;
math::VEC2 mScrollOrigin;
math::VEC2 unk_0x08;
math::VEC2 unk_0x10;
f32 mSpeed; // 0x18
f32 mSoundFreq; // 0x1C
};
@@ -94,9 +94,9 @@ namespace ipl {
f32 mUpLimit; // 0x38
f32 unk_0x3C;
f32 mScroll; // 0x40
f32 mButtonScrollOrigin;
f32 mVelocityDecay;
f32 mScrollAcceleration;
f32 unk_0x44;
f32 unk_0x48;
f32 unk_0x4C;
};
} // namespace utility
} // namespace ipl

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

@@ -130,11 +130,11 @@ typedef struct WWWProtocolData {
typedef struct WWWIMEData {
u32 imeID; // 0x00
const char* text; // 0x04
u32 creationDataA;
u32 creationDataB;
u32 creationDataC;
u32 creationDataD;
u32 creationDataE;
u32 unk_0x08;
u32 unk_0x0C;
u32 unk_0x10;
u32 unk_0x14;
u32 unk_0x18;
u32 maxLength; // 0x1C
} WWWIMEData;
@@ -153,7 +153,7 @@ typedef union {
typedef struct WWWJSPluginValue {
s32 ty;
u8 reserved[4];
u8 unk_0x04[4];
WWWJSPluginValueData data;
} WWWJSPluginValue;
@@ -171,12 +171,12 @@ typedef struct JSCallbackSet {
typedef struct WWWJSCap {
const char** name;
int capabilityWord;
int unk_0x04;
JSGetterSetter getter;
void* capabilityDataA;
void* capabilityDataB;
void* capabilityDataC;
void* capabilityDataD;
void* unk_0x0C;
void* unk_0x10;
void* unk_0x14;
void* unk_0x18;
JSAllowAccess allowAccess;
} WWWJSCap;

View File

@@ -63,7 +63,7 @@ typedef struct {
u8 mcuYRem; // 0x0F
u16 mcuYCount; // 0x10
u16 mcuXCount2; // 0x12
u32 mcuTotal; // 0x14
u32 unk_0x14;
u8 remX; // 0x18
u8 remY; // 0x19
u8 compCount; // 0x1A
@@ -142,7 +142,7 @@ struct TMCCJPEGDecWork_t {
u8 mcuYRem; // 0x17FF
u16 mcuYCount; // 0x1800
u16 mcuXCount2; // 0x1802
u32 mcuTotal; // 0x1804
u32 unk_0x1804;
u8 remX; // 0x1808
u8 remY; // 0x1809
u8 compCount; // 0x180A
@@ -192,7 +192,7 @@ typedef struct {
u8 count; // 0x0C
} TMCHuffParam;
s32 TMCJPEGDEC_make_huffdec(const u8* dht_spec, u8* tbl, TMCHuffParam* hp);
s32 TMCJPEGDEC_make_huffdec(const u8* dht_spec, const u8* tbl, TMCHuffParam* hp);
void TMCJPEGDEC_set_HuffmanTable(TMCHuffParam* tbl, s32 tblType, s32 tblID, TMCUnknownInfo* work);
s32 TMCJPEGDEC_decompmcu(u32 maxMCU, u32 mcuCount, TMCCJPEGDecWork* work, void* buf);

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,32 +96,28 @@ 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;
TMCHuffmanEntry dcLimit;
TMCHuffmanEntry acDecoded;
TMCHuffmanEntry acLimit;
s32 zz;
const u8* zztbl;
u8* huff_sym;
u16* ac_fast;
const TMCHuffmanEntry* ac_fast;
s32 idx;
u32* huff_tbl;
s32 bit_pos;
@@ -134,13 +128,13 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
TMCHuffmanEntry acEntry;
s32 extra;
s32 t;
s32 zz;
s32 q;
u16* dc_fast;
s32* conv_row;
const TMCHuffmanEntry* dc_fast;
const u8* zztbl;
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,12 +188,9 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
*block = dc_predict_row_ptr[0] * blk0;
{
u32* ac_huff_tbl;
u8* ac_huff_sym;
ac_fast = work->pACFast;
ac_huff_tbl = work->pACHuffTbl;
ac_huff_sym = work->pACHuffSym;
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
memset(block + 1, 0, 0xFC);
@@ -213,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;
@@ -224,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, ac_huff_tbl, ac_huff_sym, work, &acLimit, &acDecoded);
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &acLimit, &acDecoded);
if (r < 0) {
return r;
}
@@ -248,17 +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) & (bit_data >> bit_pos);
extra = tmp - 1;
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;
@@ -279,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,47 +3,292 @@
extern void* memcpy(void* dest, const void* src, unsigned long size);
extern void* memset(void* dest, int value, unsigned long size);
s32 TMCJPEGDEC_make_huffdec(const u8* dht, u8* tb, TMCHuffParam* hp) {
typedef struct {
u16 length;
u16 symbol;
} TMCHuffEntry;
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_make_huffdec(register const u8* dht, register const u8* tb, register TMCHuffParam* hp) {
nofralloc
stwu r1, -0x840(r1)
mflr r0
li r6, 1
li r7, 1
stw r0, 0x844(r1)
stmw r20, 0x810(r1)
mr r26, r3
mr r27, r4
addi r4, r1, 0x408
addi r3, r3, 1
lwz r31, 0(r5)
lwz r30, 4(r5)
lwz r29, 8(r5)
lbz r28, 0xc(r5)
li r5, 0
_make_huffdec_count_loop:
lbz r0, 0(r3)
cmpw r7, r0
ble _make_huffdec_count_store
addi r6, r6, 1
li r7, 1
cmpwi r6, 0x10
addi r3, r3, 1
ble _make_huffdec_count_loop
slwi r0, r5, 2
addi r7, r1, 0x408
li r3, 0
stwx r3, r7, r0
b _make_huffdec_count_done
_make_huffdec_count_store:
addi r5, r5, 1
stw r6, 0(r4)
cmpw r5, r28
addi r4, r4, 4
ble _make_huffdec_count_next
li r3, -0x40
b _make_huffdec_return
_make_huffdec_count_next:
addi r7, r7, 1
b _make_huffdec_count_loop
_make_huffdec_count_done:
lwz r0, 0x408(r1)
addi r6, r1, 8
li r9, 0
li r8, 0
clrlwi r10, r0, 24
li r4, 1
b _make_huffdec_values_loop
_make_huffdec_values_inner:
clrlwi r5, r10, 24
slwi r3, r8, 2
b _make_huffdec_values_store_check
_make_huffdec_values_store:
clrlwi r0, r9, 16
addi r7, r7, 4
stwx r0, r6, r3
addi r8, r8, 1
addi r3, r3, 4
addi r9, r9, 1
_make_huffdec_values_store_check:
lwz r0, 0(r7)
clrlwi r0, r0, 24
cmplw r5, r0
beq _make_huffdec_values_store
clrlwi r3, r9, 16
slw r0, r4, r5
cmpw r3, r0
blt _make_huffdec_values_next
li r3, -0x40
b _make_huffdec_return
_make_huffdec_values_next:
clrlslwi r9, r9, 17, 1
addi r10, r10, 1
_make_huffdec_values_loop:
lwz r0, 0(r7)
cmpwi r0, 0
bne _make_huffdec_values_inner
mr r3, r30
li r4, 0
li r5, 0x44
bl memset
addi r4, r1, 0x408
addi r5, r1, 8
li r6, 0
mtctr r28
cmpwi r28, 0
ble _make_huffdec_valptr_done
_make_huffdec_valptr_loop:
lwz r0, 0(r4)
cmplwi r0, 0x10
bgt _make_huffdec_valptr_next
slwi r3, r0, 2
lwz r0, 0(r5)
add r3, r30, r3
sth r6, 2(r3)
sth r0, 0(r3)
_make_huffdec_valptr_next:
addi r4, r4, 4
addi r5, r5, 4
addi r6, r6, 1
bdnz _make_huffdec_valptr_loop
_make_huffdec_valptr_done:
addi r4, r1, 8
addi r12, r26, 1
li r6, 0
li r7, 1
lis r3, 0x8000
_make_huffdec_table_loop:
subfic r0, r7, 8
li r8, 1
slw r5, r8, r0
b _make_huffdec_table_count
_make_huffdec_table_store:
lwz r10, 0(r4)
cmpwi cr1, r5, 0
mr r9, r5
slw r10, r10, r0
ble cr1, _make_huffdec_table_next
cmpwi r5, 8
ble _make_huffdec_table_short
li r21, 0
blt cr1, _make_huffdec_table_short_check
addi r11, r3, 1
cmpw r5, r11
blt _make_huffdec_table_short_check
li r21, 1
_make_huffdec_table_short_check:
cmpwi r21, 0
beq _make_huffdec_table_short
subi r11, r5, 1
slwi r26, r10, 2
srwi r11, r11, 3
mtctr r11
cmpwi r5, 8
ble _make_huffdec_table_short
_make_huffdec_table_unrolled:
sthx r7, r31, r26
add r25, r31, r26
addi r11, r10, 1
addi r22, r10, 2
lbzx r24, r27, r6
slwi r21, r11, 2
addi r11, r10, 3
addi r30, r10, 6
sth r24, 2(r25)
slwi r23, r11, 2
addi r11, r10, 4
add r20, r31, r21
sthx r7, r31, r21
slwi r24, r11, 2
addi r11, r10, 5
slwi r22, r22, 2
lbzx r21, r27, r6
slwi r25, r11, 2
addi r11, r10, 7
slwi r30, r30, 2
sth r21, 2(r20)
add r20, r31, r23
add r21, r31, r24
slwi r11, r11, 2
sthux r7, r22, r31
add r23, r31, r25
add r25, r31, r11
add r24, r31, r30
lbzx r11, r27, r6
addi r10, r10, 8
addi r26, r26, 0x20
subi r9, r9, 8
sth r11, 2(r22)
sth r7, 0(r20)
lbzx r11, r27, r6
sth r11, 2(r20)
sth r7, 0(r21)
lbzx r11, r27, r6
sth r11, 2(r21)
sth r7, 0(r23)
lbzx r11, r27, r6
sth r11, 2(r23)
sthx r7, r31, r30
lbzx r11, r27, r6
sth r11, 2(r24)
sth r7, 0(r25)
lbzx r11, r27, r6
sth r11, 2(r25)
bdnz _make_huffdec_table_unrolled
_make_huffdec_table_short:
slwi r10, r10, 2
add r11, r31, r10
mtctr r9
cmpwi r9, 0
ble _make_huffdec_table_next
_make_huffdec_table_short_loop:
sth r7, 0(r11)
subi r9, r9, 1
lbzx r10, r27, r6
sth r10, 2(r11)
addi r11, r11, 4
bdnz _make_huffdec_table_short_loop
_make_huffdec_table_next:
addi r8, r8, 1
addi r4, r4, 4
addi r6, r6, 1
_make_huffdec_table_count:
lbz r9, 0(r12)
cmpw r8, r9
ble _make_huffdec_table_store
addi r7, r7, 1
addi r12, r12, 1
cmpwi r7, 8
ble _make_huffdec_table_loop
mr r3, r29
mr r4, r27
mr r5, r28
bl memcpy
li r3, 0
_make_huffdec_return:
lmw r20, 0x810(r1)
lwz r0, 0x844(r1)
mtlr r0
addi r1, r1, 0x840
blr
}
#else
s32 TMCJPEGDEC_make_huffdec(const u8* dht, const u8* tb, TMCHuffParam* hp) {
u32 huffCount[256];
u32 huffVal[256];
TMCHuffEntry* huffTable;
TMCHuffEntry* valptr;
u8* symbols;
s32 count;
{
const u8* bits;
u32* sizes;
s32 index;
s32 bitLength;
s32 remaining;
u32* huffTable;
u32* destTable;
u8* valptr;
u32 count;
sizes = huffCount;
bitLength = 1;
remaining = 1;
bits = dht + 1;
huffTable = (TMCHuffEntry*)hp->huffTable;
valptr = (TMCHuffEntry*)hp->valptr;
symbols = (u8*)hp->maxCode;
{
u32* dest = huffCount;
s32 bit_len = 1;
s32 remaining = 1;
const u8* bits = dht + 1;
s32 sym_idx;
huffTable = hp->huffTable;
valptr = hp->valptr;
destTable = hp->maxCode;
count = hp->count;
index = 0;
sym_idx = 0;
for (;;) {
if (remaining > *bits) {
bitLength++;
s32 cnt = *bits;
if (remaining > cnt) {
bit_len++;
remaining = 1;
bits++;
if (bitLength > 16) {
huffCount[index] = 0;
if (bit_len > 16) {
huffCount[sym_idx] = 0;
break;
}
} else {
*sizes++ = bitLength;
index++;
if (index > count) {
*dest = bit_len;
dest++;
sym_idx++;
if (sym_idx > (s32)count) {
return -0x40;
}
remaining++;
@@ -52,73 +297,76 @@ s32 TMCJPEGDEC_make_huffdec(const u8* dht, u8* tb, TMCHuffParam* hp) {
}
{
u32* sizes = huffCount;
s32 index;
u16 code;
u8 size;
s32 sv_idx = 0;
s32 i = 0;
u32 cur = huffCount[0] & 0xFF;
code = 0;
index = 0;
size = huffCount[0];
while (*sizes != 0) {
while (size == (u8)*sizes) {
sizes++;
huffVal[index++] = code;
code++;
while (cur != 0) {
while (i < (s32)count && (huffCount[i] & 0xFF) == cur) {
huffVal[i] = sv_idx & 0xFFFF;
sv_idx++;
i++;
}
if (code >= (1 << size)) {
if (sv_idx > (1 << cur)) {
return -0x40;
}
code <<= 1;
size++;
sv_idx <<= 1;
cur = huffCount[i] & 0xFF;
}
}
memset(valptr, 0, 0x44);
{
s32 index;
for (index = 0; index < count; index++) {
u32 length = huffCount[index];
if (length <= 16) {
valptr[length].symbol = index;
valptr[length].length = huffVal[index];
}
}
}
{
u32* codes;
s32 step;
s32 index;
s32 bitLength;
s32 entry;
s32 left;
s32 base;
codes = huffVal;
index = 0;
for (bitLength = 1; bitLength <= 8; bitLength++) {
s32 shift = 8 - bitLength;
entry = 1;
step = entry << shift;
while (entry <= dht[bitLength]) {
base = *codes << shift;
for (left = step; left > 0; left--) {
huffTable[base].length = bitLength;
huffTable[base].symbol = tb[index];
base++;
}
entry++;
codes++;
index++;
s32 i;
for (i = 0; i < (s32)count; i++) {
u32 bl = huffCount[i];
if (bl <= 16) {
valptr[bl] = (i << 16) | (huffVal[i] & 0xFFFF);
}
}
}
memcpy(symbols, tb, count);
{
const u8* bits_ptr = dht + 1;
u32* hv_ptr = huffVal;
s32 sym = 0;
u32 bl;
u32 cnt;
u32 step;
u32 n;
u32 code;
u32 base;
s32 kk;
for (bl = 1; bl <= 8; bl++) {
cnt = *bits_ptr;
step = 1 << (8 - bl);
for (n = 0; n < cnt; n++) {
code = *hv_ptr;
hv_ptr++;
base = code << (8 - bl);
for (kk = 0; kk < (s32)step; kk++) {
((u16*)huffTable)[(base + kk) * 2] = bl;
((u16*)huffTable)[(base + kk) * 2 + 1] = tb[sym];
}
sym++;
}
bits_ptr++;
}
}
memcpy(destTable, tb, count);
return 0;
}
#endif
void TMCJPEGDEC_set_HuffmanTable(TMCHuffParam* tbl, s32 tblType, s32 tblID, TMCUnknownInfo* info) {
TMCCJPEGDecWork* work = (TMCCJPEGDecWork*)info;

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);
@@ -241,20 +241,14 @@ _error:
return -2;
}
static s32 TMCJPEGDEC_exif_parse(const u8* entries, u32 size, TMCCJPEGDecExifData* pInfo) {
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo) {
u16 byteOrder;
u32 ifdOffset;
const u8* data = entries;
const u8* exifEntries;
u32 exifCount;
u16 exifIndex;
const u8* ifd1Entries;
u32 ifd1Count;
u16 ifd1Index;
const u8* entries;
u16 remaining;
u16 index;
u32 count;
s32 entriesSize;
u16 count;
pInfo->thumbnailData = (u8*)data;
pInfo->dataEnd = (u8*)data + size;
pInfo->nextIfdOffset = 0;
@@ -279,16 +273,17 @@ static s32 TMCJPEGDEC_exif_parse(const u8* entries, u32 size, TMCCJPEGDecExifDat
return -161;
}
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
remaining -= 2;
if (remaining < (s32)count * 12) {
if (remaining < entriesSize) {
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 -= (s32)count * 12;
remaining -= entriesSize;
if (remaining < 4) {
return -161;
}
@@ -301,20 +296,21 @@ static s32 TMCJPEGDEC_exif_parse(const u8* entries, u32 size, TMCCJPEGDecExifDat
return -161;
}
{
ifd1Entries = data + ifdOffset;
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
ifd1Count = readExifU16(ifd1Entries, byteOrder);
ifd1Entries += 2;
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
remaining -= 2;
if (remaining < (s32)ifd1Count * 12) {
if (remaining < entriesSize) {
return -161;
}
for (ifd1Index = 0; ifd1Index < ifd1Count; ifd1Index++) {
TMCJPEGDEC_IFD1_tag_parse(pInfo, byteOrder, ifd1Entries);
ifd1Entries += 12;
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD1_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
}
ifdOffset = pInfo->nextIfdOffset;
@@ -322,31 +318,32 @@ static s32 TMCJPEGDEC_exif_parse(const u8* entries, u32 size, TMCCJPEGDecExifDat
return -161;
}
{
exifEntries = data + ifdOffset;
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
exifCount = readExifU16(exifEntries, byteOrder);
exifEntries += 2;
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
remaining -= 2;
if (remaining < (s32)exifCount * 12) {
if (remaining < entriesSize) {
return -161;
}
for (exifIndex = 0; exifIndex < exifCount; exifIndex++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)exifEntries);
exifEntries += 12;
for (index = 0; index < count; index++) {
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:
@@ -369,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;
}
@@ -389,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;
}
@@ -504,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;
}
@@ -523,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;
}
@@ -545,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

@@ -51,7 +51,7 @@ s32 TMCJPEGDEC_Setsize(TMCCJPEGDecWork* work) {
}
state->componentCount = work->componentCount;
state->result = work->mcuTotal;
state->result = work->unk_0x1804;
state->maxX = work->mcuYCount;
state->maxY = work->mcuXCount2;

File diff suppressed because it is too large Load Diff

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;
@@ -260,38 +260,15 @@ static void TMCJPEGDEC_converterYUV411toRGB565(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV411toRGB565edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
u16* output;
s32 tileRow;
s32 columnInTile;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 red;
s32 green;
s32 blue;
s32 height;
u8* luminance = work->convBuf + 4;
s8* cb = (s8*)&work->convBuf[260];
s8* cr = (s8*)&work->convBuf[324];
TMCCJPEGDecState* state = work->pState;
u32 tileWidth = state->convWidth >> 2;
u8* texture = state->pTexBuffer;
s32 width;
TMCCJPEGDecState* state;
s32 cbValue;
s8 crValue;
s32 value;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = state->convWidth >> 2;
texture = state->pTexBuffer;
s32 height;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
@@ -302,67 +279,69 @@ static void TMCJPEGDEC_converterYUV411toRGB565edge(TMCCJPEGDecWork* work, s32 x,
} else {
height = 8 / state->scaleFactor;
}
xEnd = x + width;
yEnd = y + height;
lumaSkip = 32 - width;
chromaSkip = lumaSkip >> 2;
ASSERTLINE((x & 3) == 0, __LINE__);
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
for (column = x; column < xEnd; column += 1) {
columnInTile = column & 3;
if (columnInTile == 0) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
{
s32 xEnd = x + width;
s32 yEnd = y + height;
s32 lumaSkip = 32 - width;
s32 chromaSkip = lumaSkip >> 2;
s32 redOffset, greenOffset, blueOffset;
ASSERTLINE((x & 3) == 0, __LINE__);
for (; y < yEnd; y++) {
s32 tileRow = (y >> 2) * tileWidth;
u16* output = (u16*)(texture + ((y & 3) << 3));
for (column = x; column < xEnd; column += 1) {
if ((column & 3) == 0) {
s32 cbValue = *cb++;
s32 crValue = *cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
s32 value = *luminance++;
s32 green = value + greenOffset;
s32 red = value + redOffset;
s32 blue = value + 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);
}
}
value = *luminance++;
red = value + redOffset;
blue = value + blueOffset;
green = value + greenOffset;
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[columnInTile + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
luminance += lumaSkip;
cb += chromaSkip;
cr += chromaSkip;
}
luminance += lumaSkip;
cb += chromaSkip;
cr += chromaSkip;
}
}
static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
u16* output;
s32 tileRow;
s32 redOffset;
s32 secondGreen;
s32 width;
s32 blue;
s32 lumaSkip;
s32 red;
s32 secondRed;
s32 tileRow;
u16* output;
u32 tileWidth;
u8* texture;
TMCCJPEGDecState* state;
s32 crValue;
u8* luminance;
u8* cb;
u8* cr;
s32 height;
s32 column;
s32 cbValue;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 green;
s32 blue;
s32 value;
TMCCJPEGDecState* state;
s32 width;
s32 height;
s32 crValue;
s32 cbValue;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
@@ -385,26 +364,30 @@ static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
value = *luminance++;
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
blue = *luminance++;
green = blue + greenOffset;
red = blue + redOffset;
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));
value = *luminance++;
secondGreen = value + greenOffset;
secondRed = value + redOffset;
blue = value + blueOffset;
if ((secondRed | secondGreen | blue) >> 8) {
blue = *luminance++;
green = blue + greenOffset;
red = blue + redOffset;
blue = blue + blueOffset;
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
secondGreen = secondGreen > 255 ? 255 : secondGreen < 0 ? 0 : secondGreen;
secondRed = secondRed > 255 ? 255 : secondRed < 0 ? 0 : secondRed;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
output[((column + 1) & 3) + ((((column + 1) >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((secondRed & 0xF8) << 8) + ((secondGreen & 0xFC) << 3));
output[((column + 1) & 3) + ((((column + 1) >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
}
luminance += lumaSkip;
cb += chromaSkip;
@@ -488,107 +471,118 @@ static void TMCJPEGDEC_converterYUV422toRGB565edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV420toRGB565(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
s32 chromaWidth;
u16* output;
s32 tileRow;
s32 redOffset;
s32 secondGreen;
s32 red;
s32 secondRed;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 greenOffset;
s32 blueOffset;
s32 green;
s32 blue;
s32 value;
TMCCJPEGDecState* state;
s32 width;
s32 redOffset;
s32 green;
u32 tileWidth;
u8* texture;
s32 chromaSkip;
s32 height;
s32 yEnd;
u8* luminance;
s32 crValue;
s32 value;
u8* cb;
s32 xEnd;
s32 column;
u8* cr;
s32 greenOffset;
s32 tileRow;
s32 cbValue;
s32 lumaSkip;
s32 blueOffset;
s32 red;
TMCCJPEGDecState* state;
s32 blue;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
cb = work->convBuf + 260;
cr = work->convBuf + 324;
state = work->pState;
tileWidth = state->convWidth >> 2;
texture = state->pTexBuffer;
width = 16 / state->scaleFactor;
height = 16 / state->scaleFactor;
xEnd = x + width;
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
chromaWidth = (width + 1) >> 1;
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
for (column = x; column < xEnd; column += 2) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
value = *luminance++;
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
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;
{
xEnd = x + width;
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
for (; y < yEnd; y++) {
tileRow = (y >> 2) * tileWidth;
output = (u16*)(texture + ((y & 3) << 3));
for (column = x; column < xEnd; column += 2) {
{
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
value = *luminance++;
red = value + redOffset;
green = value + greenOffset;
blue = value + 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);
}
{
value = *luminance++;
red = value + redOffset;
green = value + greenOffset;
blue = value + 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 + 1 & 3) + ((((column + 1) >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
value = *luminance++;
secondGreen = value + greenOffset;
secondRed = value + redOffset;
blue = value + blueOffset;
if ((secondRed | secondGreen | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
secondGreen = secondGreen > 255 ? 255 : secondGreen < 0 ? 0 : secondGreen;
secondRed = secondRed > 255 ? 255 : secondRed < 0 ? 0 : secondRed;
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= (width + 1) >> 1;
cr -= (width + 1) >> 1;
}
output[((column + 1) & 3) + ((((column + 1) >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((secondRed & 0xF8) << 8) + ((secondGreen & 0xFC) << 3));
}
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= chromaWidth;
cr -= chromaWidth;
}
}
}
static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
s32 chromaWidth;
u16* output;
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;
u32 tileWidth;
s32 green;
s32 lumaSkip;
s32 chromaSkip;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
@@ -613,7 +607,6 @@ static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x,
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
chromaWidth = (width + 1) >> 1;
ASSERTLINE((x & 1) == 0, __LINE__);
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
@@ -626,26 +619,24 @@ 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 green = value + greenOffset;
s32 blue = value + blueOffset;
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));
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) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= chromaWidth;
cr -= chromaWidth;
cb -= (width + 1) >> 1;
cr -= (width + 1) >> 1;
}
}
}
@@ -825,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;
@@ -849,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,31 +285,29 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 red;
s32 chromaSkip;
u16* output;
s32 tileRow;
s32 columnInTile;
s32 xEnd;
u8* texture;
TMCCJPEGDecState* state;
u8* luminance;
u8* cb;
s32 width;
s32 height;
u8* cr;
s32 column;
s32 xEnd;
s32 lumaSkip;
s32 yEnd;
s32 tileWidth;
u16* output;
s32 cbValue;
s8 crValue;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 green;
s32 blue;
s32 value;
s32 width;
s32 height;
TMCCJPEGDecState* state;
s32 cbValue;
s8 crValue;
s32 red;
s32 green;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
@@ -333,28 +331,32 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
chromaSkip = lumaSkip >> 2;
ASSERTLINE((x & 3) == 0, __LINE__);
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
output = (u16*)(texture + ((y & 3) << 3));
for (column = x; column < xEnd; column += 1) {
columnInTile = column & 3;
if (columnInTile == 0) {
if ((column & 3) == 0) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
value = *luminance++;
red = value + redOffset;
green = value + greenOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
blue = *luminance++;
red = blue + redOffset;
green = blue + greenOffset;
blue = blue + blueOffset;
if ((green | red | 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[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
{
red = (u8)red + 0x10000 - 0x100;
green = (green & 255) << 8;
blue = blue & 255;
output[(column & 3) + ((((column >> 2) << 1) + tileRow) << 4)] = red;
output[(column & 3) + ((((column >> 2) << 1) + tileRow + 1) << 4)] = green + blue;
}
}
luminance += lumaSkip;
cb += chromaSkip;
@@ -363,35 +365,30 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
s32 lumaSkip;
s32 cbValue;
s32 tileWidth;
TMCCJPEGDecState* state;
u16* output;
s32 tileRow;
s32 red;
s32 secondBlue;
s32 columnInTile;
u8* texture;
s32 width;
s32 height;
u8* luminance;
u8* cb;
s32 red;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
s32 tileRow;
s32 greenOffset;
s32 blueOffset;
s32 value;
s32 green;
s32 blue;
s32 secondGreen;
s32 secondRed;
s32 secondColumnInTile;
s32 value;
TMCCJPEGDecState* state;
s32 width;
s32 height;
s8 crValue;
s32 cbValue;
s32 crValue;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
@@ -423,21 +420,19 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
output[(column & 3) + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[(column & 3) + ((((column >> 2) << 1) + tileRow + 1) << 4)] = ((green & 255) << 8) + (blue & 255);
value = *luminance++;
secondGreen = value + greenOffset;
secondRed = value + redOffset;
secondBlue = value + blueOffset;
if ((secondRed | secondGreen | secondBlue) >> 8) {
secondBlue = secondBlue > 255 ? 255 : secondBlue < 0 ? 0 : secondBlue;
secondGreen = secondGreen > 255 ? 255 : secondGreen < 0 ? 0 : secondGreen;
secondRed = secondRed > 255 ? 255 : secondRed < 0 ? 0 : secondRed;
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
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;
}
secondColumnInTile = (column + 1) & 3;
output[secondColumnInTile + (((((column + 1) >> 2) << 1) + tileRow) << 4)] = (u8)secondRed + 0x10000 - 0x100;
output[secondColumnInTile + (((((column + 1) >> 2) << 1) + (tileRow + 1)) << 4)] = ((secondGreen & 255) << 8) + (secondBlue & 255);
output[((column + 1) & 3) + (((((column + 1) >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[((column + 1) & 3) + (((((column + 1) >> 2) << 1) + tileRow + 1) << 4)] = ((green & 255) << 8) + (blue & 255);
}
luminance += lumaSkip;
cb += chromaSkip;
@@ -446,31 +441,30 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
s32 blue;
u16* output;
s32 tileRow;
s32 columnInTile;
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;
s8 crValue;
s32 crValue;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 value;
s32 red;
s32 lumaSkip;
s32 green;
s32 blue;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
@@ -513,9 +507,8 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
output[(column & 3) + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[(column & 3) + ((((column >> 2) << 1) + tileRow + 1) << 4)] = ((green & 255) << 8) + (blue & 255);
}
luminance += lumaSkip;
cb += chromaSkip;
@@ -524,35 +517,29 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 red;
s32 secondBlue;
s32 chromaSkip;
s32 chromaWidth;
u16* output;
s32 tileRow;
s32 columnInTile;
u8* texture;
s8 crValue;
s32 chromaSkip;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 green;
s32 blue;
s32 secondGreen;
s32 secondRed;
s32 secondColumnInTile;
s32 value;
TMCCJPEGDecState* state;
u8* texture;
s32 width;
s32 height;
s8 crValue;
s32 green;
s32 blue;
s32 lumaSkip;
s32 yEnd;
s32 xEnd;
s32 value;
s32 column;
u8* cr;
s32 greenOffset;
s32 tileWidth;
s32 redOffset;
u8* cb;
u16* output;
s32 blueOffset;
s32 red;
s32 cbValue;
luminance = work->convBuf + 4;
@@ -561,92 +548,84 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
state = work->pState;
tileWidth = (state->convWidth >> 2) << 1;
texture = state->pTexBuffer;
width = 16 / state->scaleFactor;
height = 16 / state->scaleFactor;
xEnd = x + width;
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
chromaWidth = (width + 1) >> 1;
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
for (column = x; column < xEnd; column += 2) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
value = *luminance++;
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
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;
{
yEnd = y + height;
xEnd = x + width;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
for (column = x; column < xEnd; column += 2) {
{
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
}
{
value = *luminance++;
redOffset = (crValue * 359) >> 8;
red = value + redOffset;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
green = value + greenOffset;
blueOffset = (cbValue * 454) >> 8;
blue = value + blueOffset;
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) << 1) + tileRow) << 4)] =
(u8)red + 0x10000 - 0x100;
output[(column & 3) + (((((column) >> 2) << 1) + tileRow + 1) << 4)] =
((green & 255) << 8) + (blue & 255);
}
{
value = *luminance++;
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
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 + 1 & 3) + (((((column + 1) >> 2) << 1) + tileRow) << 4)] =
(u8)red + 0x10000 - 0x100;
output[(column + 1 & 3) + (((((column + 1) >> 2) << 1) + tileRow + 1) << 4)] =
((green & 255) << 8) + (blue & 255);
}
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
value = *luminance++;
secondGreen = value + greenOffset;
secondRed = value + redOffset;
secondBlue = value + blueOffset;
if ((secondRed | secondGreen | secondBlue) >> 8) {
secondBlue = secondBlue > 255 ? 255 : secondBlue < 0 ? 0 : secondBlue;
secondGreen = secondGreen > 255 ? 255 : secondGreen < 0 ? 0 : secondGreen;
secondRed = secondRed > 255 ? 255 : secondRed < 0 ? 0 : secondRed;
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= (width + 1) >> 1;
cr -= (width + 1) >> 1;
}
secondColumnInTile = (column + 1) & 3;
output[secondColumnInTile + (((((column + 1) >> 2) << 1) + tileRow) << 4)] = (u8)secondRed + 0x10000 - 0x100;
output[secondColumnInTile + (((((column + 1) >> 2) << 1) + (tileRow + 1)) << 4)] = ((secondGreen & 255) << 8) + (secondBlue & 255);
}
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= chromaWidth;
cr -= chromaWidth;
}
}
}
static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 red;
s32 chromaSkip;
s32 chromaWidth;
u16* output;
s32 tileRow;
s32 columnInTile;
TMCCJPEGDecState* state;
u8* texture;
u8* luminance;
u8* luminance = work->convBuf + 4;
u8* cb = work->convBuf + 260;
s32 width;
TMCCJPEGDecState* state = work->pState;
s32 tileWidth = (state->convWidth >> 2) << 1;
u8* texture = state->pTexBuffer;
u8* cr = work->convBuf + 324;
s32 height;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 cbValue;
s8 crValue;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 value;
s32 green;
s32 blue;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = (state->convWidth >> 2) << 1;
texture = state->pTexBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
@@ -657,72 +636,78 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
} else {
height = 16 / state->scaleFactor;
}
xEnd = x + width;
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
chromaWidth = (width + 1) >> 1;
ASSERTLINE((x & 1) == 0, __LINE__);
{
s32 yEnd = y + height;
s32 xEnd = x + width;
s32 lumaSkip = 16 - width;
s32 chromaSkip = lumaSkip >> 1;
s32 redOffset, greenOffset, blueOffset;
ASSERTLINE((x & 1) == 0, __LINE__);
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
for (column = x; column < xEnd; column += 1) {
if ((column & 1) == 0) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
u16* output = (u16*)(texture + ((y & 3) << 3));
s32 tileRow = (y >> 2) * tileWidth;
s32 column;
for (column = x; column < xEnd; column += 1) {
if ((column & 1) == 0) {
s32 cbValue = (s8)*cb++;
s32 crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
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;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
output[(column & 3) + (((((column) >> 2) << 1) + tileRow) << 4)] =
(u8)red + 0x10000 - 0x100;
output[(column & 3) + (((((column) >> 2) << 1) + tileRow + 1) << 4)] =
((green & 255) << 8) + (blue & 255);
}
}
value = *luminance++;
red = value + redOffset;
blue = value + blueOffset;
green = value + greenOffset;
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;
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= (width + 1) >> 1;
cr -= (width + 1) >> 1;
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
}
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= chromaWidth;
cr -= chromaWidth;
}
}
}
static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
u16* output;
s32 tileRow;
s32 columnInTile;
s32 redOffset;
TMCCJPEGDecState* state;
s32 lumaSkip;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
s32 height;
s32 column;
s32 chromaSkip;
s32 width;
s32 xEnd;
s32 yEnd;
s32 cbValue;
s32 tileWidth;
s32 blueOffset;
s32 red;
s32 crValue;
s32 value;
s32 green;
s32 blue;
s32 redOffset;
TMCCJPEGDecState* state;
s32 height;
s32 chromaSkip;
s32 cbValue;
s32 blueOffset;
s8 crValue;
s32 value;
s32 greenOffset;
luminance = work->convBuf + 4;
@@ -740,8 +725,8 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
lumaSkip = 8 - width;
chromaSkip = lumaSkip >> 0;
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
output = (u16*)(texture + ((y & 3) << 3));
for (column = x; column < xEnd; column += 1) {
@@ -762,9 +747,10 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
output[(column & 3) + (((((column) >> 2) << 1) + tileRow) << 4)] =
(u8)red + 0x10000 - 0x100;
output[(column & 3) + (((((column) >> 2) << 1) + tileRow + 1) << 4)] =
((green & 255) << 8) + (blue & 255);
}
}
@@ -781,31 +767,30 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
u16* output;
s32 tileRow;
s32 columnInTile;
s32 lumaSkip;
s32 blue;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 height;
s32 width;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 red;
s32 green;
s32 blue;
s32 height;
TMCCJPEGDecState* state;
s32 chromaSkip;
s32 greenOffset;
s32 yEnd;
s32 cbValue;
s32 tileRow;
s32 blueOffset;
s32 red;
s8 crValue;
s32 value;
u8 value;
s32 green;
s32 redOffset;
s32 tileWidth;
luminance = work->convBuf + 4;
cb = work->convBuf + 132;
@@ -830,8 +815,8 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
lumaSkip = 8 - width;
chromaSkip = lumaSkip >> 0;
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
output = (u16*)(texture + ((y & 3) << 3));
for (column = x; column < xEnd; column += 1) {
{
@@ -851,9 +836,10 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
output[(column & 3) + (((((column) >> 2) << 1) + tileRow) << 4)] =
(u8)red + 0x10000 - 0x100;
output[(column & 3) + (((((column) >> 2) << 1) + tileRow + 1) << 4)] =
((green & 255) << 8) + (blue & 255);
}
}
luminance += lumaSkip;
@@ -869,16 +855,15 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 rowSkip;
u16* output;
s32 tileRow;
s32 columnInTile;
s32 rowSkip;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
TMCCJPEGDecState* state;
s8 crValue;
s32 crValue;
s32 height;
s32 width;
s32 column;
@@ -904,8 +889,9 @@ static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
yEnd = y + height;
rowSkip = 8 - width;
for (row = y; row < yEnd; row++) {
output = (u16*)(texture + ((row & 3) << 3));
tileRow = (row >> 2) * tileWidth;
output = (u16*)(texture + ((row & 3) << 3));
for (column = x; column < xEnd; column++) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
@@ -918,10 +904,9 @@ static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] =
output[(column & 3) + ((((column >> 2) << 1) + tileRow) << 4)] =
(u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] =
output[(column & 3) + ((((column >> 2) << 1) + tileRow + 1) << 4)] =
((green & 255) << 8) + (blue & 255);
}
luminance += rowSkip;
@@ -932,26 +917,25 @@ static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
static void TMCJPEGDEC_converterYUV444toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 rowSkip;
u16* output;
s32 tileRow;
s32 columnInTile;
u8* texture;
u16* output;
s32 green;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 red;
s32 green;
s32 blue;
s32 width;
s32 yEnd;
s32 red;
s32 height;
s32 tileWidth;
s32 cbValue;
s8 crValue;
s32 crValue;
s32 value;
TMCCJPEGDecState* state;
u8* texture;
s32 blue;
luminance = work->convBuf + 4;
cb = work->convBuf + 68;
@@ -982,14 +966,15 @@ static void TMCJPEGDEC_converterYUV444toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
green = value + (-(cbValue * 88 + crValue * 183) >> 8);
red = value + ((crValue * 359) >> 8);
blue = value + ((cbValue * 454) >> 8);
if ((red | green | blue) >> 8) {
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;
}
columnInTile = column & 3;
output[columnInTile + ((((column >> 2) << 1) + tileRow) << 4)] = (u8)red + 0x10000 - 0x100;
output[columnInTile + ((((column >> 2) << 1) + (tileRow + 1)) << 4)] = ((green & 255) << 8) + (blue & 255);
output[(column & 3) + ((((column >> 2) << 1) + tileRow) << 4)] =
(u8)red + 0x10000 - 0x100;
output[(column & 3) + ((((column >> 2) << 1) + tileRow + 1) << 4)] =
(blue & 255) + ((green & 255) << 8);
}
luminance += rowSkip;
cb += rowSkip;

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 reserved; // 0x28
ziU8 letters; // 0x21
ziU8 count; // 0x22
ziU8* scratch; // 0x24
ziU32 unk_0x28; // 0x28
} ziGetParam;
typedef struct _ziLanguageEntry {
@@ -180,7 +180,7 @@ typedef struct _zi8DawgRec {
ziU8* node;
ziU32 attr;
ziU16 key;
ziU8 reserved[2];
ziU8 unk_0x0A[2];
ziU8* back;
} zi8DawgRec;
@@ -189,13 +189,13 @@ typedef struct _zi8DawgCtx {
ziU8 key; // 0x01
ziU16 cnt; // 0x02
ziU16 cap; // 0x04
ziU8 reserved[2];
ziU8* characters; // 0x08
ziU8* characterFlags; // 0x0C
ziU8 unk_0x06[2];
ziU8* p08; // 0x08
ziU8* p0C; // 0x0C
ziU8* table; // 0x10
ziU8* keyCodes; // 0x14
ziU8* p14; // 0x14
zi8DawgRec recs[0x32]; // 0x18
ziU32 endNode; // 0x338
ziU32 unk_0x338; // 0x338
} zi8DawgCtx;
typedef struct _ziUwdNode {
@@ -204,154 +204,154 @@ typedef struct _ziUwdNode {
} ziUwdNode;
struct __zi8_work_data_s {
ziU8 getcPhase; // 0x00
ziU8 unk_0x00;
ziU8 countOnly; // 0x01
ziU8 reservedAlignment[2];
ziU8 unk_0x02[2];
ziLanguageEntry* langEntries; // 0x04
ziU8 initializationState;
ziU8 dictionaryFlags;
ziU8 maxWordLength;
ziU8 reservedSettings;
ziU32 targetCount; // 0x0C
ziU32 maxCandidateCount;
ziU16 errorCode;
ziU8 unk_0x08;
ziU8 unk_0x09;
ziU8 unk_0x0A;
ziU8 unk_0x0B;
ziU32 unk_0x0C;
ziU32 unk_0x10;
ziU16 unk_0x14;
ziU8 cangjieEnabled; // 0x16
ziU8 zhPudMinPrefix;
ziU8 unk_0x17;
ziU8 subLanguage; // 0x18
ziU8 reservedSubLanguage;
ziU8 unk_0x19;
ziU16 separator; // 0x1A
ziU8 searchModes[3];
ziU8 ignoreCase;
ziU16 duplicateCharacters[0x40];
ziU16 duplicateOrdinalCache[0x42];
ziU16* zhUwdPointers[1];
ziU8* reservedUwdPointer;
ziU8 uwdPtrCount; // 0x12C
ziU8 zhPudCount;
ziU8 uwdPrioritySort; // 0x12E
ziU8 reservedUwdState;
ziPtr uwdDicts[2]; // 0x130
ziU8 uwdDictCount; // 0x138
ziU8 reservedUwdAlignment[3];
ziU32 uwdSkipCount;
ziU8 uwdContextEnabled;
ziU8 uwdContextRecord[0x43];
ziU8 uwdContextAlternateCase[0x43];
ziU8 unk_0x1C[3];
ziU8 unk_0x1F;
ziU16 unk_0x20[0x40];
ziU16 unk_0xA0[0x42];
ziU16* unk_0x124[1];
ziU8* unk_0x128;
ziU8 unk_0x12C;
ziU8 unk_0x12D;
ziU8 unk_0x12E;
ziU8 unk_0x12F;
ziPtr unk_0x130[2];
ziU8 unk_0x138;
ziU8 unk_0x139[3];
ziU32 unk_0x13C;
ziU8 unk_0x140;
ziU8 unk_0x141[0x43];
ziU8 unk_0x184[0x43];
ziU8 uwdCount; // 0x1C7
ziUwdNode uwdNodes[0x20]; // 0x1C8
ziUwdNode* uwdList; // 0x2C8
ziU32 pudTable[0x10]; // 0x2CC
ziU8 pudCount; // 0x30C
ziU8 reservedPudAlignment[3];
ziU32 pudWordAddress;
ziU32 pudWordCount;
ziU32 pudWordIndex;
ziU8 unk_0x30D[3];
ziU32 unk_0x310;
ziU32 unk_0x314;
ziU32 unk_0x318;
ziU8 pdRemoveOpt; // 0x31C
ziU8 reservedPudState;
ziU8 pudStopAtSpace;
ziU8 reservedOemAlignment;
ziU8 unk_0x31D;
ziU8 unk_0x31E;
ziU8 unk_0x31F;
ziU8 (*oemMatch)(ziU16 idx, ziWChar* buf, ziU8 len, ziPtr data); //0x320
ziU16 oemLen; //0x324
ziU8 reservedOemLengthAlignment[2];
ziU8 unk_0x326[2];
ziU32 oemIdx; //0x328
ziPtr oemData; //0x32C
ziU8 reservedOemState[8];
ziU32 candidateBufferHead;
ziU8 candidateBufferTail[0x1FC];
ziU8 unk_0x330[8];
ziU32 unk_0x338;
ziU8 unk_0x33C[0x1FC];
ziU8 language; // 0x538
ziU8 duplicateCount;
ziU8 duplicateWordOrder[0x40];
ziWChar duplicateBuffer[0x641];
ziPtr customKeyMap;
ziU8 unk_0x539;
ziU8 unk_0x53A[0x40];
ziWChar unk_0x57A[0x641];
ziPtr unk_0x11FC;
ziPtr userKeys[0x83]; // 0x1200
ziU8 wordLengthSettings[4];
ziU32 formats; // 0x1410
ziU8 dictionaryCountStorage[4];
ziU8 formatCount;
ziU8 reservedFormatAlignment;
ziU16 capacity; // 0x141A
ziU8 forceAltGraph; // 0x141C (lang FI + group 0xC -> graphTableId 0x10)
ziU8 advanceGroup; // 0x141D (nonzero: skip first dawg group)
ziU8 graphTableId; // 0x141E
ziU8 maxCnt; // 0x141F
ziU8 reservedDawgAlignment[4];
ziU8 unk_0x140C[4];
ziU32 unk_0x1410;
ziU8 unk_0x1414[4];
ziU8 unk_0x1418;
ziU8 unk_0x1419;
ziU16 unk_0x141A;
ziU8 unk_0x141C;
ziU8 unk_0x141D;
ziU8 unk_0x141E;
ziU8 unk_0x141F;
ziU8 unk_0x1420[4];
zi8DawgCtx dawgCtx; // 0x1424
ziU8 dawgSearchState[4]; // 0x1760
ziU8* groupPtr; // 0x1764
ziU8 dawgGroupIndex;
ziU8 reservedDawgStorage[0x81];
ziU16 matchOffset; // 0x17EA
ziU8 dawgFallbackUsed;
ziU8 reservedDawgGroupAlignment[3];
ziU8 unk_0x1760[4]; // 0x1760
ziU8* unk_0x1764; // 0x1764
ziU8 unk_0x1768;
ziU8 unk_0x1769[0x81];
ziU16 unk_0x17EA;
ziU8 unk_0x17EC;
ziU8 unk_0x17ED[3];
ziU8* dawgGroup; // 0x17F0
ziWChar dawgWord[0x40]; // 0x17F4..0x1874
ziU16 letterHyphen;
ziU8 prefixLength;
ziU8 prefixEnabled;
ziU8 requiredLength;
ziU8 highlightedLanguage;
ziWChar highlightedWord[0x41];
ziU8 suffixMode;
ziU8 suffixState;
ziWChar prefix[0x41];
ziU8 prefixCount;
ziU8 previousPrefixCount;
ziU8 prefixElementCount;
ziU8 wordLanguage;
ziU8 suffixLocked;
ziU8 previousSuffixCount;
ziU8 suffixElementCount;
ziU8 suffixStatus;
ziWChar suffix[0x41];
ziU8 suffixCount;
ziU8 alternatePrefixState[0x85];
ziWChar singleCharacter;
ziWChar rememberedWord[0x41];
ziU8 rememberedCount;
ziU8 wordSearchState[3];
ziU16* unicodeMap; // 0x1B18
ziU16 unicodeRange1Min; // 0x1B1C
ziU16 unicodeRange1Max; // 0x1B1E
ziU16 unicodeRange2Min; // 0x1B20
ziU16 unicodeRange2Max; // 0x1B22
ziU8 unicodeMapSubLang; // 0x1B24
ziU8 reservedUnicodeAlignment[3];
ziWChar unk_0x17F4[0x40]; // 0x17F4..0x1874
ziU16 unk_0x1874;
ziU8 unk_0x1876;
ziU8 unk_0x1877;
ziU8 unk_0x1878;
ziU8 unk_0x1879;
ziWChar unk_0x187A[0x41];
ziU8 unk_0x18FC;
ziU8 unk_0x18FD;
ziWChar unk_0x18FE[0x41];
ziU8 unk_0x1980;
ziU8 unk_0x1981;
ziU8 unk_0x1982;
ziU8 unk_0x1983;
ziU8 unk_0x1984;
ziU8 unk_0x1985;
ziU8 unk_0x1986;
ziU8 unk_0x1987;
ziWChar unk_0x1988[0x41];
ziU8 unk_0x1A0A;
ziU8 unk_0x1A0B[0x85];
ziWChar unk_0x1A90;
ziWChar unk_0x1A92[0x41];
ziU8 unk_0x1B14;
ziU8 unk_0x1B15[3];
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;
} zyFuzzy;
ziU8 koAltTables; // 0x1B30
ziU8 reservedKoreanAlignment;
ziU16 candidateStateWordA;
ziU16 candidateStateWordB;
ziU16 candidateStateWordC;
ziU16 initializationWordA;
ziU8 candidateStateByteA;
ziU8 candidateStateByteB;
ziU8 candidateStateByteC;
ziU8 candidateStateByteD;
ziU8 reservedCandidateStateA;
ziU8 reservedCandidateStateB;
ziU16 initializationWordB;
ziU8 reservedTail[2];
} unk_0x1B2C;
ziU8 unk_0x1B30;
ziU8 unk_0x1B31;
ziU16 unk_0x1B32;
ziU16 unk_0x1B34;
ziU16 unk_0x1B36;
ziU16 unk_0x1B38;
ziU8 unk_0x1B3A;
ziU8 unk_0x1B3B;
ziU8 unk_0x1B3C;
ziU8 unk_0x1B3D;
ziU8 unk_0x1B3E;
ziU8 unk_0x1B3F;
ziU16 unk_0x1B40;
ziU8 unk_0x1B42[2];
};
typedef struct ziMatchParam {
ziU8 count; // 0x00
ziU8 recordMasks[0xC]; // 0x01
ziU8 recordValues[0xC]; // 0x0D
ziU8 prefixMasks[4]; // 0x19
ziU8 prefixValues[4]; // 0x1D
ziU8 arr1[0xC]; // 0x01
ziU8 arrD[0xC]; // 0x0D
ziU8 arr19[4]; // 0x19
ziU8 arr1D[4]; // 0x1D
ziU8 pad_0x21; // 0x21
ziU16 componentIndex; // 0x22
ziU16 field22; // 0x22
ziU8 length; // 0x24
ziU8 nCand; // 0x25
ziWChar phon[0x10]; // 0x26
@@ -360,8 +360,8 @@ typedef struct ziMatchParam {
ziWChar first2; // 0x68
ziWChar comp; // 0x6A
ziU8 nSeg; // 0x6C
ziU8 segmentMasks[16][12]; // 0x6D
ziU8 segmentValues[16][12]; // 0x12D
ziU8 segs1[16][12]; // 0x6D
ziU8 segsD[16][12]; // 0x12D
ziU8 pad_0x1ED; // 0x1ED
} ziMatchParam;

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

@@ -7,7 +7,7 @@ typedef unsigned int Zi8UInt;
typedef struct {
ziU8 keys[4];
ziU8 recordData[4];
ziU8 unknown_04[4];
ziU8 phoneticIndexLow;
ziU8 flags;
ziU16 phraseOffset;
@@ -15,30 +15,52 @@ 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;
ziU8 dictionaryOptions[10];
ziU8 unknown_02[10];
ziS32 maxCount;
ziU16 candidateBufferSize;
} Zi8OneKeyOptions;
typedef struct {
ziU8 engineSettings[0x16];
ziU8 unknown_00[0x16];
ziU8 phraseEnabled;
ziU8 inputSettings[6];
ziU8 unknown_17[6];
ziU8 spellingSearch;
ziU8 caseMode;
ziU8 unknown_1e;
ziU8 searchFlags;
ziU8 candidateWorkspace[0xfda];
ziU8 unknown_20[0xfda];
ziU8 phoneticEnabled[512];
ziU8 phoneticFilter;
ziU8 keyTableStorage[0x211];
ziU8 unknown_11fb[0x211];
ziU8 maxWordLength;
ziU8* searchOrder;
ziU8 dictionaryCountStorage[4];
ziU8 unknown_1414[4];
ziU8 searchOrderCount;
ziU8 wordSearchWorkspace[0x6fd];
ziU8 unknown_1419[0x6fd];
ziU8 spellingOnly;
} Zi8OneKeyWork;
@@ -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

@@ -1,16 +1,16 @@
#include <zi8clib/zierror.h>
#include <zi8clib/zitypes.h>
ziU32 Zi8GetZHuwdPtr(ziU32* entriesAddress, ziU16* entryCount ZI_NEED_WORK) {
if (ZI_WORK->uwdPtrCount == 0) {
*entriesAddress = 0;
*entryCount = 0;
ziU32 Zi8GetZHuwdPtr(ziU32* arg0, ziU16* arg1 ZI_NEED_WORK) {
if (ZI_WORK->unk_0x12C == 0) {
*arg0 = 0;
*arg1 = 0;
Zi8LogError(0x1A5, ZI_WORK);
return 0;
} else {
*entryCount = ZI_WORK->zhUwdPointers[ZI_WORK->uwdPtrCount - 1][1] / 3;
*entriesAddress = (ziU32)ZI_WORK->zhUwdPointers[ZI_WORK->uwdPtrCount - 1];
*entriesAddress += 8;
*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,19 +160,19 @@ 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);
extern ziBool Zi8PriMatchNextChar(ziU8* record, ziU8 firstByteMask, ziU8 firstByteValue, ziU8 secondByteMask, ziU8 secondByteValue, ziU8 thirdByteMask, ziU8 thirdByteValue, ziU8 fourthByteMask, ziU8 fourthByteValue, ziU16* count, ziU8** result, ziU16* code, ziPtr work);
extern ziBool Zi8ExactMatchNextChar(ziU8* record, ziU8 firstByteMask, ziU8 firstByteValue, ziU8 secondByteMask, ziU8 secondByteValue, ziU8 thirdByteMask, ziU8 thirdByteValue, ziU8 fourthByteMask, ziU8 fourthByteValue, ziU16* count, ziU8** result, ziU16* code, ziPtr work);
extern ziBool Zi8PriMatchNextComp(ziU8* component, ziU8 firstByteMask, ziU8 firstByteValue, ziU8 secondByteMask, ziU8 secondByteValue, ziU8 thirdByteMask, ziU8 thirdByteValue, ziU8 fourthByteMask, ziU8 fourthByteValue, ziU16* count, ziU8** result, ziPtr work);
extern ziBool Zi8PriMatchNextChar(ziU8* record, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8 value1, ziU8 mask2, ziU8 value2, ziU8 mask3, ziU8 value3, ziU16* count, ziU8** result, ziU16* code, ziPtr work);
extern ziBool Zi8ExactMatchNextChar(ziU8* record, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8 value1, ziU8 mask2, ziU8 value2, ziU8 mask3, ziU8 value3, ziU16* count, ziU8** result, ziU16* code, ziPtr work);
extern ziBool Zi8PriMatchNextComp(ziU8* component, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8 value1, ziU8 mask2, ziU8 value2, ziU8 mask3, ziU8 value3, ziU16* count, ziU8** result, ziPtr work);
extern ziBool Zi8SecMatchComp(ziPtr component, ziMatchParam* match, ziPtr dictionary, ziPtr work);
extern void Zi8InitDupWordBuf(ziPtr work);
extern ziU8 Zi8MatchPUDdata_ZHS(ziWChar* word, ziU8 length, ziU8 language, ziWChar* spelling, ziU16 spellingCapacity, ziWChar* candidate, ziU16 candidateCapacity, ziU8 mode, ziU8 next, 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 {
@@ -451,68 +451,68 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
} else {
if (getMode == 10) getMode = 9;
for (index = 0; index < 6; ++index) {
match.recordMasks[index] = match.recordValues[index] = 0;
match.arr1[index] = match.arrD[index] = 0;
}
if (elements[0] >= 'A' && elements[0] <= 'Y') {
match.recordMasks[0] = 31;
match.recordValues[0] = zi8CangjieCodes[elements[0] - 'A'];
match.arr1[0] = 31;
match.arrD[0] = zi8CangjieCodes[elements[0] - 'A'];
} else if (elements[0] >= 0xEFF2 && elements[0] <= 0xEFF9) {
match.recordMasks[0] = 28;
match.recordValues[0] = (elements[0] - 0xEFF2) << 2;
match.arr1[0] = 28;
match.arrD[0] = (elements[0] - 0xEFF2) << 2;
}
if (request->elementCount > 1 && elements[1] != ' ') {
if (elements[1] >= 'A' && elements[1] <= 'Y') {
match.recordMasks[1] = 31;
match.recordValues[1] = zi8CangjieCodes[elements[1] - 'A'];
match.arr1[1] = 31;
match.arrD[1] = zi8CangjieCodes[elements[1] - 'A'];
} else if (elements[1] >= 0xEFF2 && elements[1] <= 0xEFF9) {
match.recordMasks[1] = 28;
match.recordValues[1] = (elements[1] - 0xEFF2) << 2;
match.arr1[1] = 28;
match.arrD[1] = (elements[1] - 0xEFF2) << 2;
}
phraseMasks[1].bytes[0] = phraseValues[1].bytes[0] = 0xFF;
totalResults = (match.recordMasks[0] << 3) | (match.recordMasks[1] << 8) | 7;
totalResults = (match.arr1[0] << 3) | (match.arr1[1] << 8) | 7;
phraseMasks[2].bytes[0] = totalResults;
phraseMasks[2].bytes[1] = (totalResults >> 8) & 0xff;
totalResults = (match.recordValues[0] << 3) | (match.recordValues[1] << 8) | 2;
totalResults = (match.arrD[0] << 3) | (match.arrD[1] << 8) | 2;
phraseValues[2].bytes[0] = totalResults;
phraseValues[2].bytes[1] = (totalResults >> 8) & 0xff;
totalResults = (match.recordMasks[0] << 3) | (match.recordMasks[1] << 13) | 7;
totalResults = (match.arr1[0] << 3) | (match.arr1[1] << 13) | 7;
phraseMasks[3].bytes[0] = totalResults;
phraseMasks[3].bytes[1] = (totalResults >> 8) & 0xff;
phraseMasks[3].bytes[2] = (totalResults >> 16) & 0xff;
totalResults = (match.recordValues[0] << 3) | (match.recordValues[1] << 13) | 3;
totalResults = (match.arrD[0] << 3) | (match.arrD[1] << 13) | 3;
phraseValues[3].bytes[0] = totalResults;
phraseValues[3].bytes[1] = (totalResults >> 8) & 0xff;
phraseValues[3].bytes[2] = (totalResults >> 16) & 0xff;
totalResults = (match.recordMasks[0] << 3) | (match.recordMasks[1] << 18) | 7;
totalResults = (match.arr1[0] << 3) | (match.arr1[1] << 18) | 7;
phraseMasks[4].bytes[0] = totalResults;
phraseMasks[4].bytes[1] = (totalResults >> 8) & 0xff;
phraseMasks[4].bytes[2] = (totalResults >> 16) & 0xff;
phraseMasks[4].bytes[3] = (Zi8UInt)totalResults >> 24;
totalResults = (match.recordValues[0] << 3) | (match.recordValues[1] << 18) | 4;
totalResults = (match.arrD[0] << 3) | (match.arrD[1] << 18) | 4;
phraseValues[4].bytes[0] = totalResults;
phraseValues[4].bytes[1] = (totalResults >> 8) & 0xff;
phraseValues[4].bytes[2] = (totalResults >> 16) & 0xff;
phraseValues[4].bytes[3] = (Zi8UInt)totalResults >> 24;
totalResults = (match.recordMasks[0] << 3) | (match.recordMasks[1] << 23) | 7;
totalResults = (match.arr1[0] << 3) | (match.arr1[1] << 23) | 7;
phraseMasks[5].bytes[0] = totalResults;
phraseMasks[5].bytes[1] = (totalResults >> 8) & 0xff;
phraseMasks[5].bytes[2] = (totalResults >> 16) & 0xff;
phraseMasks[5].bytes[3] = (Zi8UInt)totalResults >> 24;
totalResults = (match.recordValues[0] << 3) | (match.recordValues[1] << 23) | 5;
totalResults = (match.arrD[0] << 3) | (match.arrD[1] << 23) | 5;
phraseValues[5].bytes[0] = totalResults;
phraseValues[5].bytes[1] = (totalResults >> 8) & 0xff;
phraseValues[5].bytes[2] = (totalResults >> 16) & 0xff;
phraseValues[5].bytes[3] = (Zi8UInt)totalResults >> 24;
} else {
if (request->elementCount > 1) {
match.recordMasks[5] = 7;
match.recordValues[5] = 1;
match.arr1[5] = 7;
match.arrD[5] = 1;
}
totalResults = (match.recordMasks[0] << 3) | match.recordMasks[5];
totalResults = (match.arr1[0] << 3) | match.arr1[5];
phraseMasks[1].bytes[0] = phraseMasks[2].bytes[0] =
phraseMasks[3].bytes[0] = phraseMasks[4].bytes[0] =
phraseMasks[5].bytes[0] = totalResults;
totalResults = (match.recordValues[0] << 3) | match.recordValues[5];
totalResults = (match.arrD[0] << 3) | match.arrD[5];
phraseValues[1].bytes[0] = phraseValues[2].bytes[0] =
phraseValues[3].bytes[0] = phraseValues[4].bytes[0] =
phraseValues[5].bytes[0] = totalResults;
@@ -520,20 +520,20 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
}
}
for (index = 0; index < 6; ++index) {
match.recordMasks[index] = match.recordValues[index] = 0;
match.arr1[index] = match.arrD[index] = 0;
}
for (index = 0; index < request->elementCount; ++index) {
if (elements[index] >= 'A' && elements[index] <= 'Y') {
match.recordMasks[index] = 31;
match.recordValues[index] = zi8CangjieCodes[elements[index] - 'A'];
match.arr1[index] = 31;
match.arrD[index] = zi8CangjieCodes[elements[index] - 'A'];
} else if (elements[index] != '*') {
if (elements[index] >= 0xEFF2 && elements[index] <= 0xEFF9) {
match.recordMasks[index] = 28;
match.recordValues[index] = (elements[index] - 0xEFF2) << 2;
match.arr1[index] = 28;
match.arrD[index] = (elements[index] - 0xEFF2) << 2;
}
if (elements[index] == ' ') {
match.recordMasks[5] = 7;
match.recordValues[5] = index;
match.arr1[5] = 7;
match.arrD[5] = index;
if (!index || index + 1 != request->elementCount) {
resultFallback = 0;
goto engine_finish;
@@ -548,20 +548,20 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
}
if (index) match.length = index;
else match.length = 1;
totalResults = match.recordMasks[5] | ((match.recordMasks[4] << 23) |
((match.recordMasks[3] << 18) | ((match.recordMasks[2] << 13) |
((match.recordMasks[0] << 3) | (match.recordMasks[1] << 8)))));
match.prefixMasks[0] = totalResults;
match.prefixMasks[1] = (totalResults >> 8) & 0xff;
match.prefixMasks[2] = (totalResults >> 16) & 0xff;
match.prefixMasks[3] = (Zi8UInt)totalResults >> 24;
totalResults = match.recordValues[5] | ((match.recordValues[4] << 23) |
((match.recordValues[3] << 18) | ((match.recordValues[2] << 13) |
((match.recordValues[0] << 3) | (match.recordValues[1] << 8)))));
match.prefixValues[0] = totalResults;
match.prefixValues[1] = (totalResults >> 8) & 0xff;
match.prefixValues[2] = (totalResults >> 16) & 0xff;
match.prefixValues[3] = (Zi8UInt)totalResults >> 24;
totalResults = match.arr1[5] | ((match.arr1[4] << 23) |
((match.arr1[3] << 18) | ((match.arr1[2] << 13) |
((match.arr1[0] << 3) | (match.arr1[1] << 8)))));
match.arr19[0] = totalResults;
match.arr19[1] = (totalResults >> 8) & 0xff;
match.arr19[2] = (totalResults >> 16) & 0xff;
match.arr19[3] = (Zi8UInt)totalResults >> 24;
totalResults = match.arrD[5] | ((match.arrD[4] << 23) |
((match.arrD[3] << 18) | ((match.arrD[2] << 13) |
((match.arrD[0] << 3) | (match.arrD[1] << 8)))));
match.arr1D[0] = totalResults;
match.arr1D[1] = (totalResults >> 8) & 0xff;
match.arr1D[2] = (totalResults >> 16) & 0xff;
match.arr1D[3] = (Zi8UInt)totalResults >> 24;
}
totalResults = 0;
if ((getMode == 1 || getMode == 2) && match.phon[0] == 0xFFFF && match.phon2[0] == 0xFFFF &&
@@ -577,63 +577,63 @@ 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 {
switch ((int)match.phon2[index] >> 9) {
case 24: case 25:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->cANDch) ordinalIndex = 0xFDFF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->cANDch) ordinalIndex = 0xFDFF;
break;
case 26: case 27:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->sANDsh) ordinalIndex = 0xFDFF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->sANDsh) ordinalIndex = 0xFDFF;
break;
case 28: case 29:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->zANDzh) ordinalIndex = 0xFDFF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->zANDzh) ordinalIndex = 0xFDFF;
break;
case 56: case 59:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 60: case 63:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->bANDp) ordinalIndex = 0xF9FF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 52: case 55:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->gANDk) ordinalIndex = 0xF9FF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->bANDp) ordinalIndex = 0xF9FF;
break;
case 60: case 63:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->gANDk) ordinalIndex = 0xF9FF;
break;
case 38:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->nANDl && ((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->rANDn) ordinalIndex = 0xE1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->rANDn) ordinalIndex = 0xE3FF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->nANDl && ((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->rANDn) ordinalIndex = 0xE1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->nANDl) ordinalIndex = 0xE5FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->rANDn) ordinalIndex = 0xE3FF;
break;
case 43:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->nANDl && ((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->nANDl && ((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->nANDl) ordinalIndex = 0xE5FF;
break;
case 44:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->rANDn && ((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->rANDn) ordinalIndex = 0xE3FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->rANDn && ((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->rANDn) ordinalIndex = 0xE3FF;
else if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->lANDr) ordinalIndex = 0xF1FF;
break;
}
}
@@ -650,22 +650,22 @@ 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 {
switch (match.phon2[index] & 0x1F0) {
case 0x60: case 0xE0: case 0x160:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->anANDang) ordinalIndex = 0xFFF7;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->anANDang) ordinalIndex = 0xFFF7;
break;
case 0x70:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->zyFuzzy.word)->enANDeng) ordinalIndex = 0xFFF7;
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->enANDeng) ordinalIndex = 0xFFF7;
break;
}
}
@@ -709,7 +709,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
firstPhoneticPass = 0;
for (rangeIndex = 1; rangeIndex < match.nSeg; ++rangeIndex) {
for (rangeCount = 4; rangeCount < 12; ++rangeCount) {
if (match.segmentMasks[rangeIndex][rangeCount]) goto engine_finish;
if (match.segs1[rangeIndex][rangeCount]) goto engine_finish;
}
}
}
@@ -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;
}
@@ -822,10 +822,10 @@ engine_search:
case 7: case 8:
phraseEntry = phraseTable + ((record[9] & 15) << 16 | (record[11] | record[10] << 8));
if ((phraseEntry[0] & 7) >= match.length &&
match.prefixValues[0] == (match.prefixMasks[0] & phraseEntry[0]) &&
match.prefixValues[1] == (match.prefixMasks[1] & phraseEntry[1]) &&
match.prefixValues[2] == (match.prefixMasks[2] & phraseEntry[2]) &&
match.prefixValues[3] == (match.prefixMasks[3] & phraseEntry[3])) {
match.arr1D[0] == (match.arr19[0] & phraseEntry[0]) &&
match.arr1D[1] == (match.arr19[1] & phraseEntry[1]) &&
match.arr1D[2] == (match.arr19[2] & phraseEntry[2]) &&
match.arr1D[3] == (match.arr19[3] & phraseEntry[3])) {
candidateStatus = 1;
break;
}
@@ -839,10 +839,10 @@ engine_search:
(phraseEntry[3] & phraseMasks[index].bytes[3]) == phraseValues[index].bytes[3]) candidateStatus = 1;
break;
case 0:
if (match.recordValues[0] == (record[0] & match.recordMasks[0]) &&
(match.count || (match.recordValues[3] == (record[3] & match.recordMasks[3]) &&
match.recordValues[2] == (record[2] & match.recordMasks[2]) &&
match.recordValues[1] == (record[1] & match.recordMasks[1]))) &&
if (match.arrD[0] == (record[0] & match.arr1[0]) &&
(match.count || (match.arrD[3] == (record[3] & match.arr1[3]) &&
match.arrD[2] == (record[2] & match.arr1[2]) &&
match.arrD[1] == (record[1] & match.arr1[1]))) &&
(ziU8)Zi8SecMatchChar(record, componentTable, &match, 0, work)) candidateStatus = 1;
if (candidateStatus && getMode == 0 && match.nSeg > 1) {
emittedWords = 0;
@@ -857,10 +857,10 @@ engine_search:
candidateOrdinal = Zi8Uni2Ord(character, work);
if (candidateOrdinal == 0xFFFF) break;
record = records + candidateOrdinal * 12;
if (match.segmentValues[index][0] != (record[0] & match.segmentMasks[index][0]) ||
match.segmentValues[index][1] != (record[1] & match.segmentMasks[index][1]) ||
match.segmentValues[index][2] != (record[2] & match.segmentMasks[index][2]) ||
match.segmentValues[index][3] != (record[3] & match.segmentMasks[index][3])) break;
if (match.segsD[index][0] != (record[0] & match.segs1[index][0]) ||
match.segsD[index][1] != (record[1] & match.segs1[index][1]) ||
match.segsD[index][2] != (record[2] & match.segs1[index][2]) ||
match.segsD[index][3] != (record[3] & match.segs1[index][3])) break;
}
if (index < match.nSeg) candidateStatus = 0;
}
@@ -930,21 +930,21 @@ 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;
}
}
pud_search:
if (((struct __zi8_work_data_s*)work)->zhPudCount) {
if (((struct __zi8_work_data_s*)work)->unk_0x12D) {
savedPudCount = ((struct __zi8_work_data_s*)work)->pudCount;
wordSearchPhase = 1;
((struct __zi8_work_data_s*)work)->pudCount = ((struct __zi8_work_data_s*)work)->zhPudCount;
((struct __zi8_work_data_s*)work)->pudCount = ((struct __zi8_work_data_s*)work)->unk_0x12D;
}
pud_start:
if (((options->countOnly && getOptions != 5) || !wordLength || getMode == 5 ||
@@ -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;
@@ -1011,10 +1011,10 @@ pud_candidate:
candidateOrdinal = Zi8Uni2Ord(character, work);
if (candidateOrdinal == 0xFFFF) break;
record = records + candidateOrdinal * 12;
if (match.segmentValues[index][0] != (record[0] & match.segmentMasks[index][0]) ||
match.segmentValues[index][1] != (record[1] & match.segmentMasks[index][1]) ||
match.segmentValues[index][2] != (record[2] & match.segmentMasks[index][2]) ||
match.segmentValues[index][3] != (record[3] & match.segmentMasks[index][3])) break;
if (match.segsD[index][0] != (record[0] & match.segs1[index][0]) ||
match.segsD[index][1] != (record[1] & match.segs1[index][1]) ||
match.segsD[index][2] != (record[2] & match.segs1[index][2]) ||
match.segsD[index][3] != (record[3] & match.segs1[index][3])) break;
}
if (index < match.nSeg) goto pud_next;
}
@@ -1027,10 +1027,10 @@ pud_candidate:
case 7: case 8:
phraseEntry = phraseTable + ((record[9] & 15) << 16 | (record[11] | record[10] << 8));
if ((phraseEntry[0] & 7) >= match.length &&
match.prefixValues[0] == (match.prefixMasks[0] & phraseEntry[0]) &&
match.prefixValues[1] == (match.prefixMasks[1] & phraseEntry[1]) &&
match.prefixValues[2] == (match.prefixMasks[2] & phraseEntry[2]) &&
match.prefixValues[3] == (match.prefixMasks[3] & phraseEntry[3])) {
match.arr1D[0] == (match.arr19[0] & phraseEntry[0]) &&
match.arr1D[1] == (match.arr19[1] & phraseEntry[1]) &&
match.arr1D[2] == (match.arr19[2] & phraseEntry[2]) &&
match.arr1D[3] == (match.arr19[3] & phraseEntry[3])) {
candidateStatus = 1;
break;
}
@@ -1044,10 +1044,10 @@ pud_candidate:
(phraseEntry[3] & phraseMasks[index].bytes[3]) == phraseValues[index].bytes[3]) candidateStatus = 1;
break;
case 0:
if (match.recordValues[0] == (record[0] & match.recordMasks[0]) &&
(match.count || (match.recordValues[3] == (record[3] & match.recordMasks[3]) &&
match.recordValues[2] == (record[2] & match.recordMasks[2]) &&
match.recordValues[1] == (record[1] & match.recordMasks[1]))) &&
if (match.arrD[0] == (record[0] & match.arr1[0]) &&
(match.count || (match.arrD[3] == (record[3] & match.arr1[3]) &&
match.arrD[2] == (record[2] & match.arr1[2]) &&
match.arrD[1] == (record[1] & match.arr1[1]))) &&
(ziU8)Zi8SecMatchChar(record, componentTable, &match, 0, work)) candidateStatus = 1;
break;
case 1: case 2:
@@ -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;
}
}
@@ -1194,10 +1194,10 @@ context_word_lookup:
case 7: case 8:
phraseEntry = phraseTable + ((record[9] & 15) << 16 | (record[11] | record[10] << 8));
if ((phraseEntry[0] & 7) >= match.length &&
match.prefixValues[0] == (match.prefixMasks[0] & phraseEntry[0]) &&
match.prefixValues[1] == (match.prefixMasks[1] & phraseEntry[1]) &&
match.prefixValues[2] == (match.prefixMasks[2] & phraseEntry[2]) &&
match.prefixValues[3] == (match.prefixMasks[3] & phraseEntry[3])) {
match.arr1D[0] == (match.arr19[0] & phraseEntry[0]) &&
match.arr1D[1] == (match.arr19[1] & phraseEntry[1]) &&
match.arr1D[2] == (match.arr19[2] & phraseEntry[2]) &&
match.arr1D[3] == (match.arr19[3] & phraseEntry[3])) {
candidateStatus = 1;
break;
}
@@ -1211,20 +1211,20 @@ context_word_lookup:
(phraseEntry[3] & phraseMasks[index].bytes[3]) == phraseValues[index].bytes[3]) candidateStatus = 1;
break;
case 0:
if (match.recordValues[0] == (record[0] & match.recordMasks[0]) &&
(match.count || (match.recordValues[3] == (record[3] & match.recordMasks[3]) &&
match.recordValues[2] == (record[2] & match.recordMasks[2]) &&
match.recordValues[1] == (record[1] & match.recordMasks[1]))) &&
if (match.arrD[0] == (record[0] & match.arr1[0]) &&
(match.count || (match.arrD[3] == (record[3] & match.arr1[3]) &&
match.arrD[2] == (record[2] & match.arr1[2]) &&
match.arrD[1] == (record[1] & match.arr1[1]))) &&
(ziU8)Zi8SecMatchChar(record, componentTable, &match, 0, work)) candidateStatus = 1;
if (candidateStatus && match.nSeg >= 2) {
duplicateIndex = 0;
relatedOrdinal = character;
while (candidateStatus) {
record = records + relatedOrdinal * 12;
if (match.segmentValues[duplicateIndex][0] != (record[0] & match.segmentMasks[duplicateIndex][0]) ||
match.segmentValues[duplicateIndex][1] != (record[1] & match.segmentMasks[duplicateIndex][1]) ||
match.segmentValues[duplicateIndex][2] != (record[2] & match.segmentMasks[duplicateIndex][2]) ||
match.segmentValues[duplicateIndex][3] != (record[3] & match.segmentMasks[duplicateIndex][3])) {
if (match.segsD[duplicateIndex][0] != (record[0] & match.segs1[duplicateIndex][0]) ||
match.segsD[duplicateIndex][1] != (record[1] & match.segs1[duplicateIndex][1]) ||
match.segsD[duplicateIndex][2] != (record[2] & match.segs1[duplicateIndex][2]) ||
match.segsD[duplicateIndex][3] != (record[3] & match.segs1[duplicateIndex][3])) {
candidateStatus = 0;
break;
}
@@ -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,14 +1321,14 @@ 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)) {
wordLength = 0;
savedPudCount = ((struct __zi8_work_data_s*)work)->pudCount;
wordSearchPhase = 2;
((struct __zi8_work_data_s*)work)->pudCount = ((struct __zi8_work_data_s*)work)->zhPudCount;
((struct __zi8_work_data_s*)work)->pudCount = ((struct __zi8_work_data_s*)work)->unk_0x12D;
goto pud_start;
}
dictionary_search:
@@ -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;
@@ -1410,10 +1410,10 @@ candidate_dictionary_search:
} else if (getMode == 9) continue;
}
if (!candidateStatus && !((phraseEntry[0] & 7) >= match.length &&
match.prefixValues[0] == (match.prefixMasks[0] & phraseEntry[0]) &&
match.prefixValues[1] == (match.prefixMasks[1] & phraseEntry[1]) &&
match.prefixValues[2] == (match.prefixMasks[2] & phraseEntry[2]) &&
match.prefixValues[3] == (match.prefixMasks[3] & phraseEntry[3]) &&
match.arr1D[0] == (match.arr19[0] & phraseEntry[0]) &&
match.arr1D[1] == (match.arr19[1] & phraseEntry[1]) &&
match.arr1D[2] == (match.arr19[2] & phraseEntry[2]) &&
match.arr1D[3] == (match.arr19[3] & phraseEntry[3]) &&
((resultFallback && (phraseEntry[0] & 7) == match.length) || (!resultFallback && (phraseEntry[0] & 7) > match.length)))) continue;
if (charsetTable) {
charsetEntry = charsetTable + candidateOrdinal;
@@ -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) {
@@ -1486,13 +1486,13 @@ character_range_start:
while (1) {
if (match.count) {
if (!candidateCount--) goto character_range_done;
if (match.prefixValues[0] != (record[0] & match.prefixMasks[0])) goto character_range_next;
if (match.arr1D[0] != (record[0] & match.arr19[0])) goto character_range_next;
if ((ziU8)Zi8SecMatchChar(record, componentTable, &match, &candidateOrdinal, work) == 2) goto character_range_accept;
} else {
if (!Zi8ExactMatchNextChar(record, match.prefixMasks[0], match.prefixValues[0], match.prefixMasks[1], match.prefixValues[1],
match.prefixMasks[2], match.prefixValues[2], match.prefixMasks[3], match.prefixValues[3],
if (!Zi8ExactMatchNextChar(record, match.arr19[0], match.arr1D[0], match.arr19[1], match.arr1D[1],
match.arr19[2], match.arr1D[2], match.arr19[3], match.arr1D[3],
&candidateCount, &record, &candidateOrdinal, work)) goto character_range_done;
if ((!match.componentIndex && match.length < 8) ||
if ((!match.field22 && match.length < 8) ||
(ziU8)Zi8SecMatchChar(record, componentTable, &match, &candidateOrdinal, work) == 2) goto character_range_accept;
}
character_range_next:
@@ -1545,8 +1545,8 @@ character_range_done:
record = records + phraseOrdinal * 12;
candidateCount = 1;
if (exactPhrase) {
if (!Zi8PriMatchNextChar(record, match.recordMasks[0], match.recordValues[0], match.recordMasks[1], match.recordValues[1],
match.recordMasks[2], match.recordValues[2], match.recordMasks[3], match.recordValues[3],
if (!Zi8PriMatchNextChar(record, match.arr1[0], match.arrD[0], match.arr1[1], match.arrD[1],
match.arr1[2], match.arrD[2], match.arr1[3], match.arrD[3],
&candidateCount, &record, &candidateOrdinal, work) ||
!(ziU8)Zi8SecMatchChar(record, componentTable, &match, &candidateOrdinal, work)) { ++tableIndex; continue; }
((ZiChineseWork*)work)->duplicateOrdinals[((ZiChineseWork*)work)->duplicateIndex] = phraseOrdinal;
@@ -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];
@@ -1766,10 +1766,10 @@ user_character_search:
case 7: case 8:
phraseEntry = phraseTable + ((record[9] & 15) << 16 | (record[11] | record[10] << 8));
if ((phraseEntry[0] & 7) >= match.length &&
match.prefixValues[0] == (match.prefixMasks[0] & phraseEntry[0]) &&
match.prefixValues[1] == (match.prefixMasks[1] & phraseEntry[1]) &&
match.prefixValues[2] == (match.prefixMasks[2] & phraseEntry[2]) &&
match.prefixValues[3] == (match.prefixMasks[3] & phraseEntry[3]) &&
match.arr1D[0] == (match.arr19[0] & phraseEntry[0]) &&
match.arr1D[1] == (match.arr19[1] & phraseEntry[1]) &&
match.arr1D[2] == (match.arr19[2] & phraseEntry[2]) &&
match.arr1D[3] == (match.arr19[3] & phraseEntry[3]) &&
((resultFallback && (phraseEntry[0] & 7) == match.length) || (!resultFallback && (phraseEntry[0] & 7) > match.length))) {
candidateStatus = 1;
break;
@@ -1785,14 +1785,14 @@ user_character_search:
((resultFallback && index == match.length) || (!resultFallback && index > match.length))) candidateStatus = 1;
break;
case 0:
if (match.recordValues[0] == (record[0] & match.recordMasks[0]) &&
(match.count || (match.recordValues[3] == (record[3] & match.recordMasks[3]) &&
match.recordValues[2] == (record[2] & match.recordMasks[2]) &&
match.recordValues[1] == (record[1] & match.recordMasks[1]))) &&
if (match.arrD[0] == (record[0] & match.arr1[0]) &&
(match.count || (match.arrD[3] == (record[3] & match.arr1[3]) &&
match.arrD[2] == (record[2] & match.arr1[2]) &&
match.arrD[1] == (record[1] & match.arr1[1]))) &&
(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;
@@ -1859,10 +1859,10 @@ user_character_next:
} else if (getMode == 9) goto global_character_next;
}
if (!candidateStatus && !((phraseEntry[0] & 7) >= match.length &&
match.prefixValues[0] == (match.prefixMasks[0] & phraseEntry[0]) &&
match.prefixValues[1] == (match.prefixMasks[1] & phraseEntry[1]) &&
match.prefixValues[2] == (match.prefixMasks[2] & phraseEntry[2]) &&
match.prefixValues[3] == (match.prefixMasks[3] & phraseEntry[3]) &&
match.arr1D[0] == (match.arr19[0] & phraseEntry[0]) &&
match.arr1D[1] == (match.arr19[1] & phraseEntry[1]) &&
match.arr1D[2] == (match.arr19[2] & phraseEntry[2]) &&
match.arr1D[3] == (match.arr19[3] & phraseEntry[3]) &&
((resultFallback && (phraseEntry[0] & 7) == match.length) || (!resultFallback && (phraseEntry[0] & 7) > match.length)))) goto global_character_next;
if (!emitWords) {
if (trackDuplicates) {
@@ -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:
@@ -1940,8 +1940,8 @@ cangjie_components:
component_retry:
remainingOrdinals = candidateCount;
while (phoneticRetry && match.nSeg > 1) {
if (!Zi8PriMatchNextChar(record, match.recordMasks[0], match.recordValues[0], match.recordMasks[1], match.recordValues[1],
match.recordMasks[2], match.recordValues[2], match.recordMasks[3], match.recordValues[3],
if (!Zi8PriMatchNextChar(record, match.arr1[0], match.arrD[0], match.arr1[1], match.arrD[1],
match.arr1[2], match.arrD[2], match.arr1[3], match.arrD[3],
&candidateCount, &record, &candidateOrdinal, work)) {
if (phase != 0xFF) goto component_phase;
if (switchedPhonetic) {
@@ -1993,10 +1993,10 @@ component_retry:
component_phrase_word:
relatedRecord = records + (candidateOrdinal & 0x7FFF) * 12;
if (duplicateIndex < match.nSeg &&
(match.segmentValues[duplicateIndex][0] != (relatedRecord[0] & match.segmentMasks[duplicateIndex][0]) ||
match.segmentValues[duplicateIndex][1] != (relatedRecord[1] & match.segmentMasks[duplicateIndex][1]) ||
match.segmentValues[duplicateIndex][2] != (relatedRecord[2] & match.segmentMasks[duplicateIndex][2]) ||
match.segmentValues[duplicateIndex][3] != (relatedRecord[3] & match.segmentMasks[duplicateIndex][3]))) goto component_phrase_next;
(match.segsD[duplicateIndex][0] != (relatedRecord[0] & match.segs1[duplicateIndex][0]) ||
match.segsD[duplicateIndex][1] != (relatedRecord[1] & match.segs1[duplicateIndex][1]) ||
match.segsD[duplicateIndex][2] != (relatedRecord[2] & match.segs1[duplicateIndex][2]) ||
match.segsD[duplicateIndex][3] != (relatedRecord[3] & match.segs1[duplicateIndex][3]))) goto component_phrase_next;
currentSpelling[duplicateIndex] = ((ziU16)relatedRecord[6] << 8) + relatedRecord[7];
if (++duplicateIndex >= match.nSeg) {
if (switchedPhonetic) {
@@ -2052,13 +2052,13 @@ component_record_next:
if (getMode != 5) {
while (exactPhrase) {
while (match.count) {
if ((candidateCount -= 1) == 0xFFFF) goto frequency_range_retry;
if (match.recordValues[0] == (record[0] & match.recordMasks[0]) &&
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;
}
if (!Zi8PriMatchNextChar(record, match.recordMasks[0], match.recordValues[0], match.recordMasks[1], match.recordValues[1],
match.recordMasks[2], match.recordValues[2], match.recordMasks[3], match.recordValues[3],
if (!Zi8PriMatchNextChar(record, match.arr1[0], match.arrD[0], match.arr1[1], match.arrD[1],
match.arr1[2], match.arrD[2], match.arr1[3], match.arrD[3],
&candidateCount, &record, &candidateOrdinal, work)) {
frequency_range_retry:
if (phase != 0xFF) goto component_phase;
@@ -2100,8 +2100,8 @@ frequency_record_next:
}
}
while (firstPhoneticPass) {
if (!Zi8PriMatchNextComp(componentCursor, match.recordMasks[0], match.recordValues[0], match.recordMasks[1], match.recordValues[1],
match.recordMasks[2], match.recordValues[2], match.recordMasks[3], match.recordValues[3],
if (!Zi8PriMatchNextComp(componentCursor, match.arr1[0], match.arrD[0], match.arr1[1], match.arrD[1],
match.arr1[2], match.arrD[2], match.arr1[3], match.arrD[3],
&componentIndex, &componentCursor, work)) {
alternateCharacter = 0;
componentFrequency = 0;
@@ -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;
@@ -2489,10 +2489,10 @@ filtered_search:
case 8:
phraseEntry = phraseTable + ((record[9] & 15) << 16 | (record[11] | record[10] << 8));
if ((phraseEntry[0] & 7) >= match.length &&
match.prefixValues[0] == (match.prefixMasks[0] & phraseEntry[0]) &&
match.prefixValues[1] == (match.prefixMasks[1] & phraseEntry[1]) &&
match.prefixValues[2] == (match.prefixMasks[2] & phraseEntry[2]) &&
match.prefixValues[3] == (match.prefixMasks[3] & phraseEntry[3])) goto filtered_accept;
match.arr1D[0] == (match.arr19[0] & phraseEntry[0]) &&
match.arr1D[1] == (match.arr19[1] & phraseEntry[1]) &&
match.arr1D[2] == (match.arr19[2] & phraseEntry[2]) &&
match.arr1D[3] == (match.arr19[3] & phraseEntry[3])) goto filtered_accept;
if (getMode == 7) goto filtered_next;
case 9:
phraseEntry = phraseTable + ((record[9] & 15) << 16 | (record[11] | record[10] << 8));
@@ -2503,18 +2503,18 @@ filtered_search:
(phraseEntry[3] & phraseMasks[rangeCount].bytes[3]) != phraseValues[rangeCount].bytes[3]) goto filtered_next;
break;
case 0:
if (match.recordValues[0] != (record[0] & match.recordMasks[0]) ||
(!match.count && (match.recordValues[3] != (record[3] & match.recordMasks[3]) ||
match.recordValues[2] != (record[2] & match.recordMasks[2]) ||
match.recordValues[1] != (record[1] & match.recordMasks[1]))) ||
if (match.arrD[0] != (record[0] & match.arr1[0]) ||
(!match.count && (match.arrD[3] != (record[3] & match.arr1[3]) ||
match.arrD[2] != (record[2] & match.arr1[2]) ||
match.arrD[1] != (record[1] & match.arr1[1]))) ||
!(ziU8)Zi8SecMatchChar(record, componentTable, &match, 0, work)) goto filtered_next;
for (rangeCount = 1; rangeCount < match.nSeg; ++rangeCount) {
record = (ziU8*)((ZiChineseRecord*)records + (ziU16)frequencyTable[(rangeIndex + rangeCount) * 2] +
((ziU16)frequencyTable[(rangeIndex + rangeCount) * 2 + 1] << 8));
if (match.segmentValues[rangeCount][0] != (record[0] & match.segmentMasks[rangeCount][0]) ||
match.segmentValues[rangeCount][1] != (record[1] & match.segmentMasks[rangeCount][1]) ||
match.segmentValues[rangeCount][2] != (record[2] & match.segmentMasks[rangeCount][2]) ||
match.segmentValues[rangeCount][3] != (record[3] & match.segmentMasks[rangeCount][3])) goto filtered_next;
if (match.segsD[rangeCount][0] != (record[0] & match.segs1[rangeCount][0]) ||
match.segsD[rangeCount][1] != (record[1] & match.segs1[rangeCount][1]) ||
match.segsD[rangeCount][2] != (record[2] & match.segs1[rangeCount][2]) ||
match.segsD[rangeCount][3] != (record[3] & match.segs1[rangeCount][3])) goto filtered_next;
}
break;
case 1:
@@ -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);
@@ -52,8 +52,8 @@ ziU32 Zi8MatchROMdata0(ziWChar* elements, ziU8 count, ziU8 language,
}
context->table = graphData;
context->cap = (((ziU16)context->table[2] << 8) + context->table[3]) / 3;
context->characters = context->table + 4;
context->characterFlags = context->table + context->cap * 2 + 4;
context->p08 = context->table + 4;
context->p0C = context->table + context->cap * 2 + 4;
context->lang = language;
context->key = graphTable;
index = 0;
@@ -77,13 +77,13 @@ check_keys:
if (index < keyCount) goto next_key;
keys[index] = 0;
keyData = (ziU8*)Zi8GetTableAddress(language, keyTable, ZI_WORK);
context->keyCodes = keyData + 2;
context->p14 = keyData + 2;
keyData += context->cap * 2 + 2;
records[0].node = ZiDAWGGetGraphInfo(context, keyData, (ziS16*)keys);
} else {
records[0].node = ZiDAWGGetGraph(context);
context->endNode = 0;
context->keyCodes = 0;
context->unk_0x338 = 0;
context->p14 = 0;
}
records[0].key = 0;
if (records[0].node == (ziU8*)0) goto finish_graph;
@@ -98,15 +98,15 @@ 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) {
if (context->keyCodes == 0) {
if (context->p14 == 0) {
convertedKey = Zi8ConvertWC2Key((ziU16)current->attr, language, ZI_WORK);
} else {
convertedKey = ((ziU16)context->keyCodes[(current->attr >> 24) * 2] << 8) +
(context->keyCodes + (current->attr >> 24) * 2)[1];
convertedKey = ((ziU16)context->p14[(current->attr >> 24) * 2] << 8) +
(context->p14 + (current->attr >> 24) * 2)[1];
}
key = convertedKey;
if (key != elements[context->cnt - 1] &&
@@ -136,7 +136,7 @@ descend:
records[context->cnt].node = ZiDAWGGetChild(records[context->cnt - 1].node);
if (records[context->cnt].node == (ziU8*)0) goto next_sibling;
context->cnt++;
if (ZI_WORK->maxCnt < context->cnt) ZI_WORK->maxCnt = context->cnt;
if (ZI_WORK->unk_0x141F < context->cnt) ZI_WORK->unk_0x141F = context->cnt;
goto update_current;
next_sibling:
while (context->cnt != 0) {
@@ -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->dawgSearchState,ZI_WORK);
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->dawgCtx,ZI_WORK->dawgSearchState,ZI_WORK);
*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;
}
}
@@ -229,58 +229,58 @@ unsigned int Zi8MatchROMdata2(ziWChar* elements, ziU8 count, ziU8 language,
if (reservedMode != 0) return 0;
if (status == 0) {
ZI_WORK->dawgGroupIndex = 0;
ZI_WORK->matchOffset = 0;
if (group != 0 && *group == 0xc && language == 10 && ZI_WORK->forceAltGraph != 0) {
ZI_WORK->graphTableId = 0x10;
ZI_WORK->unk_0x1768 = 0;
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->dawgWord[ZI_WORK->matchOffset], capacity,
mode, status, ZI_WORK->dawgGroupIndex, (char*)group,
ZI_WORK->unk_0x141F = 1;
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--) {
output[index - 1] = ZI_WORK->dawgWord[index - 1];
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->dawgGroupIndex == 0 &&
(ziU8)Zi8MatchROMdata1(elements + ZI_WORK->matchOffset,
count - ZI_WORK->matchOffset, language,
&ZI_WORK->dawgWord[ZI_WORK->matchOffset], capacity,
0, status, ZI_WORK->dawgGroupIndex, (char*)group,
if (mode == 1 && ZI_WORK->unk_0x1768 == 0 &&
(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) {
for (index = 0; index < count; index++) {
if (elements[index] == 0xeff1) goto finish_segments;
}
}
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->dawgWord[ZI_WORK->matchOffset], capacity,
1, 0, ZI_WORK->dawgGroupIndex, (char*)group,
if (ZI_WORK->unk_0x141F > capacity) goto finish_segments;
for (index = ZI_WORK->unk_0x141F; index != 0; index--) {
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->dawgGroupIndex++;
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++) {
switch (ZI_WORK->dawgWord[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;
}
}
@@ -305,9 +305,9 @@ ziU32 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language,
Zi8LogError(100, ZI_WORK);
} else {
if (status == 0) {
ZI_WORK->dawgFallbackUsed = 0;
ZI_WORK->unk_0x17EC = 0;
ZI_WORK->dawgGroup = NextDawgGroup(0, language, ZI_WORK);
} else if (ZI_WORK->dawgFallbackUsed != 0) {
} else if (ZI_WORK->unk_0x17EC != 0) {
Zi8LogError(100, ZI_WORK);
goto finish_match;
}
@@ -328,7 +328,7 @@ ziU32 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language,
}
if ((ziU8)result == 0 && status == 0 && mode == 1 && count == 1 && capacity >= 1) {
mode = 0;
ZI_WORK->dawgFallbackUsed = 1;
ZI_WORK->unk_0x17EC = 1;
if (tableSize != 0) {
ZI_WORK->dawgGroup = NextDawgGroup(0, language, ZI_WORK);
while (ZI_WORK->dawgGroup != 0) {
@@ -380,6 +380,6 @@ void Zi8SyllablesROMdata(ziWChar *elements, ziU8 count, ziU8 language, ziWChar *
}
}
Zi8MatchROMdata0(elements,count,language & 0xff,output,capacity,1,status,graphTable,keyTable,0,(ziU8 *)prefixLength,
&ZI_WORK->dawgCtx,ZI_WORK->dawgSearchState,ZI_WORK);
&ZI_WORK->dawgCtx,ZI_WORK->unk_0x1760,ZI_WORK);
return;
}

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

@@ -4,12 +4,12 @@
extern ziU8 _Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK);
ziU8 Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK) {
ZI_WORK->candidateStateByteA = 0;
ZI_WORK->candidateStateByteC = 0;
ZI_WORK->candidateStateByteB = 0;
ZI_WORK->candidateStateByteD = 0;
ZI_WORK->candidateStateWordC = 0;
ZI_WORK->candidateStateWordA = 0;
ZI_WORK->candidateStateWordB = 0;
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B3C = 0;
ZI_WORK->unk_0x1B3B = 0;
ZI_WORK->unk_0x1B3D = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
ZI_WORK->unk_0x1B34 = 0;
return _Zi8GetCandidates(getParam, ZI_WORK);
}

View File

@@ -32,29 +32,29 @@ 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;
}
ziBool Zi8ZHsetZYfuzzyPairs(ziFuzzyZYPairs pairs ZI_NEED_WORK) {
if (pairs.ziDefault) {
ZI_WORK->zyFuzzy.word = *(const ziU32*)&Zi8ZYdefaultFuzzyPairs;
ZI_WORK->unk_0x1B2C.word = *(const ziU32*)&Zi8ZYdefaultFuzzyPairs;
} else {
ZI_WORK->zyFuzzy.word = *(ziU32*)&pairs;
ZI_WORK->unk_0x1B2C.word = *(ziU32*)&pairs;
}
return 1;
}
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_0x1410 = (ziU32)Zi8SOdefaultArray;
ZI_WORK->unk_0x1418 = 9;
} else {
ZI_WORK->formats = (ziU32)searchArray;
ZI_WORK->formatCount = searchSize;
ZI_WORK->unk_0x1410 = (ziU32)searchArray;
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;
@@ -166,7 +166,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
if ((parameters->getOptions & 0x80) == 0) {
ZI_WORK->language = parameters->language;
parameters->candidates[0] = 0xfff0;
output = (ziWChar*)&ZI_WORK->candidateBufferHead;
output = (ziWChar*)&ZI_WORK->unk_0x338;
}
if (parameters->firstCandidate != 0) {
current = signatures.second;
@@ -175,8 +175,8 @@ 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 ((parameters->elementCount < ZI_WORK->wordLengthSettings[0] ||
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,8 +185,8 @@ 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 ((parameters->elementCount < ZI_WORK->wordLengthSettings[0] ||
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->maxCandidateCount;
options->maxWordLength = ZI_WORK->maxWordLength;
ZI_WORK->maxWordLength = -1;
options->maxCount = ZI_WORK->unk_0x10;
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)) {
@@ -588,7 +588,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
saved.savedOptions = parameters->getOptions;
saved.savedCandidates = parameters->candidates;
parameters->getOptions |= 0x81;
parameters->candidates = (ziWChar*)&ZI_WORK->candidateBufferHead;
parameters->candidates = (ziWChar*)&ZI_WORK->unk_0x338;
options->capacity = 0x100;
}
if (parameters->getMode == 2) {
@@ -618,7 +618,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
}
void Zi8InitDupWordBuf(ziPtr __zi8_work_data) {
ZI_WORK->duplicateCount = 0;
ZI_WORK->unk_0x539 = 0;
}
ziBool Zi8IsDupWChar(ziWChar character ZI_NEED_WORK) {
@@ -626,26 +626,26 @@ ziBool Zi8IsDupWChar(ziWChar character ZI_NEED_WORK) {
ziU16* buffer;
unsigned int index;
duplicate = 0;
buffer = ZI_WORK->duplicateBuffer;
if (ZI_WORK->duplicateCount == 0) {
buffer = ZI_WORK->unk_0x57A;
if (ZI_WORK->unk_0x539 == 0) {
buffer[0] = 2;
buffer[1] = character;
ZI_WORK->duplicateCount = 1;
ZI_WORK->unk_0x539 = 1;
Zi8LogError(0x8fd, ZI_WORK);
return 0;
}
for (index = ZI_WORK->duplicateCount; index != 0; index--) {
for (index = ZI_WORK->unk_0x539; index != 0; index--) {
if (character == buffer[index]) {
duplicate = 1;
break;
}
}
ZI_WORK->duplicateCount++;
ZI_WORK->unk_0x539++;
buffer[(*buffer)++] = character;
if (*buffer > 100) {
*buffer = 2;
buffer[1] = character;
ZI_WORK->duplicateCount = 1;
ZI_WORK->unk_0x539 = 1;
}
Zi8LogError(100, ZI_WORK);
return duplicate;
@@ -664,38 +664,38 @@ ziBool Zi8IsDupWordW(ziWChar* word, ziU8 length ZI_NEED_WORK) {
word += length - 20;
length = 20;
}
for (index = 0; index < ZI_WORK->duplicateCount; index++) {
slot = ZI_WORK->duplicateWordOrder[index];
for (index = 0; index < ZI_WORK->unk_0x539; index++) {
slot = ZI_WORK->unk_0x53A[index];
for (character = 0; character < length; character++) {
if (word[character] != ((ziWChar (*)[21])ZI_WORK->duplicateBuffer)[slot][character]) break;
if (word[character] != ((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character]) break;
}
if (character >= length && ((ziWChar (*)[21])ZI_WORK->duplicateBuffer)[slot][character] == 0) {
if (character >= length && ((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character] == 0) {
duplicate = 1;
break;
}
}
if (!duplicate) {
if (ZI_WORK->duplicateCount < 64) {
slot = ZI_WORK->duplicateWordOrder[ZI_WORK->duplicateCount] = ZI_WORK->duplicateCount;
ZI_WORK->duplicateCount++;
if (ZI_WORK->unk_0x539 < 64) {
slot = ZI_WORK->unk_0x53A[ZI_WORK->unk_0x539] = ZI_WORK->unk_0x539;
ZI_WORK->unk_0x539++;
} else {
slot = ZI_WORK->duplicateWordOrder[0];
for (index = 1; index < ZI_WORK->duplicateCount; index++) {
ZI_WORK->duplicateWordOrder[index - 1] = ZI_WORK->duplicateWordOrder[index];
slot = ZI_WORK->unk_0x53A[0];
for (index = 1; index < ZI_WORK->unk_0x539; index++) {
ZI_WORK->unk_0x53A[index - 1] = ZI_WORK->unk_0x53A[index];
}
ZI_WORK->duplicateWordOrder[index - 1] = slot;
ZI_WORK->unk_0x53A[index - 1] = slot;
}
} else {
slot = ZI_WORK->duplicateWordOrder[index];
for (; index < ZI_WORK->duplicateCount - 1; index++) {
ZI_WORK->duplicateWordOrder[index] = ZI_WORK->duplicateWordOrder[index + 1];
slot = ZI_WORK->unk_0x53A[index];
for (; index < ZI_WORK->unk_0x539 - 1; index++) {
ZI_WORK->unk_0x53A[index] = ZI_WORK->unk_0x53A[index + 1];
}
ZI_WORK->duplicateWordOrder[index] = slot;
ZI_WORK->unk_0x53A[index] = slot;
}
for (character = 0; character < length; character++) {
((ziWChar (*)[21])ZI_WORK->duplicateBuffer)[slot][character] = word[character];
((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character] = word[character];
}
((ziWChar (*)[21])ZI_WORK->duplicateBuffer)[slot][character] = 0;
((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character] = 0;
Zi8LogError(100, ZI_WORK);
return duplicate;
}
@@ -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

@@ -16,22 +16,22 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
ziU32* ppyFuzzy;
Zi8Memset(__zi8_work_data, 0, 0x1B44);
ZI_WORK->initializationState = 1;
ZI_WORK->dictionaryFlags = 1;
ZI_WORK->maxWordLength = 0xFF;
ZI_WORK->maxCandidateCount = 0x64;
*(ziU16*)&ZI_WORK->targetCount = 0xFFFF;
ZI_WORK->unk_0x08 = 1;
ZI_WORK->unk_0x09 = 1;
ZI_WORK->unk_0x0A = 0xFF;
ZI_WORK->unk_0x10 = 0x64;
*(ziU16*)&ZI_WORK->unk_0x0C = 0xFFFF;
ZI_WORK->separator = 0x20;
ZI_WORK->searchModes[2] = 0;
ZI_WORK->koAltTables = 0;
ZI_WORK->candidateStateByteA = 0;
ZI_WORK->candidateStateWordC = 0;
ZI_WORK->candidateStateWordA = 0;
ZI_WORK->candidateStateWordB = 0;
ZI_WORK->candidateStateByteB = 0;
ZI_WORK->candidateStateByteC = 0;
ZI_WORK->initializationWordB = 0;
ZI_WORK->initializationWordA = 0;
ZI_WORK->unk_0x1C[2] = 0;
ZI_WORK->unk_0x1B30 = 0;
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
ZI_WORK->unk_0x1B34 = 0;
ZI_WORK->unk_0x1B3B = 0;
ZI_WORK->unk_0x1B3C = 0;
ZI_WORK->unk_0x1B40 = 0;
ZI_WORK->unk_0x1B38 = 0;
ZI_WORK->langEntries = langEntries;
if (ZI_WORK->langEntries == ZI8_NULL) {
Zi8LogError(0x578, ZI_WORK);
@@ -41,20 +41,20 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
Zi8LogError(0x582, ZI_WORK);
return 0;
}
ZI_WORK->letterHyphen = 0x2D;
ZI_WORK->unk_0x1874 = 0x2D;
ZI_WORK->language = 0;
ZI_WORK->searchModes[3] = 0;
ZI_WORK->capacity = 0x100;
ZI_WORK->unk_0x1C[3] = 0;
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->zyFuzzy.bits.msb = 1;
zyFuzzy = ZI_WORK->zyFuzzy.word;
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

@@ -75,10 +75,10 @@ const ziU8 nodeHeaderTable[0x20] = {
0x00, 0x17, 0x00, 0x1D, 0x00, 0x1F, 0x00, 0x35
};
ziBool Zi8PriMatchNextChar(ziU8* node, ziU8 firstByteMask, ziU8 firstByteValue, ziU8 secondByteMask, ziU8 secondByteValue, ziU8 thirdByteMask, ziU8 thirdByteValue, ziU8 fourthByteMask, ziU8 fourthByteValue, ziU16* count, ziU8** result, ziU16* code ZI_NEED_WORK) {
ziBool Zi8PriMatchNextChar(ziU8* node, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8 value1, ziU8 mask2, ziU8 value2, ziU8 mask3, ziU8 value3, ziU16* count, ziU8** result, ziU16* code ZI_NEED_WORK) {
ziU16 remaining = *count;
while (remaining-- != 0) {
if ((firstByteValue == (node[0] & firstByteMask)) && (fourthByteValue == (node[3] & fourthByteMask)) && (thirdByteValue == (node[2] & thirdByteMask)) && (secondByteValue == (node[1] & secondByteMask))) {
if ((value0 == (node[0] & mask0)) && (value3 == (node[3] & mask3)) && (value2 == (node[2] & mask2)) && (value1 == (node[1] & mask1))) {
*result = node;
*code = ((ziU16)node[6] << 8) + (ziU16)node[7];
*count = remaining;
@@ -91,11 +91,11 @@ ziBool Zi8PriMatchNextChar(ziU8* node, ziU8 firstByteMask, ziU8 firstByteValue,
return 0;
}
ziBool Zi8ExactMatchNextChar(ziU8* node, ziU8 firstByteMask, ziU8 firstByteValue, ziU8 secondByteMask, ziU8 secondByteValue, ziU8 thirdByteMask, ziU8 thirdByteValue, ziU8 fourthByteMask, ziU8 fourthByteValue, ziU16* count, ziU8** result, ziU16* code ZI_NEED_WORK) {
ziBool Zi8ExactMatchNextChar(ziU8* node, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8 value1, ziU8 mask2, ziU8 value2, ziU8 mask3, ziU8 value3, ziU16* count, ziU8** result, ziU16* code ZI_NEED_WORK) {
ziU16 remaining = *count;
ziU8* current = node;
while (remaining-- != 0) {
if ((firstByteValue == (current[0] & firstByteMask)) && (fourthByteValue == (current[3] & fourthByteMask)) && (thirdByteValue == (current[2] & thirdByteMask)) && (secondByteValue == (current[1] & secondByteMask))) {
if ((value0 == (current[0] & mask0)) && (value3 == (current[3] & mask3)) && (value2 == (current[2] & mask2)) && (value1 == (current[1] & mask1))) {
*result = current;
*code = ((ziU16)current[6] << 8) + (ziU16)current[7];
*count = remaining;
@@ -119,8 +119,8 @@ ziU32 Zi8SecMatchChar(ziPtr nodeAddress, ziU8* dictionaryAddress, ziMatchParam*
ziU16 targetCode;
} state;
if (match->componentIndex != 0) {
state.targetCode = match->componentIndex;
if (match->field22 != 0) {
state.targetCode = match->field22;
matchCode = ((ziU16)(((ziU8*)nodeAddress)[4] & 3) << 8) | ((ziU8*)nodeAddress)[5];
value = 0;
while (value++ < 6) {
@@ -222,7 +222,7 @@ ziU32 Zi8SecMatchChar(ziPtr nodeAddress, ziU8* dictionaryAddress, ziMatchParam*
}
if (match->count == 0) {
while (state.remaining != 0) {
if ((data[0] & match->recordMasks[state.dataIndex]) != match->recordValues[state.dataIndex]) {
if ((data[0] & match->arr1[state.dataIndex]) != match->arrD[state.dataIndex]) {
return 0;
}
state.dataIndex++;
@@ -239,10 +239,10 @@ ziU32 Zi8SecMatchChar(ziPtr nodeAddress, ziU8* dictionaryAddress, ziMatchParam*
return 1;
}
ziBool Zi8PriMatchNextComp(ziU8* node, ziU8 firstByteMask, ziU8 firstByteValue, ziU8 secondByteMask, ziU8 secondByteValue, ziU8 thirdByteMask, ziU8 thirdByteValue, ziU8 fourthByteMask, ziU8 fourthByteValue, ziU16* count, ziU8** result ZI_NEED_WORK) {
ziBool Zi8PriMatchNextComp(ziU8* node, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8 value1, ziU8 mask2, ziU8 value2, ziU8 mask3, ziU8 value3, ziU16* count, ziU8** result ZI_NEED_WORK) {
ziU16 remaining = *count;
while (remaining-- != 0) {
if ((firstByteValue == (node[0] & firstByteMask)) && (secondByteValue == (node[1] & secondByteMask)) && (thirdByteValue == (node[2] & thirdByteMask)) && (fourthByteValue == (node[3] & fourthByteMask))) {
if ((value0 == (node[0] & mask0)) && (value1 == (node[1] & mask1)) && (value2 == (node[2] & mask2)) && (value3 == (node[3] & mask3))) {
*result = node;
*count = remaining;
Zi8LogError(0x64, ZI_WORK);
@@ -254,13 +254,13 @@ ziBool Zi8PriMatchNextComp(ziU8* node, ziU8 firstByteMask, ziU8 firstByteValue,
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;
if (matchAddress->componentIndex != 0) {
targetCode = matchAddress->componentIndex;
if (matchAddress->field22 != 0) {
targetCode = matchAddress->field22;
matchCode = ((ziU16)(((ziU8*)nodeAddress)[6] & 3) << 8) | ((ziU8*)nodeAddress)[7];
chainIndex = 0;
while (chainIndex++ < 6) {
@@ -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

@@ -25,8 +25,8 @@ ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
table2 = Zi8GetTableAddress(1, 1, __zi8_work_data);
if (buf == ZI8_NULL) {
for (i = 0; i < 0x40; i++) {
if (ch == WORKP->duplicateCharacters[i]) {
i = WORKP->duplicateOrdinalCache[i];
if (ch == WORKP->unk_0x20[i]) {
i = WORKP->unk_0xA0[i];
e = (ziU8*)table + i * 0xC;
if (i >= count) {
break;
@@ -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,29 +88,29 @@ ziU8 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
Zi8LogError(0x4F6, __zi8_work_data);
return 0;
}
ZI_WORK->pudWordCount = ((ziU16)section->count[0] << 8) + (ziU16)section->count[1];
ZI_WORK->pudWordAddress = (ziU32)table + (((ziU16)section->offset[0] << 8) + (ziU16)section->offset[1]);
ZI_WORK->pudWordIndex = 0;
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 (;;) {
word = (ziU8*)ZI_WORK->pudWordAddress;
word = (ziU8*)ZI_WORK->unk_0x310;
if (word == 0) {
Zi8LogError(0x4B3, __zi8_work_data);
return 0;
}
while ((ziS32)ZI_WORK->pudWordIndex < (ziS32)ZI_WORK->pudWordCount) {
while ((ziS32)ZI_WORK->unk_0x318 < (ziS32)ZI_WORK->unk_0x314) {
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++;
wordSize = ZiGetZHWordSize((ziWChar*)word, entrySize);
} else if (ZI_WORK->pudStopAtSpace != 0 && complete != 0 && length < wordSize && word[length] == 0x20) goto matchText;
} else if (ZI_WORK->unk_0x31E != 0 && complete != 0 && length < wordSize && word[length] == 0x20) goto matchText;
if ((ziS32)length > (ziS32)wordSize || (complete != 0 && wordSize != length) || (complete == 0 && wordSize == length)) {
next:
ZI_WORK->pudWordIndex++;
ZI_WORK->unk_0x318++;
word += entrySize;
} else {
if (language == 1) {
@@ -131,14 +126,14 @@ 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) {
ZI_WORK->pudWordAddress = 0;
ZI_WORK->pudWordIndex = 0;
ZI_WORK->pudWordCount = 0;
if (fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
if (*pattern >= 0xEFF1) *output = *pattern;
else *output = Zi8ConvertWC2Key(*pattern, language, __zi8_work_data);
return 1;
@@ -155,36 +150,36 @@ matched:
} else {
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
if (ZI_WORK->pudStopAtSpace != 0 && copied >= length && output[copied] == 0x20) {
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
if (complete != 0 || copied >= length) break;
goto next;
}
}
}
ZI_WORK->pudWordIndex++;
ZI_WORK->pudWordAddress = (ziU32)(word + entrySize);
ZI_WORK->unk_0x318++;
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
Zi8LogError(100, __zi8_work_data);
return (ziU8)copied;
}
}
if (length == 1 && complete != 0 && continuation == 0) {
complete = 0;
match.fallback = 1;
ZI_WORK->pudWordIndex = 0;
fallback = 1;
ZI_WORK->unk_0x318 = 0;
} else {
ZI_WORK->pudWordAddress = 0;
ZI_WORK->pudWordIndex = 0;
ZI_WORK->pudWordCount = 0;
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
return 0;
}
}
}
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;
@@ -127,8 +127,8 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
}
{
Zi8_8148047C(__zi8_work_data);
ZI_WORK->uwdSkipCount = 0;
if (currentWord == 0 || currentLength == 0 || currentWord[currentLength - 1] != 0x20) ZI_WORK->uwdContextEnabled = 0;
ZI_WORK->unk_0x13C = 0;
if (currentWord == 0 || currentLength == 0 || currentWord[currentLength - 1] != 0x20) ZI_WORK->unk_0x140 = 0;
else {
prefixLength = 0;
for (position = currentLength - 2; position >= 0;) {
@@ -137,23 +137,23 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
prefixLength++;
}
position++;
if (prefixLength == 0 || prefixLength > 63) ZI_WORK->uwdContextEnabled = 0;
if (prefixLength == 0 || prefixLength > 63) ZI_WORK->unk_0x140 = 0;
else {
ZI_WORK->uwdContextEnabled = 1;
ZI_WORK->uwdContextRecord[prefixLength + 4] = ZI_WORK->uwdContextRecord[0] = prefixLength + 5;
ZI_WORK->uwdContextRecord[1] = language;
ZI_WORK->uwdContextRecord[2] = prefixLength;
ZI_WORK->unk_0x140 = 1;
ZI_WORK->unk_0x141[prefixLength + 4] = ZI_WORK->unk_0x141[0] = prefixLength + 5;
ZI_WORK->unk_0x141[1] = language;
ZI_WORK->unk_0x141[2] = prefixLength;
previousOffset = 4;
while (prefixLength > 0) {
folded = currentWord[position];
ZI_WORK->uwdContextRecord[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
ZI_WORK->uwdContextAlternateCase[previousOffset] = 0;
if (ZI_WORK->ignoreCase != 0) {
ZI_WORK->unk_0x141[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = 0;
if (ZI_WORK->unk_0x1F != 0) {
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data)) Zi8ChangeCharCase(0, &folded, language, __zi8_work_data);
ZI_WORK->uwdContextAlternateCase[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
}
if (ZI_WORK->uwdContextRecord[previousOffset++] == 0) {
ZI_WORK->uwdContextEnabled = 0;
if (ZI_WORK->unk_0x141[previousOffset++] == 0) {
ZI_WORK->unk_0x140 = 0;
break;
}
prefixLength--;
@@ -161,7 +161,7 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
}
}
}
if (ZI_WORK->uwdContextEnabled == 0 && length == 0) return 0;
if (ZI_WORK->unk_0x140 == 0 && length == 0) return 0;
rescan:
cursor = begin = dictionary->entries + dictionary->current;
boundary = (ziU8*)dictionary + dictionary->boundary + 7;
@@ -170,7 +170,7 @@ rescan:
else firstSegment = 0;
while ((cursor < boundary && firstSegment) || (cursor < end && !firstSegment)) {
size = *cursor;
if ((ziS32)ZI_WORK->uwdSkipCount > visited++ || (((ziUserWord*)cursor)->size & 0xC0) != 0) {
if ((ziS32)ZI_WORK->unk_0x13C > visited++ || (((ziUserWord*)cursor)->size & 0xC0) != 0) {
next:
if ((cursor += size) > end) {
if (firstSegment) break;
@@ -192,15 +192,15 @@ 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->uwdContextEnabled != 0) {
if (ZI_WORK->uwdContextRecord[0] != previous->size || ZI_WORK->uwdContextRecord[1] != previous->language || ZI_WORK->uwdContextRecord[2] != previous->length) goto next;
if (ZI_WORK->unk_0x140 != 0) {
if (ZI_WORK->unk_0x141[0] != previous->size || ZI_WORK->unk_0x141[1] != previous->language || ZI_WORK->unk_0x141[2] != previous->length) goto next;
prefixLength = 4;
position = ZI_WORK->uwdContextRecord[2] + 4;
position = ZI_WORK->unk_0x141[2] + 4;
for (; prefixLength < position; prefixLength++) {
if (ZI_WORK->uwdContextRecord[prefixLength] != ((ziU8*)previous)[prefixLength] && ZI_WORK->uwdContextAlternateCase[prefixLength] != ((ziU8*)previous)[prefixLength]) goto next;
if (ZI_WORK->unk_0x141[prefixLength] != ((ziU8*)previous)[prefixLength] && ZI_WORK->unk_0x184[prefixLength] != ((ziU8*)previous)[prefixLength]) goto next;
}
}
Zi8_81480224((ziUserWord*)cursor, __zi8_work_data);
@@ -208,8 +208,8 @@ next:
goto next;
}
}
if (ZI_WORK->uwdContextEnabled != 0 && length != 0) {
ZI_WORK->uwdContextEnabled = 0;
if (ZI_WORK->unk_0x140 != 0 && length != 0) {
ZI_WORK->unk_0x140 = 0;
visited = 0;
goto rescan;
}

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

@@ -149,9 +149,9 @@ ziU32 ZiDAWGgetCHARattribute(zi8DawgCtx* context, ziU32 node, ziPtr __zi8_work_d
}
attribute = key << 24;
attribute |= ((ziU8*)context->characterFlags)[key] << 16;
attribute |= (((ziU32)((ziU8*)context->characters)[key * 2] & 0xFFFF) << 8) +
((ziU8*)context->characters + key * 2)[1];
attribute |= ((ziU8*)context->p0C)[key] << 16;
attribute |= (((ziU32)((ziU8*)context->p08)[key * 2] & 0xFFFF) << 8) +
((ziU8*)context->p08 + key * 2)[1];
Zi8LogError(0x64, __zi8_work_data);
return attribute;
}
@@ -163,9 +163,9 @@ ziU32 ZiDAWGGetGraph(ziPtr context) {
}
ziU32 ZiDAWGGetGraphInfo(zi8DawgCtx* context, ziU8* entry, ziU16* keys) {
ziU32 graph;
ziU8 depth;
ziU32 end;
ziU32 graph;
ziS32 result;
graph = ZiDAWGGetGraph(context);
@@ -199,10 +199,10 @@ checkEntry:
}
result = graph + (ziU32)entry[4] * 0x10000 + (((ziU16)entry[5] << 8) + entry[6]);
context->endNode =
((zi8DawgCtx*)context)->unk_0x338 =
graph + (ziU32)entry[7] * 0x10000 + (((ziU16)entry[8] << 8) + entry[9]);
if (context->endNode == graph) {
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

@@ -45,8 +45,8 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
ziWChar* cursor;
ziU8* data;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziU32 savedFormats = ZI_WORK->formats;
ziU8 savedCount = ZI_WORK->formatCount;
ziU32 savedFormats = ZI_WORK->unk_0x1410;
ziU8 savedCount = ZI_WORK->unk_0x1418;
ziSearchState search = {0};
Zi8LogError(100, __zi8_work_data);
if (word == 0 || *word == 0) {
@@ -73,22 +73,22 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
request.candidates = ordinals;
request.maxCandidates = 1;
request.firstCandidate = 0;
ZI_WORK->formats = (ziU32)formats;
if (ZI_WORK->searchModes[0] == 2) {
ZI_WORK->formatCount = 0;
if (ZI_WORK->dictionaryFlags & 1) formats[ZI_WORK->formatCount++] = 1;
if (ZI_WORK->dictionaryFlags & 4) formats[ZI_WORK->formatCount++] = 2;
if (ZI_WORK->dictionaryFlags & 2) formats[ZI_WORK->formatCount++] = 3;
if (ZI_WORK->dictionaryFlags & 8) formats[ZI_WORK->formatCount++] = 4;
if (ZI_WORK->dictionaryFlags & 1) formats[ZI_WORK->formatCount++] = 5;
if (ZI_WORK->dictionaryFlags & 4) formats[ZI_WORK->formatCount++] = 6;
if (ZI_WORK->dictionaryFlags & 2) formats[ZI_WORK->formatCount++] = 7;
if (ZI_WORK->dictionaryFlags & 8) formats[ZI_WORK->formatCount++] = 8;
} else if (ZI_WORK->searchModes[0] != 0) ZI_WORK->formatCount = 2;
else ZI_WORK->formatCount = 1;
ZI_WORK->unk_0x1410 = (ziU32)formats;
if (ZI_WORK->unk_0x1C[0] == 2) {
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_0x1410 = savedFormats;
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

@@ -132,8 +132,8 @@ ziBool Zi8ChangeCharCase(ziBool upper, ziWChar* character, ziU8 language ZI_NEED
Zi8LogError(0x64, ZI_WORK);
if (ZI_WORK->userKeys[language] != 0) {
customTables = (ziUserKeyMap*)ZI_WORK->userKeys[language];
} else if (ZI_WORK->customKeyMap != 0) {
customTables = (ziUserKeyMap*)ZI_WORK->customKeyMap;
} else if (ZI_WORK->unk_0x11FC != 0) {
customTables = (ziUserKeyMap*)ZI_WORK->unk_0x11FC;
} else {
tableCount = Zi8GetTableCount(language, 0x1e, ZI_WORK);
if (tableCount != 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,16 +58,14 @@ 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->componentIndex = ((buffers.componentIndex[1] & 0x3f) << 8) + *buffers.componentIndex;
buffers.component += (ziU32)match->componentIndex * 8;
match->field22 = (((ziU16)buffers.componentIndex[1] & 0x3f) << 8) + *buffers.componentIndex;
buffers.component += (ziU32)match->field22 * 8;
switch(*buffers.component & 0xf) {
case 0:
case 9:
@@ -103,14 +99,14 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
for (index = 0; index < (buffers.component[5] >> 1) + 1; index++) {
if (index < 4) {
match->recordValues[index] = buffers.component[index];
match->recordMasks[index] = 0xff;
match->arrD[index] = buffers.component[index];
match->arr1[index] = 0xff;
}
}
if ((index != 0) && ((buffers.component[5] & 1) == 0)) {
index--;
match->recordValues[index] &= 0xf0;
match->recordMasks[index] &= 0xf0;
match->arrD[index] &= 0xf0;
match->arr1[index] &= 0xf0;
}
nibbles = (ziU8)(buffers.component[5] + 1);
if (8 < nibbles) {
@@ -118,8 +114,8 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
}
}
match->recordMasks[0] &= 0xf;
match->recordValues[0] &= 0xf;
match->arr1[0] &= 0xf;
match->arrD[0] &= 0xf;
if (skipMode == '\0') {
mode = 0;
if ((request->subLanguage & 0x80) != 0 || (request->subLanguage & 0x40) != 0) {
@@ -136,8 +132,8 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
case 1:
case 2:
case 4:
match->recordMasks[0] |= (ziU8)(mode << 4);
match->recordValues[0] |= (ziU8)(mode << 4);
match->arr1[0] |= (ziU8)(mode << 4);
match->arrD[0] |= (ziU8)(mode << 4);
break;
}
}
@@ -146,8 +142,8 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
if (((request->getMode == '\0') || (request->getMode == '\x10')) ||
(request->getMode == '\x05')) {
Zi8Memcpy(buffers.masks,match->recordMasks,0xc);
Zi8Memcpy(buffers.strokes,match->recordValues,0xc);
Zi8Memcpy(buffers.masks,match->arr1,0xc);
Zi8Memcpy(buffers.strokes,match->arrD,0xc);
do {
while (elementIndex < elementCount) {
element = request->elements[elementIndex++];
@@ -214,23 +210,22 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
}
if (match->nSeg == 0) {
Zi8Memcpy(match->recordMasks,buffers.masks,0xc);
Zi8Memcpy(match->recordValues,buffers.strokes,0xc);
Zi8Memcpy(match->prefixMasks,buffers.maskPrefix,4);
Zi8Memcpy(match->prefixValues,buffers.strokePrefix,4);
Zi8Memcpy(match->arr1,buffers.masks,0xc);
Zi8Memcpy(match->arrD,buffers.strokes,0xc);
Zi8Memcpy(match->arr19,buffers.maskPrefix,4);
Zi8Memcpy(match->arr1D,buffers.strokePrefix,4);
match->length = savedNibbles;
}
Zi8Memcpy((ziU8 (*)[12])match->segmentMasks + match->nSeg,buffers.masks,0xc);
Zi8Memcpy((ziU8 (*)[12])match->segmentValues + match->nSeg,buffers.strokes,0xc);
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->recordMasks[0] & 0xf0;
buffers.strokes[0] = match->recordValues[0] & 0xf0;
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
@@ -242,8 +242,8 @@ typedef struct WPADCB {
WPADCallback getInfoCB; // 0x988
u8 getInfoBusy; // 0x98C
u8 encStatus; // 0x98D
u8 continuous; // 0x98E
u8 unk_0x98D; // 0x98D
u8 unk_0x98E; // 0x98E
u8 unk_0x98F[0x9A0 - 0x990];
} WPADCB;
@@ -261,7 +261,7 @@ void WPADiExcludeButton(s32 chan);
void WPADiCopyOut(s32 chan);
BOOL WPADiSendSetPort(WPADCommandQueue* pQueue, u8 port, WPADCallback pCallback);
BOOL WPADiSendSetReportType(WPADCommandQueue* pQueue, s32 format, BOOL continuous, WPADCallback pCallback);
BOOL WPADiSendSetReportType(WPADCommandQueue* pQueue, s32 format, BOOL unk, WPADCallback pCallback);
BOOL WPADiSendEnableDPD(WPADCommandQueue* pQueue, BOOL enable, WPADCallback pCallback);
BOOL WPADiSendEnableSpeaker(WPADCommandQueue* pQueue, BOOL enable, WPADCallback pCallback);
BOOL WPADiSendGetContStat(WPADCommandQueue* pQueue, WPADInfo* pInfo, WPADCallback pCallback);

View File

@@ -24,7 +24,7 @@ typedef struct WPADMemBlock {
int unk_0x04; // 0x04
s16 unk_0x08; // 0x08
int unk_0x0C; // 0x0C
WPADCallback callback; // 0x10
WPADCallback unk_0x10; // 0x10
} WPADMemBlock;
typedef struct WPADGameInfo {

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();
}

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