Compare commits
35 Commits
cleanup/ip
...
agent/w092
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
edbc2b6766 | ||
|
|
230401c1d0 | ||
|
|
c99cc7922d | ||
|
|
048f578ed5 | ||
|
|
633193d5b3 | ||
|
|
ac8ff7f6e9 | ||
|
|
0a801b7420 | ||
|
|
a15dd68674 | ||
|
|
861ed1c446 | ||
|
|
61ce21d35f | ||
|
|
2cf9bb4f88 | ||
|
|
98205461d6 | ||
|
|
681deff3d7 | ||
|
|
34537f9931 | ||
|
|
60b8903833 | ||
|
|
5cf3207119 | ||
|
|
4afe002d09 | ||
|
|
b81e66b57f | ||
|
|
f42599fb46 | ||
|
|
0630899b66 | ||
|
|
cb18542e6f | ||
|
|
7f51543e7f | ||
|
|
5463295790 | ||
|
|
1e3e622fe3 | ||
|
|
2555f31a8b | ||
|
|
59a2a0af19 | ||
|
|
36ecc0c3c2 | ||
|
|
61eb7d8953 | ||
|
|
319b2f0d29 | ||
|
|
7c3f3b2f0a | ||
|
|
273365f68e | ||
|
|
a56e34f215 | ||
|
|
921c4ccd8b | ||
|
|
ad5317d876 | ||
|
|
89239f3668 |
19
.github/workflows/readme-progress.yml
vendored
19
.github/workflows/readme-progress.yml
vendored
@@ -2,8 +2,6 @@ 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.
|
||||
# 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 +15,7 @@ concurrency:
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
contents: write
|
||||
|
||||
jobs:
|
||||
progress:
|
||||
@@ -50,8 +48,15 @@ jobs:
|
||||
- name: Report
|
||||
run: build/tools/objdiff-cli report generate -p . -o build/43U/report.json -f json
|
||||
|
||||
- name: Summary
|
||||
- name: Update README
|
||||
run: python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
|
||||
|
||||
- name: Commit
|
||||
run: |
|
||||
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
|
||||
if git diff --quiet README.md; then exit 0; fi
|
||||
git config user.name "github-actions[bot]"
|
||||
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
|
||||
git add README.md
|
||||
git commit -m "docs: update progress [skip ci]"
|
||||
git pull --rebase origin main || { git rebase --abort; echo "main moved, next run will update"; exit 0; }
|
||||
git push origin HEAD:main
|
||||
|
||||
@@ -78,12 +78,6 @@ Helper tools live in `tools/decomp-assist/`:
|
||||
between your object and the original. This is the main iteration loop.
|
||||
- `disasm_fn.py <object> <symbol>` — disassembly with relocation-resolved call
|
||||
names, so you can see which real functions are being called.
|
||||
- `literal_reference_diff.py [unit ...]` — advisory check of actual narrow-string
|
||||
bytes passed at corresponding calls, including addresses derived from a shared
|
||||
data base. Defaults to functions scored 100% in the live report; use
|
||||
`--all-functions` to include other equal-sized functions. Inspect every
|
||||
candidate against the assembly. This does not follow mutable pointer globals,
|
||||
infer compiler aliases, or prove complete data matching; skips are reported.
|
||||
- `pool_diff.py` — diffs the string pool in `.data` between your object and the
|
||||
original, string by string. See below; this is the highest-signal tool.
|
||||
- `export_pyghidra.py` — regenerates `ghidra_decomp.txt`, decompiled C for the
|
||||
|
||||
@@ -53,9 +53,9 @@ Progress
|
||||
<!-- progress:start -->
|
||||
| Decompiled | Matched | Linked | Data |
|
||||
|:---:|:---:|:---:|:---:|
|
||||
| 99.59% | 90.81% | 71.43% | 99.37% |
|
||||
| 99.46% | 88.57% | 62.98% | 97.20% |
|
||||
|
||||
units 956/1027 complete, functions 12365/12563 matched.
|
||||
units 925/1027 complete, functions 12264/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 -->
|
||||
|
||||
@@ -11,8 +11,6 @@ splits: 'config/43U/splits.txt'
|
||||
ldscript_template: 'config/ldscript_ipl2.lcf'
|
||||
|
||||
force_active:
|
||||
- SOGetSockOpt
|
||||
- SOSetInterfaceOpt
|
||||
- fprintf
|
||||
- leap_days
|
||||
- __msl_time2tm
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
66
configure.py
66
configure.py
@@ -738,11 +738,11 @@ config.libs = [
|
||||
]
|
||||
),
|
||||
IPLSection("board", [
|
||||
Object(Matching, "scene/board/iplBoard.cpp"),
|
||||
Object(Equivalent, "scene/board/iplBoard.cpp"),
|
||||
Object(Matching, "scene/board/iplBoardObject.cpp"),
|
||||
Object(Matching, "scene/board/iplBoardSD.cpp"),
|
||||
Object(Matching, "scene/board/iplUrlProcessor.cpp"),
|
||||
Object(Matching, "scene/board/iplFocusObject.cpp"),
|
||||
Object(Equivalent, "scene/board/iplFocusObject.cpp"),
|
||||
]
|
||||
),
|
||||
IPLSection("button", [
|
||||
@@ -772,7 +772,7 @@ config.libs = [
|
||||
]
|
||||
),
|
||||
IPLSection("channelTitle", [
|
||||
Object(Matching, "scene/channelTitle/iplChannelTitle.cpp"),
|
||||
Object(Equivalent, "scene/channelTitle/iplChannelTitle.cpp"),
|
||||
]
|
||||
),
|
||||
IPLSection("faceSelect", [
|
||||
@@ -816,7 +816,7 @@ config.libs = [
|
||||
Object(Matching, "scene/memoryCard/iplMemoryCardBase.cpp"),
|
||||
Object(NonMatching, "scene/memoryCard/iplMemoryCardManager.cpp"),
|
||||
Object(Matching, "scene/memoryCard/iplGCSaveData.cpp"),
|
||||
Object(Matching, "scene/memoryCard/iplGCWindow.cpp"),
|
||||
Object(NonMatching, "scene/memoryCard/iplGCWindow.cpp"),
|
||||
]
|
||||
),
|
||||
IPLSection("textBalloon", [
|
||||
@@ -850,7 +850,7 @@ config.libs = [
|
||||
),
|
||||
IPLSection("sdChannelSelect", [
|
||||
Object(NonMatching, "scene/sdChannelSelect/iplSDChannelSelect.cpp"),
|
||||
Object(Matching, "scene/sdChannelSelect/iplSDChannelObj.cpp"),
|
||||
Object(NonMatching, "scene/sdChannelSelect/iplSDChannelObj.cpp"),
|
||||
]
|
||||
),
|
||||
IPLSection("sdChannelTitle", [
|
||||
@@ -874,10 +874,10 @@ config.libs = [
|
||||
Object(Matching, "scene/setting/iplParental.cpp"),
|
||||
Object(Matching, "scene/setting/iplAPScanThread.cpp"),
|
||||
Object(Matching, "scene/setting/iplUSBAP.cpp"),
|
||||
Object(Matching, "scene/setting/iplUSBAPThread.cpp"),
|
||||
Object(NonMatching, "scene/setting/iplUSBAPThread.cpp"),
|
||||
Object(Matching, "scene/setting/iplAOSSThread.cpp"),
|
||||
Object(NonMatching, "scene/setting/AOSSLink.c"),
|
||||
Object(Matching, "scene/setting/iplRakuRakuThread.cpp"),
|
||||
Object(NonMatching, "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 off"]),
|
||||
]
|
||||
@@ -901,7 +901,7 @@ config.libs = [
|
||||
),
|
||||
IPLSection("bannerSound", [
|
||||
Object(Matching, "bannerSound/AudioWavePlayer.cpp"),
|
||||
Object(Matching, "bannerSound/AxAdpcmPlayer.cpp"),
|
||||
Object(Equivalent, "bannerSound/AxAdpcmPlayer.cpp"),
|
||||
Object(Matching, "bannerSound/BannerSoundPlayer.cpp"),
|
||||
Object(Matching, "bannerSound/AudioWaveUtility.cpp"),
|
||||
]
|
||||
@@ -927,8 +927,8 @@ config.libs = [
|
||||
Object(Matching, "keyboard/tiPkData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
|
||||
Object(Matching, "keyboard/tiLanguageIndependentData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
|
||||
Object(Matching, "keyboard/tiTextInputBase.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/MyTiInputForm.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(NonMatching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(NonMatching, "keyboard/MyTiInputForm.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/MyTiLetterForm.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/MyTiBg.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/tiDebug.cpp", extra_cflags=["-O4,p"]),
|
||||
@@ -989,7 +989,7 @@ config.libs = [
|
||||
Object(NonMatching, "clib/zi8cgetc.c"),
|
||||
Object(Matching, "clib/zi8cinfo.c"),
|
||||
Object(Matching, "clib/zi8copy.c"),
|
||||
Object(Matching, "clib/zi8dawg.c"),
|
||||
Object(NonMatching, "clib/zi8dawg.c"),
|
||||
Object(Matching, "clib/zi8getc.c"),
|
||||
Object(NonMatching, "clib/zi8getc2.c"),
|
||||
Object(Matching, "clib/zi8getSW.c"),
|
||||
@@ -1005,7 +1005,7 @@ config.libs = [
|
||||
Object(Matching, "clib/zi8ZHuwd.c"),
|
||||
Object(NonMatching, "clib/zidawg1.c"),
|
||||
Object(Matching, "clib/zikorean.c"),
|
||||
Object(Matching, "clib/ziswordw.c"),
|
||||
Object(NonMatching, "clib/ziswordw.c"),
|
||||
Object(NonMatching, "clib/zkokeyp.c"),
|
||||
Object(Matching, "clib/zierror.c"),
|
||||
Object(NonMatching, "clib/zmtkey.c"),
|
||||
@@ -1045,7 +1045,7 @@ config.libs = [
|
||||
Object(Matching, "net/crc.c"),
|
||||
Object(NonMatching, "net/md5.c"),
|
||||
Object(Matching, "net/sha1.c"),
|
||||
Object(Matching, "net/hmac.c"),
|
||||
Object(NonMatching, "net/hmac.c"),
|
||||
Object(Matching, "net/neterrorcode.c"),
|
||||
Object(Matching, "net/NETVersion.c"),
|
||||
Object(NonMatching, "net/aes.c"),
|
||||
@@ -1060,9 +1060,9 @@ config.libs = [
|
||||
Object(NonMatching, "nhttp/NHTTP_recvbuf.c"),
|
||||
Object(Matching, "nhttp/NHTTP_request.c"),
|
||||
Object(Matching, "nhttp/NHTTP_response.c"),
|
||||
Object(Matching, "nhttp/NHTTP_socket_RVL.c"),
|
||||
Object(NonMatching, "nhttp/NHTTP_socket_RVL.c"),
|
||||
Object(NonMatching, "nhttp/NHTTP_stdlib_RVL.c"),
|
||||
Object(Matching, "nhttp/NHTTP_thread.c"),
|
||||
Object(NonMatching, "nhttp/NHTTP_thread.c"),
|
||||
Object(Matching, "nhttp/d_nhttp_private.c"),
|
||||
Object(Matching, "nhttp/d_nhttp.c"),
|
||||
Object(Matching, "nhttp/d_nhttp_common.c"),
|
||||
@@ -1075,12 +1075,12 @@ config.libs = [
|
||||
Object(Matching, "nwc24/NWC24Utils.c"),
|
||||
Object(Matching, "nwc24/NWC24Manage.c"),
|
||||
Object(Matching, "nwc24/NWC24MsgObj.c"),
|
||||
Object(Matching, "nwc24/NWC24MBoxCtrl.c"),
|
||||
Object(Matching, "nwc24/NWC24Mime.c"),
|
||||
Object(NonMatching, "nwc24/NWC24MBoxCtrl.c"),
|
||||
Object(NonMatching, "nwc24/NWC24Mime.c"),
|
||||
Object(Matching, "nwc24/NWC24Stream.c"),
|
||||
Object(Matching, "nwc24/NWC24Parser.c"),
|
||||
Object(Matching, "nwc24/NWC24MsgCommit.c"),
|
||||
Object(Matching, "nwc24/NWC24MsgRead.c"),
|
||||
Object(NonMatching, "nwc24/NWC24MsgCommit.c"),
|
||||
Object(NonMatching, "nwc24/NWC24MsgRead.c"),
|
||||
Object(NonMatching, "nwc24/NWC24MsgSubject.c"),
|
||||
Object(Matching, "nwc24/NWC24Schedule.c"),
|
||||
Object(NonMatching, "nwc24/NWC24DateParser.c"),
|
||||
@@ -1097,8 +1097,8 @@ config.libs = [
|
||||
RevoEXLib("so", [
|
||||
Object(Matching, "so/SOCommon.c"),
|
||||
Object(NonMatching, "so/SOBasic.c"),
|
||||
Object(Matching, "so/SOInformation.c"),
|
||||
Object(Matching, "so/SOOption.c"),
|
||||
Object(NonMatching, "so/SOInformation.c"),
|
||||
Object(NonMatching, "so/SOOption.c"),
|
||||
]
|
||||
),
|
||||
RevoEXLib("ssl", [
|
||||
@@ -1212,7 +1212,7 @@ config.libs = [
|
||||
Object(NonMatching, "exif/exif_parse.c"),
|
||||
|
||||
Object(Matching, "reschange/iqdec_resolution_change_a3.c"),
|
||||
Object(Matching, "reschange/idct_resolution_change_var.c"),
|
||||
Object(NonMatching, "reschange/idct_resolution_change_var.c"),
|
||||
|
||||
Object(NonMatching, "texturecvtr/Texture_MCUtoY8U8V8.c"),
|
||||
Object(NonMatching, "texturecvtr/Texture_MCUtoRGB565.c"),
|
||||
@@ -1453,7 +1453,7 @@ config.libs = [
|
||||
Object(Matching, "axfx/AXFXReverbStd.c"),
|
||||
Object(Matching, "axfx/AXFXReverbStdExp.c"),
|
||||
Object(Matching, "axfx/AXFXChorus.c"),
|
||||
Object(Matching, "axfx/AXFXChorusExp.c"),
|
||||
Object(NonMatching, "axfx/AXFXChorusExp.c"),
|
||||
Object(Matching, "axfx/AXFXLfoTable.c"),
|
||||
Object(Matching, "axfx/AXFXSrcCoef.c"),
|
||||
Object(Matching, "axfx/AXFXHooks.c"),
|
||||
@@ -1692,19 +1692,19 @@ config.libs = [
|
||||
Object(Matching, "fa/pdm_disk.c"),
|
||||
Object(NonMatching, "fa/pdm_partition.c"),
|
||||
Object(NonMatching, "fa/pf_cache.c"),
|
||||
Object(Matching, "fa/pf_cluster.c"),
|
||||
Object(Matching, "fa/pf_dir.c"),
|
||||
Object(NonMatching, "fa/pf_cluster.c"),
|
||||
Object(NonMatching, "fa/pf_dir.c"),
|
||||
Object(Matching, "fa/pf_entry.c"),
|
||||
Object(Matching, "fa/pf_entry_iterator.c"),
|
||||
Object(Matching, "fa/pf_fat.c"),
|
||||
Object(Matching, "fa/pf_fat12.c"),
|
||||
Object(NonMatching, "fa/pf_entry_iterator.c"),
|
||||
Object(NonMatching, "fa/pf_fat.c"),
|
||||
Object(NonMatching, "fa/pf_fat12.c"),
|
||||
Object(Matching, "fa/pf_fat16.c"),
|
||||
Object(Matching, "fa/pf_fat32.c"),
|
||||
Object(Matching, "fa/pf_fatfs.c"),
|
||||
Object(Matching, "fa/pf_file.c"),
|
||||
Object(Matching, "fa/pf_path.c"),
|
||||
Object(NonMatching, "fa/pf_file.c"),
|
||||
Object(NonMatching, "fa/pf_path.c"),
|
||||
Object(Matching, "fa/pf_sector.c"),
|
||||
Object(Matching, "fa/pf_volume.c"),
|
||||
Object(NonMatching, "fa/pf_volume.c"),
|
||||
Object(Matching, "fa/pf_volume_apiadd.c"),
|
||||
Object(Matching, "fa/pf_cp932.c"),
|
||||
Object(Matching, "fa/pf_api_util.c"),
|
||||
@@ -1860,7 +1860,7 @@ config.libs = [
|
||||
|
||||
Object(Matching, "fa/msc/puh_msc.c"),
|
||||
Object(Matching, "fa/msc/puh_msc_cmd.c"),
|
||||
Object(Matching, "fa/msc/puh_msc_blk.c"),
|
||||
Object(NonMatching, "fa/msc/puh_msc_blk.c"),
|
||||
]
|
||||
),
|
||||
RVLSDKLib("sdi", [
|
||||
@@ -1892,7 +1892,7 @@ config.libs = [
|
||||
]
|
||||
),
|
||||
RVLSDKLib("kpr", [
|
||||
Object(Matching, "kpr/kpr_lib.c"),
|
||||
Object(NonMatching, "kpr/kpr_lib.c"),
|
||||
]
|
||||
),
|
||||
RVLSDKLib("usbkbd", [
|
||||
|
||||
@@ -37,11 +37,7 @@ namespace ipl {
|
||||
u8 unk_0x06; // 0x06
|
||||
u8 unk_0x07; // 0x07
|
||||
u8 iconFmt[8]; // 0x08
|
||||
#ifdef IPL_MEMORY_CARD_MANAGER_CPP
|
||||
volatile u16 anmFrameBits;
|
||||
#else
|
||||
u16 anmFrameBits;
|
||||
#endif
|
||||
u16 anmFrameBits; // 0x10
|
||||
#ifdef IPL_MEMORY_CARD_MANAGER_CPP
|
||||
volatile s16 anmMax;
|
||||
#else
|
||||
|
||||
@@ -197,7 +197,6 @@ namespace textinput {
|
||||
bool mbMaintainCursorCache;
|
||||
#elif defined(MYTIINPUTFORM_IMPLEMENTATION)
|
||||
protected:
|
||||
void setDrawScrollY(const f32& scroll) { mfDrawScrollY = scroll; }
|
||||
u8 mDrawState[0x27];
|
||||
f32 mfDrawScrollY;
|
||||
u8 mDrawCacheState[0x14];
|
||||
|
||||
@@ -55,7 +55,7 @@ namespace textinput {
|
||||
public:
|
||||
Animation() : mfAnimationTime(0.0f), mbInAnimation(false), mbSE(false), mpAnimObserver(NULL) {}
|
||||
|
||||
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(MYTIMANAGER_IMPLEMENTATION)
|
||||
#ifdef TIINPUTFORM_IMPLEMENTATION
|
||||
virtual void startAnm(f32 start, f32 end, f32 duration, AnimObserver* observer, void* data);
|
||||
#else
|
||||
virtual void startAnm(AnimObserver*, f32, f32, f32, void*);
|
||||
|
||||
@@ -34,14 +34,14 @@ namespace gui {
|
||||
virtual void draw(Mtx& mtx) {} // 0x14 (0x05)
|
||||
virtual void draw() {} // 0x18 (0x06)
|
||||
|
||||
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
|
||||
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
|
||||
virtual ~Interface(); // 0x1C (0x07)
|
||||
#else
|
||||
virtual ~Interface() {} // 0x1C (0x07)
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(IPL_GC_WINDOW_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
|
||||
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_WINDOW_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
|
||||
class __declspec(novtable) EventHandler {
|
||||
#else
|
||||
class EventHandler {
|
||||
|
||||
@@ -24,7 +24,7 @@ namespace ipl {
|
||||
mbDisableCon(bDisableCon) {}
|
||||
#endif
|
||||
|
||||
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
|
||||
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
|
||||
virtual ~PaneManager();
|
||||
#else
|
||||
virtual ~PaneManager() {}
|
||||
|
||||
@@ -96,7 +96,7 @@ namespace ipl {
|
||||
template <>
|
||||
class LinearIntp<VEC3> : public Interporation<VEC3> {
|
||||
public:
|
||||
LinearIntp();
|
||||
LinearIntp() {}
|
||||
virtual ~LinearIntp();
|
||||
VEC3 get() const;
|
||||
};
|
||||
|
||||
@@ -143,11 +143,7 @@ namespace ipl {
|
||||
#else
|
||||
VEC3 operator-(const VEC3& rhs) const { return VEC3(x - rhs.x, y - rhs.y, z - rhs.z); }
|
||||
#endif
|
||||
#ifdef IPL_FOCUS_OBJECT_CPP
|
||||
VEC3 operator*(f32 val) const;
|
||||
#else
|
||||
VEC3 operator*(f32 val) const { return VEC3(x * val, y * val, z * val); }
|
||||
#endif
|
||||
VEC3 operator*(f64 val) const {
|
||||
nw4r::math::VEC3 vecOut;
|
||||
VEC3Scale(&vecOut, this, (f32)val);
|
||||
|
||||
@@ -53,7 +53,24 @@ namespace ipl {
|
||||
mBScroller.init();
|
||||
}
|
||||
|
||||
BOOL calc(bool canScroll);
|
||||
BOOL calc(bool canScroll) __attribute__((never_inline)) /*for now*/ {
|
||||
BOOL result = FALSE;
|
||||
|
||||
if (canScroll) {
|
||||
if (mBScroller.calc()) {
|
||||
result = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
mScroller.calc();
|
||||
|
||||
f32 movable = mScroller.movable_pos(mBScroller.getSpeed());
|
||||
|
||||
mScroller.addScroll(movable);
|
||||
mBScroller.addSoundFreq(movable);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
BOOL is_busy() const {
|
||||
BOOL result = TRUE;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -65,11 +65,7 @@ namespace ipl {
|
||||
virtual BOOL isReady() const { return FALSE; }
|
||||
|
||||
/** @brief If the user can power off/reset the system */
|
||||
#ifdef IPL_SD_CHANNEL_TITLE_CPP
|
||||
virtual BOOL isResetAcceptable() { return TRUE; }
|
||||
#else
|
||||
virtual BOOL isResetAcceptable() const { return TRUE; }
|
||||
#endif
|
||||
/** @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 */
|
||||
|
||||
@@ -102,7 +102,12 @@ namespace ipl {
|
||||
static const char* getButtonName(int button) { return smButtonName[button]; }
|
||||
#endif
|
||||
|
||||
void setEventHandler(::gui::EventHandler * event);
|
||||
#ifdef IPL_SD_CHANNEL_SELECT_CPP
|
||||
void setEventHandler(::gui::EventHandler * event,
|
||||
::gui::EventHandler * optOutEvent = NULL);
|
||||
#else
|
||||
void setEventHandler(::gui::EventHandler * event, ::gui::EventHandler * optOutEvent);
|
||||
#endif
|
||||
|
||||
void setText(const char* paneName, u32 msgId);
|
||||
void setText(const char* paneName, const wchar_t* text);
|
||||
@@ -145,7 +150,7 @@ namespace ipl {
|
||||
ANIM_MAX,
|
||||
};
|
||||
|
||||
int mAnimWait;
|
||||
int unk_0x54;
|
||||
|
||||
layout::Object* mpLayout; // 0x58
|
||||
nand::LayoutFile* mpLayoutFile; // 0x5C
|
||||
|
||||
@@ -203,9 +203,9 @@ namespace ipl {
|
||||
bool enqueueLoadNotice();
|
||||
bool enqueuePageNotice();
|
||||
bool enqueueResultNotice(u32 result);
|
||||
bool enqueueChannelNotice(u64 titleId, u32 value);
|
||||
bool enqueueChannelNotice(u32 controller, u32 page, u32 index, u32 value);
|
||||
bool enqueueMoveNotice(u32 controller, u32 page, u32 index);
|
||||
bool enqueueStateNotice(u64 titleId, u32 state);
|
||||
bool enqueueStateNotice(u32 controller, u32 page, u32 index, u32 state);
|
||||
bool enqueueErrorNotice(u32 page, u32 index);
|
||||
bool enqueueCommandNotice(u32 page, u32 index, u32 command);
|
||||
bool enqueueDeleteNotice(u32 controller, u32 page, u32 index);
|
||||
|
||||
@@ -62,17 +62,17 @@ namespace ipl {
|
||||
void start_left_event(const char* paneName);
|
||||
void start_trig_event(const char* paneName);
|
||||
|
||||
typedef struct CmdEntry {
|
||||
typedef struct Unk {
|
||||
int command; // 0x00
|
||||
u32 msgID; // 0x04
|
||||
} CmdEntry;
|
||||
} Unk;
|
||||
|
||||
CmdEntry mCmdQueue[64];
|
||||
Unk unk_0x64[64];
|
||||
|
||||
int mQueueCapacity;
|
||||
int mQueueCount;
|
||||
int mQueueRead;
|
||||
int mQueueWrite;
|
||||
int unk_0x264;
|
||||
int unk_0x268;
|
||||
int unk_0x26C;
|
||||
int unk_0x270;
|
||||
|
||||
int mSettingArg; // 0x274
|
||||
|
||||
|
||||
@@ -89,10 +89,10 @@ namespace ipl {
|
||||
|
||||
int mIPLState; // 0x04
|
||||
volatile BS2State mState; // 0x08
|
||||
bool mbTickEnabled; // 0x0C
|
||||
bool mbUpdateRequested; // 0x0D
|
||||
bool mbAbortRequested; // 0x0E
|
||||
bool mbRestartRequested; // 0x0F
|
||||
bool unk_0x0C;
|
||||
bool unk_0x0D;
|
||||
bool unk_0x0E;
|
||||
bool unk_0x0F;
|
||||
bool mbIsDiagDisc; // 0x10
|
||||
bool mbIncludesSeatTitles; // 0x11
|
||||
u8* mpBannerBuffer; // 0x14
|
||||
|
||||
@@ -33,7 +33,7 @@ namespace ipl {
|
||||
u64 titleId; // 0x10
|
||||
bool threadTerminated; // 0x18
|
||||
bool unk_0x19;
|
||||
bool mbHasNewMessage; // 0x1A
|
||||
bool unk_0x1A;
|
||||
|
||||
EGG::ExpHeap* getHeap() { return heap; }
|
||||
} CSData;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -145,13 +145,6 @@ namespace ipl {
|
||||
mpCommonFile = commonFile;
|
||||
mpLangFile = langFile;
|
||||
}
|
||||
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
|
||||
virtual ~LangFile() {}
|
||||
virtual void read() {}
|
||||
virtual bool isFinished() { return false; }
|
||||
virtual int checkData() { return 0; }
|
||||
virtual bool isFatalError() { return false; }
|
||||
#else
|
||||
virtual ~LangFile(); // 0x08
|
||||
|
||||
virtual void read(); // 0x0C
|
||||
@@ -159,7 +152,6 @@ namespace ipl {
|
||||
virtual bool isFinished(); // 0x14
|
||||
virtual int checkData(); // 0x18
|
||||
virtual bool isFatalError(); // 0x1C
|
||||
#endif
|
||||
|
||||
File* getCmnFile() const { return mpCommonFile; }
|
||||
File* getLangFile() const { return mpLangFile; }
|
||||
@@ -173,11 +165,7 @@ namespace ipl {
|
||||
public:
|
||||
LayoutFile(EGG::Heap* heap, const char* dirName, const char* fileName, ARCHandle* arc, bool bIsNandFile);
|
||||
LayoutFile(File* commonFile, File* langFile = NULL) : LangFile(commonFile, langFile) {}
|
||||
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
|
||||
virtual ~LayoutFile() {} // 0x08
|
||||
#else
|
||||
virtual ~LayoutFile(); // 0x08
|
||||
#endif
|
||||
};
|
||||
} // namespace nand
|
||||
} // namespace ipl
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -38,19 +38,6 @@ namespace EGG {
|
||||
|
||||
virtual void calc(); // 0x30
|
||||
|
||||
#ifdef EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
|
||||
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, u32 id); // 0x34
|
||||
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, unsigned int id); // 0x38
|
||||
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, const char* pName); // 0x3C
|
||||
|
||||
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, u32 id); // 0x44
|
||||
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, unsigned int id); // 0x44
|
||||
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, const char* pName); // 0x48
|
||||
|
||||
virtual bool holdSound(nw4r::snd::SoundHandle* pHandle, u32 id); // 0x50
|
||||
virtual bool holdSound(nw4r::snd::SoundHandle* pHandle, unsigned int id); // 0x50
|
||||
virtual bool holdSound(nw4r::snd::SoundHandle* pHandle, const char* pName); // 0x58
|
||||
#else
|
||||
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, u32 id) { return mSoundArchivePlayer.StartSound(pHandle, id); } // 0x34
|
||||
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, unsigned int id) { return mSoundArchivePlayer.StartSound(pHandle, id); } // 0x38
|
||||
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, const char* pName) NO_INLINE {
|
||||
@@ -79,7 +66,6 @@ namespace EGG {
|
||||
u32 id = changeNameToId(pName);
|
||||
return mSoundArchivePlayer.HoldSound(pHandle, id);
|
||||
} // 0x58
|
||||
#endif
|
||||
|
||||
u32 changeNameToId(const char* pName) { return mpArchive->ConvertLabelStringToSoundId(pName); }
|
||||
const char* changeIdToName(u32 id) { return mpArchive->GetSoundLabelString(id); }
|
||||
|
||||
@@ -19,10 +19,6 @@ namespace EGG {
|
||||
|
||||
~SoundHeapMgr() { destroySoundHeap(); }
|
||||
|
||||
#ifdef EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
|
||||
virtual bool loadState(s32 id); // 0x08
|
||||
virtual s32 getCurrentLevel(); // 0x0C
|
||||
#else
|
||||
virtual bool loadState(s32 id) {
|
||||
#ifdef IPL_SOUND_MATCHING
|
||||
if (id > 0 && mHeap.GetCurrentLevel() >= id) {
|
||||
@@ -39,7 +35,6 @@ namespace EGG {
|
||||
} // 0x08
|
||||
|
||||
virtual s32 getCurrentLevel() { return mHeap.GetCurrentLevel(); } // 0x0C
|
||||
#endif
|
||||
|
||||
s32 saveState() { return mHeap.SaveState(); }
|
||||
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
#define EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
|
||||
|
||||
#include <egg/core.h>
|
||||
|
||||
namespace EGG {
|
||||
|
||||
@@ -1120,7 +1120,6 @@ 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"";
|
||||
@@ -1128,24 +1127,22 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
|
||||
|
||||
if (format.alternate_form) {
|
||||
wchar_t first = *wcs_ptr++;
|
||||
wideLength = (unsigned char)first;
|
||||
num_chars = (unsigned char)first;
|
||||
|
||||
if (format.precision_specified && wideLength > format.precision) {
|
||||
wideLength = format.precision;
|
||||
if (format.precision_specified && num_chars > format.precision) {
|
||||
num_chars = format.precision;
|
||||
}
|
||||
} else if (format.precision_specified) {
|
||||
wideLength = format.precision;
|
||||
num_chars = format.precision;
|
||||
|
||||
if ((string_end = wmemchr((wchar_t*)wcs_ptr, 0, wideLength)) != 0) {
|
||||
wideLength = string_end - wcs_ptr;
|
||||
if ((string_end = wmemchr((wchar_t*)wcs_ptr, 0, num_chars)) != 0) {
|
||||
num_chars = string_end - wcs_ptr;
|
||||
}
|
||||
|
||||
} else {
|
||||
wideLength = wcslen(wcs_ptr);
|
||||
num_chars = wcslen(wcs_ptr);
|
||||
}
|
||||
|
||||
num_chars = wideLength;
|
||||
|
||||
buff_ptr = wcs_ptr;
|
||||
break;
|
||||
} else {
|
||||
|
||||
@@ -1,45 +1,32 @@
|
||||
|
||||
// Yes, versions other than 4.3U align by 8.
|
||||
#if defined(VERSION_43U)
|
||||
#pragma function_align 32
|
||||
#else
|
||||
#pragma function_align 8
|
||||
#endif
|
||||
#endif // VERSION_43U
|
||||
|
||||
#include <TRK_Hollywood_Revolution.h>
|
||||
|
||||
#pragma force_active on
|
||||
|
||||
// clang-format off
|
||||
asm DSIOResult TRKAccessFile(MessageCommandID cmd, unsigned int handle, int* count, unsigned char* buffer) {
|
||||
#ifdef __MWERKS__
|
||||
// Encapsulating function to get the file to align properly
|
||||
asm void __targsupp() {
|
||||
// clang-format off
|
||||
#ifdef __MWERKS__
|
||||
nofralloc
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
#endif
|
||||
entry TRKAccessFile
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
entry TRKOpenFile
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
entry TRKCloseFile
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
entry TRKPositionFile
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
#endif // __MWERKS__
|
||||
// clang-format on
|
||||
}
|
||||
|
||||
#pragma function_align 8
|
||||
|
||||
asm DSIOResult TRKOpenFile() {
|
||||
#ifdef __MWERKS__
|
||||
nofralloc
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
#endif
|
||||
}
|
||||
|
||||
asm DSIOResult TRKCloseFile() {
|
||||
#ifdef __MWERKS__
|
||||
nofralloc
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
#endif
|
||||
}
|
||||
|
||||
asm DSIOResult TRKPositionFile() {
|
||||
#ifdef __MWERKS__
|
||||
nofralloc
|
||||
twi 31, r0, 0
|
||||
blr
|
||||
#endif
|
||||
}
|
||||
// clang-format on
|
||||
|
||||
@@ -19,13 +19,8 @@ namespace nw4r {
|
||||
template <typename T>
|
||||
class AutoLock : private NonCopyable {
|
||||
public:
|
||||
#ifdef EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
|
||||
explicit AutoLock(T& rLockObj);
|
||||
~AutoLock();
|
||||
#else
|
||||
explicit AutoLock(T& rLockObj) : mLockObj(rLockObj) { Lock(rLockObj); }
|
||||
~AutoLock() { Unlock(mLockObj); }
|
||||
#endif
|
||||
|
||||
private:
|
||||
T& mLockObj; // 0x00
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
#include <nw4r/db/assert.h>
|
||||
|
||||
extern "C" const u8 scLytFatalColorR;
|
||||
extern "C" const u8 scLytFatalColorG;
|
||||
extern "C" const u8 scLytFatalColorB;
|
||||
extern "C" const u8 scLytFatalColorA;
|
||||
extern "C" const u8 scLytFatalColorR = 255;
|
||||
extern "C" const u8 scLytFatalColorG = 255;
|
||||
extern "C" const u8 scLytFatalColorB = 255;
|
||||
extern "C" const u8 scLytFatalColorA = 0;
|
||||
extern "C" char scLytFatalMsg[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
|
||||
|
||||
#undef NW4R_ASSERT
|
||||
#define NW4R_GLOBAL_ASSERT(x) \
|
||||
#define NW4R_ASSERT(x) \
|
||||
{ \
|
||||
if (!(x)) { \
|
||||
GXColor front = {*((volatile const u8*)&::scLytFatalColorR), *((volatile const u8*)&::scLytFatalColorG), \
|
||||
@@ -17,15 +17,6 @@ extern "C" char scLytFatalMsg[] = "Error#004\nAn error has occurred.\nThe system
|
||||
} \
|
||||
}
|
||||
|
||||
#define NW4R_ASSERT(x) \
|
||||
{ \
|
||||
if (!(x)) { \
|
||||
GXColor front = {255, 255, 255, 0}; \
|
||||
GXColor back = {0, 0, 0, 0}; \
|
||||
OSFatal((GXColor)front, (GXColor)back, ::scLytFatalMsg); \
|
||||
} \
|
||||
}
|
||||
|
||||
#include <nw4r/lyt/window.h>
|
||||
|
||||
#include <nw4r/lyt/common.h>
|
||||
@@ -497,7 +488,7 @@ namespace nw4r {
|
||||
}
|
||||
|
||||
Material* Window::GetFrameMaterial(u32 frameIdx) const {
|
||||
NW4R_GLOBAL_ASSERT(frameIdx < WINDOWFRAME_MAX);
|
||||
NW4R_ASSERT(frameIdx < WINDOWFRAME_MAX);
|
||||
if (frameIdx >= mFrameNum) {
|
||||
return NULL;
|
||||
}
|
||||
@@ -510,8 +501,3 @@ namespace nw4r {
|
||||
}
|
||||
} // namespace lyt
|
||||
} // namespace nw4r
|
||||
|
||||
extern "C" const u8 scLytFatalColorR = 255;
|
||||
extern "C" const u8 scLytFatalColorG = 255;
|
||||
extern "C" const u8 scLytFatalColorB = 255;
|
||||
extern "C" const u8 scLytFatalColorA = 0;
|
||||
|
||||
@@ -314,7 +314,7 @@ namespace nw4r {
|
||||
ArchiveFontBase::ConstructState ArchiveFontBase::ConstructOpAnalyzeGLGR(ConstructContext* ctx, CachedStreamReader* reader) {
|
||||
u32 glgrInnerLen;
|
||||
HeaderedGlyphGroups* pGlgr;
|
||||
const ArchiveFontBinaryLayout* font;
|
||||
ArchiveFontBinaryLayout* font;
|
||||
u8* glgrEnd;
|
||||
|
||||
u32 expectedMaxSize;
|
||||
@@ -337,7 +337,7 @@ namespace nw4r {
|
||||
|
||||
// Copy the glgr to work
|
||||
{
|
||||
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
|
||||
pGlgr = &font->glgr;
|
||||
glgrEnd = (u8*)pGlgr + (u32)ctx->mNextBlockHdr.size;
|
||||
|
||||
memcpy(pGlgr, &ctx->mNextBlockHdr, sizeof(BinaryBlockHeader));
|
||||
@@ -368,21 +368,21 @@ namespace nw4r {
|
||||
|
||||
u32 sheetOffsetsScratchSize;
|
||||
|
||||
sheetGlyphCount = font->glgr.inner.sheetGlyphCount; // 0x1C
|
||||
dataBlockCount = font->hdr.dataBlocks; // 0x0E
|
||||
sheetGlyphCount = font->glgr.inner.sheetGlyphCount; // 0x1C
|
||||
// countName = font->glgr.inner.nameCount;
|
||||
countSheet = font->glgr.inner.sheetCount;
|
||||
// count0A = font->glgr.inner.smthCount_0x0a;
|
||||
// count0C = font->glgr.inner.smthCount_0x0c;
|
||||
sheetOffsetsSize = ROUNDUP(countSheet * sizeof(u16), 4);
|
||||
sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)font + ctx->remWorkSpace()) - sheetOffsetsSize, 2);
|
||||
|
||||
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;
|
||||
pGlgr = &font->glgr;
|
||||
ENSURE_WORK_HAS_SIZE(ctx, glgrEnd - (u8*)font + sheetOffsetsSize);
|
||||
// if (ctx->pWorkEnd - workCurr < fontSizeToEndOfGlgr + sheetOffsetsSize) {
|
||||
// return CONSTRUCT_STATE_FATAL_ERR;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -10,12 +10,14 @@ static TMCHuffmanEntry readHuffmanEntry(const TMCHuffmanEntry* entries, u32 inde
|
||||
return entries[index];
|
||||
}
|
||||
|
||||
static void readHuffmanLimit(const TMCHuffmanEntry* entries, TMCHuffmanEntry* limit) {
|
||||
limit->bitLength = entries->bitLength;
|
||||
limit->symbol = entries->symbol;
|
||||
static TMCHuffmanEntry readHuffmanLimit(const TMCHuffmanEntry* entries) {
|
||||
TMCHuffmanEntry limit;
|
||||
limit.bitLength = entries->bitLength;
|
||||
limit.symbol = entries->symbol;
|
||||
return limit;
|
||||
}
|
||||
|
||||
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
|
||||
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work) {
|
||||
u32 bitData;
|
||||
u32 code;
|
||||
u32 length;
|
||||
@@ -49,21 +51,17 @@ static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table,
|
||||
code |= (bitData >> bitCount) & 1;
|
||||
read_entry:
|
||||
{
|
||||
readHuffmanLimit(entry, limit);
|
||||
*decoded = *limit;
|
||||
if (code > (u32)decoded->bitLength) {
|
||||
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
|
||||
if (code > (u32)decoded.bitLength) {
|
||||
continue;
|
||||
}
|
||||
{
|
||||
u32 relativeCode = code - entry->bitLength;
|
||||
u32 symbolIndex = relativeCode + entry->symbol;
|
||||
return symbols[symbolIndex & 0xFF];
|
||||
}
|
||||
code = code - entry->bitLength + entry->symbol;
|
||||
return symbols[code & 0xFF];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
|
||||
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work) {
|
||||
u32 bitData;
|
||||
u32 code;
|
||||
u32 length;
|
||||
@@ -96,41 +94,33 @@ static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, co
|
||||
code |= (bitData >> bitCount) & 1;
|
||||
read_entry:
|
||||
{
|
||||
readHuffmanLimit(entry, limit);
|
||||
*decoded = *limit;
|
||||
if (code > (u32)decoded->bitLength) {
|
||||
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
|
||||
if (code > (u32)decoded.bitLength) {
|
||||
continue;
|
||||
}
|
||||
{
|
||||
u32 relativeCode = code - entry->bitLength;
|
||||
u32 symbolIndex = relativeCode + entry->symbol;
|
||||
return symbols[symbolIndex & 0xFF];
|
||||
}
|
||||
code = code - entry->bitLength + entry->symbol;
|
||||
return symbols[code & 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;
|
||||
u8* huff_sym;
|
||||
TMCHuffmanEntry acEntry;
|
||||
const TMCHuffmanEntry* ac_fast;
|
||||
s32 idx;
|
||||
u8* huff_sym;
|
||||
u32* huff_tbl;
|
||||
s32 bit_pos;
|
||||
u32 bit_data;
|
||||
u32 tmp;
|
||||
const TMCHuffmanEntry* dc_fast;
|
||||
s32 r;
|
||||
s32 blk0;
|
||||
TMCHuffmanEntry acEntry;
|
||||
s32 idx;
|
||||
s32 extra;
|
||||
s32 t;
|
||||
s32 zz;
|
||||
s32 q;
|
||||
const TMCHuffmanEntry* dc_fast;
|
||||
u32 tmp;
|
||||
const u8* zztbl;
|
||||
|
||||
bit_pos = work->bitCount;
|
||||
@@ -145,19 +135,22 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
|
||||
|
||||
bit_pos = work->bitCount;
|
||||
bit_data = work->bitBuf;
|
||||
tmp = bit_pos - 8;
|
||||
tmp = ((bit_data >> tmp) & 0xFF) << 2;
|
||||
{
|
||||
dcEntry = readHuffmanEntry(dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
|
||||
dcEntry = readHuffmanEntry(dc_fast, tmp >> 2);
|
||||
r = dcEntry.bitLength;
|
||||
extra = dcEntry.symbol;
|
||||
}
|
||||
|
||||
if (r != 0) {
|
||||
work->bitCount = bit_pos - r;
|
||||
bit_pos -= r;
|
||||
work->bitCount = bit_pos;
|
||||
r = extra;
|
||||
} else {
|
||||
huff_sym = work->pDCHuffSym;
|
||||
huff_tbl = work->pDCHuffTbl;
|
||||
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &dcLimit, &dcDecoded);
|
||||
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
|
||||
if (r < 0) {
|
||||
return r;
|
||||
}
|
||||
@@ -217,7 +210,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, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &acLimit, &acDecoded);
|
||||
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
|
||||
if (r < 0) {
|
||||
return r;
|
||||
}
|
||||
|
||||
@@ -16,7 +16,7 @@ static u16 readU16(const u8* p, u16 byteOrder) {
|
||||
}
|
||||
|
||||
static u16 readExifU16(const u8* data, u16 byteOrder) {
|
||||
u16 value = data[0] | data[1] << 8;
|
||||
u32 value = data[0] | data[1] << 8;
|
||||
if (byteOrder == 0x4949) {
|
||||
return (u16)value;
|
||||
}
|
||||
@@ -246,9 +246,9 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
|
||||
u32 ifdOffset;
|
||||
const u8* entries;
|
||||
u16 remaining;
|
||||
u16 index;
|
||||
s32 entriesSize;
|
||||
u16 count;
|
||||
s32 entriesSize;
|
||||
u16 index;
|
||||
pInfo->thumbnailData = (u8*)data;
|
||||
pInfo->dataEnd = (u8*)data + size;
|
||||
pInfo->nextIfdOffset = 0;
|
||||
@@ -339,7 +339,7 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
|
||||
}
|
||||
|
||||
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry) {
|
||||
s32 tag;
|
||||
u16 tag;
|
||||
u16 type;
|
||||
|
||||
tag = readU16(entry, byteOrder);
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -567,7 +567,7 @@ s32 TMCJPEGDEC_scan_varinit(TMCCJPEGDecWork* work) {
|
||||
|
||||
p->mcuYCount = p->mcuYCount + ((u8)remX != 0 ? 1 : 0);
|
||||
p->mcuXCount2 = p->mcuXCount2 + ((u8)remY != 0 ? 1 : 0);
|
||||
p->mcuTotal = (u32)p->mcuYCount * (u32)p->mcuXCount2;
|
||||
p->unk_0x14 = (u32)p->mcuYCount * (u32)p->mcuXCount2;
|
||||
|
||||
for (idx = 0; idx < (s32)p->scanCompCount; idx++) {
|
||||
u8 compId;
|
||||
@@ -1929,7 +1929,7 @@ static s32 TMCJPEGDEC_parse_sof(TMCCJPEGDecWork* work) {
|
||||
mcuCountY += yr;
|
||||
frameInfo->mcuYCount = mcuCountX;
|
||||
frameInfo->mcuXCount2 = mcuCountY;
|
||||
work->mcuTotal = (u32)mcuCountX * (u32)mcuCountY;
|
||||
work->unk_0x1804 = (u32)mcuCountX * (u32)mcuCountY;
|
||||
}
|
||||
|
||||
compCount2 = frameInfo->compCount;
|
||||
|
||||
@@ -15,13 +15,9 @@ static s8 clampS8(s32 v) {
|
||||
|
||||
void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
|
||||
s32 bd;
|
||||
s32 d;
|
||||
s32 c;
|
||||
s32 a;
|
||||
s32 cd;
|
||||
s32 oddrot;
|
||||
s32 evsum;
|
||||
s32 rot;
|
||||
s32 d;
|
||||
s32 b;
|
||||
|
||||
s32* sp;
|
||||
@@ -30,41 +26,57 @@ void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag
|
||||
s32 tmp[64];
|
||||
s32 i;
|
||||
|
||||
s32 evsum, rot, oddrot, cd;
|
||||
|
||||
sp = block + 24;
|
||||
dp = tmp + 24;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
s32 a, b, c, d;
|
||||
s32 odddiff, bd, evsum, cd, rot, oddrot;
|
||||
a = sp[0];
|
||||
b = sp[1];
|
||||
c = sp[2];
|
||||
d = sp[3];
|
||||
odddiff = b - d;
|
||||
for (i = 0; i < 2; i++) {
|
||||
a = sp[0]; // 0x0
|
||||
b = sp[1]; // 0x4
|
||||
c = sp[2]; // 0x8
|
||||
d = sp[3]; // 0xc
|
||||
bd = b + d;
|
||||
evsum = a + c;
|
||||
cd = a - c;
|
||||
rot = (odddiff * 0xB5) >> 8;
|
||||
oddrot = rot + bd;
|
||||
dp[0] = evsum + oddrot;
|
||||
dp[1] = cd + rot;
|
||||
dp[2] = cd - rot;
|
||||
|
||||
oddrot = (0xB5 * (sp[1] - sp[3]) >> 8) + bd;
|
||||
rot = (0xB5 * (sp[1] - sp[3])) >> 8;
|
||||
|
||||
dp[1] = (a - c) + rot;
|
||||
dp[2] = (a - c) - rot;
|
||||
dp[3] = evsum - oddrot;
|
||||
sp -= 8;
|
||||
dp -= 8;
|
||||
dp[0] = evsum + oddrot;
|
||||
|
||||
b = sp[-7]; // -0x1c
|
||||
d = sp[-5]; // -0x14
|
||||
|
||||
bd = b + d;
|
||||
rot = ((b - d) * 0xB5) >> 8;
|
||||
oddrot = rot + bd;
|
||||
|
||||
a = sp[-8]; // -0x20
|
||||
c = sp[-6]; // -0x18
|
||||
|
||||
dp[-8] = (a + c) + oddrot;
|
||||
dp[-7] = (a - c) + rot;
|
||||
dp[-6] = (a - c) - rot;
|
||||
dp[-5] = (a + c) - oddrot;
|
||||
|
||||
sp -= 16;
|
||||
dp -= 16;
|
||||
}
|
||||
|
||||
{
|
||||
u32 idx = 3;
|
||||
sp = tmp + 3;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
u8* bp = conv_row_ptr + idx;
|
||||
|
||||
a = tmp[idx] + 0x40000;
|
||||
b = tmp[idx + 8];
|
||||
d = tmp[idx + 24];
|
||||
c = tmp[idx + 16];
|
||||
a = sp[0] + 0x40000;
|
||||
b = sp[8];
|
||||
d = sp[24];
|
||||
c = sp[16];
|
||||
|
||||
evsum = a + c;
|
||||
cd = a - c;
|
||||
@@ -78,6 +90,7 @@ void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag
|
||||
bp[pitch * 2] = clampU8((cd - rot) >> 11);
|
||||
bp[pitch * 4 - pitch] = clampU8((evsum - oddrot) >> 11);
|
||||
|
||||
sp--;
|
||||
idx -= 1;
|
||||
}
|
||||
}
|
||||
@@ -118,37 +131,38 @@ void TMCJPEGDEC_IdctBlock4x4_Col(s32* sp, u8* conv_row_ptr, u16 pitch, s32 zigza
|
||||
s32 a, b, c, d;
|
||||
s32 evsum, evdiff, oddsum, odddiff, rot, oddrot;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
a = src[0];
|
||||
b = src[1];
|
||||
c = src[2];
|
||||
d = src[3];
|
||||
odddiff = b - d;
|
||||
oddsum = b + d;
|
||||
evsum = a + c;
|
||||
evdiff = a - c;
|
||||
rot = (odddiff * 0xB5) >> 8;
|
||||
oddrot = rot + oddsum;
|
||||
dst[0] = evsum + oddrot;
|
||||
dst[1] = evdiff + rot;
|
||||
dst[2] = evdiff - rot;
|
||||
dst[3] = evsum - oddrot;
|
||||
src -= 8;
|
||||
dst -= 8;
|
||||
for (i = 0; i < 2; i++) {
|
||||
s32 a0 = src[0], b0 = src[1], c0 = src[2], d0 = src[3];
|
||||
s32 a1 = src[-8], b1 = src[-7], c1 = src[-6], d1 = src[-5];
|
||||
|
||||
s32 odddiff0 = b0 - d0;
|
||||
s32 oddsum0 = b0 + d0;
|
||||
s32 evsum0 = a0 + c0;
|
||||
s32 evdiff0 = a0 - c0;
|
||||
s32 rot0 = (odddiff0 * 0xB5) >> 8;
|
||||
|
||||
s32 odddiff1 = b1 - d1;
|
||||
s32 oddsum1 = b1 + d1;
|
||||
s32 evsum1 = a1 + c1;
|
||||
s32 evdiff1 = a1 - c1;
|
||||
s32 rot1 = (odddiff1 * 0xB5) >> 8;
|
||||
|
||||
dst[0] = evsum0 + (oddsum0 + rot0);
|
||||
dst[1] = evdiff0 + rot0;
|
||||
dst[2] = evdiff0 - rot0;
|
||||
dst[3] = evsum0 - (oddsum0 + rot0);
|
||||
|
||||
dst[-8] = evsum1 + (oddsum1 + rot1);
|
||||
dst[-7] = evdiff1 + rot1;
|
||||
dst[-6] = evdiff1 - rot1;
|
||||
dst[-5] = evsum1 - (oddsum1 + rot1);
|
||||
|
||||
src -= 16;
|
||||
dst -= 16;
|
||||
}
|
||||
|
||||
src = tmp + 3;
|
||||
for (i = 3; i >= 0; i--) {
|
||||
s32 evdiff;
|
||||
s32 a;
|
||||
s32 c;
|
||||
s32 b;
|
||||
s32 evsum;
|
||||
s32 d;
|
||||
s32 oddsum;
|
||||
s32 odddiff;
|
||||
s32 rot;
|
||||
s32 oddrot;
|
||||
u8* out = conv_row_ptr + i;
|
||||
a = src[0];
|
||||
b = src[8];
|
||||
@@ -156,7 +170,7 @@ void TMCJPEGDEC_IdctBlock4x4_Col(s32* sp, u8* conv_row_ptr, u16 pitch, s32 zigza
|
||||
d = src[24];
|
||||
|
||||
odddiff = b - d;
|
||||
oddsum = d + b;
|
||||
oddsum = b + d;
|
||||
evsum = a + c;
|
||||
evdiff = a - c;
|
||||
rot = odddiff * 0xB5 >> 8;
|
||||
|
||||
@@ -166,23 +166,23 @@ s32 TMCJPEGDEC_set_converterRGBA8(TMCCJPEGDecWork* work) {
|
||||
}
|
||||
|
||||
static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
s32 red;
|
||||
s8 crValue;
|
||||
u8* luminance;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
TMCCJPEGDecState* state;
|
||||
u8* texture;
|
||||
s32 height;
|
||||
s32 column;
|
||||
s32 yEnd;
|
||||
s32 xEnd;
|
||||
s32 green;
|
||||
s32 yEnd;
|
||||
s32 column;
|
||||
s32 tileWidth;
|
||||
s32 blueOffset;
|
||||
u16* output;
|
||||
s32 tileRow;
|
||||
s32 lumaSkip;
|
||||
s8 crValue;
|
||||
s32 red;
|
||||
s32 chromaSkip;
|
||||
s32 width;
|
||||
s32 cbValue;
|
||||
@@ -216,7 +216,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
cbValue = (s8)*cb++;
|
||||
crValue = (s8)*cr++;
|
||||
redOffset = (crValue * 359) >> 8;
|
||||
greenOffset = -(crValue * 183 + cbValue * 88) >> 8;
|
||||
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
|
||||
blueOffset = (cbValue * 454) >> 8;
|
||||
}
|
||||
{
|
||||
@@ -224,7 +224,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
if ((red | green | blue) >> 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;
|
||||
@@ -238,7 +238,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
if ((red | green | blue) >> 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;
|
||||
@@ -252,7 +252,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
if ((red | green | blue) >> 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;
|
||||
@@ -266,7 +266,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
if ((red | green | blue) >> 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;
|
||||
@@ -285,20 +285,20 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
}
|
||||
|
||||
static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
s32 chromaSkip;
|
||||
s32 tileRow;
|
||||
s32 xEnd;
|
||||
u8* texture;
|
||||
TMCCJPEGDecState* state;
|
||||
s32 column;
|
||||
u8* luminance;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
TMCCJPEGDecState* state;
|
||||
s32 tileWidth;
|
||||
u8* texture;
|
||||
s32 width;
|
||||
s32 height;
|
||||
u8* cr;
|
||||
s32 column;
|
||||
s32 lumaSkip;
|
||||
s32 xEnd;
|
||||
s32 yEnd;
|
||||
s32 tileWidth;
|
||||
s32 lumaSkip;
|
||||
s32 chromaSkip;
|
||||
s32 tileRow;
|
||||
u16* output;
|
||||
s32 cbValue;
|
||||
s8 crValue;
|
||||
@@ -345,7 +345,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
red = blue + redOffset;
|
||||
green = blue + greenOffset;
|
||||
blue = blue + blueOffset;
|
||||
if ((green | red | 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;
|
||||
@@ -366,11 +366,11 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
|
||||
static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
s32 chromaSkip;
|
||||
s32 lumaSkip;
|
||||
s32 blue;
|
||||
s32 cbValue;
|
||||
s32 tileWidth;
|
||||
TMCCJPEGDecState* state;
|
||||
u16* output;
|
||||
s32 xEnd;
|
||||
u8* texture;
|
||||
s32 width;
|
||||
s32 height;
|
||||
@@ -379,7 +379,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
s32 red;
|
||||
u8* cr;
|
||||
s32 column;
|
||||
s32 xEnd;
|
||||
u16* output;
|
||||
s32 yEnd;
|
||||
s32 redOffset;
|
||||
s32 tileRow;
|
||||
@@ -387,7 +387,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
s32 blueOffset;
|
||||
s32 value;
|
||||
s32 green;
|
||||
s32 blue;
|
||||
s32 lumaSkip;
|
||||
s32 crValue;
|
||||
|
||||
luminance = work->convBuf + 4;
|
||||
@@ -415,7 +415,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
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;
|
||||
@@ -426,7 +426,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
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;
|
||||
@@ -441,21 +441,21 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
}
|
||||
|
||||
static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
s32 blue;
|
||||
u16* output;
|
||||
s32 xEnd;
|
||||
s32 column;
|
||||
u8* luminance;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
TMCCJPEGDecState* state;
|
||||
s32 tileWidth;
|
||||
u8* luminance;
|
||||
u8* texture;
|
||||
s32 width;
|
||||
s32 height;
|
||||
u8* cb;
|
||||
u8* texture;
|
||||
s32 column;
|
||||
s32 chromaSkip;
|
||||
s32 xEnd;
|
||||
s32 yEnd;
|
||||
s32 lumaSkip;
|
||||
s32 chromaSkip;
|
||||
s32 tileRow;
|
||||
u16* output;
|
||||
s32 cbValue;
|
||||
s32 crValue;
|
||||
s32 redOffset;
|
||||
@@ -463,7 +463,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
s32 blueOffset;
|
||||
s32 value;
|
||||
s32 red;
|
||||
s32 lumaSkip;
|
||||
s32 blue;
|
||||
s32 green;
|
||||
|
||||
luminance = work->convBuf + 4;
|
||||
@@ -502,7 +502,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
green = value + greenOffset;
|
||||
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;
|
||||
@@ -517,19 +517,19 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
}
|
||||
|
||||
static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
s32 tileRow;
|
||||
s32 blue;
|
||||
s8 crValue;
|
||||
s32 chromaSkip;
|
||||
u8* luminance;
|
||||
TMCCJPEGDecState* state;
|
||||
u8* texture;
|
||||
s32 xEnd;
|
||||
s32 width;
|
||||
s32 height;
|
||||
s32 green;
|
||||
s32 blue;
|
||||
s32 blueOffset;
|
||||
u8* texture;
|
||||
s32 lumaSkip;
|
||||
s32 yEnd;
|
||||
s32 xEnd;
|
||||
s32 tileRow;
|
||||
s32 value;
|
||||
s32 column;
|
||||
u8* cr;
|
||||
@@ -538,7 +538,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
s32 redOffset;
|
||||
u8* cb;
|
||||
u16* output;
|
||||
s32 blueOffset;
|
||||
s32 green;
|
||||
s32 red;
|
||||
s32 cbValue;
|
||||
|
||||
@@ -578,7 +578,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
|
||||
|
||||
|
||||
if ((red | green | blue) >> 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;
|
||||
@@ -593,7 +593,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
if ((red | green | blue) >> 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;
|
||||
@@ -620,11 +620,11 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u8* luminance = work->convBuf + 4;
|
||||
u8* cb = work->convBuf + 260;
|
||||
s32 width;
|
||||
u8* cr = work->convBuf + 324;
|
||||
TMCCJPEGDecState* state = work->pState;
|
||||
s32 tileWidth = (state->convWidth >> 2) << 1;
|
||||
u8* texture = state->pTexBuffer;
|
||||
u8* cr = work->convBuf + 324;
|
||||
s32 width;
|
||||
s32 height;
|
||||
if (state->dataSizeX == (u32)x) {
|
||||
width = state->stepXExt;
|
||||
@@ -660,7 +660,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
s32 green = value + greenOffset;
|
||||
s32 red = value + redOffset;
|
||||
s32 blue = value + blueOffset;
|
||||
if ((green | red | 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;
|
||||
@@ -686,7 +686,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
|
||||
static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u16* output;
|
||||
s32 tileRow;
|
||||
s32 column;
|
||||
s32 redOffset;
|
||||
TMCCJPEGDecState* state;
|
||||
s32 lumaSkip;
|
||||
@@ -695,7 +695,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
s32 height;
|
||||
s32 column;
|
||||
s32 tileRow;
|
||||
s32 chromaSkip;
|
||||
s32 width;
|
||||
s32 xEnd;
|
||||
@@ -742,7 +742,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
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;
|
||||
@@ -770,7 +770,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
u16* output;
|
||||
s32 lumaSkip;
|
||||
s32 blue;
|
||||
u8* texture;
|
||||
s32 tileRow;
|
||||
u8* luminance;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
@@ -783,7 +783,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
s32 greenOffset;
|
||||
s32 yEnd;
|
||||
s32 cbValue;
|
||||
s32 tileRow;
|
||||
u8* texture;
|
||||
s32 blueOffset;
|
||||
s32 red;
|
||||
s8 crValue;
|
||||
@@ -831,7 +831,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
green = value + greenOffset;
|
||||
red = value + redOffset;
|
||||
blue = value + blueOffset;
|
||||
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;
|
||||
@@ -856,20 +856,20 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
|
||||
|
||||
static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u16* output;
|
||||
s32 tileWidth;
|
||||
s32 tileRow;
|
||||
s32 rowSkip;
|
||||
u8* texture;
|
||||
s32 xEnd;
|
||||
u8* luminance;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
TMCCJPEGDecState* state;
|
||||
s32 crValue;
|
||||
s8 crValue;
|
||||
s32 height;
|
||||
s32 width;
|
||||
s32 column;
|
||||
s32 xEnd;
|
||||
s32 rowSkip;
|
||||
s32 yEnd;
|
||||
s32 tileWidth;
|
||||
u8* texture;
|
||||
s32 row;
|
||||
s32 red;
|
||||
s32 cbValue;
|
||||
@@ -899,7 +899,7 @@ static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
|
||||
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;
|
||||
|
||||
@@ -171,7 +171,9 @@ s32 TMCJPEGDEC_set_converterY8U8V8(TMCCJPEGDecWork* work) {
|
||||
static void TMCJPEG_814EFEAC(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
s32 rowSkip;
|
||||
u8* output;
|
||||
s32 chromaXEnd;
|
||||
u32 tileRow;
|
||||
u32 chromaTileWidth;
|
||||
s32 chromaYEnd;
|
||||
u8* lumaTexture;
|
||||
TMCCJPEGDecState* state;
|
||||
@@ -214,17 +216,17 @@ static void TMCJPEG_814EFEAC(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
}
|
||||
luminance += rowSkip;
|
||||
}
|
||||
tileWidth = state->chromaWidth >> 3;
|
||||
chromaTileWidth = state->chromaWidth >> 3;
|
||||
x = (u32)x >> 2;
|
||||
width = 8 / state->scaleFactor;
|
||||
height = 8 / state->scaleFactor;
|
||||
xEnd = x + width;
|
||||
chromaXEnd = x + width;
|
||||
chromaYEnd = y + height;
|
||||
for (; y < chromaYEnd; y++) {
|
||||
for (column = x; column < xEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
|
||||
for (column = x; column < chromaXEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
|
||||
cb++;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
|
||||
cr++;
|
||||
}
|
||||
cb += 8 - width;
|
||||
@@ -233,6 +235,7 @@ static void TMCJPEG_814EFEAC(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
}
|
||||
|
||||
static void TMCJPEG_814F043C(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u32 chromaTileWidth;
|
||||
TMCCJPEGDecState* state;
|
||||
u8* lumaTexture;
|
||||
u8* luminance;
|
||||
@@ -247,9 +250,9 @@ static void TMCJPEG_814F043C(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u8* output;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
s32 width;
|
||||
s32 tileOffset;
|
||||
s32 xEnd;
|
||||
s32 tileOffset;
|
||||
s32 width;
|
||||
u32 tileWidth;
|
||||
|
||||
luminance = work->convBuf + 4;
|
||||
@@ -284,13 +287,13 @@ static void TMCJPEG_814F043C(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
x = (u32)x >> 2;
|
||||
width = (width + 3) >> 2;
|
||||
xEnd = x + width;
|
||||
tileWidth = state->chromaWidth >> 3;
|
||||
chromaTileWidth = state->chromaWidth >> 3;
|
||||
chromaEnd = y + height;
|
||||
for (; y < chromaEnd; y++) {
|
||||
for (column = x; column < xEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
|
||||
cb++;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
|
||||
cr++;
|
||||
}
|
||||
cb += 8 - width;
|
||||
@@ -303,7 +306,9 @@ static void TMCJPEG_814F0A58(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u8* lumaTexture;
|
||||
u8* luminance;
|
||||
s32 column;
|
||||
s32 chromaXEnd;
|
||||
s32 row;
|
||||
u32 chromaTileWidth;
|
||||
TMCCJPEGDecState* state;
|
||||
s32 width;
|
||||
s32 height;
|
||||
@@ -314,6 +319,7 @@ static void TMCJPEG_814F0A58(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u8* cb;
|
||||
u32 tileWidth;
|
||||
u8* cr;
|
||||
s32 chromaRowSkip;
|
||||
|
||||
row = y;
|
||||
luminance = work->convBuf + 4;
|
||||
@@ -338,22 +344,24 @@ static void TMCJPEG_814F0A58(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
x = (u32)x >> 1;
|
||||
width = 8 / state->scaleFactor;
|
||||
height = 8 / state->scaleFactor;
|
||||
xEnd = x + width;
|
||||
chromaXEnd = x + width;
|
||||
chromaYEnd = y + height;
|
||||
tileWidth = state->chromaWidth >> 3;
|
||||
for (row = y; row < chromaYEnd; row++) {
|
||||
for (column = x; column < xEnd; column += 1) {
|
||||
(cbTexture + ((row & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (row >> 2) * tileWidth) << 5)] = *cb + 128;
|
||||
chromaTileWidth = state->chromaWidth >> 3;
|
||||
chromaRowSkip = 8 - width;
|
||||
for (; y < chromaYEnd; y++) {
|
||||
for (column = x; column < chromaXEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
|
||||
cb++;
|
||||
(crTexture + ((row & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (row >> 2) * tileWidth) << 5)] = *cr + 128;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
|
||||
cr++;
|
||||
}
|
||||
cb += 8 - width;
|
||||
cb += chromaRowSkip;
|
||||
cr += 8 - width;
|
||||
}
|
||||
}
|
||||
|
||||
static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u32 chromaTileWidth;
|
||||
TMCCJPEGDecState* state;
|
||||
u8* lumaTexture;
|
||||
u8* luminance;
|
||||
@@ -368,9 +376,9 @@ static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u8* output;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
s32 width;
|
||||
s32 tileOffset;
|
||||
s32 xEnd;
|
||||
s32 tileOffset;
|
||||
s32 width;
|
||||
u32 tileWidth;
|
||||
|
||||
luminance = work->convBuf + 4;
|
||||
@@ -405,13 +413,13 @@ static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
x = (u32)x >> 1;
|
||||
width = (width + 1) >> 1;
|
||||
xEnd = x + width;
|
||||
tileWidth = state->chromaWidth >> 3;
|
||||
chromaTileWidth = state->chromaWidth >> 3;
|
||||
chromaEnd = y + height;
|
||||
for (; y < chromaEnd; y++) {
|
||||
for (column = x; column < xEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
|
||||
cb++;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
|
||||
cr++;
|
||||
}
|
||||
cb += 8 - width;
|
||||
@@ -420,21 +428,23 @@ static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
}
|
||||
|
||||
static void TMCJPEG_814F17E0(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
s32 chromaYEnd;
|
||||
u8* lumaTexture;
|
||||
s32 height;
|
||||
u8* luminance;
|
||||
s32 chromaYEnd;
|
||||
s32 column;
|
||||
u8* lumaTexture;
|
||||
s32 chromaXEnd;
|
||||
u8* luminance;
|
||||
u32 chromaTileWidth;
|
||||
u8* cbTexture;
|
||||
s32 row;
|
||||
s32 width;
|
||||
u8* crTexture;
|
||||
s32 xEnd;
|
||||
u32 tileWidth;
|
||||
u8* cb;
|
||||
TMCCJPEGDecState* state;
|
||||
s32 yEnd;
|
||||
s32 width;
|
||||
s32 xEnd;
|
||||
u8* cr;
|
||||
u32 tileWidth;
|
||||
s32 row;
|
||||
|
||||
row = y;
|
||||
luminance = work->convBuf + 4;
|
||||
@@ -460,14 +470,14 @@ static void TMCJPEG_814F17E0(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
y = (u32)y >> 1;
|
||||
width = 8 / state->scaleFactor;
|
||||
height = 8 / state->scaleFactor;
|
||||
xEnd = x + width;
|
||||
chromaXEnd = x + width;
|
||||
chromaYEnd = y + height;
|
||||
tileWidth = state->chromaWidth >> 3;
|
||||
chromaTileWidth = state->chromaWidth >> 3;
|
||||
for (; y < chromaYEnd; y++) {
|
||||
for (column = x; column < xEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
|
||||
for (column = x; column < chromaXEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
|
||||
cb++;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
|
||||
cr++;
|
||||
}
|
||||
cb += 8 - width;
|
||||
@@ -476,6 +486,7 @@ static void TMCJPEG_814F17E0(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
}
|
||||
|
||||
static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u32 chromaTileWidth;
|
||||
TMCCJPEGDecState* state;
|
||||
u8* lumaTexture;
|
||||
u8* luminance;
|
||||
@@ -486,13 +497,13 @@ static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u8* crTexture;
|
||||
u32 tileRow;
|
||||
s32 height;
|
||||
s32 width;
|
||||
s32 yEnd;
|
||||
u8* output;
|
||||
u8* cb;
|
||||
u8* cr;
|
||||
s32 xEnd;
|
||||
s32 tileOffset;
|
||||
s32 yEnd;
|
||||
s32 width;
|
||||
u32 tileWidth;
|
||||
|
||||
luminance = work->convBuf + 4;
|
||||
@@ -528,13 +539,13 @@ static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
x = (u32)x >> 1;
|
||||
width = (width + 1) >> 1;
|
||||
xEnd = x + width;
|
||||
tileWidth = state->chromaWidth >> 3;
|
||||
chromaTileWidth = state->chromaWidth >> 3;
|
||||
chromaEnd = y + ((height + 1) >> 1);
|
||||
for (; y < chromaEnd; y++) {
|
||||
for (column = x; column < xEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
|
||||
cb++;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
|
||||
cr++;
|
||||
}
|
||||
cb += 8 - width;
|
||||
@@ -543,8 +554,9 @@ static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
}
|
||||
|
||||
static void TMCJPEG_814F2570(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
u8* lumaTexture;
|
||||
u32 chromaTileWidth;
|
||||
TMCCJPEGDecState* state;
|
||||
u8* lumaTexture;
|
||||
u8* luminance;
|
||||
s32 column;
|
||||
s32 row;
|
||||
@@ -584,13 +596,13 @@ static void TMCJPEG_814F2570(TMCCJPEGDecWork* work, s32 x, s32 y) {
|
||||
luminance += 8 - width;
|
||||
}
|
||||
y = (u32)y >> 1;
|
||||
tileWidth = state->chromaWidth >> 3;
|
||||
chromaTileWidth = state->chromaWidth >> 3;
|
||||
chromaEnd = y + 8 / state->scaleFactor;
|
||||
for (; y < chromaEnd; y++) {
|
||||
for (column = x; column < xEnd; column += 1) {
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
|
||||
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
|
||||
cb++;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
|
||||
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
|
||||
cr++;
|
||||
}
|
||||
cb += 8 - width;
|
||||
|
||||
@@ -205,7 +205,7 @@ typedef struct _ziUwdNode {
|
||||
|
||||
struct __zi8_work_data_s {
|
||||
ziU8 unk_0x00;
|
||||
ziU8 countOnly; // 0x01
|
||||
ziU8 unk_0x01;
|
||||
ziU8 unk_0x02[2];
|
||||
ziLanguageEntry* langEntries; // 0x04
|
||||
ziU8 unk_0x08;
|
||||
@@ -219,7 +219,7 @@ struct __zi8_work_data_s {
|
||||
ziU8 unk_0x17;
|
||||
ziU8 subLanguage; // 0x18
|
||||
ziU8 unk_0x19;
|
||||
ziU16 separator; // 0x1A
|
||||
ziU16 unk_0x1A;
|
||||
ziU8 unk_0x1C[3];
|
||||
ziU8 unk_0x1F;
|
||||
ziU16 unk_0x20[0x40];
|
||||
@@ -265,25 +265,25 @@ struct __zi8_work_data_s {
|
||||
ziPtr unk_0x11FC;
|
||||
ziPtr userKeys[0x83]; // 0x1200
|
||||
ziU8 unk_0x140C[4];
|
||||
ziU32 formats; // 0x1410
|
||||
ziU32 unk_0x1410;
|
||||
ziU8 unk_0x1414[4];
|
||||
ziU8 formatCount;
|
||||
ziU8 unk_0x1418;
|
||||
ziU8 unk_0x1419;
|
||||
ziU16 unk_0x141A;
|
||||
ziU8 unk_0x141C;
|
||||
ziU8 unk_0x141D;
|
||||
ziU8 unk_0x141E;
|
||||
ziU8 maxCnt; // 0x141F
|
||||
ziU8 unk_0x141F;
|
||||
ziU8 unk_0x1420[4];
|
||||
zi8DawgCtx dawgCtx; // 0x1424
|
||||
ziU8 unk_0x1760[4]; // 0x1760
|
||||
ziU8* groupPtr; // 0x1764
|
||||
ziU8* unk_0x1764; // 0x1764
|
||||
ziU8 unk_0x1768;
|
||||
ziU8 unk_0x1769[0x81];
|
||||
ziU16 matchOffset; // 0x17EA
|
||||
ziU16 unk_0x17EA;
|
||||
ziU8 unk_0x17EC;
|
||||
ziU8 unk_0x17ED[3];
|
||||
ziU8* dawgGroup; // 0x17F0
|
||||
ziU8* unk_0x17F0;
|
||||
ziWChar unk_0x17F4[0x40]; // 0x17F4..0x1874
|
||||
ziU16 unk_0x1874;
|
||||
ziU8 unk_0x1876;
|
||||
|
||||
@@ -27,11 +27,11 @@ ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
|
||||
ziWChar Zi8ConvertUC2UserKey(ziChar, ziU8 ZI_NEED_WORK);
|
||||
|
||||
ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
|
||||
const ziConversionTables* defaults;
|
||||
ziU8* table;
|
||||
ziWChar* mapped;
|
||||
ziU8* cursor;
|
||||
ziU16 first, last;
|
||||
ziU8* table;
|
||||
const ziConversionTables* defaults;
|
||||
if (character == 0) {
|
||||
Zi8LogError(0x133, __zi8_work_data);
|
||||
return 0;
|
||||
|
||||
@@ -796,11 +796,11 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
|
||||
if (remaining != 0) {
|
||||
remaining--;
|
||||
} else {
|
||||
totalCandidates = totalCandidates + 1;
|
||||
totalCandidates++;
|
||||
if (options->countOnly == '\0') {
|
||||
*output++ = spellingBuffer[spellingIndex];
|
||||
*output++ = 0;
|
||||
candidateCount = candidateCount + 1;
|
||||
candidateCount++;
|
||||
}
|
||||
else if ((int)totalCandidates >= options->maxCount) goto finishSpelling;
|
||||
if (candidateCount >= params->maxCandidates) goto finishSpelling;
|
||||
@@ -940,7 +940,8 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
|
||||
for (tableIndex = 0; tableIndex < params->count;) {
|
||||
while (*output != 0) {
|
||||
if (*output != 0x27) {
|
||||
*output++ |= 0xf300;
|
||||
*output |= 0xf300;
|
||||
output++;
|
||||
} else {
|
||||
*output++ = 0xf360;
|
||||
}
|
||||
@@ -1000,10 +1001,10 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
|
||||
}
|
||||
if (Zi8IsDupWordW(output,(ziU8)phoneticIndex,work) == 0) {
|
||||
if (remaining == 0) {
|
||||
totalCandidates = totalCandidates + 1;
|
||||
totalCandidates++;
|
||||
if (options->countOnly == 0) {
|
||||
output += phoneticIndex + 1;
|
||||
++candidateCount;
|
||||
candidateCount++;
|
||||
} else if ((int)totalCandidates >= options->maxCount) goto finishSpelling;
|
||||
if (candidateCount >= params->maxCandidates) goto finishSpelling;
|
||||
} else {
|
||||
|
||||
@@ -285,9 +285,9 @@ static ziBool ZiIsLetterHyphen(ziWChar character ZI_NEED_WORK) {
|
||||
else return ZI8_FALSE;
|
||||
}
|
||||
|
||||
void Zi8ChangeWordCase(ziWChar* word, ziU8 language, ZiAlphaWork* work) {
|
||||
void Zi8ChangeWordCase(ziWChar* word, ziU8 language, ziPtr work) {
|
||||
enum { LOWER_CASE, UPPER_CASE } upper = LOWER_CASE;
|
||||
if (work->caseMode == 3) {
|
||||
if (((ZiAlphaWork*)work)->caseMode == 3) {
|
||||
Zi8ChangeCharCase(1, word++, language, work);
|
||||
} else if (((ZiAlphaWork*)work)->caseMode == 1) {
|
||||
upper = UPPER_CASE;
|
||||
|
||||
@@ -18,7 +18,7 @@ static Zi8UInt Zi8SetFindCand(ziU8* foundCandidates, Zi8UInt ordinal, ziPtr work
|
||||
}
|
||||
|
||||
ziWChar* ZiGetNextPhonetic(ziWChar* spelling, ziWChar* end ZI_NEED_WORK) {
|
||||
while (*spelling && *spelling != ZI_WORK->separator && *spelling != 0xF360 && spelling < end) {
|
||||
while (*spelling && *spelling != ZI_WORK->unk_0x1A && *spelling != 0xF360 && spelling < end) {
|
||||
++spelling;
|
||||
}
|
||||
if (!*spelling || spelling == end) {
|
||||
@@ -37,8 +37,8 @@ int ZiPartialMatch(ziWChar* spelling, ziWChar* spellingEnd,
|
||||
if (spelling == spellingEnd || candidate == candidateEnd || !*spelling || !*candidate) {
|
||||
return 1;
|
||||
}
|
||||
while (*spelling != ZI_WORK->separator && *spelling != 0xF360) {
|
||||
if (*candidate == ZI_WORK->separator || *candidate == 0xF360) {
|
||||
while (*spelling != ZI_WORK->unk_0x1A && *spelling != 0xF360) {
|
||||
if (*candidate == ZI_WORK->unk_0x1A || *candidate == 0xF360) {
|
||||
break;
|
||||
}
|
||||
if (*spelling != *candidate) {
|
||||
@@ -753,7 +753,8 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
|
||||
if (!componentTable) {
|
||||
componentCount = Zi8GetTableCount(1, 7, work);
|
||||
componentOrdinals = (ziU8*)Zi8GetTableAddress(1, 7, work);
|
||||
componentTable = componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
|
||||
componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
|
||||
componentTable = componentCursor;
|
||||
componentCursor += 8;
|
||||
--componentCount;
|
||||
componentIndex = componentCount;
|
||||
@@ -2868,7 +2869,7 @@ ziU8 Zi8GetElementCount(ziWChar* elements, ziU8 elementCount, ziU8 charCount ZI_
|
||||
ziU8 count;
|
||||
ziWChar spacedElements[256];
|
||||
struct { ziWChar separator; } savedState;
|
||||
savedState.separator = ZI_WORK->separator;
|
||||
savedState.separator = ZI_WORK->unk_0x1A;
|
||||
if (elementCount <= 1 || !charCount) {
|
||||
return elementCount;
|
||||
}
|
||||
@@ -2881,9 +2882,9 @@ ziU8 Zi8GetElementCount(ziWChar* elements, ziU8 elementCount, ziU8 charCount ZI_
|
||||
if (spacedIndex == elementCount) {
|
||||
return elementCount;
|
||||
}
|
||||
ZI_WORK->separator = 0xF360;
|
||||
ZI_WORK->unk_0x1A = 0xF360;
|
||||
Zi8ZHaddSpace(elements, elementCount, spacedElements, 256, __zi8_work_data);
|
||||
ZI_WORK->separator = savedState.separator;
|
||||
ZI_WORK->unk_0x1A = savedState.separator;
|
||||
spacedIndex = elementIndex = count = 0;
|
||||
while (charCount && elementIndex < elementCount) {
|
||||
if (spacedElements[spacedIndex] == 0xF360) {
|
||||
|
||||
@@ -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) {
|
||||
@@ -184,36 +184,37 @@ 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));
|
||||
tableAddress = Zi8GetTableAddress(language & 0xff,0xb,ZI_WORK);
|
||||
ZI_WORK->unk_0x1764 = (ziU8*)tableAddress;
|
||||
}
|
||||
}
|
||||
if (ZI_WORK->groupPtr != 0) {
|
||||
for (; (*ZI_WORK->groupPtr != 0xff && ((groupIndex & 0xff) != 0));
|
||||
if (ZI_WORK->unk_0x1764 != 0) {
|
||||
for (; (*ZI_WORK->unk_0x1764 != 0xff && ((groupIndex & 0xff) != 0));
|
||||
groupIndex = groupIndex - 1) {
|
||||
while (*ZI_WORK->groupPtr != 0xff) {
|
||||
ZI_WORK->groupPtr += 2;
|
||||
while (*ZI_WORK->unk_0x1764 != 0xff) {
|
||||
ZI_WORK->unk_0x1764 += 2;
|
||||
}
|
||||
ZI_WORK->groupPtr++;
|
||||
ZI_WORK->unk_0x1764++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ZI_WORK->groupPtr == 0) {
|
||||
if (ZI_WORK->unk_0x1764 == 0) {
|
||||
result = Zi8MatchROMdata0(elements,count,language & 0xff,output,capacity & 0xffff,
|
||||
mode & 0xff,status & 0xff,0,1,acceptPrefix,0,&ZI_WORK->dawgCtx,
|
||||
ZI_WORK->unk_0x1760,ZI_WORK);
|
||||
}
|
||||
else {
|
||||
while (*ZI_WORK->groupPtr != 0xff) {
|
||||
while (*ZI_WORK->unk_0x1764 != 0xff) {
|
||||
result = Zi8MatchROMdata0(elements,count,language & 0xff,output,
|
||||
capacity & 0xffff,mode & 0xff,status & 0xff,
|
||||
*ZI_WORK->groupPtr,
|
||||
ZI_WORK->groupPtr[1],acceptPrefix,0,
|
||||
*ZI_WORK->unk_0x1764,
|
||||
ZI_WORK->unk_0x1764[1],acceptPrefix,0,
|
||||
&ZI_WORK->dawgCtx,ZI_WORK->unk_0x1760,ZI_WORK);
|
||||
if ((result & 0xff) != 0) break;
|
||||
ZI_WORK->groupPtr += 2;
|
||||
ZI_WORK->unk_0x1764 += 2;
|
||||
status = 0;
|
||||
}
|
||||
}
|
||||
@@ -230,7 +231,7 @@ unsigned int Zi8MatchROMdata2(ziWChar* elements, ziU8 count, ziU8 language,
|
||||
if (reservedMode != 0) return 0;
|
||||
if (status == 0) {
|
||||
ZI_WORK->unk_0x1768 = 0;
|
||||
ZI_WORK->matchOffset = 0;
|
||||
ZI_WORK->unk_0x17EA = 0;
|
||||
if (group != 0 && *group == 0xc && language == 10 && ZI_WORK->unk_0x141C != 0) {
|
||||
ZI_WORK->unk_0x141E = 0x10;
|
||||
} else {
|
||||
@@ -238,23 +239,23 @@ unsigned int Zi8MatchROMdata2(ziWChar* elements, ziU8 count, ziU8 language,
|
||||
}
|
||||
}
|
||||
search_segment:
|
||||
ZI_WORK->maxCnt = 1;
|
||||
result = Zi8MatchROMdata1(elements + ZI_WORK->matchOffset,
|
||||
count - ZI_WORK->matchOffset, language,
|
||||
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
|
||||
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--) {
|
||||
for (index = (ziU8)(ZI_WORK->unk_0x17EA + result); index != 0; index--) {
|
||||
output[index - 1] = ZI_WORK->unk_0x17F4[index - 1];
|
||||
}
|
||||
result = (ziU8)(result + ZI_WORK->matchOffset);
|
||||
result = (ziU8)(result + ZI_WORK->unk_0x17EA);
|
||||
} else {
|
||||
if (status != 0 || count == 1) goto finish_segments;
|
||||
if (mode == 1 && ZI_WORK->unk_0x1768 == 0 &&
|
||||
(ziU8)Zi8MatchROMdata1(elements + ZI_WORK->matchOffset,
|
||||
count - ZI_WORK->matchOffset, language,
|
||||
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
|
||||
(ziU8)Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA,
|
||||
count - ZI_WORK->unk_0x17EA, language,
|
||||
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], capacity,
|
||||
0, status, ZI_WORK->unk_0x1768, (char*)group,
|
||||
acceptPrefix, ZI_WORK) != 0) goto finish_segments;
|
||||
if ((Zi8GetTableCount(language, 0x1f, ZI_WORK) & 4) == 0) {
|
||||
@@ -262,20 +263,20 @@ search_segment:
|
||||
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->unk_0x17F4[ZI_WORK->matchOffset], capacity,
|
||||
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->unk_0x17EA += (ziU8)result;
|
||||
if (ZI_WORK->unk_0x17EA == count) return 0;
|
||||
ZI_WORK->unk_0x1768++;
|
||||
status = 0;
|
||||
ZI_WORK->unk_0x141E = 0;
|
||||
if (ZI_WORK->dawgCtx.key == 0 && language == 10) {
|
||||
for (index = 0; index < ZI_WORK->matchOffset; index++) {
|
||||
for (index = 0; index < ZI_WORK->unk_0x17EA; index++) {
|
||||
switch (ZI_WORK->unk_0x17F4[index]) {
|
||||
case 0x61:
|
||||
case 0x6f:
|
||||
@@ -306,7 +307,7 @@ ziU32 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language,
|
||||
} else {
|
||||
if (status == 0) {
|
||||
ZI_WORK->unk_0x17EC = 0;
|
||||
ZI_WORK->dawgGroup = NextDawgGroup(0, language, ZI_WORK);
|
||||
ZI_WORK->unk_0x17F0 = NextDawgGroup(0, language, ZI_WORK);
|
||||
} else if (ZI_WORK->unk_0x17EC != 0) {
|
||||
Zi8LogError(100, ZI_WORK);
|
||||
goto finish_match;
|
||||
@@ -316,30 +317,30 @@ ziU32 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language,
|
||||
result = Zi8MatchROMdata2(elements, count, language, output, capacity,
|
||||
mode, status, reservedMode, 0, acceptPrefix, ZI_WORK);
|
||||
} else {
|
||||
while (ZI_WORK->dawgGroup != 0) {
|
||||
while (ZI_WORK->unk_0x17F0 != 0) {
|
||||
result = Zi8MatchROMdata2(elements, count, language, output, capacity,
|
||||
mode, status, reservedMode, ZI_WORK->dawgGroup,
|
||||
mode, status, reservedMode, ZI_WORK->unk_0x17F0,
|
||||
acceptPrefix, ZI_WORK);
|
||||
if ((ziU8)result != 0) break;
|
||||
status = 0;
|
||||
if (count <= 1 && language == 0x36) break;
|
||||
ZI_WORK->dawgGroup = NextDawgGroup(ZI_WORK->dawgGroup, language, ZI_WORK);
|
||||
ZI_WORK->unk_0x17F0 = NextDawgGroup(ZI_WORK->unk_0x17F0, language, ZI_WORK);
|
||||
}
|
||||
}
|
||||
if ((ziU8)result == 0 && status == 0 && mode == 1 && count == 1 && capacity >= 1) {
|
||||
mode = 0;
|
||||
ZI_WORK->unk_0x17EC = 1;
|
||||
if (tableSize != 0) {
|
||||
ZI_WORK->dawgGroup = NextDawgGroup(0, language, ZI_WORK);
|
||||
while (ZI_WORK->dawgGroup != 0) {
|
||||
ZI_WORK->unk_0x17F0 = NextDawgGroup(0, language, ZI_WORK);
|
||||
while (ZI_WORK->unk_0x17F0 != 0) {
|
||||
if ((ziU8)Zi8MatchROMdata2(elements, count, language, output, capacity,
|
||||
mode, status, reservedMode, ZI_WORK->dawgGroup,
|
||||
mode, status, reservedMode, ZI_WORK->unk_0x17F0,
|
||||
acceptPrefix, ZI_WORK) != 0) {
|
||||
*output = *elements;
|
||||
result = 1;
|
||||
break;
|
||||
}
|
||||
ZI_WORK->dawgGroup = NextDawgGroup(ZI_WORK->dawgGroup, language, ZI_WORK);
|
||||
ZI_WORK->unk_0x17F0 = NextDawgGroup(ZI_WORK->unk_0x17F0, language, ZI_WORK);
|
||||
}
|
||||
} else {
|
||||
if ((ziU8)Zi8MatchROMdata2(elements, count, language, output, capacity,
|
||||
|
||||
@@ -50,11 +50,11 @@ ziBool Zi8ZHsetZYfuzzyPairs(ziFuzzyZYPairs pairs ZI_NEED_WORK) {
|
||||
|
||||
ziBool Zi8SetLatinSearchOrder(ziU8* searchArray, ziU8 searchSize ZI_NEED_WORK) {
|
||||
if (searchArray == 0 || *searchArray == 0) {
|
||||
ZI_WORK->formats = (ziU32)Zi8SOdefaultArray;
|
||||
ZI_WORK->formatCount = 9;
|
||||
ZI_WORK->unk_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;
|
||||
}
|
||||
@@ -339,11 +339,11 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
|
||||
if ((parameters->elementCount == 1) && (parameters->firstCandidate == 0)) {
|
||||
switch (parameters->language) {
|
||||
case 1:
|
||||
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
|
||||
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->unk_0x01 == options->countOnly)) {
|
||||
switch(ZI_WORK->unk_0x00) {
|
||||
case '\0':
|
||||
if (parameters->elements[0] == 0xEF04) {
|
||||
ZI_WORK->countOnly = options->countOnly;
|
||||
ZI_WORK->unk_0x01 = options->countOnly;
|
||||
ZI_WORK->unk_0x00 = '\x01';
|
||||
}
|
||||
break;
|
||||
@@ -400,11 +400,11 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
|
||||
break;
|
||||
case 0x11:
|
||||
default:
|
||||
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
|
||||
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->unk_0x01 == options->countOnly)) {
|
||||
switch(ZI_WORK->unk_0x00) {
|
||||
case '\0':
|
||||
if (parameters->elements[0] == 0xEFF2) {
|
||||
ZI_WORK->countOnly = options->countOnly;
|
||||
ZI_WORK->unk_0x01 = options->countOnly;
|
||||
ZI_WORK->unk_0x00 = '\x01';
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -21,7 +21,7 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
|
||||
ZI_WORK->unk_0x0A = 0xFF;
|
||||
ZI_WORK->unk_0x10 = 0x64;
|
||||
*(ziU16*)&ZI_WORK->unk_0x0C = 0xFFFF;
|
||||
ZI_WORK->separator = 0x20;
|
||||
ZI_WORK->unk_0x1A = 0x20;
|
||||
ZI_WORK->unk_0x1C[2] = 0;
|
||||
ZI_WORK->unk_0x1B30 = 0;
|
||||
ZI_WORK->unk_0x1B3A = 0;
|
||||
|
||||
@@ -49,42 +49,39 @@ void Zi8CopyZHSpelling(ziU8* source, ziWChar* output, ziU16 capacity, int size,
|
||||
}
|
||||
}
|
||||
}
|
||||
ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option, struct __zi8_work_data_s* __zi8_work_data) {
|
||||
ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option ZI_NEED_WORK) {
|
||||
ziU8 previous;
|
||||
previous = __zi8_work_data->pdRemoveOpt;
|
||||
__zi8_work_data->pdRemoveOpt = option;
|
||||
previous = ZI_WORK->pdRemoveOpt;
|
||||
ZI_WORK->pdRemoveOpt = option;
|
||||
Zi8LogError(100, __zi8_work_data);
|
||||
return previous;
|
||||
}
|
||||
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;
|
||||
int wordSize;
|
||||
int copied;
|
||||
ziU32 entrySize, wordSize, copied;
|
||||
ziU8* entry;
|
||||
ziU8* word;
|
||||
int index;
|
||||
ziU32 entrySize;
|
||||
int fallback = 0;
|
||||
ziPudHeader* table;
|
||||
ziU8* byteOutput;
|
||||
ziPudSection* section;
|
||||
if (!(ZI_WORK->pudCount <= 16 && ZI_WORK->pudCount != 0 && ZI_WORK->pudTable[ZI_WORK->pudCount - 1] != 0)) {
|
||||
Zi8LogError(0x4B0, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
if (language == 1) {
|
||||
length &= 0x7F;
|
||||
length *= 2;
|
||||
}
|
||||
if (continuation == 0) {
|
||||
table = (ziPudHeader*)ZI_WORK->pudTable[ZI_WORK->pudCount - 1];
|
||||
section = table->sections;
|
||||
index = 0;
|
||||
while (index < table->languageCount) {
|
||||
if (section->language == language) break;
|
||||
section++;
|
||||
section = table->sections;
|
||||
while (index < table->languageCount && section->language != language) {
|
||||
index++;
|
||||
section++;
|
||||
}
|
||||
if (index >= table->languageCount) {
|
||||
if (table->languageCount <= index) {
|
||||
Zi8LogError(0x4F6, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
@@ -93,97 +90,90 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
|
||||
ZI_WORK->unk_0x318 = 0;
|
||||
}
|
||||
for (;;) {
|
||||
word = (ziU8*)ZI_WORK->unk_0x310;
|
||||
if (word == 0) {
|
||||
entry = (ziU8*)ZI_WORK->unk_0x310;
|
||||
if (entry == 0) {
|
||||
Zi8LogError(0x4B3, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
while ((ziS32)ZI_WORK->unk_0x318 < (ziS32)ZI_WORK->unk_0x314) {
|
||||
wordSize = *word++;
|
||||
word = entry + 1;
|
||||
wordSize = *entry;
|
||||
entrySize = wordSize;
|
||||
if (language == 1) {
|
||||
if (ZI_WORK->unk_0x17 > *word) goto next;
|
||||
wordSize--;
|
||||
entrySize--;
|
||||
word++;
|
||||
if (*word < ZI_WORK->unk_0x17) goto next;
|
||||
entrySize = wordSize - 1;
|
||||
word = entry + 2;
|
||||
wordSize = ZiGetZHWordSize((ziWChar*)word, entrySize);
|
||||
} 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->unk_0x318++;
|
||||
word += entrySize;
|
||||
} else {
|
||||
if (language == 1) {
|
||||
bytePattern = (ziU8*)pattern;
|
||||
for (index = 0; index < length; index++) {
|
||||
if (word[index] != bytePattern[index]) goto next;
|
||||
}
|
||||
goto matched;
|
||||
}
|
||||
matchText:
|
||||
} else if (ZI_WORK->unk_0x31E != 0 && complete != 0 && wordSize > length && word[length] == 0x20) goto matchText;
|
||||
if ((ziS32)length > (ziS32)wordSize || (complete != 0 && wordSize != length) || (complete == 0 && wordSize == length)) goto next;
|
||||
if (language == 1) {
|
||||
for (index = 0; index < length; index++) {
|
||||
if (pattern[index] >= 0xEFF1 && pattern[index] <= 0xF37F) {
|
||||
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->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
|
||||
}
|
||||
if (word[index] != ((ziU8*)pattern)[index]) goto next;
|
||||
}
|
||||
matched:
|
||||
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;
|
||||
}
|
||||
if (language == 1) {
|
||||
byteOutput = (ziU8*)output;
|
||||
for (index = copied = 0; index < (ziS32)wordSize && copied < capacity; copied++) {
|
||||
byteOutput[index] = word[index];
|
||||
index++;
|
||||
byteOutput[index] = word[index];
|
||||
index++;
|
||||
}
|
||||
Zi8CopyZHSpelling(word, spelling, spellingCapacity, entrySize, wordSize);
|
||||
} else {
|
||||
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
|
||||
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
|
||||
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
|
||||
if (complete != 0 || copied >= length) break;
|
||||
goto next;
|
||||
}
|
||||
}
|
||||
}
|
||||
ZI_WORK->unk_0x318++;
|
||||
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
|
||||
Zi8LogError(100, __zi8_work_data);
|
||||
return (ziU8)copied;
|
||||
goto matched;
|
||||
}
|
||||
matchText:
|
||||
for (index = 0; index < length; index++) {
|
||||
if (pattern[index] < 0xEFF1 || pattern[index] > 0xF37F) {
|
||||
folded = Zi8ConvertUC2WC(word[index], language, __zi8_work_data);
|
||||
if (folded != pattern[index] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
|
||||
} else if (pattern[index] != Zi8ConvertUC2Key(word[index], language, __zi8_work_data)) goto next;
|
||||
}
|
||||
matched:
|
||||
if (fallback) {
|
||||
ZI_WORK->unk_0x310 = 0;
|
||||
ZI_WORK->unk_0x318 = 0;
|
||||
ZI_WORK->unk_0x314 = 0;
|
||||
if (*pattern < 0xEFF1) *output = Zi8ConvertWC2Key(*pattern, language, __zi8_work_data);
|
||||
else *output = *pattern;
|
||||
return 1;
|
||||
}
|
||||
if (language == 1) {
|
||||
index = 0;
|
||||
for (copied = 0; index < (ziS32)wordSize && copied < capacity; copied++) {
|
||||
((ziU8*)output)[index] = word[index];
|
||||
((ziU8*)output)[index + 1] = word[index + 1];
|
||||
index += 2;
|
||||
}
|
||||
Zi8CopyZHSpelling(word, spelling, spellingCapacity, entrySize, wordSize);
|
||||
} else {
|
||||
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
|
||||
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
|
||||
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
|
||||
if (complete != 0 || copied >= length) break;
|
||||
goto next;
|
||||
}
|
||||
}
|
||||
}
|
||||
ZI_WORK->unk_0x318++;
|
||||
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
|
||||
Zi8LogError(100, __zi8_work_data);
|
||||
return (ziU8)copied;
|
||||
next:
|
||||
ZI_WORK->unk_0x318++;
|
||||
entry = word + entrySize;
|
||||
}
|
||||
if (length == 1 && complete != 0 && continuation == 0) {
|
||||
complete = 0;
|
||||
fallback = 1;
|
||||
ZI_WORK->unk_0x318 = 0;
|
||||
} else {
|
||||
if (length != 1 || complete == 0 || continuation != 0) {
|
||||
ZI_WORK->unk_0x310 = 0;
|
||||
ZI_WORK->unk_0x318 = 0;
|
||||
ZI_WORK->unk_0x314 = 0;
|
||||
return 0;
|
||||
}
|
||||
complete = 0;
|
||||
fallback = 1;
|
||||
ZI_WORK->unk_0x318 = 0;
|
||||
}
|
||||
}
|
||||
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 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
|
||||
ziU32 result;
|
||||
if (continuation == 0) __zi8_work_data->pudCount = 1;
|
||||
if (continuation == 0) ZI_WORK->pudCount = 1;
|
||||
for (;;) {
|
||||
result = Zi8_8147FD7C(pattern, length, language, output, capacity, complete, continuation, __zi8_work_data);
|
||||
if ((ziU8)result != 0) break;
|
||||
if (++__zi8_work_data->pudCount <= 16) {
|
||||
if (++ZI_WORK->pudCount <= 16) {
|
||||
continuation = 0;
|
||||
} else {
|
||||
__zi8_work_data->pudCount = 1;
|
||||
ZI_WORK->pudCount = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -68,7 +68,7 @@ ziU8 Zi8ZHaddSpace(ziWChar* src, ziU8 count, ziWChar* dst,
|
||||
}
|
||||
if (pdst[k - 1] != 0xF360 &&
|
||||
(pdst[k - 1] < 0xF331 || pdst[k - 1] > 0xF335)) {
|
||||
pdst[k++] = ZI_WORK->separator;
|
||||
pdst[k++] = ZI_WORK->unk_0x1A;
|
||||
}
|
||||
psrc += i;
|
||||
n -= i;
|
||||
|
||||
@@ -15,11 +15,11 @@ void Zi8Memset(ziPtr, ziU32, ziU32);
|
||||
|
||||
ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
|
||||
ziU8 length;
|
||||
ziU8 position;
|
||||
ziUwdNode* previous;
|
||||
ziUwdNode* current;
|
||||
ziUwdNode* added;
|
||||
ziUserWord* candidate;
|
||||
ziU8 position;
|
||||
if (ZI_WORK->uwdCount >= 32) {
|
||||
Zi8LogError(0x19D, __zi8_work_data);
|
||||
return 0;
|
||||
@@ -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->unk_0x12E == 1 && candidate->priority < word->priority) break;
|
||||
if (ZI_WORK->unk_0x12E == 1 && word->priority > candidate->priority) break;
|
||||
if (candidate->length == length) {
|
||||
position = 0;
|
||||
while (position < length) {
|
||||
@@ -56,7 +56,8 @@ ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
|
||||
previous = current;
|
||||
current = current->next;
|
||||
}
|
||||
added = &ZI_WORK->uwdNodes[ZI_WORK->uwdCount++];
|
||||
length = ZI_WORK->uwdCount++;
|
||||
added = &ZI_WORK->uwdNodes[length];
|
||||
if (previous == 0) {
|
||||
ZI_WORK->uwdList = added;
|
||||
added->next = current;
|
||||
@@ -86,24 +87,23 @@ void Zi8_8148047C(ziPtr __zi8_work_data) {
|
||||
ZI_WORK->uwdList = 0;
|
||||
}
|
||||
ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16 currentLength, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
|
||||
ziUserDictionary* dictionary;
|
||||
ziWChar folded;
|
||||
int fallback = 0;
|
||||
int visited = 0;
|
||||
int prefixLength;
|
||||
int position, previousOffset;
|
||||
ziU32 size;
|
||||
ziU8 entryLanguage;
|
||||
ziU32 entryLength;
|
||||
ziU8* cursor;
|
||||
ziU8* begin;
|
||||
ziU8* boundary;
|
||||
ziU8* end;
|
||||
ziUserWord* candidate;
|
||||
ziUserWord* previous;
|
||||
ziUserWord* result;
|
||||
ziUserDictionary* dictionary;
|
||||
int firstSegment;
|
||||
ziU32 size;
|
||||
int headerSize;
|
||||
int entryLanguage;
|
||||
volatile int entryLength;
|
||||
int previousOffset;
|
||||
int visited = 0;
|
||||
int fallback = 0;
|
||||
ziWChar folded;
|
||||
ziU8* text;
|
||||
int position;
|
||||
int prefixLength;
|
||||
Zi8LogError(100, __zi8_work_data);
|
||||
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);
|
||||
@@ -111,17 +111,16 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
|
||||
}
|
||||
dictionary = ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1];
|
||||
if (continuation != 0) {
|
||||
text = (ziU8*)Zi8_814803F4(__zi8_work_data);
|
||||
result = Zi8_814803F4(__zi8_work_data);
|
||||
entryLength = 0;
|
||||
if (text != 0) {
|
||||
language = ((ziUserWord*)text)->language;
|
||||
entryLength = ((ziUserWord*)text)->length;
|
||||
if (result != 0) {
|
||||
entryLanguage = result->language;
|
||||
entryLength = result->length;
|
||||
if (entryLength >= capacity) {
|
||||
Zi8_8148047C(__zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
text = ((ziUserWord*)text)->text;
|
||||
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
|
||||
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(result->text[position], entryLanguage, __zi8_work_data);
|
||||
}
|
||||
return entryLength;
|
||||
}
|
||||
@@ -131,20 +130,17 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
|
||||
if (currentWord == 0 || currentLength == 0 || currentWord[currentLength - 1] != 0x20) ZI_WORK->unk_0x140 = 0;
|
||||
else {
|
||||
prefixLength = 0;
|
||||
for (position = currentLength - 2; position >= 0;) {
|
||||
if (currentWord[position] == 0x20) break;
|
||||
position--;
|
||||
prefixLength++;
|
||||
}
|
||||
for (position = currentLength - 2; currentWord[position] != 0x20 && position >= 0; position--) prefixLength++;
|
||||
position++;
|
||||
if (prefixLength == 0 || prefixLength > 63) ZI_WORK->unk_0x140 = 0;
|
||||
else {
|
||||
ZI_WORK->unk_0x140 = 1;
|
||||
ZI_WORK->unk_0x141[prefixLength + 4] = ZI_WORK->unk_0x141[0] = prefixLength + 5;
|
||||
ZI_WORK->unk_0x141[0] = prefixLength + 5;
|
||||
ZI_WORK->unk_0x141[prefixLength + 4] = prefixLength + 5;
|
||||
ZI_WORK->unk_0x141[1] = language;
|
||||
ZI_WORK->unk_0x141[2] = prefixLength;
|
||||
previousOffset = 4;
|
||||
while (prefixLength > 0) {
|
||||
for (; prefixLength > 0; prefixLength--, position++) {
|
||||
folded = currentWord[position];
|
||||
ZI_WORK->unk_0x141[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
|
||||
ZI_WORK->unk_0x184[previousOffset] = 0;
|
||||
@@ -156,56 +152,48 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
|
||||
ZI_WORK->unk_0x140 = 0;
|
||||
break;
|
||||
}
|
||||
prefixLength--;
|
||||
position++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ZI_WORK->unk_0x140 == 0 && length == 0) return 0;
|
||||
rescan:
|
||||
cursor = begin = dictionary->entries + dictionary->current;
|
||||
begin = dictionary->entries + dictionary->current;
|
||||
boundary = (ziU8*)dictionary + dictionary->boundary + 7;
|
||||
end = (ziU8*)dictionary + dictionary->end + 7;
|
||||
cursor = begin;
|
||||
if (begin < boundary) firstSegment = 1;
|
||||
else firstSegment = 0;
|
||||
while ((cursor < boundary && firstSegment) || (cursor < end && !firstSegment)) {
|
||||
while (firstSegment ? cursor < boundary : cursor < end) {
|
||||
size = *cursor;
|
||||
if ((ziS32)ZI_WORK->unk_0x13C > visited++ || (((ziUserWord*)cursor)->size & 0xC0) != 0) {
|
||||
next:
|
||||
if ((cursor += size) > end) {
|
||||
if (firstSegment) break;
|
||||
firstSegment = 1;
|
||||
size = cursor - end - 1;
|
||||
cursor = dictionary->entries + size;
|
||||
}
|
||||
} else {
|
||||
candidate = (ziUserWord*)cursor;
|
||||
position = visited++;
|
||||
if ((ziS32)ZI_WORK->unk_0x13C <= position && (size & 0xC0) == 0) {
|
||||
previous = (ziUserWord*)(cursor + size);
|
||||
if ((ziU8*)previous > end) previous = (ziUserWord*)(dictionary->entries + (cursor - end - 1));
|
||||
text = cursor;
|
||||
headerSize = *text++;
|
||||
entryLanguage = *text++;
|
||||
entryLength = *text++;
|
||||
text++;
|
||||
if (entryLanguage == language && entryLength >= length && entryLength < capacity && (complete == 0 || entryLength == length) && (complete != 0 || entryLength != length)) {
|
||||
if ((ziU8*)previous > end) previous = (ziUserWord*)(cursor + ((ziU8*)dictionary - end) + 7);
|
||||
entryLanguage = candidate->language;
|
||||
entryLength = candidate->length;
|
||||
if (entryLanguage == language && length <= entryLength && entryLength < capacity && (complete == 0 || entryLength == length) && (complete != 0 || entryLength != length)) {
|
||||
for (position = 0; position < length; position++) {
|
||||
if (pattern[position] >= 0xEFF1 && pattern[position] <= 0xF010) {
|
||||
if (pattern[position] != Zi8ConvertUC2Key(text[position], language, __zi8_work_data)) goto next;
|
||||
} else {
|
||||
folded = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
|
||||
if (pattern[position] < 0xEFF1 || pattern[position] > 0xF010) {
|
||||
folded = Zi8ConvertUC2WC(candidate->text[position], language, __zi8_work_data);
|
||||
if (folded != pattern[position] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
|
||||
}
|
||||
} else if (pattern[position] != Zi8ConvertUC2Key(candidate->text[position], language, __zi8_work_data)) 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->unk_0x141[2] + 4;
|
||||
for (; prefixLength < position; prefixLength++) {
|
||||
if (ZI_WORK->unk_0x141[prefixLength] != ((ziU8*)previous)[prefixLength] && ZI_WORK->unk_0x184[prefixLength] != ((ziU8*)previous)[prefixLength]) goto next;
|
||||
for (position = 4; position < ZI_WORK->unk_0x141[2] + 4; position++) {
|
||||
if (ZI_WORK->unk_0x141[position] != ((ziU8*)previous)[position] && ZI_WORK->unk_0x184[position] != ((ziU8*)previous)[position]) goto next;
|
||||
}
|
||||
}
|
||||
Zi8_81480224((ziUserWord*)cursor, __zi8_work_data);
|
||||
Zi8_81480224(candidate, __zi8_work_data);
|
||||
}
|
||||
goto next;
|
||||
}
|
||||
next:
|
||||
cursor += size;
|
||||
if (end < cursor) {
|
||||
if (firstSegment) break;
|
||||
firstSegment = 1;
|
||||
cursor = dictionary->entries + (cursor - end - 1);
|
||||
}
|
||||
}
|
||||
if (ZI_WORK->unk_0x140 != 0 && length != 0) {
|
||||
@@ -213,24 +201,23 @@ next:
|
||||
visited = 0;
|
||||
goto rescan;
|
||||
}
|
||||
if (length == 1 && complete != 0 && continuation == 0) {
|
||||
if (complete == 1 && length != 0 && continuation == 0) {
|
||||
complete = 0;
|
||||
fallback = 1;
|
||||
visited = 0;
|
||||
goto rescan;
|
||||
}
|
||||
}
|
||||
text = (ziU8*)Zi8_814803F4(__zi8_work_data);
|
||||
if (text != 0) {
|
||||
language = ((ziUserWord*)text)->language;
|
||||
entryLength = ((ziUserWord*)text)->length;
|
||||
result = Zi8_814803F4(__zi8_work_data);
|
||||
entryLength = 0;
|
||||
if (result != 0) {
|
||||
entryLanguage = result->language;
|
||||
entryLength = result->length;
|
||||
if (entryLength >= capacity) {
|
||||
Zi8_8148047C(__zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
text = ((ziUserWord*)text)->text;
|
||||
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
|
||||
return entryLength;
|
||||
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(result->text[position], entryLanguage, __zi8_work_data);
|
||||
}
|
||||
return 0;
|
||||
return entryLength;
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include <zi8clib/zierror.h>
|
||||
#include <zi8clib/zitypes.h>
|
||||
|
||||
extern const ziU16 nodeHeaderTable[16];
|
||||
extern ziU16 nodeHeaderTable[16];
|
||||
|
||||
ziU32 ZiDAWGGetChild(ziU32 node) {
|
||||
ziU32 base;
|
||||
@@ -22,10 +22,11 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
|
||||
node += offset;
|
||||
if (((ziU32)header & 2) != 0) {
|
||||
if ((*(ziU8*)node & 0x80) != 0) {
|
||||
offset = ((*(ziU8*)node & 0x7f) << 16) +
|
||||
((((ziU32)*((ziU8*)node + 1) & 0xffff) << 8) + *((ziU8*)node + 2)) + 0x8000;
|
||||
offset = (*(ziU8*)node & 0x7f) * 0x10000 + ((ziU32)*((ziU8*)node + 1) & 0xffff) * 0x100 + 0x8000;
|
||||
offset += *((ziU8*)node + 2);
|
||||
} else {
|
||||
offset = (((ziU32)*(ziU8*)node & 0xffff) << 8) + (ziU32)*((ziU8*)node + 1);
|
||||
offset = ((ziU32)*(ziU8*)node & 0xffff) * 0x100;
|
||||
offset += (ziU32)*((ziU8*)node + 1);
|
||||
}
|
||||
} else if (((ziU32)header & 8) != 0) {
|
||||
if ((*(ziU8*)node & 0x80) != 0) {
|
||||
@@ -41,50 +42,41 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
typedef struct ziDawgLongOffset {
|
||||
ziU8 flags;
|
||||
ziU8 middle;
|
||||
ziU8 low;
|
||||
} ziDawgLongOffset;
|
||||
typedef char ziDawgLongOffsetSizeCheck[(sizeof(ziDawgLongOffset) == 3) ? 1 : -1];
|
||||
|
||||
ziU8* ZiDAWGGetSibling(ziU8* cursor) {
|
||||
ziS32 depth;
|
||||
ziU8* node;
|
||||
ziU8* ZiDAWGGetSibling(ziU8* node) {
|
||||
ziU16 header;
|
||||
ziU8* cursor = node;
|
||||
ziS32 depth;
|
||||
ziS32 offset;
|
||||
|
||||
depth = 0;
|
||||
node = cursor;
|
||||
offset = 0;
|
||||
header = nodeHeaderTable[cursor[0] >> 4];
|
||||
header = nodeHeaderTable[node[0] >> 4];
|
||||
if ((header & 4) == 0) {
|
||||
return 0;
|
||||
node = 0;
|
||||
} else {
|
||||
if ((header & 8) != 0) {
|
||||
if ((cursor[0] & 0xf) == 0xf) {
|
||||
cursor += 2;
|
||||
if ((node[0] & 0xf) == 0xf) {
|
||||
node += 2;
|
||||
} else {
|
||||
cursor += 1;
|
||||
node += 1;
|
||||
}
|
||||
|
||||
if ((header & 2) != 0) {
|
||||
if ((*cursor & 0x80) != 0) {
|
||||
cursor += 3;
|
||||
if ((*node & 0x80) == 0) {
|
||||
node += 2;
|
||||
} else {
|
||||
cursor += 2;
|
||||
node += 3;
|
||||
}
|
||||
}
|
||||
|
||||
if ((*cursor & 0x80) != 0) {
|
||||
node += (((const ziDawgLongOffset*)cursor)->flags & 0x7f) * 0x10000 +
|
||||
(((ziU32)(ziU16)cursor[1] << 8) +
|
||||
((const ziDawgLongOffset*)cursor)->low) + 0x8000;
|
||||
if ((*node & 0x80) != 0) {
|
||||
node += (*node & 0x7f) * 0x10000 + (ziU32)node[1] * 0x100 +
|
||||
(ziU32)node[2] + 0x8000;
|
||||
} else {
|
||||
node = cursor[1] + (node + (ziU16)*cursor * 0x100);
|
||||
node += (ziU16)*node * 0x100 + (ziU32)node[1];
|
||||
}
|
||||
return node;
|
||||
} else {
|
||||
cursor = node;
|
||||
do {
|
||||
header = nodeHeaderTable[cursor[0] >> 4];
|
||||
if ((cursor[0] & 0xf) == 0xf) {
|
||||
@@ -96,16 +88,14 @@ ziU8* ZiDAWGGetSibling(ziU8* cursor) {
|
||||
}
|
||||
|
||||
if ((header & 1) != 0) {
|
||||
if ((header & 2) != 0) {
|
||||
if ((*cursor & 0x80) != 0) {
|
||||
cursor += 3;
|
||||
offset += 3;
|
||||
} else {
|
||||
cursor += 2;
|
||||
offset += 2;
|
||||
}
|
||||
} else {
|
||||
if ((header & 2) == 0) {
|
||||
depth++;
|
||||
} else if ((*cursor & 0x80) != 0) {
|
||||
cursor += 3;
|
||||
offset += 3;
|
||||
} else {
|
||||
cursor += 2;
|
||||
offset += 2;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -123,17 +113,18 @@ ziU8* ZiDAWGGetSibling(ziU8* cursor) {
|
||||
}
|
||||
} while (0 < depth);
|
||||
|
||||
return node + offset;
|
||||
node += offset;
|
||||
}
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
ziU8 ZiDAWGgetEOWattribute(ziU32 node) {
|
||||
return (nodeHeaderTable[*(ziU8*)node >> 4] & 0x10) > 0;
|
||||
}
|
||||
|
||||
ziU32 ZiDAWGgetCHARattribute(zi8DawgCtx* context, ziU32 node, ziPtr __zi8_work_data) {
|
||||
ziU32 ZiDAWGgetCHARattribute(ziPtr context, ziU32 node, ziPtr __zi8_work_data) {
|
||||
ziU8 key;
|
||||
ziU32 attribute;
|
||||
|
||||
@@ -143,15 +134,15 @@ ziU32 ZiDAWGgetCHARattribute(zi8DawgCtx* context, ziU32 node, ziPtr __zi8_work_d
|
||||
key = (ziU32)*(ziU8*)node & 0xf;
|
||||
}
|
||||
|
||||
if (key > context->cap) {
|
||||
if (key > ((zi8DawgCtx*)context)->cap) {
|
||||
Zi8LogError(0x138b, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
attribute = key << 24;
|
||||
attribute |= ((ziU8*)context->p0C)[key] << 16;
|
||||
attribute |= (((ziU32)((ziU8*)context->p08)[key * 2] & 0xFFFF) << 8) +
|
||||
((ziU8*)context->p08 + key * 2)[1];
|
||||
attribute |= ((ziU8*)((zi8DawgCtx*)context)->p0C)[key] << 16;
|
||||
attribute += ((ziU32)((ziU8*)((zi8DawgCtx*)context)->p08)[key * 2] & 0xFFFF) << 8;
|
||||
attribute += ((ziU8*)((zi8DawgCtx*)context)->p08)[key * 2 + 1];
|
||||
Zi8LogError(0x64, __zi8_work_data);
|
||||
return attribute;
|
||||
}
|
||||
@@ -164,55 +155,60 @@ ziU32 ZiDAWGGetGraph(ziPtr context) {
|
||||
|
||||
ziU32 ZiDAWGGetGraphInfo(zi8DawgCtx* context, ziU8* entry, ziU16* keys) {
|
||||
ziU32 graph;
|
||||
ziU8 depth;
|
||||
ziU32 end;
|
||||
ziS32 result;
|
||||
ziU32 end;
|
||||
ziU8 depth;
|
||||
ziU32 pair;
|
||||
|
||||
graph = ZiDAWGGetGraph(context);
|
||||
result = 0;
|
||||
if ((((ziU16)entry[0] << 8) + entry[1]) != 0 || (((ziU16)entry[2] << 8) + entry[3]) != 0) {
|
||||
pair = (((ziU16)entry[0] << 8) + entry[1]);
|
||||
if (pair != 0) {
|
||||
return 0;
|
||||
}
|
||||
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
|
||||
entry += 10;
|
||||
depth = 0;
|
||||
while ((depth < 2) && (*keys != 0)) {
|
||||
if (*keys >= 0xeff1 && *keys <= 0xf010) {
|
||||
goto checkEntry;
|
||||
pair = (((ziU16)entry[2] << 8) + entry[3]);
|
||||
if (pair == 0) {
|
||||
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
|
||||
entry += 10;
|
||||
depth = 0;
|
||||
while ((depth < 2) && (*keys != 0)) {
|
||||
if ((*keys < 0xeff1) || (0xf010 < *keys)) {
|
||||
break;
|
||||
}
|
||||
|
||||
while (1) {
|
||||
if (*keys == (ziS32)(((ziU16)entry[2] << 8) + entry[3])) {
|
||||
if (*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8))) {
|
||||
break;
|
||||
}
|
||||
entry += (((ziU16)entry[0] << 8) + entry[1]) * 10 + 10;
|
||||
checkEntry:
|
||||
entry += (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10;
|
||||
if (((ziU32)entry >= end) ||
|
||||
(*keys == (ziS32)(((ziU16)entry[2] << 8) + entry[3]))) {
|
||||
(*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8)))) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((ziU32)entry >= end) {
|
||||
return 0;
|
||||
}
|
||||
if ((ziU32)entry >= end) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
result = graph + (ziU32)entry[4] * 0x10000 + (((ziU16)entry[5] << 8) + entry[6]);
|
||||
((zi8DawgCtx*)context)->unk_0x338 =
|
||||
graph + (ziU32)entry[7] * 0x10000 + (((ziU16)entry[8] << 8) + entry[9]);
|
||||
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
|
||||
((zi8DawgCtx*)context)->unk_0x338 = 0;
|
||||
}
|
||||
result = graph + (ziU32)entry[4] * 0x10000 + ((ziU16)entry[5] << 8) +
|
||||
entry[6];
|
||||
((zi8DawgCtx*)context)->unk_0x338 =
|
||||
graph + (ziU32)entry[7] * 0x10000 + ((ziU16)entry[8] << 8) +
|
||||
entry[9];
|
||||
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
|
||||
((zi8DawgCtx*)context)->unk_0x338 = 0;
|
||||
}
|
||||
|
||||
if ((((ziU16)entry[0] << 8) + entry[1]) == 0) {
|
||||
break;
|
||||
}
|
||||
if ((entry[1] + ((ziU16)entry[0] << 8)) == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
end = (((ziU16)entry[0] << 8) + entry[1]) * 10 + ((ziU32)entry + 10);
|
||||
entry += 10;
|
||||
depth++;
|
||||
keys++;
|
||||
end = (ziU32)(entry + (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10);
|
||||
entry += 10;
|
||||
depth++;
|
||||
keys++;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
|
||||
@@ -20,134 +20,127 @@ typedef struct ziChineseEntry {
|
||||
ziU8 offsetLow[2];
|
||||
} ziChineseEntry;
|
||||
|
||||
ziU32 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
|
||||
ziU8 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
|
||||
ziU8 Zi8GetFormatVersion(ziU8 ZI_NEED_WORK);
|
||||
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
|
||||
ziU16 Zi8Uni2Ord(ziWChar ZI_NEED_WORK);
|
||||
|
||||
typedef struct ziEncodedOrdinal {
|
||||
ziU8 low;
|
||||
ziU8 high;
|
||||
} ziEncodedOrdinal;
|
||||
typedef char ziEncodedOrdinalSizeCheck[(sizeof(ziEncodedOrdinal) == 2) ? 1 : -1];
|
||||
|
||||
ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
|
||||
ziChineseEntry* table = 0;
|
||||
ziU8* baseData = 0;
|
||||
ziU8 group = 0;
|
||||
ziU8 remaining = 0;
|
||||
ziU16 value = 0;
|
||||
int count;
|
||||
int offset;
|
||||
ziU8 group;
|
||||
ziU8 remaining;
|
||||
ziU16 value;
|
||||
ziWChar* cursor;
|
||||
ziSearchState search;
|
||||
ziGetParam request;
|
||||
ziWChar ordinals[65];
|
||||
int count;
|
||||
int countLeft;
|
||||
int length;
|
||||
int unmatched;
|
||||
ziChineseEntry* entry;
|
||||
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;
|
||||
ziSearchState search = {0};
|
||||
ziU32 savedFormats = ZI_WORK->unk_0x1410;
|
||||
ziU8 savedCount = ZI_WORK->unk_0x1418;
|
||||
search.flags = 0;
|
||||
search.word = 0;
|
||||
search.length = 0;
|
||||
search.position = 0;
|
||||
search.capacity = 0;
|
||||
search.options = 0;
|
||||
Zi8LogError(100, __zi8_work_data);
|
||||
if (word == 0 || *word == 0) {
|
||||
Zi8ReplaceLastError(300, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
if (language != 1) {
|
||||
for (count = 0; word[count] != 0; count++) {
|
||||
if (word[count] >= 0xEFF1 || count == 64) return 0;
|
||||
for (length = 0; word[length] != 0; length++) {
|
||||
if (word[length] >= 0xEFF1 || length == 64) return 0;
|
||||
}
|
||||
((ziU8*)&search.length)[0] = count;
|
||||
((ziU8*)&search.length)[0] = length;
|
||||
((ziU8*)&search.flags)[2] = 1;
|
||||
search.word = word;
|
||||
((ziU16*)&search.capacity)[0] = 64;
|
||||
search.word = word;
|
||||
request.language = language;
|
||||
request.getMode = 0;
|
||||
request.subLanguage = 7;
|
||||
request.context = 1;
|
||||
request.getOptions = 0x81;
|
||||
request.elements = word;
|
||||
request.elementCount = count;
|
||||
request.elementCount = length;
|
||||
request.currentWord = 0;
|
||||
request.wordCharCount = 0;
|
||||
request.candidates = ordinals;
|
||||
request.maxCandidates = 1;
|
||||
request.firstCandidate = 0;
|
||||
ZI_WORK->formats = (ziU32)formats;
|
||||
ZI_WORK->unk_0x1410 = (ziU32)formats;
|
||||
if (ZI_WORK->unk_0x1C[0] == 2) {
|
||||
ZI_WORK->formatCount = 0;
|
||||
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 1;
|
||||
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 2;
|
||||
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 3;
|
||||
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 4;
|
||||
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 5;
|
||||
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 6;
|
||||
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 7;
|
||||
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 8;
|
||||
} else if (ZI_WORK->unk_0x1C[0] != 0) ZI_WORK->formatCount = 2;
|
||||
else ZI_WORK->formatCount = 1;
|
||||
ZI_WORK->unk_0x1418 = 0;
|
||||
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 1;
|
||||
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 2;
|
||||
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 3;
|
||||
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 4;
|
||||
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 5;
|
||||
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 6;
|
||||
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 7;
|
||||
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 8;
|
||||
} else if (ZI_WORK->unk_0x1C[0] == 0) ZI_WORK->unk_0x1418 = 1;
|
||||
else ZI_WORK->unk_0x1418 = 2;
|
||||
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) {
|
||||
Zi8ReplaceLastError(0x26C, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
{
|
||||
count = 0;
|
||||
while (word[count] != 0) {
|
||||
ordinals[count] = Zi8Uni2Ord(word[count], __zi8_work_data);
|
||||
if (ordinals[count] == 0xFFFF) return 0;
|
||||
count++;
|
||||
if (count == 64) return 0;
|
||||
}
|
||||
if (language == 1) {
|
||||
length = 0;
|
||||
do {
|
||||
ordinals[length] = Zi8Uni2Ord(word[length], __zi8_work_data);
|
||||
if (ordinals[length] == 0xFFFF) return 0;
|
||||
length++;
|
||||
if (length == 64) return 0;
|
||||
} while (word[length] != 0);
|
||||
{
|
||||
if (count-- == 1) return 1;
|
||||
if (length == 1) return 1;
|
||||
count = --length;
|
||||
ordinals[count] |= 0x8000;
|
||||
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
|
||||
table = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data);
|
||||
entry = table + ordinals[0];
|
||||
baseData = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data);
|
||||
baseData += ((entry->offsetHigh & 15) << 16 | (entry->offsetLow[1] | (entry->offsetLow[0] << 8)));
|
||||
data = baseData;
|
||||
entry = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data) + ordinals[0];
|
||||
data = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data) + ((entry->offsetHigh & 15) << 16 | ((entry->offsetLow[0] << 8) | entry->offsetLow[1]));
|
||||
if (ZI_WORK->cangjieEnabled != 0) {
|
||||
switch (*data & 7) {
|
||||
case 2:
|
||||
countLeft = 2;
|
||||
offset = 2;
|
||||
break;
|
||||
case 3:
|
||||
case 4:
|
||||
countLeft = 3;
|
||||
offset = 3;
|
||||
break;
|
||||
case 5:
|
||||
countLeft = 4;
|
||||
offset = 4;
|
||||
break;
|
||||
default:
|
||||
countLeft = 1;
|
||||
offset = 1;
|
||||
break;
|
||||
}
|
||||
data += countLeft;
|
||||
data += offset;
|
||||
}
|
||||
if ((*data & 0x80) != 0) {
|
||||
group = 0;
|
||||
data += ((*data & 0x7F) >> 4) + 1;
|
||||
} else return 0;
|
||||
if ((*data & 0x80) == 0) return 0;
|
||||
group = 0;
|
||||
data += ((*data & 0x7F) >> 4) + 1;
|
||||
while ((group & 0x80) == 0) {
|
||||
group = *data++;
|
||||
for (remaining = group & 15; remaining != 0; remaining--) {
|
||||
countLeft = count;
|
||||
unmatched = count;
|
||||
cursor = ordinals;
|
||||
while (countLeft > 0) {
|
||||
value = ((ziU32)(ziU16)data[1] << 8) |
|
||||
((const ziEncodedOrdinal*)data)->low;
|
||||
while (unmatched > 0) {
|
||||
value = data[0] | (data[1] << 8);
|
||||
data += 2;
|
||||
if (value != *++cursor) break;
|
||||
countLeft--;
|
||||
cursor++;
|
||||
if (value != *cursor) break;
|
||||
unmatched--;
|
||||
if (value & 0x8000) break;
|
||||
}
|
||||
if (countLeft == 0) return 1;
|
||||
if (unmatched == 0) return 1;
|
||||
if (!(value & 0x8000)) {
|
||||
data++;
|
||||
while (!(*data & 0x80)) data += 2;
|
||||
@@ -158,7 +151,7 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
|
||||
Zi8LogError(0x2BD, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
} else Zi8ReplaceLastError(0x26C, __zi8_work_data);
|
||||
return 0;
|
||||
}
|
||||
ziWChar Zi8ConvertUC2UserKey(ziChar character, ziU8 language ZI_NEED_WORK) {
|
||||
|
||||
@@ -30,7 +30,8 @@ ziU8 Zi8MatchOEMdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* word
|
||||
index = ZI_WORK->oemIdx;
|
||||
if ((ziS32)index >= ZI_WORK->oemLen) goto failed;
|
||||
if (ZI_WORK->oemMatch == 0) goto failed;
|
||||
if ((ziS32)length >= (ziS32)--capacity) {
|
||||
capacity--;
|
||||
if ((ziS32)length >= (ziS32)capacity) {
|
||||
failed:
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -72,11 +72,7 @@ struct DVDCommandBlock {
|
||||
DVDCommandBlock* prev; // 0x04
|
||||
|
||||
u32 command; // 0x08
|
||||
#ifdef BS2_MACH_VOLATILE_DVD_STATE
|
||||
volatile s32 state;
|
||||
#else
|
||||
s32 state; // 0x0C
|
||||
#endif
|
||||
|
||||
u32 offset; // 0x10
|
||||
u32 length; // 0x14
|
||||
|
||||
@@ -86,15 +86,9 @@ s32 uhf_msc_blk_mount(FADisk* disk) {
|
||||
return ((device->flags >> 2) & 1) - 1;
|
||||
}
|
||||
|
||||
static inline u16 ReadTransferBlocks(u32 remaining, u32 limit) {
|
||||
u16 count = limit;
|
||||
if (remaining <= limit) { count = remaining; }
|
||||
return count;
|
||||
}
|
||||
|
||||
s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* completed) {
|
||||
struct { UHF_MSC_DEVICE* device; u16 blocks; } transfer;
|
||||
s32 error;
|
||||
UHF_MSC_DEVICE* device;
|
||||
u32 block_size;
|
||||
u8* transfer_buffer;
|
||||
u32 transfer_limit;
|
||||
@@ -108,24 +102,14 @@ s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* com
|
||||
if (blocks == 0) {
|
||||
return 0;
|
||||
}
|
||||
transfer.device = NULL;
|
||||
{
|
||||
u32 index;
|
||||
UHF_MSC_DEVICE* candidate;
|
||||
for (candidate = uhg_msc_blk_device_tbl, index = 0; index < 8; candidate++, index++) {
|
||||
if (candidate->disk == disk) {
|
||||
transfer.device = &uhg_msc_blk_device_tbl[index];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (transfer.device == NULL) {
|
||||
device = uhf_msc_blk_find_device(disk);
|
||||
if (device == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (!(transfer.device->flags & 4)) {
|
||||
if (!(device->flags & 4)) {
|
||||
return -1;
|
||||
}
|
||||
block_size = transfer.device->block_size;
|
||||
block_size = device->block_size;
|
||||
if (block_size == 0) {
|
||||
return -1;
|
||||
}
|
||||
@@ -143,18 +127,21 @@ s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* com
|
||||
transfer_buffer = buffer;
|
||||
}
|
||||
do {
|
||||
transfer.blocks = ReadTransferBlocks(blocks, transfer_limit);
|
||||
error = usbh_msc_read10(transfer.device, sector, transfer.blocks, transfer_buffer, sense);
|
||||
u16 transfer_blocks = transfer_limit;
|
||||
if (blocks <= transfer_limit) {
|
||||
transfer_blocks = blocks;
|
||||
}
|
||||
error = usbh_msc_read10(device, sector, transfer_blocks, transfer_buffer, sense);
|
||||
if (error == 0) {
|
||||
if (!cacheable) {
|
||||
memcpy(buffer, transfer_buffer, transfer.blocks * block_size);
|
||||
buffer += transfer.blocks * block_size;
|
||||
memcpy(buffer, transfer_buffer, transfer_blocks * block_size);
|
||||
buffer += transfer_blocks * block_size;
|
||||
} else {
|
||||
transfer_buffer += transfer.blocks * block_size;
|
||||
transfer_buffer += transfer_blocks * block_size;
|
||||
}
|
||||
blocks -= transfer.blocks;
|
||||
sector += transfer.blocks;
|
||||
*completed += transfer.blocks;
|
||||
blocks -= transfer_blocks;
|
||||
sector += transfer_blocks;
|
||||
*completed += transfer_blocks;
|
||||
if (blocks == 0) {
|
||||
break;
|
||||
}
|
||||
@@ -164,8 +151,8 @@ s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* com
|
||||
case 11:
|
||||
break;
|
||||
case 34:
|
||||
if (transfer.device->disk != NULL) {
|
||||
pdm_disk_notify_media_insert(transfer.device->disk);
|
||||
if (device->disk != NULL) {
|
||||
pdm_disk_notify_media_insert(device->disk);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
@@ -199,17 +186,7 @@ s32 uhf_msc_blk_pwrite(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* co
|
||||
if (blocks == 0) {
|
||||
return 0;
|
||||
}
|
||||
device = NULL;
|
||||
{
|
||||
u32 index;
|
||||
UHF_MSC_DEVICE* candidate;
|
||||
for (candidate = uhg_msc_blk_device_tbl, index = 0; index < 8; candidate++, index++) {
|
||||
if (candidate->disk == disk) {
|
||||
device = &uhg_msc_blk_device_tbl[index];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
device = uhf_msc_blk_find_device(disk);
|
||||
if (device == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -550,15 +550,7 @@ pf_s32 PFCACHE_DoWriteSector(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf
|
||||
|
||||
#pragma dont_inline reset
|
||||
|
||||
static inline pf_u32 PFCACHE_RecordPageEndOverlap(PF_CACHE_PAGE* p_page, pf_u32 end_sector, pf_u32* p_num_success, pf_u32* p_num_rest_sector) {
|
||||
pf_u32 last_sector = end_sector - 1;
|
||||
pf_u32 num_overlap = end_sector - p_page->sector;
|
||||
*p_num_success += num_overlap;
|
||||
*p_num_rest_sector -= num_overlap;
|
||||
p_page->stat |= 2;
|
||||
return last_sector;
|
||||
}
|
||||
|
||||
#pragma dont_inline on
|
||||
pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf_u8* p_buf, pf_u32 sector,
|
||||
pf_u32 num_sector, pf_u32* p_num_success) {
|
||||
PF_CACHE_PAGE* p_page = PF_NULL;
|
||||
@@ -617,9 +609,11 @@ pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE**
|
||||
(p_page->sector + p_page->size) >= (sector + num_sector)) {
|
||||
pf_memcpy(p_page->buffer, (pf_u8*)&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector],
|
||||
(sector + num_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector);
|
||||
num_overlap = num_sector;
|
||||
num_overlap += sector;
|
||||
last_sector = PFCACHE_RecordPageEndOverlap(p_page, num_overlap, p_num_success, &num_rest_sector);
|
||||
num_overlap = p_page->size - ((p_page->sector + p_page->size) - (num_sector + sector));
|
||||
last_sector = p_page->sector + num_overlap - 1;
|
||||
*p_num_success += num_overlap;
|
||||
num_rest_sector -= num_overlap;
|
||||
p_page->stat |= 2;
|
||||
p_ebuf = &p_page->buffer[(last_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector];
|
||||
p_page->p_mod_sbuf = p_page->buffer;
|
||||
if (p_page->p_mod_ebuf == NULL || p_page->p_mod_ebuf < p_ebuf) {
|
||||
|
||||
@@ -603,35 +603,31 @@ pf_s32 PFCLUSTER_InsertCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
|
||||
|
||||
pf_s32 PFCLUSTER_DeleteCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
|
||||
pf_u32 cluster_index, pf_u32 num_clusters, pf_u32* p_deleted_clusters) {
|
||||
struct ClusterDeletion {
|
||||
pf_u32 length;
|
||||
pf_u32 cluster_size;
|
||||
pf_u32 position;
|
||||
};
|
||||
struct ClusterDeletion deletion;
|
||||
pf_s32 err;
|
||||
pf_u32 previous_cluster;
|
||||
pf_u32 next_cluster;
|
||||
pf_u32 first_deleted_cluster;
|
||||
pf_u32 last_deleted_cluster;
|
||||
PF_VOLUME* p_vol;
|
||||
pf_u32 cluster_size;
|
||||
pf_u32 byte_position;
|
||||
|
||||
p_vol = p_ent->p_vol;
|
||||
deletion.cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
|
||||
deletion.position = cluster_index * deletion.cluster_size;
|
||||
cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
|
||||
byte_position = cluster_index * cluster_size;
|
||||
err = PFFAT_TraceClustersChain(&p_iter->ffd, *p_iter->ffd.p_start_cluster,
|
||||
deletion.position, &previous_cluster, &first_deleted_cluster);
|
||||
byte_position, &previous_cluster, &first_deleted_cluster);
|
||||
if (err != 0) return err;
|
||||
if (cluster_index == 0) first_deleted_cluster = p_ent->start_cluster;
|
||||
deletion.length = num_clusters * deletion.cluster_size;
|
||||
if (deletion.length > p_ent->file_size - deletion.position) deletion.length = p_ent->file_size - deletion.position;
|
||||
err = PFFAT_TraceClustersChain(&p_iter->ffd, first_deleted_cluster, deletion.length, &last_deleted_cluster, &next_cluster);
|
||||
num_clusters = num_clusters * cluster_size;
|
||||
if (num_clusters > p_ent->file_size - byte_position) num_clusters = p_ent->file_size - byte_position;
|
||||
err = PFFAT_TraceClustersChain(&p_iter->ffd, first_deleted_cluster, num_clusters, &last_deleted_cluster, &next_cluster);
|
||||
if (err != 0) return err;
|
||||
if (cluster_index == 0) {
|
||||
if (next_cluster == PFFAT_GetValueOfEOC2(p_vol)) next_cluster = 0;
|
||||
p_ent->start_cluster = next_cluster;
|
||||
}
|
||||
p_ent->file_size -= deletion.length;
|
||||
p_ent->file_size -= num_clusters;
|
||||
PFENT_getcurrentDateTimeForEnt(&p_ent->modify_date, &p_ent->modify_time);
|
||||
p_ent->access_date = p_ent->modify_date;
|
||||
err = PFENT_updateEntry(p_ent, 1);
|
||||
@@ -640,13 +636,13 @@ pf_s32 PFCLUSTER_DeleteCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
|
||||
err = PFCACHE_FlushDataCacheSpecific(p_vol, PF_NULL);
|
||||
if (err != 0) return err;
|
||||
}
|
||||
err = PFFAT_FreeChain(&p_iter->ffd, first_deleted_cluster, -1U, deletion.length);
|
||||
err = PFFAT_FreeChain(&p_iter->ffd, first_deleted_cluster, -1U, num_clusters);
|
||||
if (err != 0) return err;
|
||||
if (cluster_index != 0) {
|
||||
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, previous_cluster, next_cluster);
|
||||
if (err != 0) return err;
|
||||
}
|
||||
*p_deleted_clusters = deletion.length / deletion.cluster_size;
|
||||
if (deletion.length % deletion.cluster_size != 0) ++*p_deleted_clusters;
|
||||
*p_deleted_clusters = num_clusters / cluster_size;
|
||||
if (num_clusters % cluster_size != 0) ++*p_deleted_clusters;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -140,19 +140,15 @@ extern pf_s32 PFVOL_CheckCurrentDir(PF_VOLUME* volume, pf_u32 start_cluster);
|
||||
extern pf_s32 PFENT_RemoveEntry(PF_DIR_ENT* entry, PF_ENT_ITER* iter);
|
||||
extern pf_s32 PFFAT_FreeChain(PFDIR_FFD* ffd, pf_u32 start_cluster, pf_u32 chain_index, pf_u32 size);
|
||||
|
||||
static inline PF_CUR_DIR* current_directories(PFDIR_VOLUME_DIRS* state) {
|
||||
return state->current_dirs;
|
||||
}
|
||||
|
||||
static inline pf_u32 current_directory_is_open(PF_VOLUME* volume, const PF_DIR_ENT* entry) {
|
||||
static inline pf_u32 current_directory_is_open(PF_VOLUME* volume, pf_u32 cluster) {
|
||||
pf_u32 index;
|
||||
for (index = 0; index < 4; index++) {
|
||||
if (volume == pf_vol_set.volume_state.volumes[index].p_vol) {
|
||||
PFDIR_VOLUME_DIRS* state = (PFDIR_VOLUME_DIRS*)pf_vol_set.volume_state.volumes[index].p_vol;
|
||||
PF_CUR_DIR* directory = current_directories(state);
|
||||
if (pf_vol_set.volume_state.volumes[index].p_vol == volume) {
|
||||
PFDIR_VOLUME_DIRS* state = (PFDIR_VOLUME_DIRS*)volume;
|
||||
PF_CUR_DIR* directory = state->current_dirs;
|
||||
pf_u32 slot;
|
||||
for (slot = 0; slot < 4; slot++, directory++) {
|
||||
if ((directory->stat & 1) != 0 && directory->directory.start_cluster == entry->start_cluster) { return 1; }
|
||||
if ((directory->stat & 1) != 0 && directory->directory.start_cluster == cluster) { return 1; }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -385,7 +381,7 @@ pf_s32 PFDIR_p_readdir(PFDIR_DIR* dir, PFDIR_READ_RESULT* result) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern pf_s32 PFENT_findEntry(PFDIR_FFD*, PF_DIR_ENT*, pf_u32, PFDIR_STR*, pf_u32, pf_u32);
|
||||
extern pf_s32 PFENT_findEntry(PFDIR_FFD*, PF_DIR_ENT*, pf_u32, PFDIR_STR*, pf_u8, pf_u32*, pf_u32*);
|
||||
extern pf_s32 PFFAT_GetSectorSpecified(PFDIR_FFD*, pf_u32, pf_u32, pf_u32*);
|
||||
extern pf_s32 PFPATH_transformInUnicode(pf_u16*, const pf_s8*);
|
||||
extern void PFPATH_SetSearchPattern(pf_s8*, pf_u16*, PFDIR_STR*);
|
||||
@@ -412,9 +408,17 @@ extern void PFPATH_AdjustExtShortName(pf_s8* name, pf_u32 position);
|
||||
extern pf_s32 PFCACHE_AllocateDataPage(PF_VOLUME* volume, pf_u32 sector, PF_CACHE_PAGE** page, pf_u32* size);
|
||||
extern void PFCACHE_FreeDataPage(PF_VOLUME* volume, PF_CACHE_PAGE* page);
|
||||
static inline void set_dot_entry(pf_u8* buffer) {
|
||||
pf_u32 index;
|
||||
buffer[0] = '.';
|
||||
for (index = 1; index < 11; index++) { buffer[index] = ' '; }
|
||||
buffer[1] = ' ';
|
||||
buffer[2] = ' ';
|
||||
buffer[3] = ' ';
|
||||
buffer[4] = ' ';
|
||||
buffer[5] = ' ';
|
||||
buffer[6] = ' ';
|
||||
buffer[7] = ' ';
|
||||
buffer[8] = ' ';
|
||||
buffer[9] = ' ';
|
||||
buffer[10] = ' ';
|
||||
}
|
||||
|
||||
static inline void set_dot_dot_entry(pf_u8* buffer) {
|
||||
@@ -449,7 +453,7 @@ extern pf_s32 PFENT_ITER_GetEntryOfPattern(PF_ENT_ITER* iter, PF_DIR_ENT* entry,
|
||||
extern pf_s32 PFENT_ITER_FindEntry(PF_ENT_ITER* iter, PF_DIR_ENT* entry, PFDIR_STR* pattern,
|
||||
pf_u8 attributes, pf_u32 start, pf_u32* found);
|
||||
extern pf_s32 PFENT_findEntry(PFDIR_FFD* ffd, PF_DIR_ENT* entry, pf_u32 start, PFDIR_STR* pattern,
|
||||
pf_u32 required_attributes, pf_u32 forbidden_attributes);
|
||||
pf_u8 attributes, pf_u32* logical_position, pf_u32* entry_position);
|
||||
extern pf_u32 PFSTR_GetCodeMode(PFDIR_STR* path);
|
||||
extern const pf_s8* PFSTR_GetStrPos(PFDIR_STR* path, pf_u32 target);
|
||||
extern pf_s32 PFPATH_SplitPathPattern(PF_STR* path, PFDIR_STR* directory, PFDIR_STR* pattern);
|
||||
@@ -463,16 +467,6 @@ extern pf_s32 PFFILE_FsexecOpenFile(PF_DIR_ENT* entry, PF_ENT_ITER* iter, pf_u32
|
||||
extern pf_s32 PFPATH_cmpName(const pf_s8* short_name, PFDIR_STR* pattern, pf_u32 short_search);
|
||||
extern pf_s32 PFPATH_cmpNameUni(const pf_u16* name, PFDIR_STR* pattern);
|
||||
pf_s32 PFDIR_p_mkdir(PF_VOLUME* volume, PF_STR* path, pf_u32 option, PF_DTA* data) {
|
||||
pf_u32 index;
|
||||
pf_u32* next_sector;
|
||||
pf_u16 filename_length;
|
||||
pf_u16 original_offset;
|
||||
pf_u8 checksum;
|
||||
pf_u8 lfn_count = 0;
|
||||
pf_u32 cluster;
|
||||
pf_u32 lfn_index;
|
||||
pf_u32 entry_sector;
|
||||
pf_s32 error;
|
||||
PF_DIR_ENT parent_entry;
|
||||
PF_DIR_ENT entry;
|
||||
pf_s8 normalized_name[512];
|
||||
@@ -486,9 +480,19 @@ pf_s32 PFDIR_p_mkdir(PF_VOLUME* volume, PF_STR* path, pf_u32 option, PF_DTA* dat
|
||||
pf_u32 found;
|
||||
pf_u32 page_size;
|
||||
PF_CACHE_PAGE* page;
|
||||
pf_u8 lfn_count = 0;
|
||||
pf_u32 sector = 0;
|
||||
pf_u32 written;
|
||||
pf_u32 position;
|
||||
pf_u32 entry_sector;
|
||||
pf_u16 filename_length;
|
||||
pf_u16 original_offset;
|
||||
pf_u8 checksum;
|
||||
pf_u32 cluster;
|
||||
pf_u32 index;
|
||||
pf_u32 lfn_index;
|
||||
pf_u32* next_sector;
|
||||
pf_s32 error;
|
||||
|
||||
error = PFPATH_SplitPath((PFDIR_STR*)path, &directory, &filename);
|
||||
if (error != 0) { return error; }
|
||||
@@ -866,15 +870,12 @@ pf_s32 PFDIR_p_rename(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
pf_u32 found;
|
||||
pf_u16 time;
|
||||
pf_u8 deleted_marker[1] = {0xE5};
|
||||
pf_s32 filename_length;
|
||||
pf_u32* next_sector;
|
||||
pf_s32 allocation_error = 0;
|
||||
pf_u32 sector;
|
||||
pf_u16 saved_initial_char = 0;
|
||||
pf_u32 sector;
|
||||
pf_u32* next_sector;
|
||||
pf_s32 filename_length;
|
||||
pf_s32 parse_error;
|
||||
const pf_s8* filename;
|
||||
pf_u32 remaining_lfns;
|
||||
pf_u32 lfn_index;
|
||||
pf_s32 allocation_error = 0;
|
||||
pf_s32 error;
|
||||
pf_u32 index;
|
||||
PF_DIR_ENT* update_entry;
|
||||
@@ -910,11 +911,11 @@ pf_s32 PFDIR_p_rename(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
}
|
||||
PFSTR_SetLocalStr(&destination_name, (pf_u32)normalized_name);
|
||||
if (PFSTR_GetCodeMode(&destination_name) == 1) {
|
||||
filename = PFSTR_GetStrPos(&destination_name, 1);
|
||||
const pf_s8* filename = PFSTR_GetStrPos(&destination_name, 1);
|
||||
error = pf_strcmp(PFSTR_GetStrPos(&directory, 1), filename);
|
||||
} else {
|
||||
filename = PFSTR_GetStrPos(&destination_name, 1);
|
||||
error = pf_w_strcmp((const pf_u16*)PFSTR_GetStrPos(&directory, 1), (const pf_u16*)filename);
|
||||
const pf_u16* filename = (const pf_u16*)PFSTR_GetStrPos(&destination_name, 1);
|
||||
error = pf_w_strcmp((const pf_u16*)PFSTR_GetStrPos(&directory, 1), filename);
|
||||
}
|
||||
if (error != 0) {
|
||||
error = PFENT_ITER_GetEntryOfPath(&destination_iter, &destination_entry,
|
||||
@@ -924,24 +925,23 @@ pf_s32 PFDIR_p_rename(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
}
|
||||
destination_entry.start_cluster = source_parent.start_cluster;
|
||||
PFFAT_InitFFD(&destination_iter.ffd, &destination_hint, volume, &destination_entry.start_cluster);
|
||||
error = PFENT_findEntry(&destination_iter.ffd, &destination_entry, 0, &destination_name, 0x7F, 0);
|
||||
error = PFENT_findEntry(&destination_iter.ffd, &destination_entry, 0, &destination_name, 0x7F, 0, 0);
|
||||
if (error == 0) { return 8; }
|
||||
if (error != 0 && error != 3) { return error; }
|
||||
if ((source_entry.attr & 0x10) == 0) {
|
||||
if (PFFILE_IsOpened(&source_entry) != 0) { return 0x13; }
|
||||
} else {
|
||||
if (directory_is_open(&source_entry) != 0) { return 0x13; }
|
||||
if (current_directory_is_open(source_entry.p_vol, &source_entry) != 0) { return 0x1C; }
|
||||
if (current_directory_is_open(source_entry.p_vol, source_entry.start_cluster) != 0) { return 0x1C; }
|
||||
if (PFSTR_StrNCmp(&source_name, (const pf_s8*)"..", 1, 0, 2) == 0) { return 0x1C; }
|
||||
if (PFSTR_StrNCmp(&source_name, (const pf_s8*)".", 1, 0, 1) == 0) { return 0x1C; }
|
||||
{
|
||||
pf_u32 directory_sector;
|
||||
PFDIR_SFD* file = ((PFDIR_VOLUME_DIRS*)volume)->sfds;
|
||||
directory_sector = volume->bpb.first_data_sector +
|
||||
pf_u32 directory_sector = volume->bpb.first_data_sector +
|
||||
((source_entry.start_cluster - 2) << volume->bpb.log2_sectors_per_cluster);
|
||||
for (index = 0; index < 5; index++, file++) {
|
||||
if ((file->stat & 1) != 0 && (file->stat & 2) != 0) {
|
||||
if (volume == file->dir_entry.p_vol && directory_sector == file->dir_entry.entry_sector) { return 0x13; }
|
||||
if (file->dir_entry.p_vol == volume && file->dir_entry.entry_sector == directory_sector) { return 0x13; }
|
||||
found = 0;
|
||||
error = PFENT_ITER_FindCluster(&file->dir_entry, source_entry.start_cluster, &found);
|
||||
if (error != 0) { return error; }
|
||||
@@ -961,13 +961,12 @@ pf_s32 PFDIR_p_rename(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
destination_entry.num_entry_LFNs = 0;
|
||||
PFENT_getcurrentDateTimeForEnt(&destination_entry.access_date, &time);
|
||||
error = PFENT_updateEntry(&destination_entry, 1);
|
||||
if (error != 0) { return error; }
|
||||
goto return_allocation_error;
|
||||
goto finish_rename;
|
||||
}
|
||||
if (source_entry.num_entry_LFNs != 0 && (source_entry.small_letter_flag & 0x18) == 0) {
|
||||
saved_initial_char = source_entry.long_name[0];
|
||||
source_entry.long_name[0] = 0;
|
||||
for (lfn_index = 1; lfn_index <= source_entry.num_entry_LFNs; lfn_index++) {
|
||||
for (index = 1; index <= source_entry.num_entry_LFNs; index++) {
|
||||
error = PFENT_ITER_Retreat(&source_iter, 0);
|
||||
if (error != 0) { return error; }
|
||||
error = PFSEC_WriteData(volume, deleted_marker, source_iter.sector,
|
||||
@@ -1005,7 +1004,7 @@ pf_s32 PFDIR_p_rename(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
if (allocation_error != 0) {
|
||||
if (source_entry.num_entry_LFNs != 0 && (source_entry.small_letter_flag & 0x18) == 0) {
|
||||
source_entry.long_name[0] = saved_initial_char;
|
||||
source_entry.entry_offset -= ((pf_u32)source_entry.num_entry_LFNs << 5) & (0xffU << 5);
|
||||
source_entry.entry_offset -= (pf_u16)(source_entry.num_entry_LFNs * 32);
|
||||
}
|
||||
update_entry = &source_entry;
|
||||
} else {
|
||||
@@ -1014,13 +1013,13 @@ pf_s32 PFDIR_p_rename(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
PFENT_getcurrentDateTimeForEnt(&destination_entry.access_date, &time);
|
||||
update_entry = &destination_entry;
|
||||
}
|
||||
remaining_lfns = update_entry->num_entry_LFNs;
|
||||
if (remaining_lfns != 0 && (update_entry->small_letter_flag & 0x18) == 0) {
|
||||
index = update_entry->num_entry_LFNs;
|
||||
if (index != 0 && (update_entry->small_letter_flag & 0x18) == 0) {
|
||||
sector = update_entry->entry_sector;
|
||||
next_sector = previous_chain;
|
||||
while (remaining_lfns >= 1) {
|
||||
PFENT_storeLFNEntryFieldsToBuf(entry_buffer, update_entry, remaining_lfns,
|
||||
update_entry->check_sum, remaining_lfns == update_entry->num_entry_LFNs);
|
||||
while (index >= 1) {
|
||||
PFENT_storeLFNEntryFieldsToBuf(entry_buffer, update_entry, index,
|
||||
update_entry->check_sum, index == update_entry->num_entry_LFNs);
|
||||
error = PFSEC_WriteData(volume, entry_buffer, sector, update_entry->entry_offset, 32, &written, 0);
|
||||
if (error != 0) { return error; }
|
||||
if (written != 32) { return 0x11; }
|
||||
@@ -1029,13 +1028,13 @@ pf_s32 PFDIR_p_rename(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
update_entry->entry_offset = 0;
|
||||
sector = *next_sector++;
|
||||
}
|
||||
remaining_lfns--;
|
||||
index--;
|
||||
}
|
||||
update_entry->entry_sector = sector;
|
||||
}
|
||||
error = PFENT_updateEntry(update_entry, 1);
|
||||
if (error != 0) { return error; }
|
||||
return_allocation_error:
|
||||
finish_rename:
|
||||
if (error != 0) { allocation_error = error; }
|
||||
return allocation_error;
|
||||
}
|
||||
pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
@@ -1058,16 +1057,15 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
pf_u32 found;
|
||||
pf_u16 time;
|
||||
pf_u8 deleted_marker[1] = {0xE5};
|
||||
pf_s32 filename_length;
|
||||
pf_u32* next_sector;
|
||||
pf_u32 parent_cluster;
|
||||
pf_u16 saved_initial_char = 0;
|
||||
pf_u32 sector;
|
||||
pf_u32* next_sector;
|
||||
pf_s32 filename_length;
|
||||
pf_s32 parse_error;
|
||||
pf_s32 allocation_error;
|
||||
pf_s32 error;
|
||||
pf_u16 saved_initial_char = 0;
|
||||
pf_u32 lfn_index;
|
||||
pf_u32 index;
|
||||
pf_u32 lfn_index;
|
||||
PF_DIR_ENT* update_entry;
|
||||
|
||||
error = PFENT_ITER_GetEntryOfPath(&source_iter, &source_entry, volume, (PFDIR_STR*)old_path, 0);
|
||||
@@ -1085,7 +1083,7 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
if (error != 0) { return error; }
|
||||
destination_entry.start_cluster = destination_parent.start_cluster;
|
||||
PFFAT_InitFFD(&destination_iter.ffd, &destination_hint, volume, &destination_entry.start_cluster);
|
||||
error = PFENT_findEntry(&destination_iter.ffd, &destination_entry, 0, &destination_name, 0x7F, 0);
|
||||
error = PFENT_findEntry(&destination_iter.ffd, &destination_entry, 0, &destination_name, 0x7F, 0, 0);
|
||||
if (error == 0) {
|
||||
if (destination_entry.entry_sector == source_entry.entry_sector &&
|
||||
destination_entry.entry_offset == source_entry.entry_offset) { return 0; }
|
||||
@@ -1096,19 +1094,18 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
if (PFFILE_IsOpened(&source_entry) != 0) { return 0x13; }
|
||||
} else {
|
||||
if (directory_is_open(&source_entry) != 0) { return 0x13; }
|
||||
if (current_directory_is_open(source_entry.p_vol, &source_entry) != 0) { return 0x1C; }
|
||||
if (current_directory_is_open(source_entry.p_vol, source_entry.start_cluster) != 0) { return 0x1C; }
|
||||
error = PFPATH_SplitPath((PFDIR_STR*)old_path, &directory, &source_name);
|
||||
if (error != 0) { return error; }
|
||||
if (PFSTR_StrNCmp(&source_name, (const pf_s8*)"..", 1, 0, 2) == 0) { return 10; }
|
||||
if (PFSTR_StrNCmp(&source_name, (const pf_s8*)".", 1, 0, 1) == 0) { return 10; }
|
||||
{
|
||||
pf_u32 directory_sector;
|
||||
PFDIR_SFD* file = ((PFDIR_VOLUME_DIRS*)volume)->sfds;
|
||||
directory_sector = volume->bpb.first_data_sector +
|
||||
pf_u32 directory_sector = volume->bpb.first_data_sector +
|
||||
((source_entry.start_cluster - 2) << volume->bpb.log2_sectors_per_cluster);
|
||||
for (index = 0; index < 5; index++, file++) {
|
||||
if ((file->stat & 1) != 0 && (file->stat & 2) != 0) {
|
||||
if (volume == file->dir_entry.p_vol && directory_sector == file->dir_entry.entry_sector) { return 0x13; }
|
||||
if (file->dir_entry.p_vol == volume && file->dir_entry.entry_sector == directory_sector) { return 0x13; }
|
||||
found = 0;
|
||||
error = PFENT_ITER_FindCluster(&file->dir_entry, source_entry.start_cluster, &found);
|
||||
if (error != 0) { return error; }
|
||||
@@ -1118,11 +1115,12 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
}
|
||||
destination_entry.start_cluster = destination_parent.start_cluster;
|
||||
for (;;) {
|
||||
pf_u32 parent_cluster;
|
||||
if (destination_entry.start_cluster == 1 || destination_entry.start_cluster == 0) { break; }
|
||||
PFFAT_InitFFD(&destination_iter.ffd, &destination_hint, volume, &destination_entry.start_cluster);
|
||||
PFSTR_InitStr(&parent_name, (const pf_s8*)"..", 1);
|
||||
PFSTR_SetLocalStr(&parent_name, 0);
|
||||
error = PFENT_findEntry(&destination_iter.ffd, &destination_entry, 0, &parent_name, 0x7F, 0);
|
||||
error = PFENT_findEntry(&destination_iter.ffd, &destination_entry, 0, &parent_name, 0x7F, 0, 0);
|
||||
if (error != 0) { return error; }
|
||||
parent_cluster = destination_entry.start_cluster;
|
||||
if (parent_cluster == 1 || parent_cluster == 0) { break; }
|
||||
@@ -1142,10 +1140,9 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
parse_error = PFPATH_parseShortName(destination_entry.short_name, &destination_name);
|
||||
if (destination_entry.short_name[0] == 0) { return 2; }
|
||||
if (source_entry.num_entry_LFNs != 0 && (source_entry.small_letter_flag & 0x18) == 0) {
|
||||
pf_u32 entry_index;
|
||||
saved_initial_char = source_entry.long_name[0];
|
||||
source_entry.long_name[0] = 0;
|
||||
for (entry_index = 1; entry_index <= source_entry.num_entry_LFNs; entry_index++) {
|
||||
for (index = 1; index <= source_entry.num_entry_LFNs; index++) {
|
||||
error = PFENT_ITER_Retreat(&source_iter, 0);
|
||||
if (error != 0) { return error; }
|
||||
error = PFSEC_WriteData(volume, deleted_marker, source_iter.sector,
|
||||
@@ -1183,7 +1180,7 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
if (allocation_error != 0) {
|
||||
if (source_entry.num_entry_LFNs != 0 && (source_entry.small_letter_flag & 0x18) == 0) {
|
||||
source_entry.long_name[0] = saved_initial_char;
|
||||
source_entry.entry_offset -= ((pf_u32)source_entry.num_entry_LFNs << 5) & (0xffU << 5);
|
||||
source_entry.entry_offset -= (source_entry.num_entry_LFNs & 0xff) * 32;
|
||||
}
|
||||
update_entry = &source_entry;
|
||||
} else {
|
||||
@@ -1195,7 +1192,7 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
PFFAT_InitFFD(&source_iter.ffd, &source_hint, volume, &source_entry.start_cluster);
|
||||
PFSTR_InitStr(&parent_name, (const pf_s8*)"..", 1);
|
||||
PFSTR_SetLocalStr(&parent_name, 0);
|
||||
error = PFENT_findEntry(&source_iter.ffd, &source_entry, 0, &parent_name, 0x7F, 0);
|
||||
error = PFENT_findEntry(&source_iter.ffd, &source_entry, 0, &parent_name, 0x7F, 0, 0);
|
||||
if (error != 0) { return error; }
|
||||
if (destination_parent.start_cluster == 1 || destination_parent.start_cluster == 0 ||
|
||||
(destination_parent.start_cluster == 2 && volume->bpb.fat_type == FAT_32)) {
|
||||
@@ -1233,164 +1230,6 @@ pf_s32 PFDIR_p_move(PF_VOLUME* volume, PF_STR* old_path, PF_STR* new_path) {
|
||||
return allocation_error;
|
||||
}
|
||||
|
||||
pf_s32 PFDIR_p_fsnext(PF_DTA* data) {
|
||||
PFDIR_FFD ffd;
|
||||
PFDIR_FAT_HINT hint;
|
||||
PF_DIR_ENT entry;
|
||||
PFDIR_STR pattern;
|
||||
pf_u32 logical_position = 0;
|
||||
pf_u32 entry_position = 0;
|
||||
pf_u32 code_mode;
|
||||
pf_s32 index = 0;
|
||||
pf_s32 error;
|
||||
|
||||
if ((data->status & 1) == 1) {
|
||||
code_mode = 1;
|
||||
error = PFSTR_InitStr(&pattern, data->reg_exp, code_mode);
|
||||
} else {
|
||||
code_mode = 2;
|
||||
error = PFSTR_InitStr(&pattern, (const pf_s8*)((PF_DTAW*)data)->reg_expW, code_mode);
|
||||
}
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
PFSTR_SetLocalStr(&pattern, (pf_u32)data->reg_exp);
|
||||
while (entry_position < 999999) {
|
||||
if (data->parent_pos >= 999999) { return 10; }
|
||||
entry.start_cluster = data->parent_start_cluster;
|
||||
PFFAT_InitFFD(&ffd, &hint, data->p_vol, &entry.start_cluster);
|
||||
error = PFENT_findEntryPos(&ffd, &entry, data->parent_pos, &pattern, data->attr, 0,
|
||||
&logical_position, &entry_position);
|
||||
if (error != 0) { return error; }
|
||||
data->parent_pos = entry_position + 1;
|
||||
if (entry_position == 999999) { return 3; }
|
||||
else { break; }
|
||||
}
|
||||
pf_strcpy(data->FileName, entry.short_name);
|
||||
if ((data->status & 2) == 2) {
|
||||
PFPATH_transformInUnicode(((PF_DTAW*)data)->FileNameW, data->FileName);
|
||||
}
|
||||
if (entry.long_name[0] != 0) {
|
||||
if ((pf_vol_set.setting & 2) == 2) {
|
||||
pf_vol_set.setting &= 0xFFFFFFFC;
|
||||
pf_vol_set.setting |= 1;
|
||||
PFPATH_transformFromUnicodeToNormal(data->LongName, entry.long_name);
|
||||
pf_vol_set.setting &= 0xFFFFFFFC;
|
||||
pf_vol_set.setting |= 2;
|
||||
} else {
|
||||
PFPATH_transformFromUnicodeToNormal(data->LongName, entry.long_name);
|
||||
}
|
||||
if ((data->status & 2) == 2) {
|
||||
pf_w_strcpy(((PF_DTAW*)data)->LongNameW, entry.long_name);
|
||||
}
|
||||
} else {
|
||||
data->LongName[0] = 0;
|
||||
if ((data->status & 2) == 2) {
|
||||
((PF_DTAW*)data)->LongNameW[0] = 0;
|
||||
}
|
||||
}
|
||||
if (((PFDIR_VOLUME_DIRS*)data->p_vol)->num_opened_files != 0) {
|
||||
for (index = 0; index < 5; index++) {
|
||||
if ((((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].stat & 1) != 0 && (((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].stat & 2) != 0 &&
|
||||
entry.p_vol == ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.p_vol &&
|
||||
((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.entry_sector == entry.entry_sector &&
|
||||
((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.entry_offset == entry.entry_offset) {
|
||||
data->FileSize = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.file_size;
|
||||
data->Time = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.modify_time;
|
||||
data->Date = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.modify_date;
|
||||
data->Attribute = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.attr;
|
||||
data->num_entry_LFNs = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.num_entry_LFNs;
|
||||
data->ordinal = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.ordinal;
|
||||
data->check_sum = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.check_sum;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (((PFDIR_VOLUME_DIRS*)data->p_vol)->num_opened_files == 0 || index == 5) {
|
||||
data->FileSize = entry.file_size;
|
||||
data->Time = entry.modify_time;
|
||||
data->Date = entry.modify_date;
|
||||
data->Attribute = entry.attr;
|
||||
data->num_entry_LFNs = entry.num_entry_LFNs;
|
||||
data->ordinal = entry.ordinal;
|
||||
data->check_sum = entry.check_sum;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFDIR_p_fsfirst(PF_VOLUME* volume, PF_STR* path, pf_u8 attributes, PF_DTA* data) {
|
||||
PFDIR_STR directory;
|
||||
PFDIR_STR pattern;
|
||||
PF_DIR_ENT entry;
|
||||
PF_ENT_ITER iter;
|
||||
pf_s32 error;
|
||||
|
||||
error = PFPATH_SplitPathPattern(path, &directory, &pattern);
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
error = PFENT_ITER_GetEntryOfPattern(&iter, &entry, volume, &directory);
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
if ((entry.attr & 0x10) == 0) {
|
||||
return 0x14;
|
||||
}
|
||||
data->parent_start_cluster = entry.start_cluster;
|
||||
data->parent_pos = 0;
|
||||
data->p_vol = entry.p_vol;
|
||||
data->attr = attributes;
|
||||
data->status = 0;
|
||||
if (PFSTR_GetCodeMode(&pattern) == 1) {
|
||||
PFPATH_SetSearchPattern(data->reg_exp, 0, &pattern);
|
||||
data->status |= 1;
|
||||
} else {
|
||||
PFPATH_SetSearchPattern(data->reg_exp, ((PF_DTAW*)data)->reg_expW, &pattern);
|
||||
data->status |= 2;
|
||||
}
|
||||
return PFDIR_p_fsnext(data);
|
||||
}
|
||||
|
||||
pf_s32 PFDIR_p_fsexec_chmod(PF_DTA* data, PF_DIR_ENT* entry, pf_u32 mode, pf_u32 attributes) {
|
||||
PFDIR_VOLUME_DIRS* volume_dirs = (PFDIR_VOLUME_DIRS*)entry->p_vol;
|
||||
pf_u16 date;
|
||||
pf_u16 time;
|
||||
pf_u8 create_time_ms;
|
||||
pf_s32 index = 0;
|
||||
pf_s32 error;
|
||||
|
||||
if ((attributes & 0x40) != 0) {
|
||||
attributes = (pf_u8)(attributes & ~0x40);
|
||||
}
|
||||
if ((entry->attr & 0x10) != 0) {
|
||||
if ((attributes & 4) != 0) {
|
||||
return 10;
|
||||
}
|
||||
if (directory_is_open(entry) != 0) { return 0x13; }
|
||||
|
||||
entry->attr = attributes | 0x10;
|
||||
} else {
|
||||
if ((attributes & 0x10) != 0) {
|
||||
return 10;
|
||||
}
|
||||
if (PFFILE_IsOpened(entry) != 0) {
|
||||
return 0x13;
|
||||
}
|
||||
entry->attr = attributes;
|
||||
}
|
||||
PFENT_getcurrentDateTimeForEnt(&entry->access_date, &time);
|
||||
error = PFENT_updateEntry(entry, 0);
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
if ((mode & 0x80000000) == 0) {
|
||||
data->Attribute = entry->attr;
|
||||
}
|
||||
error = PFCACHE_FlushDataCacheSpecific(entry->p_vol, 0);
|
||||
if (error != 0) { return error; }
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFDIR_p_fsexec_remove(PF_DTA* data, PF_DIR_ENT* entry, PF_ENT_ITER* iter) {
|
||||
PFDIR_VOLUME_DIRS* volume_dirs = (PFDIR_VOLUME_DIRS*)entry->p_vol;
|
||||
PFDIR_FAT_HINT hint;
|
||||
@@ -1444,6 +1283,47 @@ pf_s32 PFDIR_p_fsexec_remove(PF_DTA* data, PF_DIR_ENT* entry, PF_ENT_ITER* iter)
|
||||
return release_directory_chain(&iter->ffd, start_cluster, chain_size);
|
||||
}
|
||||
|
||||
|
||||
pf_s32 PFDIR_p_fsexec_chmod(PF_DTA* data, PF_DIR_ENT* entry, pf_u32 mode, pf_u32 attributes) {
|
||||
PFDIR_VOLUME_DIRS* volume_dirs = (PFDIR_VOLUME_DIRS*)entry->p_vol;
|
||||
pf_u16 date;
|
||||
pf_u16 time;
|
||||
pf_u8 create_time_ms;
|
||||
pf_s32 index = 0;
|
||||
pf_s32 error;
|
||||
|
||||
if ((attributes & 0x40) != 0) {
|
||||
attributes = (pf_u8)(attributes & ~0x40);
|
||||
}
|
||||
if ((entry->attr & 0x10) != 0) {
|
||||
if ((attributes & 4) != 0) {
|
||||
return 10;
|
||||
}
|
||||
if (directory_is_open(entry) != 0) { return 0x13; }
|
||||
|
||||
entry->attr = attributes | 0x10;
|
||||
} else {
|
||||
if ((attributes & 0x10) != 0) {
|
||||
return 10;
|
||||
}
|
||||
if (PFFILE_IsOpened(entry) != 0) {
|
||||
return 0x13;
|
||||
}
|
||||
entry->attr = attributes;
|
||||
}
|
||||
PFENT_getcurrentDateTimeForEnt(&entry->access_date, &time);
|
||||
error = PFENT_updateEntry(entry, 0);
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
if ((mode & 0x80000000) == 0) {
|
||||
data->Attribute = entry->attr;
|
||||
}
|
||||
error = PFCACHE_FlushDataCacheSpecific(entry->p_vol, 0);
|
||||
if (error != 0) { return error; }
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFDIR_p_fsexec_fopen(PF_DTA* data, PF_DIR_ENT* entry, PF_ENT_ITER* iter, pf_u32 flags,
|
||||
pf_u32 mode) {
|
||||
pf_s8 long_name[13];
|
||||
@@ -2030,3 +1910,121 @@ void PFDIR_chdmod(PF_STR* path, pf_u8 attributes) {
|
||||
}
|
||||
volume_dirs->cache.signature = 0;
|
||||
}
|
||||
|
||||
pf_s32 PFDIR_p_fsnext(PF_DTA* data) {
|
||||
PFDIR_FFD ffd;
|
||||
PFDIR_FAT_HINT hint;
|
||||
PF_DIR_ENT entry;
|
||||
PFDIR_STR pattern;
|
||||
pf_u32 logical_position = 0;
|
||||
pf_u32 entry_position = 0;
|
||||
pf_u32 code_mode;
|
||||
pf_s32 index = 0;
|
||||
pf_s32 error;
|
||||
|
||||
if ((data->status & 1) == 1) {
|
||||
code_mode = 1;
|
||||
error = PFSTR_InitStr(&pattern, data->reg_exp, code_mode);
|
||||
} else {
|
||||
code_mode = 2;
|
||||
error = PFSTR_InitStr(&pattern, (const pf_s8*)((PF_DTAW*)data)->reg_expW, code_mode);
|
||||
}
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
PFSTR_SetLocalStr(&pattern, (pf_u32)data->reg_exp);
|
||||
while (entry_position < 999999) {
|
||||
if (data->parent_pos >= 999999) { return 10; }
|
||||
entry.start_cluster = data->parent_start_cluster;
|
||||
PFFAT_InitFFD(&ffd, &hint, data->p_vol, &entry.start_cluster);
|
||||
error = PFENT_findEntryPos(&ffd, &entry, data->parent_pos, &pattern, data->attr, 0,
|
||||
&logical_position, &entry_position);
|
||||
if (error != 0) { return error; }
|
||||
data->parent_pos = entry_position + 1;
|
||||
if (entry_position == 999999) { return 3; }
|
||||
else { break; }
|
||||
}
|
||||
pf_strcpy(data->FileName, entry.short_name);
|
||||
if ((data->status & 2) == 2) {
|
||||
PFPATH_transformInUnicode(((PF_DTAW*)data)->FileNameW, data->FileName);
|
||||
}
|
||||
if (entry.long_name[0] != 0) {
|
||||
if ((pf_vol_set.setting & 2) == 2) {
|
||||
pf_vol_set.setting &= 0xFFFFFFFC;
|
||||
pf_vol_set.setting |= 1;
|
||||
PFPATH_transformFromUnicodeToNormal(data->LongName, entry.long_name);
|
||||
pf_vol_set.setting &= 0xFFFFFFFC;
|
||||
pf_vol_set.setting |= 2;
|
||||
} else {
|
||||
PFPATH_transformFromUnicodeToNormal(data->LongName, entry.long_name);
|
||||
}
|
||||
if ((data->status & 2) == 2) {
|
||||
pf_w_strcpy(((PF_DTAW*)data)->LongNameW, entry.long_name);
|
||||
}
|
||||
} else {
|
||||
data->LongName[0] = 0;
|
||||
if ((data->status & 2) == 2) {
|
||||
((PF_DTAW*)data)->LongNameW[0] = 0;
|
||||
}
|
||||
}
|
||||
if (((PFDIR_VOLUME_DIRS*)data->p_vol)->num_opened_files != 0) {
|
||||
for (index = 0; index < 5; index++) {
|
||||
if ((((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].stat & 1) != 0 && (((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].stat & 2) != 0 &&
|
||||
entry.p_vol == ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.p_vol &&
|
||||
((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.entry_sector == entry.entry_sector &&
|
||||
((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.entry_offset == entry.entry_offset) {
|
||||
data->FileSize = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.file_size;
|
||||
data->Time = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.modify_time;
|
||||
data->Date = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.modify_date;
|
||||
data->Attribute = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.attr;
|
||||
data->num_entry_LFNs = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.num_entry_LFNs;
|
||||
data->ordinal = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.ordinal;
|
||||
data->check_sum = ((PFDIR_VOLUME_DIRS*)data->p_vol)->sfds[index].dir_entry.check_sum;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (((PFDIR_VOLUME_DIRS*)data->p_vol)->num_opened_files == 0 || index == 5) {
|
||||
data->FileSize = entry.file_size;
|
||||
data->Time = entry.modify_time;
|
||||
data->Date = entry.modify_date;
|
||||
data->Attribute = entry.attr;
|
||||
data->num_entry_LFNs = entry.num_entry_LFNs;
|
||||
data->ordinal = entry.ordinal;
|
||||
data->check_sum = entry.check_sum;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
pf_s32 PFDIR_p_fsfirst(PF_VOLUME* volume, PF_STR* path, pf_u8 attributes, PF_DTA* data) {
|
||||
PFDIR_STR directory;
|
||||
PFDIR_STR pattern;
|
||||
PF_DIR_ENT entry;
|
||||
PF_ENT_ITER iter;
|
||||
pf_s32 error;
|
||||
|
||||
error = PFPATH_SplitPathPattern(path, &directory, &pattern);
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
error = PFENT_ITER_GetEntryOfPattern(&iter, &entry, volume, &directory);
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
if ((entry.attr & 0x10) == 0) {
|
||||
return 0x14;
|
||||
}
|
||||
data->parent_start_cluster = entry.start_cluster;
|
||||
data->parent_pos = 0;
|
||||
data->p_vol = entry.p_vol;
|
||||
data->attr = attributes;
|
||||
data->status = 0;
|
||||
if (PFSTR_GetCodeMode(&pattern) == 1) {
|
||||
PFPATH_SetSearchPattern(data->reg_exp, 0, &pattern);
|
||||
data->status |= 1;
|
||||
} else {
|
||||
PFPATH_SetSearchPattern(data->reg_exp, ((PF_DTAW*)data)->reg_expW, &pattern);
|
||||
data->status |= 2;
|
||||
}
|
||||
return PFDIR_p_fsnext(data);
|
||||
}
|
||||
|
||||
@@ -511,8 +511,8 @@ pf_s32 PFENT_ITER_FindCluster(PF_DIR_ENT* p_ent, pf_u32 cluster, pf_bool* p_is_f
|
||||
iter.ffd.cluster_link.buffer = PF_NULL;
|
||||
iter.log2_entries_per_sector = p_ent->p_vol->bpb.log2_bytes_per_sector - 5;
|
||||
iter.file_sector_index = sector_index;
|
||||
iter.offset_mask = (1U << iter.log2_entries_per_sector) - 1;
|
||||
entries_per_sector = 1U << iter.log2_entries_per_sector;
|
||||
entries_per_sector = 1 << iter.log2_entries_per_sector;
|
||||
iter.offset_mask = entries_per_sector - 1;
|
||||
iter.p_vol = p_ent->p_vol;
|
||||
iter.sector = p_ent->entry_sector;
|
||||
iter.offset = p_ent->entry_offset;
|
||||
@@ -726,29 +726,25 @@ pf_s32 PFENT_ITER_GetEntryOfIter(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline pf_u32 CopyLongNameFragment(PFITER_ENT_ITER* iter, pf_u8* destination, pf_u32 offset) {
|
||||
pf_memcpy(destination, &iter->buf[1], 10);
|
||||
pf_memcpy(destination + 10, &iter->buf[14], 12);
|
||||
pf_memcpy(destination + 22, &iter->buf[28], 4);
|
||||
return offset + 26;
|
||||
}
|
||||
|
||||
pf_s32 PFENT_ITER_GetLFNEntryName(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
|
||||
pf_u32 index;
|
||||
pf_u8* destination;
|
||||
pf_u32 i;
|
||||
pf_u32 index;
|
||||
pf_s32 err;
|
||||
if (p_ent->num_entry_LFNs != 0 && !(p_ent->small_letter_flag & 0x18)) {
|
||||
i = 0;
|
||||
for (index = 0; i < p_ent->num_entry_LFNs; ++i) {
|
||||
index = 0;
|
||||
for (i = 0; i < p_ent->num_entry_LFNs; ++i) {
|
||||
pf_u16* destination;
|
||||
err = PFENT_ITER_Retreat(p_iter, 0);
|
||||
if (err != 0) return err;
|
||||
err = PFENT_ITER_LoadEntry(p_iter);
|
||||
if (err != 0) return err;
|
||||
destination = (pf_u8*)p_ent->long_name + index;
|
||||
index = CopyLongNameFragment(p_iter, destination, index);
|
||||
destination = &p_ent->long_name[index];
|
||||
pf_memcpy(destination, &p_iter->buf[1], 10);
|
||||
pf_memcpy(destination + 5, &p_iter->buf[14], 12);
|
||||
pf_memcpy(destination + 11, &p_iter->buf[28], 4);
|
||||
index += 13;
|
||||
}
|
||||
p_ent->long_name[(p_ent->num_entry_LFNs * 26U) >> 1] = 0;
|
||||
p_ent->long_name[index] = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1458,19 +1458,6 @@ s32 PFFAT_CountFreeClusters(PF_VOLUME* volume, u32* numFreeClusters)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline s32 PFFAT_ClearEntryWithBuf(PF_VOLUME* volume, u32 cluster, PF_CACHE_PAGE* page) {
|
||||
switch (volume->bpb.fat_type) {
|
||||
case FAT_12:
|
||||
return PFFAT12_WriteFATEntryWithBuf(volume, (u16)cluster, 0, page);
|
||||
case FAT_16:
|
||||
return PFFAT16_WriteFATEntryWithBuf(volume, cluster, 0, page);
|
||||
case FAT_32:
|
||||
return PFFAT32_WriteFATEntryWithBuf(volume, cluster, 0, page);
|
||||
default:
|
||||
return 15;
|
||||
}
|
||||
}
|
||||
|
||||
s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
|
||||
u32 size)
|
||||
{
|
||||
@@ -1536,9 +1523,9 @@ s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
|
||||
}
|
||||
if (nextCluster == 0) {
|
||||
s32 firstFlushError;
|
||||
u32 fatSector;
|
||||
PF_CACHE_PAGE* flushPage;
|
||||
u16 fatIndex;
|
||||
const PF_CACHE_PAGE* flushPage;
|
||||
u32 fatSector;
|
||||
|
||||
firstFlushError = 0;
|
||||
flushPage = page;
|
||||
@@ -1559,20 +1546,34 @@ s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
|
||||
PFCACHE_FreeDataPage(volume, page);
|
||||
return 0;
|
||||
}
|
||||
{
|
||||
s32 writeError;
|
||||
if (chainIndex != -1) {
|
||||
writeError = PFFAT_WriteClusterWithBuf(file, startCluster, chainIndex,
|
||||
0, 1, page);
|
||||
chainIndex++;
|
||||
} else {
|
||||
writeError = PFFAT_ClearEntryWithBuf(volume, startCluster, page);
|
||||
}
|
||||
if (writeError != 0) {
|
||||
PFCACHE_FreeDataPage(volume, page);
|
||||
return writeError;
|
||||
if (chainIndex != -1) {
|
||||
error = PFFAT_WriteClusterWithBuf(file, startCluster, chainIndex,
|
||||
0, 1, page);
|
||||
chainIndex++;
|
||||
} else {
|
||||
currentPage = page;
|
||||
switch (volume->bpb.fat_type) {
|
||||
case FAT_12:
|
||||
error = PFFAT12_WriteFATEntryWithBuf(
|
||||
volume, (u16)startCluster, 0, currentPage);
|
||||
break;
|
||||
case FAT_16:
|
||||
error = PFFAT16_WriteFATEntryWithBuf(volume, startCluster, 0,
|
||||
currentPage);
|
||||
break;
|
||||
case FAT_32:
|
||||
error = PFFAT32_WriteFATEntryWithBuf(volume, startCluster, 0,
|
||||
currentPage);
|
||||
break;
|
||||
default:
|
||||
error = 15;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (error != 0) {
|
||||
PFCACHE_FreeDataPage(volume, page);
|
||||
return error;
|
||||
}
|
||||
if (size != 0 && fileSize != 0) {
|
||||
if (fileSize <= clusterSize) {
|
||||
fileSize = 0;
|
||||
@@ -1589,7 +1590,7 @@ s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
|
||||
s32 firstFlushError;
|
||||
u32 fatSector;
|
||||
u16 fatIndex;
|
||||
const PF_CACHE_PAGE* flushPage;
|
||||
PF_CACHE_PAGE* flushPage;
|
||||
|
||||
firstFlushError = 0;
|
||||
flushPage = page;
|
||||
|
||||
@@ -175,70 +175,68 @@ pf_s32 PFFAT12_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_s16 cluster, pf_u16 val
|
||||
|
||||
pf_s32 PFFAT12_ReadFATEntryWithBuf(PF_VOLUME* p_vol , pf_u16 cluster , pf_u32* p_value ,
|
||||
PF_CACHE_PAGE* p_page ) {
|
||||
struct {
|
||||
pf_u32 sector;
|
||||
pf_u32 current_fat;
|
||||
pf_s32 err;
|
||||
pf_u32 offset;
|
||||
} state;
|
||||
pf_s32 err;
|
||||
pf_u32 current_fat;
|
||||
pf_u32 sector;
|
||||
pf_u32 offset;
|
||||
pf_s32 result;
|
||||
|
||||
#define LOAD_FAT_SECTOR(next_sector) \
|
||||
if (p_page->sector != state.sector + (next_sector)) { \
|
||||
if (p_page->sector != sector + (next_sector)) { \
|
||||
if (p_page->option == 1) { \
|
||||
for (state.err = 0; (pf_u16)state.err < p_vol->bpb.num_active_FATs; state.err++) { \
|
||||
VFiPFSEC_WriteFAT(p_vol, p_page->p_buf, p_page->sector + (pf_u16)state.err * p_vol->bpb.sectors_per_FAT, 0, p_vol->bpb.bytes_per_sector); \
|
||||
for (err = 0; (pf_u16)err < p_vol->bpb.num_active_FATs; err++) { \
|
||||
VFiPFSEC_WriteFAT(p_vol, p_page->p_buf, p_page->sector + (pf_u16)err * p_vol->bpb.sectors_per_FAT, 0, p_vol->bpb.bytes_per_sector); \
|
||||
} \
|
||||
} \
|
||||
state.err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, state.sector + (next_sector), 0, p_vol->bpb.bytes_per_sector); \
|
||||
if (state.err != 0) { continue; } \
|
||||
p_page->sector = state.sector + (next_sector); \
|
||||
err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, sector + (next_sector), 0, p_vol->bpb.bytes_per_sector); \
|
||||
if (err != 0) { continue; } \
|
||||
p_page->sector = sector + (next_sector); \
|
||||
}
|
||||
|
||||
state.offset = (pf_u16)(cluster + (cluster >> 1));
|
||||
state.sector = p_vol->bpb.active_FAT_sector + (state.offset >> p_vol->bpb.log2_bytes_per_sector) & 0xFFFF;
|
||||
offset = (pf_u16)(cluster + (cluster >> 1));
|
||||
sector = p_vol->bpb.active_FAT_sector + (offset >> p_vol->bpb.log2_bytes_per_sector) & 0xFFFF;
|
||||
if ((p_vol->bpb.ext_flags & 0x80) != 0) {
|
||||
state.current_fat = p_vol->bpb.ext_flags & (0x01 | 0x02 | 0x04);
|
||||
current_fat = p_vol->bpb.ext_flags & (0x01 | 0x02 | 0x04);
|
||||
} else {
|
||||
state.current_fat = 1;
|
||||
current_fat = 1;
|
||||
}
|
||||
state.err = 0;
|
||||
err = 0;
|
||||
while (PF_TRUE) {
|
||||
if (state.err == 0x1000 && p_vol->p_callback != PF_NULL) {
|
||||
if (err == 0x1000 && p_vol->p_callback != PF_NULL) {
|
||||
result = ((PF_VOLUME_CB)p_vol->p_callback)(p_vol->last_driver_error);
|
||||
if (result == 0) {
|
||||
state.err = 0;
|
||||
err = 0;
|
||||
continue;
|
||||
}
|
||||
if (result == 1 && p_vol->bpb.num_active_FATs >= 2 && state.current_fat < p_vol->bpb.num_active_FATs) {
|
||||
state.current_fat++;
|
||||
state.sector += p_vol->bpb.sectors_per_FAT;
|
||||
state.err = 0;
|
||||
if (result == 1 && p_vol->bpb.num_active_FATs >= 2 && current_fat < p_vol->bpb.num_active_FATs) {
|
||||
current_fat++;
|
||||
sector += p_vol->bpb.sectors_per_FAT;
|
||||
err = 0;
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
LOAD_FAT_SECTOR(0);
|
||||
state.offset &= p_vol->bpb.bytes_per_sector - 1;
|
||||
if (state.offset == (p_vol->bpb.bytes_per_sector - 1)) {
|
||||
*p_value = *(p_page->p_buf + state.offset);
|
||||
offset &= p_vol->bpb.bytes_per_sector - 1;
|
||||
if (offset == (p_vol->bpb.bytes_per_sector - 1)) {
|
||||
*p_value = *(p_page->p_buf + offset);
|
||||
if (p_page->option == 1) {
|
||||
for (state.err = 0; (pf_u16)state.err < p_vol->bpb.num_active_FATs; state.err++) {
|
||||
VFiPFSEC_WriteFAT(p_vol, p_page->p_buf, p_page->sector + (pf_u16)state.err * p_vol->bpb.sectors_per_FAT, 0, p_vol->bpb.bytes_per_sector);
|
||||
for (err = 0; (pf_u16)err < p_vol->bpb.num_active_FATs; err++) {
|
||||
VFiPFSEC_WriteFAT(p_vol, p_page->p_buf, p_page->sector + (pf_u16)err * p_vol->bpb.sectors_per_FAT, 0, p_vol->bpb.bytes_per_sector);
|
||||
}
|
||||
}
|
||||
state.err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, state.sector + 1, 0, p_vol->bpb.bytes_per_sector);
|
||||
if (state.err != 0) { continue; }
|
||||
p_page->sector = state.sector + 1;
|
||||
err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, sector + 1, 0, p_vol->bpb.bytes_per_sector);
|
||||
if (err != 0) { continue; }
|
||||
p_page->sector = sector + 1;
|
||||
*p_value += (pf_u16)(*p_page->p_buf) << 8;
|
||||
} else {
|
||||
*p_value = ((pf_u16)p_page->p_buf[state.offset + 1] << 8) + *(p_page->p_buf + state.offset);
|
||||
*p_value = ((pf_u16)p_page->p_buf[offset + 1] << 8) + *(p_page->p_buf + offset);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (state.err != 0) {
|
||||
if (err != 0) {
|
||||
*p_value = -1;
|
||||
return state.err;
|
||||
return err;
|
||||
}
|
||||
if ((cluster & 0x01) != 0) {
|
||||
*p_value = *p_value >> 4;
|
||||
|
||||
@@ -647,16 +647,18 @@ void PFFILE_Cursor_MoveToClusterEnd(PFFILE_FILE* file, pf_u32 size) {
|
||||
}
|
||||
}
|
||||
|
||||
PFFILE_SFD* PFFILE_GetSFD(PFFILE_VOLUME_DIRS* volume_dirs, PF_DIR_ENT* entry) {
|
||||
pf_u32 first_free_index = 0;
|
||||
PFFILE_SFD* PFFILE_GetSFD(PF_VOLUME* volume, PF_DIR_ENT* entry) {
|
||||
PFFILE_VOLUME_DIRS* volume_dirs = (PFFILE_VOLUME_DIRS*)volume;
|
||||
PFFILE_SFD* first_free_sfd = PF_NULL;
|
||||
pf_u32 index;
|
||||
PFFILE_SFD* sfd = volume_dirs->sfds;
|
||||
pf_u32 first_free_index = 0;
|
||||
pf_u32 index = 0;
|
||||
|
||||
for (index = 0; index < 5; index++) {
|
||||
for (; index < 5; index++, sfd++) {
|
||||
if ((volume_dirs->sfds[index].stat & 1) == 0 ||
|
||||
((volume_dirs->sfds[index].stat & 1) != 0 && (!volume_dirs->sfds[index].stat & 2) != 0)) {
|
||||
if (first_free_sfd == PF_NULL) {
|
||||
first_free_sfd = &volume_dirs->sfds[index];
|
||||
first_free_sfd = sfd;
|
||||
first_free_index = index;
|
||||
}
|
||||
} else if (entry->p_vol == volume_dirs->sfds[index].dir_entry.p_vol &&
|
||||
@@ -920,7 +922,7 @@ pf_s32 PFFILE_p_fopen(PF_VOLUME* volume, PF_STR* path, pf_u32 open_mode,
|
||||
}
|
||||
}
|
||||
volume = entry.p_vol;
|
||||
sfd = PFFILE_GetSFD((PFFILE_VOLUME_DIRS*)volume, &entry);
|
||||
sfd = PFFILE_GetSFD(volume, &entry);
|
||||
if (sfd == PF_NULL) {
|
||||
return 0x15;
|
||||
}
|
||||
@@ -1407,7 +1409,7 @@ pf_s32 PFFILE_FsexecOpenFile(PF_DIR_ENT* entry, PFFILE_ENT_ITER* iter,
|
||||
} else {
|
||||
PFENT_getcurrentDateTimeForEnt(&entry->access_date, &access_time);
|
||||
}
|
||||
sfd = PFFILE_GetSFD((PFFILE_VOLUME_DIRS*)volume, entry);
|
||||
sfd = PFFILE_GetSFD(volume, entry);
|
||||
if (sfd == PF_NULL) {
|
||||
return 0x15;
|
||||
}
|
||||
|
||||
@@ -321,7 +321,41 @@ pf_u32 PFPATH_DoMatchFileNameWithPattern(pf_u16 c_name, PF_FILE_NAME_ITER* p_nam
|
||||
return 1;
|
||||
}
|
||||
|
||||
pf_bool PFPATH_MatchFileNameWithPattern(const pf_s8* file_name, PF_STR* p_pattern, pf_bool is_long_name);
|
||||
pf_bool PFPATH_MatchFileNameWithPattern(const pf_s8* file_name, PF_STR* p_pattern, pf_bool is_long_name) {
|
||||
pf_u16 c_name;
|
||||
pf_u16 c_pat;
|
||||
PF_FILE_NAME_ITER name;
|
||||
PF_STR pattern;
|
||||
pf_bool result;
|
||||
|
||||
result = PF_TRUE;
|
||||
name.buf = file_name;
|
||||
name.current = 0;
|
||||
name.kind = is_long_name;
|
||||
name.index = 0;
|
||||
|
||||
pattern = *p_pattern;
|
||||
|
||||
if (PFSTR_GetCodeMode(p_pattern) == 1) {
|
||||
if (is_long_name == PF_FALSE && (pf_vol_set.setting & 0x02) == 0x02 && PFPATH_CheckExtShortNameSignature(&pattern) == 1) {
|
||||
result = PFPATH_CheckExtShortNameSignature(&pattern);
|
||||
if (result == 1) {
|
||||
name.index += 2;
|
||||
pattern.p_head += 2;
|
||||
}
|
||||
}
|
||||
} else if ((pf_vol_set.setting & 0x02) == 0x02 && is_long_name == PF_FALSE &&
|
||||
PFSTR_StrNCmp(p_pattern, (pf_s8*)".", 1, 0, 1) != 0 && PFSTR_StrNCmp(p_pattern, (pf_s8*)"..", 1, 0, 2) != 0 &&
|
||||
PFPATH_CheckExtShortName(p_pattern, 1, PF_FALSE) == 0) {
|
||||
result = PF_FALSE;
|
||||
}
|
||||
if (result == PF_TRUE) {
|
||||
c_name = PFPATH_GetNextCharOfFileName(&name);
|
||||
c_pat = PFPATH_GetNextCharOfPattern(&pattern, is_long_name);
|
||||
result = PFPATH_DoMatchFileNameWithPattern(c_name, &name, c_pat, &pattern, is_long_name);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
pf_s32 PFPATH_cmpNameImpl(const pf_s8* name, const pf_s8* pattern, pf_u32* matched_end) {
|
||||
pf_u32 read_char;
|
||||
@@ -543,42 +577,6 @@ PF_VOLUME* PFPATH_GetVolumeFromPath(PF_STR* p_path) {
|
||||
return p_vol;
|
||||
}
|
||||
|
||||
pf_bool PFPATH_MatchFileNameWithPattern(const pf_s8* file_name, PF_STR* p_pattern, pf_bool is_long_name) {
|
||||
pf_u16 c_name;
|
||||
pf_u16 c_pat;
|
||||
PF_FILE_NAME_ITER name;
|
||||
PF_STR pattern;
|
||||
pf_bool result;
|
||||
|
||||
result = PF_TRUE;
|
||||
name.buf = file_name;
|
||||
name.current = 0;
|
||||
name.kind = is_long_name;
|
||||
name.index = 0;
|
||||
|
||||
pattern = *p_pattern;
|
||||
|
||||
if (PFSTR_GetCodeMode(p_pattern) == 1) {
|
||||
if (is_long_name == PF_FALSE && (pf_vol_set.setting & 0x02) == 0x02 && PFPATH_CheckExtShortNameSignature(&pattern) == 1) {
|
||||
result = PFPATH_CheckExtShortNameSignature(&pattern);
|
||||
if (result == 1) {
|
||||
name.index += 2;
|
||||
pattern.p_head += 2;
|
||||
}
|
||||
}
|
||||
} else if ((pf_vol_set.setting & 0x02) == 0x02 && is_long_name == PF_FALSE &&
|
||||
PFSTR_StrNCmp(p_pattern, (pf_s8*)".", 1, 0, 1) != 0 && PFSTR_StrNCmp(p_pattern, (pf_s8*)"..", 1, 0, 2) != 0 &&
|
||||
PFPATH_CheckExtShortName(p_pattern, 1, PF_FALSE) == 0) {
|
||||
result = PF_FALSE;
|
||||
}
|
||||
if (result == PF_TRUE) {
|
||||
c_name = PFPATH_GetNextCharOfFileName(&name);
|
||||
c_pat = PFPATH_GetNextCharOfPattern(&pattern, is_long_name);
|
||||
result = PFPATH_DoMatchFileNameWithPattern(c_name, &name, c_pat, &pattern, is_long_name);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
pf_s32 PFPATH_putShortName(pf_u8* pDirEntry, const pf_s8* short_name, pf_u8 attr) {
|
||||
pf_s32 i = 0;
|
||||
|
||||
|
||||
@@ -225,6 +225,8 @@ typedef struct PFVOL_SET {
|
||||
PFVOL_SET pf_vol_set;
|
||||
|
||||
static s8 default_volume_label[12] = "NO NAME ";
|
||||
static const u8 deleted_entry_mark[8] = {0xE5};
|
||||
|
||||
extern s32 PFDRV_mount(PFVOL_VOLUME* volume);
|
||||
extern s32 PFDRV_unmount(PFVOL_VOLUME* volume, u32 mode);
|
||||
extern s32 PFDRV_format(PFVOL_VOLUME* volume, const u8* format_options);
|
||||
@@ -370,13 +372,8 @@ static inline s32 finalize_volume(PFVOL_VOLUME* volume) {
|
||||
if (error != 0) { return error; }
|
||||
return 0;
|
||||
}
|
||||
static inline s32 copy_codeset(PFVOL_CHARCODE* code_set) {
|
||||
pf_vol_set.codeset.oem2unicode = code_set->oem2unicode;
|
||||
pf_vol_set.codeset.unicode2oem = code_set->unicode2oem;
|
||||
pf_vol_set.codeset.oem_char_width = code_set->oem_char_width;
|
||||
pf_vol_set.codeset.is_oem_mb_char = code_set->is_oem_mb_char;
|
||||
pf_vol_set.codeset.unicode_char_width = code_set->unicode_char_width;
|
||||
pf_vol_set.codeset.is_unicode_mb_char = code_set->is_unicode_mb_char;
|
||||
static inline s32 copy_codeset(const PFVOL_CHARCODE* code_set) {
|
||||
pf_vol_set.codeset = *code_set;
|
||||
return 0;
|
||||
}
|
||||
s32 PFVOL_DoMountVolume(PFVOL_VOLUME* volume) {
|
||||
@@ -587,7 +584,7 @@ s32 PFVOL_p_rmvvol(PFVOL_VOLUME* volume) {
|
||||
u32 logical_position;
|
||||
u32 entry_position;
|
||||
u32 processed;
|
||||
u8 deleted[1] = {0xE5};
|
||||
u8 deleted = deleted_entry_mark[0];
|
||||
s32 error;
|
||||
|
||||
error = PFENT_GetRootDir(volume, &root_entry);
|
||||
@@ -602,7 +599,7 @@ s32 PFVOL_p_rmvvol(PFVOL_VOLUME* volume) {
|
||||
return error;
|
||||
}
|
||||
if (entry_position != 999999) {
|
||||
error = PFSEC_WriteData(volume, deleted, entry.entry_sector, entry.entry_offset, 1, &processed, 0);
|
||||
error = PFSEC_WriteData(volume, &deleted, entry.entry_sector, entry.entry_offset, 1, &processed, 0);
|
||||
if (error != 0) {
|
||||
return error;
|
||||
}
|
||||
@@ -1105,13 +1102,7 @@ s32 PFVOL_attach(PFVOL_DRIVER* driver, s32 notify_command, void* callback_data)
|
||||
pf_vol_set.num_attached_drives++;
|
||||
if (PFDRV_IsInserted(volume) != 0) {
|
||||
driver->stat |= 0x10;
|
||||
error = clear_mount(volume);
|
||||
if (error != 0) {
|
||||
pf_vol_set.last_error = error;
|
||||
volume->last_error = error;
|
||||
return 0;
|
||||
}
|
||||
driver->stat |= 2;
|
||||
attach_mount(volume, driver);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -1467,7 +1458,7 @@ s32 PFVOL_getvolcfg(s8 drive, u32* config) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 PFVOL_setcode(PFVOL_CHARCODE* code_set) {
|
||||
s32 PFVOL_setcode(const PFVOL_CHARCODE* code_set) {
|
||||
if (pf_vol_set.num_mounted_volumes > 0) {
|
||||
pf_vol_set.last_error = 36;
|
||||
return 36;
|
||||
@@ -1475,21 +1466,17 @@ s32 PFVOL_setcode(PFVOL_CHARCODE* code_set) {
|
||||
return copy_codeset(code_set);
|
||||
}
|
||||
|
||||
static inline u32 ContextStatus(const PFVOL_CONTEXT* context) {
|
||||
return context->stat & 1;
|
||||
}
|
||||
|
||||
s32 PFVOL_regctx(void) {
|
||||
u32 context_index;
|
||||
s32 free_context_index;
|
||||
s32 context_id;
|
||||
s32 free_context_index;
|
||||
u32 context_index;
|
||||
s32 error;
|
||||
error = PFSYS_GetCurrentContextID(&context_id);
|
||||
if (error != 0) { pf_vol_set.last_error = 26; return 26; }
|
||||
free_context_index = 0;
|
||||
for (context_index = 1; context_index < 4; context_index++) {
|
||||
u32 stat;
|
||||
stat = ContextStatus(&pf_vol_set.context[context_index - 1]);
|
||||
stat = pf_vol_set.context[context_index - 1].stat & 1;
|
||||
if (stat != 0 && pf_vol_set.context[context_index - 1].context_id == context_id) { break; }
|
||||
if (stat == 0 && free_context_index == 0) { free_context_index = context_index; }
|
||||
}
|
||||
|
||||
@@ -562,13 +562,11 @@ static inline u32 kbdChannelFlags(u32 channel) {
|
||||
}
|
||||
|
||||
static void kbd_led_handler(BOOL success, void* callbackArg) {
|
||||
const KBDLEDCallbackData* callback;
|
||||
u32 index;
|
||||
u32 err;
|
||||
index = (u32)callbackArg;
|
||||
callback = &kbdLCBuf[index];
|
||||
kbdCmdBuf[index].device = 0;
|
||||
if (callback->callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[index].device) {
|
||||
if (kbdLCBuf[index].callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[index].device) {
|
||||
return;
|
||||
}
|
||||
switch (success) {
|
||||
|
||||
@@ -276,15 +276,14 @@ static inline f32 object_interval_distance(f32 interval) {
|
||||
const f32 sensorIntervalConversion = 0.383864f;
|
||||
|
||||
static void reset_kpad(KPADInside* kpad) {
|
||||
f32 sensorDistance;
|
||||
f32 upperY;
|
||||
f32 distanceValue;
|
||||
f32 zero;
|
||||
f32 upperY;
|
||||
f32 sensorDistance;
|
||||
f32 lowerY;
|
||||
f32 one;
|
||||
f32 negativeOne;
|
||||
KPADDPDObject* object;
|
||||
f32 calibratedDistance;
|
||||
negativeOne = -1.0f;
|
||||
one = 1.0f;
|
||||
zero = 0.0f;
|
||||
@@ -300,9 +299,8 @@ static void reset_kpad(KPADInside* kpad) {
|
||||
kpad->value508 = negativeOne / kp_err_dist_speed;
|
||||
kpad->value50C = kp_ah_circle_radius * kp_ah_circle_radius;
|
||||
kpad->value514 = kp_err_dist_min;
|
||||
calibratedDistance = kp_dist_vv1;
|
||||
distanceValue = calibratedDistance / sensorDistance;
|
||||
kpad->value510 = calibratedDistance;
|
||||
distanceValue = kp_dist_vv1 / sensorDistance;
|
||||
kpad->value510 = kp_dist_vv1;
|
||||
kpad->status.release = 0;
|
||||
kpad->status.trig = 0;
|
||||
kpad->status.hold = 0;
|
||||
@@ -856,33 +854,26 @@ static s8 select_1obj_continue(KPADInside* kpad) {
|
||||
}
|
||||
*matchedCandidate = *source;
|
||||
{
|
||||
f32 distance;
|
||||
f32 normY;
|
||||
f32 vertical;
|
||||
f32 directionY;
|
||||
f32 axisX = kpad->horizonTangent.x;
|
||||
f32 normX = kpad->horizonAxis.x;
|
||||
f32 axisY = kpad->horizonTangent.y;
|
||||
f32 normY = kpad->horizonAxis.y;
|
||||
f32 distance = kpad->dpdObjectDistance;
|
||||
f32 horizontal = axisX * normX;
|
||||
f32 vertical = axisY * normX;
|
||||
f32 offsetX;
|
||||
f32 axisY;
|
||||
f32 horizontal;
|
||||
f32 axisX;
|
||||
f32 directionX;
|
||||
f32 normX;
|
||||
f32 directionY;
|
||||
f32 offsetY;
|
||||
f32 tangentY;
|
||||
f32 tangentX;
|
||||
axisX = kpad->horizonTangent.x;
|
||||
normX = kpad->horizonAxis.x;
|
||||
axisY = kpad->horizonTangent.y;
|
||||
normY = kpad->horizonAxis.y;
|
||||
distance = kpad->dpdObjectDistance;
|
||||
horizontal = axisX * normX;
|
||||
vertical = axisY * normX;
|
||||
tangentY = axisY * normY;
|
||||
tangentX = axisX * normY;
|
||||
directionX = horizontal + tangentY;
|
||||
directionY = vertical - tangentX;
|
||||
offsetX = distance * directionX;
|
||||
offsetX = directionX * distance;
|
||||
kpad->dpdObjectDirection.x = directionX;
|
||||
offsetY = distance * directionY;
|
||||
offsetY = directionY * distance;
|
||||
kpad->dpdObjectDirection.y = directionY;
|
||||
if (matchedCandidate == kpad->dpdState.candidates) {
|
||||
kpad->dpdState.candidates[1].x = matchedCandidate->x + offsetX;
|
||||
|
||||
@@ -144,8 +144,8 @@ const u16 kprLookupTable437[] = {
|
||||
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
|
||||
};
|
||||
|
||||
static void (*kprProcDeadKeysFP)(KPRQueue* queue) = NULL;
|
||||
static void (*kprProcRomajiFP)(KPRQueue* queue) = NULL;
|
||||
static void (*kprProcDeadKeysFP)(KPRQueue* queue);
|
||||
static void (*kprProcRomajiFP)(KPRQueue* queue);
|
||||
const char* __KPRVersion = "<< RVL_SDK - KPR \trelease build: Apr 20 2010 11:21:44 (0x4199_60831) >>";
|
||||
|
||||
void KPRProcessDeadKeys(KPRQueue* queue);
|
||||
@@ -242,25 +242,6 @@ u8 KPRLookAhead(KPRQueue* queue, u16* destination, u32 capacity) {
|
||||
return queue->iCount + queue->oCount;
|
||||
}
|
||||
|
||||
static inline u32 KPRConvertAltValue(u32 value, u32 leadingZero) {
|
||||
if (value >= 128 && value <= 255) {
|
||||
if (leadingZero) {
|
||||
if (value < 160) {
|
||||
value = kprLookupTable1252[value - 128];
|
||||
}
|
||||
} else {
|
||||
value = kprLookupTable437[value - 128];
|
||||
}
|
||||
} else if (value > 255) {
|
||||
u32 converted = 32;
|
||||
if (value <= 0x6666666) {
|
||||
converted = (u8)value;
|
||||
}
|
||||
value = converted;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
BOOL KPRProcessAltKeypad(KPRQueue* queue, u16 character) {
|
||||
if (queue->altVal != 0) {
|
||||
u32 accumulator = queue->altVal & 0x7FFFFFFF;
|
||||
@@ -275,7 +256,21 @@ BOOL KPRProcessAltKeypad(KPRQueue* queue, u16 character) {
|
||||
return TRUE;
|
||||
}
|
||||
value = queue->altVal;
|
||||
value = KPRConvertAltValue(value, leadingZero);
|
||||
if (value >= 128 && value <= 255) {
|
||||
if (leadingZero) {
|
||||
if (value < 160) {
|
||||
value = kprLookupTable1252[value - 128];
|
||||
}
|
||||
} else {
|
||||
value = kprLookupTable437[value - 128];
|
||||
}
|
||||
} else if (value > 255) {
|
||||
u32 converted = 32;
|
||||
if (value <= 0x6666666) {
|
||||
converted = (u8)value;
|
||||
}
|
||||
value = converted;
|
||||
}
|
||||
{
|
||||
u16* destination;
|
||||
int index = queue->oCount + queue->iCount;
|
||||
|
||||
@@ -484,7 +484,6 @@ static inline unsigned long __nupBase64EncodedSize(unsigned long length) {
|
||||
}
|
||||
|
||||
static void __nupBase64Encode(u8* output, u8* input, unsigned long length) {
|
||||
static char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
u8* end = input + length;
|
||||
u32 value = 0;
|
||||
u32 count = 0;
|
||||
@@ -497,19 +496,26 @@ static void __nupBase64Encode(u8* output, u8* input, unsigned long length) {
|
||||
if (count < 3) {
|
||||
continue;
|
||||
}
|
||||
output[0] = alphabet[value >> 18 & 0x3f];
|
||||
output[1] = alphabet[value >> 12 & 0x3f];
|
||||
output[2] = alphabet[value >> 6 & 0x3f];
|
||||
output[3] = alphabet[value & 0x3f];
|
||||
u8 encodedSecond = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 12 & 0x3f];
|
||||
u8 encodedFirst = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 18 & 0x3f];
|
||||
output[0] = encodedFirst;
|
||||
u8 encodedThird = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 6 & 0x3f];
|
||||
output[1] = encodedSecond;
|
||||
u8 encodedFourth = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value & 0x3f];
|
||||
output[2] = encodedThird;
|
||||
output[3] = encodedFourth;
|
||||
count = 0;
|
||||
output += 4;
|
||||
}
|
||||
|
||||
if (count == 2) {
|
||||
value <<= 8;
|
||||
output[0] = alphabet[value >> 18 & 0x3f];
|
||||
output[1] = alphabet[value >> 12 & 0x3f];
|
||||
output[2] = alphabet[value >> 6 & 0x3f];
|
||||
u8 encodedSecond = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 12 & 0x3f];
|
||||
u8 encodedFirst = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 18 & 0x3f];
|
||||
output[0] = encodedFirst;
|
||||
u8 encodedThird = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 6 & 0x3f];
|
||||
output[1] = encodedSecond;
|
||||
output[2] = encodedThird;
|
||||
output[3] = fillByte;
|
||||
return;
|
||||
}
|
||||
@@ -517,8 +523,10 @@ static void __nupBase64Encode(u8* output, u8* input, unsigned long length) {
|
||||
return;
|
||||
}
|
||||
value <<= 16;
|
||||
output[0] = alphabet[value >> 18 & 0x3f];
|
||||
output[1] = alphabet[value >> 12 & 0x3f];
|
||||
u8 encodedSecond = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 12 & 0x3f];
|
||||
u8 encodedFirst = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[value >> 18 & 0x3f];
|
||||
output[0] = encodedFirst;
|
||||
output[1] = encodedSecond;
|
||||
output[2] = fillByte;
|
||||
output[3] = fillByte;
|
||||
}
|
||||
|
||||
@@ -1167,9 +1167,9 @@ u32 VIGetRetraceCount(void)
|
||||
|
||||
static u32 getCurrentHalfLine(void)
|
||||
{
|
||||
u32 verticalCount;
|
||||
u32 previousVerticalCount;
|
||||
u32 horizontalCount;
|
||||
u32 previousVerticalCount;
|
||||
u32 verticalCount;
|
||||
|
||||
verticalCount = __VIRegs[22] & 0x7FF;
|
||||
for (;;) {
|
||||
@@ -1180,7 +1180,7 @@ static u32 getCurrentHalfLine(void)
|
||||
break;
|
||||
}
|
||||
}
|
||||
return ((verticalCount - 1) * 2) + ((horizontalCount - 1) / CurrTiming->hlw);
|
||||
return ((horizontalCount - 1) / CurrTiming->hlw) + ((verticalCount - 1) * 2);
|
||||
}
|
||||
|
||||
static u32 getCurrentFieldEvenOdd(void)
|
||||
|
||||
@@ -1283,7 +1283,7 @@ static void __ClearControlBlock(s32 chan) {
|
||||
p->sleeping = TRUE;
|
||||
p->getInfoBusy = FALSE;
|
||||
p->getInfoCB = NULL;
|
||||
p->continuous = 0;
|
||||
p->unk_0x98E = 0;
|
||||
|
||||
memset(&p->wpInfo, 0, sizeof(p->wpInfo));
|
||||
memset(&p->wmReadDataBuf, 0, sizeof(p->wmReadDataBuf));
|
||||
@@ -1315,7 +1315,7 @@ static void __ClearControlBlock(s32 chan) {
|
||||
_wmb[chan].unk_0x04 = 0;
|
||||
_wmb[chan].unk_0x08 = 0;
|
||||
_wmb[chan].unk_0x0C = 0;
|
||||
_wmb[chan].callback = NULL;
|
||||
_wmb[chan].unk_0x10 = NULL;
|
||||
|
||||
_rumbleCnt[chan] = 0;
|
||||
}
|
||||
@@ -1551,7 +1551,7 @@ static void firmwareCheckCallback(s32 chan, s32 status) {
|
||||
|
||||
DEBUGPrint(" ==>this error means that the firmware is for NDEV %s\n", p->configIndex != 0 ? "2.0" : "2.1 or later");
|
||||
|
||||
WPADiSendSetReportType(&p->stdCmdQueue, WPAD_FMT_CORE_BTN, p->continuous, &abortConnCallback);
|
||||
WPADiSendSetReportType(&p->stdCmdQueue, WPAD_FMT_CORE_BTN, p->unk_0x98E, &abortConnCallback);
|
||||
|
||||
WPADiSendDPDCSB(&p->stdCmdQueue, FALSE, &abortConnCallback);
|
||||
WPADiSendSetPort(&p->stdCmdQueue, port, &abortConnCallback);
|
||||
@@ -1626,7 +1626,7 @@ static void WPADiConnCallback(WUDDevInfo* devInfo, u8 open) {
|
||||
p->status = WPAD_ERR_OK;
|
||||
p->radioSensitivity = 100;
|
||||
p->sleeping = FALSE;
|
||||
p->encStatus = FALSE;
|
||||
p->unk_0x98D = FALSE;
|
||||
|
||||
WPADiSendReadData(&p->stdCmdQueue, p->wmReadDataBuf, 1, WM_ADDR_MEM_1770, firmwareCheckCallback);
|
||||
|
||||
@@ -1643,8 +1643,8 @@ static void WPADiConnCallback(WUDDevInfo* devInfo, u8 open) {
|
||||
|
||||
if (p->cmdBlkCB != NULL) {
|
||||
p->cmdBlkCB(chan, WPAD_ERR_NO_CONTROLLER);
|
||||
} else if (_wmb[chan].callback != NULL) {
|
||||
_wmb[chan].callback(chan, WPAD_ERR_NO_CONTROLLER);
|
||||
} else if (_wmb[chan].unk_0x10 != NULL) {
|
||||
_wmb[chan].unk_0x10(chan, WPAD_ERR_NO_CONTROLLER);
|
||||
}
|
||||
|
||||
do {
|
||||
@@ -1886,7 +1886,7 @@ s32 WPADSetDataFormat(s32 chan, u32 format) {
|
||||
}
|
||||
|
||||
if (currFormat != format) {
|
||||
if (!WPADiSendSetReportType(&p->stdCmdQueue, format, p->continuous, NULL)) {
|
||||
if (!WPADiSendSetReportType(&p->stdCmdQueue, format, p->unk_0x98E, NULL)) {
|
||||
status = WPAD_ERR_COMMUNICATION_ERROR;
|
||||
} else {
|
||||
enabled = OSDisableInterrupts();
|
||||
@@ -2741,13 +2741,13 @@ BOOL WPADiSendSetPort(WPADCommandQueue* pQueue, u8 port, WPADCallback pCallback)
|
||||
return success;
|
||||
}
|
||||
|
||||
BOOL WPADiSendSetReportType(WPADCommandQueue* pQueue, s32 format, BOOL continuous, WPADCallback pCallback) {
|
||||
BOOL WPADiSendSetReportType(WPADCommandQueue* pQueue, s32 format, BOOL unk, WPADCallback pCallback) {
|
||||
BOOL success;
|
||||
WPADCommand command;
|
||||
|
||||
command.reportID = RPTID_SET_DATA_REPORT_MODE;
|
||||
command.dataLength = RPT12_SIZE;
|
||||
command.dataBuf[RPT12_CONT_REPORT] = continuous ? 0 : 4; // Always continuous reporting
|
||||
command.dataBuf[RPT12_CONT_REPORT] = unk ? 0 : 4; // Always continuous reporting
|
||||
command.cmdCB = pCallback;
|
||||
|
||||
switch (format) {
|
||||
|
||||
@@ -111,8 +111,8 @@ static void initExtension(s32 chan) {
|
||||
|
||||
WPADiClearQueue(&p_wpd->extCmdQueue);
|
||||
WPADiSendSetReportType(&p_wpd->extCmdQueue, p_wpd->dataFormat,
|
||||
p_wpd->continuous, abortInitExtension);
|
||||
p_wpd->encStatus = 1;
|
||||
p_wpd->unk_0x98E, abortInitExtension);
|
||||
p_wpd->unk_0x98D = 1;
|
||||
WPADiSendWriteDataCmd(&p_wpd->extCmdQueue, 0x55, 0x04a400f0,
|
||||
abortInitExtension);
|
||||
WPADiSendWriteDataCmd(&p_wpd->extCmdQueue, 0, 0x04a400fb,
|
||||
@@ -127,7 +127,7 @@ static void abortInitExtension(s32 chan, s32 result) {
|
||||
|
||||
if (result != WPAD_ERR_NONE) {
|
||||
WPADiClearQueue(&p_wpd->extCmdQueue);
|
||||
p_wpd->encStatus = 0;
|
||||
p_wpd->unk_0x98D = 0;
|
||||
if (result == WPAD_ERR_NO_CONTROLLER) {
|
||||
type = WPAD_DEV_NOT_FOUND;
|
||||
}
|
||||
@@ -142,7 +142,7 @@ static void abortInitExtension(s32 chan, s32 result) {
|
||||
|
||||
else {
|
||||
DEBUGPrint("detaching extension during initialization.\n");
|
||||
WPADiSendSetReportType(&p_wpd->extCmdQueue, p_wpd->dataFormat, p_wpd->continuous, NULL);
|
||||
WPADiSendSetReportType(&p_wpd->extCmdQueue, p_wpd->dataFormat, p_wpd->unk_0x98E, NULL);
|
||||
return;
|
||||
}
|
||||
p_wpd->devType = (u8)type;
|
||||
@@ -509,7 +509,7 @@ static void getExtType(s32 chan, s32 result) {
|
||||
}
|
||||
} else {
|
||||
if (isExtEncMain(_devType[chan])) {
|
||||
p_wpd->encStatus = 2;
|
||||
p_wpd->unk_0x98D = 2;
|
||||
WPADiSendWriteDataCmd(cmdq, 0xAA, 0x4A400F0, abortInitExtension);
|
||||
WPADiCreateKey(chan);
|
||||
WPADiSendWriteData(cmdq, p_wpd->encryptionKey, 6, 0x4A40040, abortInitExtension);
|
||||
@@ -517,7 +517,7 @@ static void getExtType(s32 chan, s32 result) {
|
||||
WPADiSendWriteData(cmdq, p_wpd->encryptionKey + 12, 4, 0x4A4004C, abortInitExtension);
|
||||
WPADiSendReadData(cmdq, p_wpd->wmReadDataBuf, 32, 0x4A40020, p_wpd->extensionCB);
|
||||
} else {
|
||||
p_wpd->encStatus = 3;
|
||||
p_wpd->unk_0x98D = 3;
|
||||
WPADiSendWriteDataCmd(cmdq, 0xAA, 0x4A400F0, abortInitExtension);
|
||||
WPADiCreateKeyFor3rd(chan);
|
||||
WPADiSendWriteData(cmdq, p_wpd->encryptionKey, 6, 0x4A40040, abortInitExtension);
|
||||
@@ -651,7 +651,7 @@ void __a1_20_status_report(u8 chan, u8* data) {
|
||||
p_wpd->devMode = 0;
|
||||
|
||||
WPADiClearQueue(&p_wpd->extCmdQueue);
|
||||
WPADiSendSetReportType(&p_wpd->extCmdQueue, p_wpd->dataFormat, p_wpd->continuous, NULL);
|
||||
WPADiSendSetReportType(&p_wpd->extCmdQueue, p_wpd->dataFormat, p_wpd->unk_0x98E, NULL);
|
||||
|
||||
if (attach) {
|
||||
if (p_wpd->extensionCB) {
|
||||
@@ -741,11 +741,11 @@ void __a1_21_user_data(u8 chan, u8* data) {
|
||||
DEBUGPrint("length : %d\n", p_wpd->wmReadLength);
|
||||
status = (p_wpd->wmReadHadError < 0) ? WPAD_ERR_TRANSFER : 0;
|
||||
DEBUGPrint("i2c = %04x\n", i2c);
|
||||
DEBUGPrint("enc = %d\n", p_wpd->encStatus);
|
||||
DEBUGPrint("enc = %d\n", p_wpd->unk_0x98D);
|
||||
|
||||
if (i2c == 0x04a4) {
|
||||
DEBUGPrint("Access to extension register.\n");
|
||||
if (p_wpd->encStatus == 2 || p_wpd->encStatus == 3) {
|
||||
if (p_wpd->unk_0x98D == 2 || p_wpd->unk_0x98D == 3) {
|
||||
DEBUGPrint("Decode!!!!\n");
|
||||
DEBUGPrint(" len = %d, addr = %04x\n", len, base);
|
||||
|
||||
|
||||
@@ -13,8 +13,8 @@ typedef struct _CDBCryptBuf {
|
||||
u32 buffer32[0xFB00];
|
||||
}; // 0x00
|
||||
|
||||
u32 size; // 0x3EC00
|
||||
u32 offset; // 0x3EC04
|
||||
u32 unk_0x3EC00;
|
||||
u32 unk_0x3EC04;
|
||||
BOOL allocated; // 0x3EC08
|
||||
u8 unk_0x3EC0C[0x34];
|
||||
} CDBCryptBuf;
|
||||
|
||||
@@ -19,7 +19,7 @@ typedef struct _CDBRecordFile {
|
||||
#else
|
||||
u8 unk_0x00[0x1C - 0x00];
|
||||
#endif
|
||||
int allocFlag; // 0x1C
|
||||
int unk_0x1C;
|
||||
CDBAttr attr; // 0x20
|
||||
CDBBridgeFile bridgeFile; // 0x42C
|
||||
u8 unk_0x434[0x438 - 0x434];
|
||||
|
||||
@@ -24,7 +24,7 @@ typedef struct NWC24MsgObjPrivate {
|
||||
#ifdef NWC24_MSG_READ
|
||||
u32 headerSize;
|
||||
#elif defined(NWC24_MBOX_CTRL) || defined(NWC24_MSG_COMMIT)
|
||||
u32 headerSize; // 0x10
|
||||
u32 unk_0x10;
|
||||
#else
|
||||
u8 unk_0x10[0x4];
|
||||
#endif
|
||||
@@ -46,8 +46,8 @@ typedef struct NWC24MsgObjPrivate {
|
||||
#endif
|
||||
u32 date; // 0x28
|
||||
u32 receivedDate; // 0x2C
|
||||
NWC24Data fromData; // 0x30
|
||||
NWC24Data toData; // 0x38
|
||||
NWC24Data unk_0x30;
|
||||
NWC24Data unk_0x38;
|
||||
NWC24Data subject; // 0x40
|
||||
NWC24Data text; // 0x48
|
||||
NWC24Data unk_0x50;
|
||||
|
||||
@@ -57,7 +57,7 @@ void CDBRecordInstanceInit(CDBRecordFile* recordFile, CDBRecord* record, int typ
|
||||
OSLockMutex((OSMutex*)recordFile);
|
||||
recordFile->used = 1;
|
||||
OSUnlockMutex((OSMutex*)recordFile);
|
||||
recordFile->allocFlag = type;
|
||||
recordFile->unk_0x1C = type;
|
||||
recordFile->database = record->unk_0x00;
|
||||
CDBAttrInit(&recordFile->attr);
|
||||
CDBRecordKeyCopy(&recordFile->key, &record->key);
|
||||
@@ -164,7 +164,7 @@ CDBErr CDBRecordOpen_(CDBRecord* record) {
|
||||
goto open_result_ready;
|
||||
open_location_ok:
|
||||
if (CDBFSSDIsMounted()) {
|
||||
err = CDBRecordDecrypt(record, cryptBuf, 0x3EC00, &cryptBuf->size, NULL);
|
||||
err = CDBRecordDecrypt(record, cryptBuf, 0x3EC00, &cryptBuf->unk_0x3EC00, NULL);
|
||||
} else {
|
||||
err = CDB_ERROR_SD_IS_NOT_MOUNTED;
|
||||
}
|
||||
@@ -174,7 +174,7 @@ CDBErr CDBRecordOpen_(CDBRecord* record) {
|
||||
CDBCryptBufFree((CDBCryptBuf**)&record->cryptBuf);
|
||||
return err;
|
||||
}
|
||||
cryptBuf->offset = sizeof(CDBAttrBuf);
|
||||
cryptBuf->unk_0x3EC04 = sizeof(CDBAttrBuf);
|
||||
}
|
||||
return CDB_ERROR_OK;
|
||||
}
|
||||
@@ -223,7 +223,7 @@ CDBErr CDBRecordOpenReadOnly_(CDBRecord* record) {
|
||||
goto result_ready;
|
||||
location_ok:
|
||||
if (CDBFSSDIsMounted()) {
|
||||
result = CDBRecordDecrypt(record, cryptBuf, 0x3EC00, &cryptBuf->size, NULL);
|
||||
result = CDBRecordDecrypt(record, cryptBuf, 0x3EC00, &cryptBuf->unk_0x3EC00, NULL);
|
||||
} else {
|
||||
result = CDB_ERROR_SD_IS_NOT_MOUNTED;
|
||||
}
|
||||
@@ -233,7 +233,7 @@ CDBErr CDBRecordOpenReadOnly_(CDBRecord* record) {
|
||||
CDBCryptBufFree((CDBCryptBuf**)&record->cryptBuf);
|
||||
return result;
|
||||
}
|
||||
cryptBuf->offset = sizeof(CDBAttrBuf);
|
||||
cryptBuf->unk_0x3EC04 = sizeof(CDBAttrBuf);
|
||||
}
|
||||
return CDB_ERROR_OK;
|
||||
}
|
||||
@@ -310,7 +310,7 @@ CDBErr CDBRecordWrite_(CDBRecord* record, void* buffer, u32 size) {
|
||||
CDBReportError("can't write data in the record; the record is closed\n");
|
||||
return CDB_ERROR_27;
|
||||
}
|
||||
if ((recordFile->allocFlag & 2) == 0) {
|
||||
if ((recordFile->unk_0x1C & 2) == 0) {
|
||||
CDBReportError("can't write data in the record; the record is opened as READONLY\n");
|
||||
return CDB_ERROR_27;
|
||||
}
|
||||
@@ -367,19 +367,6 @@ CDBErr CDBRecordSeek(CDBRecord* record, s32 offset, CDBSeek seek) {
|
||||
return err;
|
||||
}
|
||||
|
||||
CDBErr CDBRecordGetFileSize(CDBRecord* record, u32* size) {
|
||||
CDBErr err;
|
||||
CDBLock();
|
||||
if ((s32)record->file == 0) {
|
||||
CDBReportError("can't get file size of the record ; the record is closed\n");
|
||||
err = CDB_ERROR_27;
|
||||
} else {
|
||||
err = CDBRecordFileGetFileSize(record, size);
|
||||
}
|
||||
CDBUnlock();
|
||||
return err;
|
||||
}
|
||||
|
||||
CDBErr CDBRecordGetDataSize(CDBRecord* record, u32* size) {
|
||||
CDBErr err;
|
||||
CDBLock();
|
||||
@@ -669,10 +656,9 @@ CDBErr CDBCryptBuffer(void* buffer, u32 size, void* iv, u32* processedSize, BOOL
|
||||
CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32 size, u32* encryptedSize) {
|
||||
CDBRecordFile* recordFile;
|
||||
CDBErr err;
|
||||
u32 dataSize;
|
||||
u32 fileSize;
|
||||
u32 dataSize;
|
||||
u32 cryptSize;
|
||||
u32 authenticatedSize;
|
||||
int fileOffset;
|
||||
u8 iv[0x10];
|
||||
u8 wiiIdKey[0x40] ATTRIBUTE_ALIGN(64);
|
||||
@@ -687,7 +673,7 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
|
||||
if ((s32)recordFile == 0) {
|
||||
return CDB_ERROR_27;
|
||||
}
|
||||
if (recordFile->allocFlag == 1) {
|
||||
if (recordFile->unk_0x1C == 1) {
|
||||
return CDB_ERROR_26;
|
||||
}
|
||||
if ((s32)buffer == 0) {
|
||||
@@ -699,7 +685,7 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
|
||||
tempFile = record->file;
|
||||
if ((s32)tempFile == 0) {
|
||||
result = CDB_ERROR_27;
|
||||
} else if (tempFile->allocFlag == 1) {
|
||||
} else if (tempFile->unk_0x1C == 1) {
|
||||
result = CDB_ERROR_26;
|
||||
} else {
|
||||
CDBAttrSetWiiId(&tempFile->attr, CDBGetWiiId());
|
||||
@@ -713,7 +699,7 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
|
||||
CDBErr result;
|
||||
if ((s32)record->file == 0) {
|
||||
result = CDB_ERROR_27;
|
||||
} else if (((CDBRecordFile*)record->file)->allocFlag == 1) {
|
||||
} else if (((CDBRecordFile*)record->file)->unk_0x1C == 1) {
|
||||
result = CDB_ERROR_26;
|
||||
} else {
|
||||
CDBAttrInitIV(&((CDBRecordFile*)record->file)->attr);
|
||||
@@ -727,7 +713,7 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
|
||||
CDBErr result;
|
||||
if ((s32)record->file == 0) {
|
||||
result = CDB_ERROR_27;
|
||||
} else if (((CDBRecordFile*)record->file)->allocFlag == 1) {
|
||||
} else if (((CDBRecordFile*)record->file)->unk_0x1C == 1) {
|
||||
result = CDB_ERROR_26;
|
||||
} else {
|
||||
CDBAttrSetKeyStr(&((CDBRecordFile*)record->file)->attr, key);
|
||||
@@ -737,7 +723,14 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
|
||||
return CDB_ERROR_OK;
|
||||
}
|
||||
}
|
||||
err = CDBRecordGetFileSize(record, &fileSize);
|
||||
CDBLock();
|
||||
if ((s32)record->file == 0) {
|
||||
CDBReportError("can't get file size of the record ; the record is closed\n");
|
||||
err = CDB_ERROR_27;
|
||||
} else {
|
||||
err = CDBRecordFileGetFileSize(record, &fileSize);
|
||||
}
|
||||
CDBUnlock();
|
||||
CDBAttrSetFileSize(&recordFile->attr, fileSize);
|
||||
if (err != CDB_ERROR_OK) {
|
||||
return CDB_ERROR_OK;
|
||||
@@ -761,11 +754,10 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
|
||||
if ((s32)record->file == 0) {
|
||||
err = CDB_ERROR_27;
|
||||
} else {
|
||||
int position = CDBRecordFileTellData(record);
|
||||
if (position < 0) {
|
||||
fileOffset = CDBRecordFileTellData(record);
|
||||
if (fileOffset < 0) {
|
||||
err = CDB_ERROR_CANNOT_OPEN_FILE;
|
||||
} else {
|
||||
fileOffset = position;
|
||||
err = CDB_ERROR_OK;
|
||||
}
|
||||
}
|
||||
@@ -812,9 +804,8 @@ CDBErr CDBRecordEncrypt(CDBRecord* record, void* buffer, CDBRecordKey* key, u32
|
||||
CDBGetWiiIdKey((char*)wiiIdKey);
|
||||
CDBGetDeviceKey((char*)&wiiIdKey[12]);
|
||||
CDBAttrClearSignature((CDBAttr*)buffer);
|
||||
authenticatedSize = cryptSize + CDB_RECORD_BUFFER_SIZE;
|
||||
NETHMACInit(&hmac, NETGetSHA1Interface(), wiiIdKey, 0x40);
|
||||
NETHMACUpdate(&hmac, buffer, authenticatedSize);
|
||||
NETHMACUpdate(&hmac, buffer, cryptSize + CDB_RECORD_BUFFER_SIZE);
|
||||
NETHMACGetDigest(&hmac, digest);
|
||||
memcpy(((CDBAttrBuf*)buffer)->signature.sha1Hmac, digest, sizeof(digest));
|
||||
if (encryptedSize != 0) {
|
||||
|
||||
@@ -264,8 +264,8 @@ CDBErr CDBRecordFileReadData(CDBRecord* record, void* buffer, u32 size, u32* rea
|
||||
CDBCryptBuf* cryptBuf = record->cryptBuf;
|
||||
|
||||
if (cryptBuf != NULL) {
|
||||
u32 unk = cryptBuf->size - cryptBuf->offset;
|
||||
if (cryptBuf->size < unk) {
|
||||
u32 unk = cryptBuf->unk_0x3EC00 - cryptBuf->unk_0x3EC04;
|
||||
if (cryptBuf->unk_0x3EC00 < unk) {
|
||||
unk = 0;
|
||||
}
|
||||
|
||||
@@ -274,8 +274,8 @@ CDBErr CDBRecordFileReadData(CDBRecord* record, void* buffer, u32 size, u32* rea
|
||||
}
|
||||
|
||||
if (unk != 0) {
|
||||
memcpy(buffer, (u8*)&cryptBuf->buffer[cryptBuf->offset], unk);
|
||||
cryptBuf->offset += unk;
|
||||
memcpy(buffer, (u8*)&cryptBuf->buffer[cryptBuf->unk_0x3EC04], unk);
|
||||
cryptBuf->unk_0x3EC04 += unk;
|
||||
}
|
||||
|
||||
if (readSize != NULL) {
|
||||
@@ -300,16 +300,16 @@ CDBErr CDBRecordFileSeekData(CDBRecord* record, u32 offset, CDBSeek seek) {
|
||||
if (cryptBuf != NULL) {
|
||||
switch (seek) {
|
||||
case CDB_SEEK_BEGIN: {
|
||||
cryptBuf->offset = sizeof(CDBAttrBuf);
|
||||
cryptBuf->offset += offset;
|
||||
cryptBuf->unk_0x3EC04 = sizeof(CDBAttrBuf);
|
||||
cryptBuf->unk_0x3EC04 += offset;
|
||||
break;
|
||||
}
|
||||
case CDB_SEEK_END: {
|
||||
cryptBuf->offset = (cryptBuf->size - 1) - offset;
|
||||
cryptBuf->unk_0x3EC04 = (cryptBuf->unk_0x3EC00 - 1) - offset;
|
||||
break;
|
||||
}
|
||||
case CDB_SEEK_CUR: {
|
||||
cryptBuf->offset += offset;
|
||||
cryptBuf->unk_0x3EC04 += offset;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -329,7 +329,7 @@ int CDBRecordFileTellData(CDBRecord* record) {
|
||||
CDBCryptBuf* cryptBuf = record->cryptBuf;
|
||||
|
||||
if (cryptBuf != NULL) {
|
||||
return cryptBuf->offset - sizeof(CDBAttrBuf);
|
||||
return cryptBuf->unk_0x3EC04 - sizeof(CDBAttrBuf);
|
||||
}
|
||||
return CDBFTellData(&recordFile->bridgeFile, record->key.location);
|
||||
}
|
||||
|
||||
@@ -265,7 +265,7 @@ CDBErr CDBRecordFree(CDBRecord* record) {
|
||||
OSLockMutex((OSMutex*)recordFile);
|
||||
*(u32*)&recordFile->unk_0x00[0x18] = 0;
|
||||
OSUnlockMutex((OSMutex*)recordFile);
|
||||
recordFile->allocFlag = 0;
|
||||
recordFile->unk_0x1C = 0;
|
||||
record->file = NULL;
|
||||
OSUnlockMutex(&s_mutex);
|
||||
}
|
||||
|
||||
@@ -19,23 +19,15 @@ typedef struct HMACContext {
|
||||
u8 key[64];
|
||||
} HMACContext;
|
||||
|
||||
static inline void BeginDigest(HMACContext* context, u8 mask) {
|
||||
u8 blockKey[64];
|
||||
void NETHMACInit(HMACContext* context, const DigestInterface* interface, const void* key, u32 length) {
|
||||
u8 innerKey[64];
|
||||
u32 i;
|
||||
u32 keyLength;
|
||||
void* work = context->digestContext;
|
||||
keyLength = context->keyLength;
|
||||
for (i = 0; i < keyLength; ++i) blockKey[i] = context->key[i] ^ mask;
|
||||
memset(blockKey + keyLength, mask, context->interface.blockSize - keyLength);
|
||||
context->interface.init(work);
|
||||
context->interface.update(work, blockKey, context->interface.blockSize);
|
||||
}
|
||||
|
||||
void NETHMACInit(HMACContext* context, const DigestInterface* interface, const void* key, u32 length) {
|
||||
void* work = context->digestContext;
|
||||
const char* function = "NETHMACInit";
|
||||
context->interface = *interface;
|
||||
if (context->interface.contextSize > 96 || context->interface.blockSize > 64) {
|
||||
OSReport("%s(%d):[warning in %s]", "hmac.c", 100, __FUNCTION__);
|
||||
OSReport("%s(%d):[warning in %s]", "hmac.c", 100, function);
|
||||
OSReport("specified interface needs too large workmemory.");
|
||||
OSReport("\n");
|
||||
return;
|
||||
@@ -49,7 +41,11 @@ void NETHMACInit(HMACContext* context, const DigestInterface* interface, const v
|
||||
context->interface.getDigest(work, context->key);
|
||||
context->keyLength = context->interface.digestSize;
|
||||
}
|
||||
BeginDigest(context, 0x36);
|
||||
keyLength = context->keyLength;
|
||||
for (i=0; i<keyLength; ++i) innerKey[i] = context->key[i] ^ 0x36;
|
||||
memset(innerKey + keyLength, 0x36, context->interface.blockSize - keyLength);
|
||||
context->interface.init(context->digestContext);
|
||||
context->interface.update(context->digestContext, innerKey, context->interface.blockSize);
|
||||
}
|
||||
|
||||
void NETHMACUpdate(HMACContext* context, const void* data, u32 length) {
|
||||
@@ -58,9 +54,16 @@ void NETHMACUpdate(HMACContext* context, const void* data, u32 length) {
|
||||
|
||||
void NETHMACGetDigest(HMACContext* context, void* digest) {
|
||||
u8 innerDigest[64];
|
||||
u8 outerKey[64];
|
||||
u32 i;
|
||||
u32 keyLength;
|
||||
void* work = context->digestContext;
|
||||
context->interface.getDigest(work, innerDigest);
|
||||
BeginDigest(context, 0x5c);
|
||||
keyLength = context->keyLength;
|
||||
for (i=0; i<keyLength; ++i) outerKey[i] = context->key[i] ^ 0x5c;
|
||||
memset(outerKey + keyLength, 0x5c, context->interface.blockSize - keyLength);
|
||||
context->interface.init(context->digestContext);
|
||||
context->interface.update(context->digestContext, outerKey, context->interface.blockSize);
|
||||
context->interface.update(work, innerDigest, context->interface.digestSize);
|
||||
context->interface.getDigest(work, digest);
|
||||
}
|
||||
|
||||
@@ -23,7 +23,8 @@ static int ReadHeaderChar(const NHTTPResponseInfo* response, NHTTPi_HDRBUFLIST**
|
||||
}
|
||||
|
||||
static int LowerCase(int character) {
|
||||
return ((character >= 'A') & (character <= 'Z')) ? character + 32 : character;
|
||||
if((character>='A') & (character<='Z')) character+=32;
|
||||
return character;
|
||||
}
|
||||
|
||||
s32 NHTTPi_findNextLineHdrRecvBuf(const NHTTPResponseInfo* response, s32 position, s32 limit, s32* colon, s32* newlineLength) {
|
||||
@@ -75,17 +76,15 @@ s32 NHTTPi_skipSpaceHdrRecvBuf(const NHTTPResponseInfo* response, s32 position,
|
||||
s32 NHTTPi_compareTokenN_HdrRecvBuf(const NHTTPResponseInfo* response, s32 position, s32 limit, const char* token, s8 delimiter) {
|
||||
NHTTPi_HDRBUFLIST* block;
|
||||
s32 offset;
|
||||
int character;
|
||||
|
||||
if (position < limit) {
|
||||
FindHeaderBlock(response, position, &block, &offset);
|
||||
character = ReadHeaderChar(response, &block, &offset);
|
||||
while (LowerCase((s8)character) == LowerCase(*token)) {
|
||||
if (*token == 0 || *token == ' ' || *token == delimiter || position == limit - 1) return 0;
|
||||
character = ReadHeaderChar(response, &block, &offset);
|
||||
++position;
|
||||
++token;
|
||||
}
|
||||
s8 character;
|
||||
if(position>=limit) return -1;
|
||||
FindHeaderBlock(response,position,&block,&offset);
|
||||
character=ReadHeaderChar(response,&block,&offset);
|
||||
while(LowerCase(character)==LowerCase(*token)) {
|
||||
if(*token==0 || *token==' ' || *token==delimiter || position==limit-1) return 0;
|
||||
character=ReadHeaderChar(response,&block,&offset);
|
||||
++position;
|
||||
++token;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -95,7 +95,7 @@ s32 NHTTPi_SocRecv_sub(NHTTPConnectionInfo* connection, s32 socket, void* data,
|
||||
} else return result;
|
||||
}
|
||||
if(connection->recvBufDataLen!=0) {
|
||||
length = (u32)length > connection->recvBufDataLen ? connection->recvBufDataLen : length;
|
||||
if((u32)length>connection->recvBufDataLen) length=connection->recvBufDataLen;
|
||||
NHTTPi_memcpy(data,buffer+connection->recvBufOffset,length);
|
||||
connection->recvBufDataLen-=length;
|
||||
if(connection->recvBufDataLen==0) {
|
||||
@@ -135,14 +135,10 @@ s32 NHTTPi_SocSend_sub(s32 socket, const char* data, u32 length, s32 flags) {
|
||||
if(head>length) head=length;
|
||||
NHTTPi_memcpy(buffer,data,head);
|
||||
result=SOSend(socket,buffer,head,flags);
|
||||
if (result > 0) {
|
||||
sent = result;
|
||||
if ((u32)result < head) return result;
|
||||
data += result;
|
||||
length -= result;
|
||||
} else {
|
||||
return result;
|
||||
}
|
||||
if(result<=0) return result;
|
||||
sent=result;
|
||||
if((u32)result<head) return result;
|
||||
data+=result; length-=result;
|
||||
}
|
||||
if((s32)length>0) {
|
||||
head=length&~31;
|
||||
@@ -168,7 +164,7 @@ s32 NHTTPi_SocSend_sub(s32 socket, const char* data, u32 length, s32 flags) {
|
||||
return sent;
|
||||
}
|
||||
|
||||
s32 NHTTPi_SocSend(const NHTTPRequestInfo* request, s32 socket, const void* data, s32 length, s32 flags) {
|
||||
s32 NHTTPi_SocSend(NHTTPRequestInfo* request, s32 socket, const char* data, s32 length, s32 flags) {
|
||||
s32 result;
|
||||
SSLId ssl=request->sslId;
|
||||
if(ssl>0) result=SSLWrite(ssl,data,length);
|
||||
|
||||
@@ -102,25 +102,23 @@ s32 NHTTPi_strToInt(const char* string, s32 length) {
|
||||
return value;
|
||||
}
|
||||
|
||||
static inline u32 TakeDecimalDigit(u32* remaining, u32 scale) {
|
||||
u32 digit = *remaining / scale;
|
||||
*remaining -= digit * scale;
|
||||
return digit;
|
||||
}
|
||||
|
||||
s32 NHTTPi_intToStr(char* destination, u32 value) {
|
||||
u32 scales[9]={1000000000,100000000,10000000,1000000,100000,10000,1000,100,10};
|
||||
char* output;
|
||||
int digit;
|
||||
BOOL started;
|
||||
s32 length;
|
||||
output = destination;
|
||||
length = 0;
|
||||
started = FALSE;
|
||||
for(digit=0; digit<9; ++digit) {
|
||||
if(value>=scales[digit]) {
|
||||
u32 quotient=TakeDecimalDigit(&value, scales[digit]);
|
||||
u32 quotient=value/scales[digit];
|
||||
started=TRUE;
|
||||
destination[length++]=quotient+'0';
|
||||
} else if(started) { destination[length++]='0'; }
|
||||
++length;
|
||||
*output++=quotient+'0';
|
||||
value-=quotient*scales[digit];
|
||||
} else if(started) { *output++='0'; ++length; }
|
||||
}
|
||||
destination[length]=value+'0';
|
||||
return length+1;
|
||||
|
||||
@@ -82,7 +82,7 @@ s32 NHTTPi_ReceivedCallback(void* mutex, NHTTPConnectionInfo* connection);
|
||||
void NHTTPi_NotifyCompletion(NHTTPConnectionInfo* connection);
|
||||
void NHTTPi_SetVirtualContentLength(NHTTPConnectionInfo* connection, u32 length);
|
||||
BOOL NHTTPi_isRecvBufFull(NHTTPResponseInfo* response, s32 offset);
|
||||
s32 NHTTPi_SocSend(const NHTTPRequestInfo* request, s32 socket, const void* buffer, s32 length, s32 flags);
|
||||
s32 NHTTPi_SocSend(NHTTPRequestInfo* request, s32 socket, const void* buffer, s32 length, s32 flags);
|
||||
s32 NHTTPi_SocRecv(void* mutex, NHTTPRequestInfo* request, s32 socket, void* buffer, s32 length, s32 flags);
|
||||
s32 NHTTPi_SocClose(void* mutex, NHTTPRequestInfo* request, s32 socket);
|
||||
s32 NHTTPi_SocOpen(NHTTPRequestInfo* request);
|
||||
@@ -986,16 +986,9 @@ static BOOL NHTTPi_ThreadParseHeaderProc(NHTTPThreadContext* context)
|
||||
if (length > 0x100) context->keepAlive = FALSE;
|
||||
else if (length > 0)
|
||||
{
|
||||
struct TokenMatch {
|
||||
BOOL matched;
|
||||
};
|
||||
struct TokenMatch match = {FALSE};
|
||||
if (NHTTPi_compareTokenN_HdrRecvBuf(response, offset, offset + length, "Keep-Alive", 0) == 0)
|
||||
{
|
||||
match.matched = TRUE;
|
||||
context->keepAlive = match.matched;
|
||||
}
|
||||
else context->keepAlive = match.matched;
|
||||
context->keepAlive = TRUE;
|
||||
else context->keepAlive = FALSE;
|
||||
}
|
||||
else context->keepAlive = FALSE;
|
||||
}
|
||||
|
||||
@@ -120,11 +120,10 @@ NWC24Err NWC24iMinutesToOSCalendarTime(OSCalendarTime* calendar, s32 minutes) {
|
||||
NWC24Err NWC24iDateToOSCalendarTime(OSCalendarTime* calendar, const NWC24Date* date) {
|
||||
BOOL isLeapYear;
|
||||
s32 days;
|
||||
const u16 year = date->year;
|
||||
|
||||
isLeapYear = 0;
|
||||
|
||||
calendar->year = year;
|
||||
calendar->year = date->year;
|
||||
calendar->mon = date->month - 1;
|
||||
calendar->mday = date->day;
|
||||
calendar->hour = date->hour;
|
||||
@@ -133,7 +132,7 @@ NWC24Err NWC24iDateToOSCalendarTime(OSCalendarTime* calendar, const NWC24Date* d
|
||||
calendar->msec = 0;
|
||||
calendar->usec = 0;
|
||||
calendar->yday = date->day + DAYS_OF_YEAR[date->month - 1] - 1;
|
||||
if (((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) {
|
||||
if (((date->year % 4 == 0 && date->year % 100 != 0) || date->year % 400 == 0)) {
|
||||
isLeapYear = 1;
|
||||
}
|
||||
if (isLeapYear && date->month > 2) {
|
||||
@@ -206,43 +205,27 @@ void ConvertDaysToDate(u16* year, u8* month, u8* day, s32 days) {
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
u16 currentYear = *year;
|
||||
s32 previousDays = days;
|
||||
BOOL leapYear = TRUE;
|
||||
BOOL commonLeapYear = FALSE;
|
||||
if (currentYear % 4 == 0 && currentYear % 100 != 0) {
|
||||
commonLeapYear = TRUE;
|
||||
}
|
||||
if (!commonLeapYear && currentYear % 400 != 0) {
|
||||
leapYear = FALSE;
|
||||
}
|
||||
BOOL leapYear = (*year % 4 == 0 && *year % 100 != 0) || *year % 400 == 0;
|
||||
days -= 365 + (leapYear != FALSE);
|
||||
if (days < 0) {
|
||||
days = previousDays;
|
||||
break;
|
||||
}
|
||||
*year += 1;
|
||||
continue;
|
||||
*year = *year + 1;
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
s32 previousDays;
|
||||
u8 currentMonth;
|
||||
const u8* parsedMonth = month;
|
||||
previousDays = days;
|
||||
currentMonth = *parsedMonth;
|
||||
if (currentMonth == 2 && IsLeapYear(*year)) {
|
||||
s32 previousDays = days;
|
||||
if (*month == 2 && IsLeapYear(*year)) {
|
||||
days -= 29;
|
||||
} else {
|
||||
days -= DAYS_OF_MONTH[currentMonth - 1];
|
||||
days -= DAYS_OF_MONTH[*month - 1];
|
||||
}
|
||||
if (days >= 0) {
|
||||
*month += 1;
|
||||
} else {
|
||||
days = previousDays;
|
||||
if (days < 0) {
|
||||
*day += previousDays;
|
||||
break;
|
||||
}
|
||||
*month += 1;
|
||||
}
|
||||
|
||||
*day += days;
|
||||
}
|
||||
|
||||
@@ -1043,6 +1043,7 @@ closeList:
|
||||
|
||||
NWC24Err NWC24iCheckDlHeaderConsistency(DlTaskListHeader* header, BOOL repair) {
|
||||
NWC24DlTask task;
|
||||
DlTaskData* taskData = (DlTaskData*)&task;
|
||||
NWC24DlTask* taskPointer = &task;
|
||||
NWC24DlId taskId;
|
||||
NWC24Err result;
|
||||
@@ -1064,14 +1065,14 @@ NWC24Err NWC24iCheckDlHeaderConsistency(DlTaskListHeader* header, BOOL repair) {
|
||||
if (result < NWC24_OK) {
|
||||
if (ValidateDlTask(taskPointer, FALSE) == NWC24_OK) {
|
||||
result = DeleteDlTask(taskPointer);
|
||||
if (result >= NWC24_OK) { ((DlTaskData*)taskPointer)->id = 0xffff; }
|
||||
if (result >= NWC24_OK) { taskData->id = 0xffff; }
|
||||
}
|
||||
} else {
|
||||
currentHeader = GetCachedDlHeader();
|
||||
if (taskId >= currentHeader->taskCount && (s16)((DlTaskData*)taskPointer)->subTaskCount == 0) {
|
||||
if (taskId >= currentHeader->taskCount && (s16)taskData->subTaskCount == 0) {
|
||||
if (ValidateDlTask(taskPointer, FALSE) == NWC24_OK) {
|
||||
result = DeleteDlTask(taskPointer);
|
||||
if (result >= NWC24_OK) { ((DlTaskData*)taskPointer)->id = 0xffff; }
|
||||
if (result >= NWC24_OK) { taskData->id = 0xffff; }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -64,7 +64,7 @@ static NWC24Err ClearMBCEntry(MBCHeader* header, NWC24File* file, u32 offset);
|
||||
static NWC24Err MountVFMBox(NWC24MBoxType type);
|
||||
static NWC24Err CopyMsgObjToMBCFmt(const NWC24MsgObjPrivate* msg, MBCEntry* entry);
|
||||
static NWC24Err CopyMsgObjToPrvFmt(const MBCEntry* entry, NWC24MsgObjPrivate* msg) NO_INLINE;
|
||||
BOOL NWC24iIsMsgObjReadable(MBCEntry* entry) NO_INLINE;
|
||||
BOOL NWC24iIsMsgObjReadable(const MBCEntry* entry) NO_INLINE;
|
||||
NWC24Err NWC24CreateVF(const char* path, u32 size);
|
||||
|
||||
static inline NWC24Err MakeCtrlPath(char* path, NWC24MBoxType type) {
|
||||
@@ -221,7 +221,7 @@ NWC24Err NWC24GetMsgObj(NWC24MsgObj* msg, NWC24MBoxType type, u32 id) {
|
||||
return result;
|
||||
}
|
||||
|
||||
BOOL NWC24iIsMsgObjReadable(MBCEntry* entry) {
|
||||
BOOL NWC24iIsMsgObjReadable(const MBCEntry* entry) {
|
||||
if (!(entry->type & 0x200000))
|
||||
return FALSE;
|
||||
if (entry->type & 0xFE000000)
|
||||
@@ -555,14 +555,14 @@ NWC24Err NWC24iMBoxFlushHeader(NWC24MBoxType type) {
|
||||
return result != NWC24_OK ? result : closeResult;
|
||||
}
|
||||
|
||||
static inline void GetOldestMsgId(const MBCHeader* header, volatile u32* id) {
|
||||
*id = header->oldestId;
|
||||
static inline void GetOldestMsgId(const MBCHeader* header, u32* msgId) {
|
||||
*msgId = header->oldestId;
|
||||
}
|
||||
|
||||
NWC24Err NWC24iMBoxCheck(NWC24MBoxType type, u32 size) {
|
||||
u32 required;
|
||||
struct {
|
||||
volatile u32 oldestId;
|
||||
u32 oldestId;
|
||||
MBCHeader* header;
|
||||
} mailbox;
|
||||
NWC24Err err;
|
||||
@@ -783,7 +783,7 @@ static NWC24Err DuplicationCheck(MBCHeader* header, const NWC24MsgObjPrivate* ms
|
||||
continue;
|
||||
}
|
||||
if (msg->unk_0x1C != 0 && entry->crc == msg->unk_0x1C && entry->type == msg->type && entry->length == msg->length &&
|
||||
entry->flags == msg->headerSize && (s32)entry->date == (s32)msg->date) {
|
||||
entry->flags == msg->unk_0x10 && (s32)entry->date == (s32)msg->date) {
|
||||
duplicateId = entry->msgId;
|
||||
duplicateOffset = offset;
|
||||
continue;
|
||||
@@ -947,8 +947,8 @@ static NWC24Err MountVFMBox(NWC24MBoxType type) {
|
||||
}
|
||||
|
||||
static NWC24Err CopyMsgObjToMBCFmt(const NWC24MsgObjPrivate* msg, MBCEntry* entry) {
|
||||
u32 field1 = ((u32)msg->fromData.ptr & 0xFFFFF) | (msg->fromData.size << 20);
|
||||
u32 field2 = ((u32)msg->toData.ptr & 0xFFFFF) | (msg->toData.size << 20);
|
||||
u32 field1 = ((u32)msg->unk_0x30.ptr & 0xFFFFF) | (msg->unk_0x30.size << 20);
|
||||
u32 field2 = ((u32)msg->unk_0x38.ptr & 0xFFFFF) | (msg->unk_0x38.size << 20);
|
||||
u32 field3 = ((u32)msg->subject.ptr & 0xFFFFF) | (msg->subject.size << 20);
|
||||
u32 field4 = ((u32)msg->unk_0x50.ptr & 0xFFFFF) | (msg->unk_0x50.size << 20);
|
||||
u32 field5 = ((u32)msg->unk_0x58.ptr & 0xFFFFF) | (msg->unk_0x58.size << 20);
|
||||
@@ -956,7 +956,7 @@ static NWC24Err CopyMsgObjToMBCFmt(const NWC24MsgObjPrivate* msg, MBCEntry* entr
|
||||
entry->type = msg->type;
|
||||
entry->length = msg->length;
|
||||
entry->appId = msg->appId;
|
||||
entry->flags = msg->headerSize;
|
||||
entry->flags = msg->unk_0x10;
|
||||
entry->tag = msg->tag;
|
||||
entry->ledPattern = msg->ledPattern;
|
||||
entry->crc = msg->unk_0x1C;
|
||||
@@ -1003,7 +1003,7 @@ static NWC24Err CopyMsgObjToPrvFmt(const MBCEntry* entry, NWC24MsgObjPrivate* ms
|
||||
msg->type = entry->type;
|
||||
msg->length = entry->length;
|
||||
msg->appId = entry->appId;
|
||||
msg->headerSize = entry->flags;
|
||||
msg->unk_0x10 = entry->flags;
|
||||
msg->tag = entry->tag;
|
||||
msg->ledPattern = entry->ledPattern;
|
||||
msg->unk_0x1C = entry->crc;
|
||||
@@ -1019,10 +1019,10 @@ static NWC24Err CopyMsgObjToPrvFmt(const MBCEntry* entry, NWC24MsgObjPrivate* ms
|
||||
msg->textSize = entry->textSize;
|
||||
msg->dwcId = entry->dwcId;
|
||||
msg->iconNew = entry->iconNew;
|
||||
msg->fromData.ptr = (void*)offset1;
|
||||
msg->fromData.size = size1;
|
||||
msg->toData.ptr = (void*)offset2;
|
||||
msg->toData.size = size2;
|
||||
msg->unk_0x30.ptr = (void*)offset1;
|
||||
msg->unk_0x30.size = size1;
|
||||
msg->unk_0x38.ptr = (void*)offset2;
|
||||
msg->unk_0x38.size = size2;
|
||||
msg->subject.ptr = (void*)offset3;
|
||||
msg->subject.size = size3;
|
||||
msg->unk_0x50.ptr = (void*)offset4;
|
||||
|
||||
@@ -232,11 +232,16 @@ static NWC24Err QEncode(char* encoded, u32 encodedCapacity, u32* encodedSize, u8
|
||||
|
||||
static NWC24Err QDecode(char* decoded, u32 decodedCapacity, u32* decodedSize, char* encoded, u32 encodedSize, u32* encodedSizeOut, int flags) {
|
||||
u32 encodedOffset;
|
||||
u32 decodedOffset = 0;
|
||||
u8 value = 0;
|
||||
u32 decodedOffset;
|
||||
u8 value;
|
||||
char* input;
|
||||
char* output;
|
||||
NWC24Err result = NWC24_OK;
|
||||
NWC24Err result;
|
||||
int valid;
|
||||
|
||||
decodedOffset = 0;
|
||||
value = 0;
|
||||
result = NWC24_OK;
|
||||
|
||||
if (decoded == NULL)
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
@@ -264,23 +269,23 @@ static NWC24Err QDecode(char* decoded, u32 decodedCapacity, u32* decodedSize, ch
|
||||
input++;
|
||||
decodedOffset++;
|
||||
} else if (*input == '=' && encodedOffset + 2 < encodedSize) {
|
||||
BOOL validHex = TRUE;
|
||||
input++;
|
||||
encodedOffset++;
|
||||
valid = 1;
|
||||
if (*input == ' ' || *input == '\t') {
|
||||
char* next = input + 1;
|
||||
u32 scan = 1;
|
||||
while (encodedOffset + scan + 1 < encodedSize) {
|
||||
if (*next == '\r' && next[1] == '\n') {
|
||||
encodedOffset += scan;
|
||||
input = next;
|
||||
char* scan = input + 1;
|
||||
u32 scanLen = 1;
|
||||
while (encodedOffset + scanLen + 1 < encodedSize) {
|
||||
if (*scan == '\r' && scan[1] == '\n') {
|
||||
input = scan;
|
||||
encodedOffset += scanLen;
|
||||
break;
|
||||
}
|
||||
if (*next != ' ' && *next != '\t') {
|
||||
if (*scan != ' ' && *scan != '\t') {
|
||||
break;
|
||||
}
|
||||
next++;
|
||||
scan++;
|
||||
scanLen++;
|
||||
}
|
||||
}
|
||||
if (*input == '\r' && input[1] == '\n') {
|
||||
@@ -291,15 +296,17 @@ static NWC24Err QDecode(char* decoded, u32 decodedCapacity, u32* decodedSize, ch
|
||||
int low;
|
||||
if (high >= 0) {
|
||||
value = (high & 0x0F) << 4;
|
||||
} else {
|
||||
valid = 0;
|
||||
}
|
||||
if (high < 0) { validHex = FALSE; }
|
||||
low = Util_xtoi(input[1]);
|
||||
if (low >= 0) {
|
||||
value |= low & 0x0F;
|
||||
value = (value | (low & 0x0F)) & 0xFF;
|
||||
} else {
|
||||
valid = 0;
|
||||
}
|
||||
if (low < 0) { validHex = FALSE; }
|
||||
input += 2;
|
||||
if (validHex) {
|
||||
if (valid) {
|
||||
*output++ = (char)value;
|
||||
decodedOffset++;
|
||||
}
|
||||
@@ -329,90 +336,96 @@ NWC24Err NWC24DecodeQuotedPrintable(char* decoded, u32 decodedCapacity, u32* dec
|
||||
|
||||
static NWC24Err ConcatEncodedText(char* encoded, u32 encodedCapacity, u32* encodedSize, char encoding, u8* decoded, u32 decodedSize,
|
||||
u32* decodedSizeOut);
|
||||
static inline NWC24Err AppendWordPrefix(char* encoded, u32 capacity) {
|
||||
if (Mail_strlen(encoded) + 2 < capacity) {
|
||||
Mail_strncat(encoded, "=?", 2);
|
||||
} else { return NWC24_ERR_OVERFLOW; }
|
||||
return NWC24_OK;
|
||||
}
|
||||
|
||||
static inline NWC24Err AppendWordSeparator(char* encoded, u32 capacity) {
|
||||
if (Mail_strlen(encoded) + 2 < capacity) {
|
||||
Mail_strncat(encoded, "?", 1);
|
||||
} else { return NWC24_ERR_OVERFLOW; }
|
||||
return NWC24_OK;
|
||||
}
|
||||
|
||||
static inline NWC24Err AppendWordSuffix(char* encoded, u32 capacity) {
|
||||
if (Mail_strlen(encoded) + 2 < capacity) {
|
||||
Mail_strncat(encoded, "?=", 2);
|
||||
} else { return NWC24_ERR_OVERFLOW; }
|
||||
return NWC24_OK;
|
||||
}
|
||||
|
||||
static inline NWC24Err AppendWordCharset(char* encoded, u32 capacity, char* charset, u32 charsetSize) {
|
||||
if (charset == NULL) { return NWC24_ERR_INVALID_VALUE; }
|
||||
if (charsetSize + Mail_strlen(encoded) < capacity) {
|
||||
u32 length = Mail_strlen(charset);
|
||||
Mail_strncat(encoded, charset, length);
|
||||
} else { return NWC24_ERR_OVERFLOW; }
|
||||
return NWC24_OK;
|
||||
}
|
||||
|
||||
static inline NWC24Err AppendWordEncoding(char* encoded, u32 capacity, char encoding) {
|
||||
char encodingText[1];
|
||||
encodingText[0] = encoding;
|
||||
if (encoding != 'B' && encoding != 'b' && encoding != 'Q' && encoding != 'q') {
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
static inline NWC24Err AppendBounded(char* encoded, u32 encodedCapacity, u32 needed, const char* str, u32 strLen) {
|
||||
NWC24Err result;
|
||||
if (Mail_strlen(encoded) + needed < encodedCapacity) {
|
||||
Mail_strncat(encoded, str, strLen);
|
||||
result = NWC24_OK;
|
||||
} else {
|
||||
result = NWC24_ERR_OVERFLOW;
|
||||
}
|
||||
if (Mail_strlen(encoded) + 1 < capacity) {
|
||||
Mail_strncat(encoded, encodingText, 1);
|
||||
} else { return NWC24_ERR_OVERFLOW; }
|
||||
return NWC24_OK;
|
||||
return result;
|
||||
}
|
||||
|
||||
static NWC24Err EncodeWord(char* encoded, u32 encodedCapacity, u32* encodedSize, char* charset, u32 charsetSize, char encoding, u8* decoded,
|
||||
u32 decodedSize, u32* decodedSizeOut) {
|
||||
NWC24Err result;
|
||||
BOOL encodeOverflow = FALSE;
|
||||
|
||||
if (decodedSizeOut != NULL) { *decodedSizeOut = 0; }
|
||||
if (decodedSizeOut != NULL) {
|
||||
*decodedSizeOut = 0;
|
||||
}
|
||||
if (encodedCapacity == 0) {
|
||||
if (decodedSizeOut != NULL) { *decodedSizeOut = 0; }
|
||||
if (decodedSizeOut != NULL) {
|
||||
*decodedSizeOut = 0;
|
||||
}
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
}
|
||||
*encoded = '\0';
|
||||
if (encodedSize != NULL) { *encodedSize = 1; }
|
||||
|
||||
result = AppendWordPrefix(encoded, encodedCapacity);
|
||||
if (result != NWC24_OK) { *encoded = '\0'; return result; }
|
||||
|
||||
result = AppendWordCharset(encoded, encodedCapacity, charset, charsetSize);
|
||||
if (result != NWC24_OK) { *encoded = '\0'; return result; }
|
||||
|
||||
result = AppendWordSeparator(encoded, encodedCapacity);
|
||||
if (result != NWC24_OK) { *encoded = '\0'; return result; }
|
||||
|
||||
result = AppendWordEncoding(encoded, encodedCapacity, encoding);
|
||||
if (result != NWC24_OK) { *encoded = '\0'; return result; }
|
||||
|
||||
result = AppendWordSeparator(encoded, encodedCapacity);
|
||||
if (result != NWC24_OK) { *encoded = '\0'; return result; }
|
||||
|
||||
if (encodedSize != NULL) {
|
||||
*encodedSize = 1;
|
||||
}
|
||||
result = AppendBounded(encoded, encodedCapacity, 2, "=?", 2);
|
||||
if (result != NWC24_OK) {
|
||||
*encoded = '\0';
|
||||
goto done;
|
||||
}
|
||||
if (charset != NULL) {
|
||||
result = AppendBounded(encoded, encodedCapacity, charsetSize, charset, Mail_strlen(charset));
|
||||
} else {
|
||||
result = NWC24_ERR_INVALID_VALUE;
|
||||
}
|
||||
if (result != NWC24_OK) {
|
||||
*encoded = '\0';
|
||||
goto done;
|
||||
}
|
||||
result = AppendBounded(encoded, encodedCapacity, 2, "?", 1);
|
||||
if (result != NWC24_OK) {
|
||||
*encoded = '\0';
|
||||
goto done;
|
||||
}
|
||||
{
|
||||
char value[1];
|
||||
value[0] = encoding;
|
||||
if (encoding == 'B' || encoding == 'b' || encoding == 'Q' || encoding == 'q') {
|
||||
result = AppendBounded(encoded, encodedCapacity, 1, value, 1);
|
||||
} else {
|
||||
result = NWC24_ERR_INVALID_VALUE;
|
||||
}
|
||||
if (result != NWC24_OK) {
|
||||
*encoded = '\0';
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
result = AppendBounded(encoded, encodedCapacity, 2, "?", 1);
|
||||
if (result != NWC24_OK) {
|
||||
*encoded = '\0';
|
||||
goto done;
|
||||
}
|
||||
result = ConcatEncodedText(encoded, encodedCapacity, encodedSize, encoding, decoded, decodedSize, decodedSizeOut);
|
||||
if (result != NWC24_OK && result != NWC24_ERR_OVERFLOW) {
|
||||
*encoded = '\0';
|
||||
*decodedSizeOut = 1;
|
||||
return result;
|
||||
goto done;
|
||||
}
|
||||
if (result == NWC24_ERR_OVERFLOW) { encodeOverflow = TRUE; }
|
||||
result = AppendWordSuffix(encoded, encodedCapacity);
|
||||
if (result == NWC24_ERR_OVERFLOW) {
|
||||
encodeOverflow = TRUE;
|
||||
}
|
||||
result = AppendBounded(encoded, encodedCapacity, 2, "?=", 2);
|
||||
if (result != NWC24_OK) {
|
||||
*encoded = '\0';
|
||||
*decodedSizeOut = 1;
|
||||
return result;
|
||||
goto done;
|
||||
}
|
||||
*encodedSize = Mail_strlen(encoded) + 1;
|
||||
if (result == NWC24_OK && encodeOverflow) { result = NWC24_ERR_OVERFLOW; }
|
||||
if (result == NWC24_OK) {
|
||||
if (encodeOverflow) {
|
||||
result = NWC24_ERR_OVERFLOW;
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -445,15 +458,14 @@ NWC24Err NWC24EncodeWord(u8* encoded, u32 encodedCapacity, u32* encodedSize, cha
|
||||
return result;
|
||||
}
|
||||
|
||||
static NWC24Err ExtractCharset(char* charset, u32 charsetCapacity, u32* charsetSize, char* encoded, u32 encodedSize);
|
||||
static NWC24Err ExtractCharset(char* charset, u32 charsetCapacity, u32* charsetSize, char* encoded, u32 encodedSize) NO_INLINE;
|
||||
static NWC24Err ExtractEncodedText(char* decoded, u32 decodedCapacity, u32* decodedSize, char encoding, char* encoded, u32 encodedSize,
|
||||
u32* encodedSizeOut);
|
||||
|
||||
static BOOL CopyWithoutLinearWhiteSpaces(char* output, int* outputSize, char* input, int inputSize) {
|
||||
BOOL afterNewline = FALSE;
|
||||
u32 outputOffset = 0;
|
||||
BOOL afterNewline = FALSE;
|
||||
s32 capacity;
|
||||
u32 limit;
|
||||
|
||||
if (output == NULL || outputSize == NULL || *outputSize == 0) {
|
||||
return FALSE;
|
||||
@@ -464,8 +476,7 @@ static BOOL CopyWithoutLinearWhiteSpaces(char* output, int* outputSize, char* in
|
||||
*outputSize = 1;
|
||||
return TRUE;
|
||||
}
|
||||
limit = capacity - 1U;
|
||||
while (outputOffset < limit && inputSize != 0 && *input != '\0') {
|
||||
while (outputOffset < capacity - 1U && inputSize != 0 && *input != '\0') {
|
||||
char value = *input;
|
||||
switch (value) {
|
||||
case '\r':
|
||||
@@ -499,130 +510,120 @@ static BOOL CopyWithoutLinearWhiteSpaces(char* output, int* outputSize, char* in
|
||||
}
|
||||
|
||||
static inline char* FindMarker(char* input, u32 size, const char* marker) {
|
||||
u32 offset;
|
||||
u32 markerLength;
|
||||
markerLength = Mail_strlen(marker);
|
||||
s32 offset;
|
||||
u32 markerLength = Mail_strlen(marker);
|
||||
for (offset = 0; offset <= size; offset++) {
|
||||
char* current = input + offset;
|
||||
if (Mail_strncmp(current, marker, markerLength) == 0)
|
||||
char* pos = input + offset;
|
||||
if (Mail_strncmp(pos, marker, markerLength) == 0)
|
||||
return input + offset;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
static inline char* FindMarkerAfterPrefix(char* input, u32 size, u32 prefix, const char* marker) {
|
||||
char* current;
|
||||
u32 offset;
|
||||
u32 markerLength;
|
||||
markerLength = Mail_strlen(marker);
|
||||
current = input + prefix;
|
||||
for (offset = 0; offset <= size; offset++) {
|
||||
if (Mail_strncmp(current, marker, markerLength) == 0) {
|
||||
return input + prefix + offset;
|
||||
}
|
||||
current++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline char* FindEncodingMarker(char* encoded, u32 size) {
|
||||
u32 offset;
|
||||
u32 markerLength;
|
||||
const char* marker;
|
||||
char* current;
|
||||
marker = "?";
|
||||
markerLength = Mail_strlen(marker);
|
||||
current = encoded;
|
||||
for (offset = 0; offset <= size; offset++) {
|
||||
if (Mail_strncmp(current, marker, markerLength) == 0) {
|
||||
return encoded + offset;
|
||||
}
|
||||
current++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline NWC24Err ExtractWordEncoding(char* encoding, u32* encodingSize, char* encoded, u32 encodedSize) {
|
||||
char* delimiter = FindEncodingMarker(encoded, encodedSize);
|
||||
if (delimiter == NULL) { return NWC24_ERR_INVALID_VALUE; }
|
||||
*encoding = delimiter[1];
|
||||
*encodingSize = 2;
|
||||
return NWC24_OK;
|
||||
}
|
||||
static inline BOOL IsLinearWhitespaceOnly(char* text, u32 size) {
|
||||
u32 offset;
|
||||
BOOL whitespaceOnly;
|
||||
whitespaceOnly = TRUE;
|
||||
for (offset = 0; offset < size && text[offset] != '\0'; offset++) {
|
||||
char value = text[offset];
|
||||
if (value != ' ' && value != '\t' && value != '\r' && value != '\n') {
|
||||
whitespaceOnly = FALSE;
|
||||
}
|
||||
}
|
||||
return whitespaceOnly;
|
||||
}
|
||||
|
||||
static NWC24Err DecodeWord(char* charsetData, u32 charsetCapacity, char* decoded, u32 decodedCapacity, u32* decodedSize, char* encoded,
|
||||
u32 encodedSize, u32* encodedSizeOut) {
|
||||
char encoding;
|
||||
char* encodedWord;
|
||||
char* encodedWordPosition;
|
||||
u32 encodedLength;
|
||||
u32 consumedSize;
|
||||
u32 decodedLength;
|
||||
int encodedLength;
|
||||
NWC24Err result;
|
||||
|
||||
if (encodedSizeOut != NULL) { *encodedSizeOut = 0; }
|
||||
if (encodedSizeOut != NULL) {
|
||||
*encodedSizeOut = 0;
|
||||
}
|
||||
if (decodedCapacity == 0) {
|
||||
if (encodedSizeOut != NULL) { *encodedSizeOut = 0; }
|
||||
if (encodedSizeOut != NULL)
|
||||
*encodedSizeOut = 0;
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
}
|
||||
*decoded = '\0';
|
||||
if (decodedSize != NULL) { *decodedSize = 1; }
|
||||
if (encodedSizeOut != NULL) { *encodedSizeOut = 0; }
|
||||
encodedWord = FindMarker(encoded, encodedSize, "=?");
|
||||
if (encodedWord == encoded) {
|
||||
result = ExtractCharset(charsetData, charsetCapacity, &consumedSize, encodedWord, encodedSize);
|
||||
if (result != NWC24_OK) { return result; }
|
||||
encodedLength = consumedSize;
|
||||
result = ExtractWordEncoding(&encoding, &consumedSize, encodedWord + encodedLength, encodedSize - encodedLength);
|
||||
if (result != NWC24_OK) { return result; }
|
||||
encodedLength += consumedSize;
|
||||
result = ExtractEncodedText(decoded, decodedCapacity, &decodedLength, encoding, encodedWord + encodedLength,
|
||||
encodedSize - encodedLength, &consumedSize);
|
||||
if (result != NWC24_OK) { return result; }
|
||||
encodedLength += consumedSize;
|
||||
} else {
|
||||
u32 localSize;
|
||||
if (encodedWord != NULL) {
|
||||
encodedLength = encodedWord - encoded;
|
||||
} else {
|
||||
encodedLength = STD_strnlen(encoded, encodedSize);
|
||||
if (decodedSize != NULL) {
|
||||
*decodedSize = 1;
|
||||
}
|
||||
if (encodedSizeOut != NULL) {
|
||||
*encodedSizeOut = 0;
|
||||
}
|
||||
encodedWordPosition = FindMarker((char*)encoded, encodedSize, "=?");
|
||||
if (encodedWordPosition == (char*)encoded) {
|
||||
result = ExtractCharset(charsetData, charsetCapacity, &consumedSize, (char*)encoded, encodedSize);
|
||||
if (result != NWC24_OK) {
|
||||
return result;
|
||||
}
|
||||
encodedLength = consumedSize;
|
||||
{
|
||||
const char* marker = "?";
|
||||
u32 markerLength = Mail_strlen(marker);
|
||||
u32 offset;
|
||||
char* delimiter = NULL;
|
||||
char* current;
|
||||
for (offset = 0; offset <= encodedSize - consumedSize; offset++) {
|
||||
current = (char*)encodedWordPosition + consumedSize + offset;
|
||||
if (Mail_strncmp((char*)current, marker, markerLength) == 0) {
|
||||
delimiter = current;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (delimiter == 0) {
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
}
|
||||
{
|
||||
char encoding = delimiter[1];
|
||||
consumedSize = 2;
|
||||
encodedLength += consumedSize;
|
||||
result = ExtractEncodedText(decoded, decodedCapacity, &decodedLength, encoding, encoded + encodedLength, encodedSize - encodedLength,
|
||||
&consumedSize);
|
||||
if (result != NWC24_OK) {
|
||||
return result;
|
||||
}
|
||||
encodedLength += consumedSize;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
u32 localSize = decodedCapacity;
|
||||
if (encodedWordPosition == NULL) {
|
||||
encodedLength = STD_strnlen(encoded, encodedSize);
|
||||
} else {
|
||||
encodedLength = encodedWordPosition - (char*)encoded;
|
||||
}
|
||||
localSize = decodedCapacity;
|
||||
if (!CopyWithoutLinearWhiteSpaces(decoded, (int*)&localSize, encoded, encodedLength)) {
|
||||
*decodedSize = localSize;
|
||||
if (encodedSizeOut != NULL) { *encodedSizeOut = encodedLength; }
|
||||
if (encodedSizeOut != NULL) {
|
||||
*encodedSizeOut = encodedLength;
|
||||
}
|
||||
return NWC24_ERR_OVERFLOW;
|
||||
}
|
||||
decodedLength = localSize;
|
||||
if (encodedWord != NULL) {
|
||||
if (IsLinearWhitespaceOnly(decoded, localSize)) {
|
||||
if (encodedWordPosition != NULL) {
|
||||
BOOL whitespaceOnly = TRUE;
|
||||
u32 offset;
|
||||
for (offset = 0; offset < localSize && decoded[offset] != '\0'; offset++) {
|
||||
char value = decoded[offset];
|
||||
if (value != ' ' && value != '\t' && value != '\r' && value != '\n') {
|
||||
whitespaceOnly = FALSE;
|
||||
}
|
||||
}
|
||||
if (whitespaceOnly) {
|
||||
*decoded = '\0';
|
||||
decodedLength = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
*decodedSize = decodedLength;
|
||||
if (encodedSizeOut != NULL) { *encodedSizeOut = encodedLength; }
|
||||
return NWC24_OK;
|
||||
if (decodedSize != NULL) {
|
||||
*decodedSize = decodedLength;
|
||||
}
|
||||
if (encodedSizeOut != NULL) {
|
||||
*encodedSizeOut = encodedLength;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
NWC24Err NWC24DecodeMIMEHeaderFieldBody(u8* charsetData, u32 charsetDataSize, u8* decoded, u32 decodedCapacity, u32* decodedSize, u8* encoded,
|
||||
u32 encodedSize) {
|
||||
int result = 0;
|
||||
char* input;
|
||||
s32 inputSize;
|
||||
u8* output;
|
||||
s32 remainingCapacity;
|
||||
u32 inputSize;
|
||||
u32 capacity;
|
||||
u8* input;
|
||||
|
||||
if (decodedSize == NULL) {
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
@@ -638,21 +639,21 @@ NWC24Err NWC24DecodeMIMEHeaderFieldBody(u8* charsetData, u32 charsetDataSize, u8
|
||||
*decoded = 0;
|
||||
*charsetData = 0;
|
||||
*decodedSize = 1;
|
||||
input = (char*)encoded;
|
||||
inputSize = encodedSize;
|
||||
capacity = decodedCapacity;
|
||||
output = decoded;
|
||||
remainingCapacity = decodedCapacity;
|
||||
while ((s32)inputSize > 0 && remainingCapacity > 0 && *input != '\0') {
|
||||
input = encoded;
|
||||
while ((s32)inputSize > 0 && (s32)capacity > 0 && *input != '\0') {
|
||||
u32 copiedSize = 0;
|
||||
u32 consumedSize;
|
||||
result =
|
||||
DecodeWord((char*)charsetData, charsetDataSize, (char*)output, remainingCapacity, &copiedSize, (char*)input, inputSize, &consumedSize);
|
||||
DecodeWord((char*)charsetData, charsetDataSize, (char*)output, capacity, &copiedSize, (char*)input, inputSize, &consumedSize);
|
||||
if (copiedSize == 0) {
|
||||
break;
|
||||
}
|
||||
copiedSize--;
|
||||
output += copiedSize;
|
||||
remainingCapacity -= copiedSize;
|
||||
capacity -= copiedSize;
|
||||
*decodedSize += copiedSize;
|
||||
input += consumedSize;
|
||||
inputSize -= consumedSize;
|
||||
@@ -691,8 +692,6 @@ static NWC24Err ConcatEncodedText(char* encoded, u32 encodedCapacity, u32* encod
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static NWC24Err ExtractCharset(char* charset, u32 charsetCapacity, u32* charsetSize, char* encoded, u32 encodedSize) {
|
||||
char* start;
|
||||
char* end;
|
||||
@@ -705,7 +704,7 @@ static NWC24Err ExtractCharset(char* charset, u32 charsetCapacity, u32* charsetS
|
||||
if (start == NULL) {
|
||||
return NWC24_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
end = FindMarkerAfterPrefix(start, encodedSize - (u32)(start + 2 - encoded), 2, "?");
|
||||
end = FindMarker(start + 2, encodedSize - (u32)(start + 2 - encoded), "?");
|
||||
if (end == NULL) {
|
||||
return NWC24_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
@@ -713,22 +712,12 @@ static NWC24Err ExtractCharset(char* charset, u32 charsetCapacity, u32* charsetS
|
||||
if (charsetLength < charsetCapacity) {
|
||||
Mail_strncpy(charset, start + 2, charsetLength);
|
||||
charset[charsetLength] = '\0';
|
||||
} else { return NWC24_ERR_OVERFLOW; }
|
||||
} else {
|
||||
return NWC24_ERR_OVERFLOW;
|
||||
}
|
||||
*charsetSize = charsetLength + 2;
|
||||
return NWC24_OK;
|
||||
}
|
||||
static inline char* FindMarkerOffsetPrefix(char* input, u32 size, u32 prefix, const char* marker) {
|
||||
u32 offset;
|
||||
u32 markerLength;
|
||||
markerLength = Mail_strlen(marker);
|
||||
for (offset = 0; offset <= size; offset++) {
|
||||
if (Mail_strncmp(input + offset + prefix, marker, markerLength) == 0) {
|
||||
return input + prefix + offset;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static NWC24Err ExtractEncodedText(char* decoded, u32 decodedCapacity, u32* decodedSize, char encoding, char* encoded, u32 encodedSize,
|
||||
u32* encodedSizeOut) {
|
||||
@@ -737,7 +726,9 @@ static NWC24Err ExtractEncodedText(char* decoded, u32 decodedCapacity, u32* deco
|
||||
int length;
|
||||
NWC24Err result;
|
||||
|
||||
if (encoded == NULL) { return NWC24_ERR_INVALID_VALUE; }
|
||||
if (encoded == NULL) {
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
}
|
||||
if (decodedSize == NULL) {
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
}
|
||||
@@ -750,11 +741,11 @@ static NWC24Err ExtractEncodedText(char* decoded, u32 decodedCapacity, u32* deco
|
||||
if (start == NULL) {
|
||||
return NWC24_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
end = FindMarkerOffsetPrefix(start, encodedSize - (u32)(start + 1 - encoded), 1, "?=");
|
||||
end = FindMarker(start + 1, encodedSize - (u32)(start + 1 - encoded), "?=");
|
||||
if (end == NULL) {
|
||||
return NWC24_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
length = end - (start + 1);
|
||||
length = (u32)(end - (start + 1));
|
||||
if (encoding == 'B' || encoding == 'b') {
|
||||
result = NWC24Base64Decode((u8*)(start + 1), length, (u8*)decoded, decodedCapacity - 1, decodedSize);
|
||||
if (result == NWC24_OK || result == NWC24_ERR_OVERFLOW) {
|
||||
@@ -770,6 +761,8 @@ static NWC24Err ExtractEncodedText(char* decoded, u32 decodedCapacity, u32* deco
|
||||
} else {
|
||||
return NWC24_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
if (end != NULL) { *encodedSizeOut = (u32)(end - encoded) + 2; }
|
||||
if (end != NULL) {
|
||||
*encodedSizeOut = (u32)(end - encoded) + 2;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -9,7 +9,25 @@ static NWC24File* m_pFile;
|
||||
|
||||
static NWC24Err NWC24CommitMsgInternal(NWC24MsgObjPrivate* msg, NWC24MBoxType type);
|
||||
static NWC24Err CheckMsgObject(const NWC24MsgObjPrivate* msg);
|
||||
static NWC24Err WriteSubjectField(NWC24MsgObjPrivate* msg);
|
||||
static NWC24Err CheckMsgBoxSpace(const NWC24MsgObjPrivate* msg, NWC24MBoxType type);
|
||||
static inline NWC24Err WriteSubjectField(NWC24MsgObjPrivate* msg) {
|
||||
char* buffer = NWC24WorkP->stringWork;
|
||||
s32 length;
|
||||
NWC24Err err;
|
||||
if (msg->subject.size == 0)
|
||||
return NWC24_ERR_NULL;
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
Mail_strcpy(buffer, "Subject: ");
|
||||
Mail_strncat(buffer, msg->subject.ptr, 1021);
|
||||
Mail_strncat(buffer, "\r\n", 1024);
|
||||
length = STD_strnlen(buffer, 1024);
|
||||
err = NWC24FWrite(buffer, length, m_pFile);
|
||||
if (err == NWC24_OK)
|
||||
msg->length += length;
|
||||
return err;
|
||||
}
|
||||
|
||||
static NWC24Err SynthesizeAddrStr(const NWC24Data* address, u32 type, char* dest, s32 capacity, u32* length);
|
||||
static NWC24Err WriteSMTP_MAILFROM(NWC24MsgObjPrivate* msg);
|
||||
static NWC24Err WriteSMTP_RCPTTO(NWC24MsgObjPrivate* msg);
|
||||
@@ -53,22 +71,6 @@ static inline NWC24Err WriteString(NWC24MsgObjPrivate* msg, char* buffer) {
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
static inline NWC24Err WriteSubjectField(NWC24MsgObjPrivate* msg) {
|
||||
char* buffer = NWC24WorkP->stringWork;
|
||||
s32 length;
|
||||
NWC24Err err;
|
||||
if (msg->subject.size == 0)
|
||||
return NWC24_ERR_NULL;
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
Mail_strcpy(buffer, "Subject: ");
|
||||
Mail_strncat(buffer, msg->subject.ptr, 1021);
|
||||
Mail_strncat(buffer, "\r\n", 1024);
|
||||
length = STD_strnlen(buffer, 1024);
|
||||
err = NWC24FWrite(buffer, length, m_pFile);
|
||||
if (err == NWC24_OK)
|
||||
msg->length += length;
|
||||
return err;
|
||||
}
|
||||
|
||||
static inline NWC24Err WriteSMTPData(NWC24MsgObjPrivate* msg, const char* text) {
|
||||
char* buffer = NWC24WorkP->stringWork;
|
||||
@@ -202,40 +204,33 @@ static inline NWC24Err WriteMBNoReplyField(NWC24MsgObjPrivate* msg) {
|
||||
return err;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
u32 flags;
|
||||
char* buffer;
|
||||
} MBFieldWork;
|
||||
|
||||
static inline NWC24Err WriteMBRegDateField(NWC24MsgObjPrivate* msg) {
|
||||
MBFieldWork field;
|
||||
static inline NWC24Err WriteMBRegDateField(NWC24MsgObjPrivate* msg, u32 flags) {
|
||||
NWC24Err err;
|
||||
s32 length;
|
||||
field.flags = msg->msgBoardFlags.raw & 0xFFFF;
|
||||
if (!field.flags)
|
||||
char* buffer;
|
||||
if (!flags)
|
||||
return NWC24_OK;
|
||||
field.buffer = NWC24WorkP->stringWork;
|
||||
Mail_memset(field.buffer, 0, 1024);
|
||||
Mail_sprintf(field.buffer, "X-Wii-MB-RegDate: %04X\r\n", field.flags);
|
||||
length = STD_strnlen(field.buffer, 1024);
|
||||
err = NWC24FWrite(field.buffer, length, m_pFile);
|
||||
buffer = NWC24WorkP->stringWork;
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
Mail_sprintf(buffer, "X-Wii-MB-RegDate: %04X\r\n", flags);
|
||||
length = STD_strnlen(buffer, 1024);
|
||||
err = NWC24FWrite(buffer, length, m_pFile);
|
||||
if (err == NWC24_OK)
|
||||
msg->length += length;
|
||||
return err;
|
||||
}
|
||||
|
||||
static inline NWC24Err WriteMBDelayField(NWC24MsgObjPrivate* msg) {
|
||||
MBFieldWork field;
|
||||
static inline NWC24Err WriteMBDelayField(NWC24MsgObjPrivate* msg, u32 flags) {
|
||||
NWC24Err err;
|
||||
s32 length;
|
||||
field.flags = msg->msgBoardFlags.raw & 0xFF0000;
|
||||
if (!field.flags)
|
||||
char* buffer;
|
||||
if (!flags)
|
||||
return NWC24_OK;
|
||||
field.buffer = NWC24WorkP->stringWork;
|
||||
Mail_memset(field.buffer, 0, 1024);
|
||||
Mail_sprintf(field.buffer, "X-Wii-MB-Delay: %02X\r\n", field.flags >> 16);
|
||||
length = STD_strnlen(field.buffer, 1024);
|
||||
err = NWC24FWrite(field.buffer, length, m_pFile);
|
||||
buffer = NWC24WorkP->stringWork;
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
Mail_sprintf(buffer, "X-Wii-MB-Delay: %02X\r\n", flags >> 16);
|
||||
length = STD_strnlen(buffer, 1024);
|
||||
err = NWC24FWrite(buffer, length, m_pFile);
|
||||
if (err == NWC24_OK)
|
||||
msg->length += length;
|
||||
return err;
|
||||
@@ -313,8 +308,8 @@ static NWC24Err NWC24CommitMsgInternal(NWC24MsgObjPrivate* msg, NWC24MBoxType ty
|
||||
CHECK_WRITE(WriteIconNewField(msg));
|
||||
if (msg->msgBoardFlags.raw != 0) {
|
||||
CHECK_WRITE(WriteMBNoReplyField(msg));
|
||||
CHECK_WRITE(WriteMBRegDateField(msg));
|
||||
CHECK_WRITE(WriteMBDelayField(msg));
|
||||
CHECK_WRITE(WriteMBRegDateField(msg, msg->msgBoardFlags.raw & 0xFFFF));
|
||||
CHECK_WRITE(WriteMBDelayField(msg, msg->msgBoardFlags.raw & 0xFF0000));
|
||||
}
|
||||
}
|
||||
CHECK_WRITE(WriteExtraFields(msg));
|
||||
@@ -330,7 +325,7 @@ static NWC24Err NWC24CommitMsgInternal(NWC24MsgObjPrivate* msg, NWC24MBoxType ty
|
||||
}
|
||||
CHECK_WRITE(WriteString(msg, buffer));
|
||||
if (msg->type & 0x10000) {
|
||||
msg->headerSize = msg->length;
|
||||
msg->unk_0x10 = msg->length;
|
||||
buffer = NWC24WorkP->stringWork;
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
Mail_sprintf(buffer, "\r\n--%s", MultiPartDivider);
|
||||
@@ -339,10 +334,11 @@ static NWC24Err NWC24CommitMsgInternal(NWC24MsgObjPrivate* msg, NWC24MBoxType ty
|
||||
}
|
||||
CHECK_WRITE(WriteContentTypeField(msg));
|
||||
if (!(msg->type & 0x10000))
|
||||
msg->headerSize = msg->length;
|
||||
msg->unk_0x10 = msg->length;
|
||||
text.ptr = (const void*)msg->length;
|
||||
{ NWC24Err textResult = WritePlainText(msg);
|
||||
err = textResult == NWC24_ERR_NULL ? NWC24_OK : textResult; }
|
||||
err = WritePlainText(msg);
|
||||
if (err == NWC24_ERR_NULL)
|
||||
err = NWC24_OK;
|
||||
if (err != NWC24_OK) {
|
||||
NWC24FClose(&file);
|
||||
result = err;
|
||||
@@ -430,8 +426,8 @@ static NWC24Err CheckMsgObject(const NWC24MsgObjPrivate* msg) {
|
||||
return NWC24_OK;
|
||||
}
|
||||
|
||||
static inline u32 Base64StorageSize(const u32* byteCount) {
|
||||
return (*byteCount * 4 + 2) / 3 + *byteCount / 57 * 2 + 4;
|
||||
static inline u32 EstimateBase64Size(u32 size) {
|
||||
return (size * 4 + 2) / 3 + size / 57 * 2 + 4;
|
||||
}
|
||||
|
||||
static NWC24Err CheckMsgBoxSpace(const NWC24MsgObjPrivate* msg, NWC24MBoxType type) {
|
||||
@@ -440,7 +436,8 @@ static NWC24Err CheckMsgBoxSpace(const NWC24MsgObjPrivate* msg, NWC24MBoxType ty
|
||||
s32 index;
|
||||
NWC24Err err;
|
||||
for (index = 0; index < msg->numAttached; ++index) {
|
||||
total += Base64StorageSize(&msg->attachedSize[index]);
|
||||
u32 size = msg->attachedSize[index];
|
||||
total += EstimateBase64Size(size);
|
||||
}
|
||||
switch (msg->encoding) {
|
||||
case NWC24_ENC_7BIT:
|
||||
@@ -448,7 +445,7 @@ static NWC24Err CheckMsgBoxSpace(const NWC24MsgObjPrivate* msg, NWC24MBoxType ty
|
||||
textSize = msg->text.size;
|
||||
break;
|
||||
case NWC24_ENC_BASE64:
|
||||
textSize = (msg->text.size * 4 + 2) / 3 + msg->text.size / 57 * 2 + 4;
|
||||
textSize = EstimateBase64Size(msg->text.size);
|
||||
break;
|
||||
case NWC24_ENC_QUOTED_PRINTABLE:
|
||||
textSize = msg->text.size * 4 / 3;
|
||||
@@ -466,6 +463,7 @@ static NWC24Err CheckMsgBoxSpace(const NWC24MsgObjPrivate* msg, NWC24MBoxType ty
|
||||
return NWC24_OK;
|
||||
}
|
||||
|
||||
|
||||
static NWC24Err SynthesizeAddrStr(const NWC24Data* address, u32 type, char* dest, s32 capacity, u32* length) {
|
||||
char id[32];
|
||||
NWC24Err err = NWC24_OK;
|
||||
@@ -577,7 +575,7 @@ static NWC24Err WriteFromField(NWC24MsgObjPrivate* msg) {
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
Mail_strncat(buffer, "From: ", 1022);
|
||||
address = buffer + 6;
|
||||
msg->fromData.ptr = (const void*)(msg->length + 6);
|
||||
msg->unk_0x30.ptr = (const void*)(msg->length + 6);
|
||||
type = 1;
|
||||
if (msg->type & 0x100000)
|
||||
type = 2;
|
||||
@@ -596,7 +594,7 @@ static NWC24Err WriteFromField(NWC24MsgObjPrivate* msg) {
|
||||
err = NWC24FWrite(NWC24WorkP->stringWork, total, m_pFile);
|
||||
if (err == NWC24_OK) {
|
||||
msg->length += total;
|
||||
msg->fromData.size = msg->length - (u32)msg->fromData.ptr - 2;
|
||||
msg->unk_0x30.size = msg->length - (u32)msg->unk_0x30.ptr - 2;
|
||||
}
|
||||
}
|
||||
return err;
|
||||
@@ -612,7 +610,7 @@ static NWC24Err WriteToField(NWC24MsgObjPrivate* msg) {
|
||||
cursor += 4;
|
||||
index = 0;
|
||||
total = 4;
|
||||
msg->toData.ptr = (const void*)(msg->length + 4);
|
||||
msg->unk_0x38.ptr = (const void*)(msg->length + 4);
|
||||
remaining = 1018;
|
||||
for (; index < msg->numTo; ++index) {
|
||||
err = SynthesizeAddrStr(&msg->toAddrs[index], msg->type, cursor, remaining, &length);
|
||||
@@ -641,7 +639,7 @@ static NWC24Err WriteToField(NWC24MsgObjPrivate* msg) {
|
||||
err = NWC24FWrite(NWC24WorkP->stringWork, total + 2, m_pFile);
|
||||
if (err == NWC24_OK) {
|
||||
msg->length += total + 2;
|
||||
msg->toData.size = msg->length - (u32)msg->toData.ptr - 2;
|
||||
msg->unk_0x38.size = msg->length - (u32)msg->unk_0x38.ptr - 2;
|
||||
}
|
||||
}
|
||||
return err;
|
||||
@@ -769,14 +767,19 @@ static NWC24Err WriteMIMEAttachHeader(NWC24MsgObjPrivate* msg, u32 index) {
|
||||
char* buffer;
|
||||
const char* mime;
|
||||
const char* suffix;
|
||||
int mimeLength;
|
||||
s32 typeLength, encodingLength, dispositionLength, mimeLength;
|
||||
s32 first, second, third, total;
|
||||
NWC24Err err;
|
||||
Mail_memset(NWC24WorkP->stringWork, 0, 1024);
|
||||
buffer = NWC24WorkP->stringWork;
|
||||
mime = NWC24GetMIMETypeStr(msg->attachedType[index]);
|
||||
suffix = NWC24iGetMIMETypeSuffix(msg->attachedType[index]);
|
||||
mimeLength = (Mail_strlen(ContentTypeA) + Mail_strlen(ContentTxEncA)) + Mail_strlen(ContentDispA) + Mail_strlen(mime) + 4;
|
||||
encodingLength = Mail_strlen(ContentTxEncA);
|
||||
typeLength = Mail_strlen(ContentTypeA);
|
||||
dispositionLength = Mail_strlen(ContentDispA);
|
||||
typeLength += encodingLength;
|
||||
mimeLength = Mail_strlen(mime);
|
||||
mimeLength = (dispositionLength + typeLength) + mimeLength + 4;
|
||||
if (mimeLength >= 1024)
|
||||
return NWC24_ERR_NOMEM;
|
||||
first = Mail_sprintf(buffer, (char*)ContentTypeA, mime, (char)('a' + index), msg->msgId, suffix);
|
||||
|
||||
@@ -73,8 +73,8 @@ NWC24Err NWC24InitMsgObj(NWC24MsgObj* msg, NWC24MsgType type) {
|
||||
msgObj->attachedType[i] = NWC24_TEXT_PLAIN;
|
||||
}
|
||||
|
||||
NWC24Data_Init(&msgObj->fromData);
|
||||
NWC24Data_Init(&msgObj->toData);
|
||||
NWC24Data_Init(&msgObj->unk_0x30);
|
||||
NWC24Data_Init(&msgObj->unk_0x38);
|
||||
NWC24Data_Init(&msgObj->unk_0x50);
|
||||
NWC24Data_Init(&msgObj->unk_0x58);
|
||||
NWC24Data_Init(&msgObj->unk_0xD0);
|
||||
|
||||
@@ -8,10 +8,11 @@ static NWC24Err ReadMsgTextInternal(const NWC24MsgObj* msg, char* text, u32 capa
|
||||
NWC24Err ReadBase64Data(NWC24File* file, const NWC24Data* data, u8* output, u32 capacity, u32* outputSize);
|
||||
NWC24Err ReadQPText(const NWC24MsgObjPrivate* msg, NWC24File* file, char* output, u32 capacity);
|
||||
|
||||
static inline NWC24Err SelectMBox(const NWC24MsgObjPrivate* msg, NWC24MBoxType* type) {
|
||||
if (msg->type & 0x10)
|
||||
static inline NWC24Err SelectMBox(const NWC24MsgObj* msg, NWC24MBoxType* type) {
|
||||
u32 msgType = msg->data[1];
|
||||
if (msgType & 0x10)
|
||||
*type = NWC24_MBOX_TYPE_SEND;
|
||||
else if (msg->type & 0x20)
|
||||
else if (msgType & 0x20)
|
||||
*type = NWC24_MBOX_TYPE_RECV;
|
||||
else
|
||||
return NWC24_ERR_INVALID_VALUE;
|
||||
@@ -19,7 +20,7 @@ static inline NWC24Err SelectMBox(const NWC24MsgObjPrivate* msg, NWC24MBoxType*
|
||||
}
|
||||
|
||||
NWC24Err NWC24ReadMsgField(const NWC24MsgObj* msg, char* fieldName, u8* output, u32 capacity) {
|
||||
NWC24MsgObjPrivate* privateMsg = (NWC24MsgObjPrivate*)msg;
|
||||
const NWC24MsgObjPrivate* privateMsg = (const NWC24MsgObjPrivate*)msg;
|
||||
NWC24File file;
|
||||
NWC24FileStream stream;
|
||||
char* field;
|
||||
@@ -32,7 +33,8 @@ NWC24Err NWC24ReadMsgField(const NWC24MsgObj* msg, char* fieldName, u8* output,
|
||||
return NWC24_ERR_LIB_NOT_OPENED;
|
||||
if (!(privateMsg->type & 0x200))
|
||||
return NWC24_ERR_PROTECTED;
|
||||
result = SelectMBox(privateMsg, &type);
|
||||
type = NWC24_MBOX_TYPE_SEND;
|
||||
result = SelectMBox(msg, &type);
|
||||
switch (result) {
|
||||
case NWC24_OK:
|
||||
break;
|
||||
@@ -75,7 +77,8 @@ NWC24Err NWC24ReadMsgFaceData(const NWC24MsgObj* msg, u8* faceData) {
|
||||
char* buffer;
|
||||
u32 length;
|
||||
NWC24Err result;
|
||||
if ((privateMsg->type & 2) && !(privateMsg->type & 0x1000))
|
||||
u32 msgType = privateMsg->type;
|
||||
if ((msgType & 2) && !(msgType & 0x1000))
|
||||
return NWC24_ERR_NOT_FOUND;
|
||||
buffer = NWC24WorkP->stringWork;
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
@@ -268,7 +271,7 @@ NWC24Err NWC24ReadMsgMBOptOutFlag(const NWC24MsgObj* msg, BOOL* optOut, u32* app
|
||||
}
|
||||
|
||||
NWC24Err NWC24ReadMsgFromAddr(const NWC24MsgObj* msg, char* address, u32 capacity) {
|
||||
NWC24MsgObjPrivate* privateMsg = (NWC24MsgObjPrivate*)msg;
|
||||
const NWC24MsgObjPrivate* privateMsg = (const NWC24MsgObjPrivate*)msg;
|
||||
NWC24MBoxType type;
|
||||
NWC24File file;
|
||||
NWC24FileStream stream;
|
||||
@@ -282,14 +285,14 @@ NWC24Err NWC24ReadMsgFromAddr(const NWC24MsgObj* msg, char* address, u32 capacit
|
||||
Mail_memset(buffer, 0, 1024);
|
||||
if (!(privateMsg->type & 2))
|
||||
return NWC24_ERR_NOT_SUPPORTED;
|
||||
result = SelectMBox(privateMsg, &type);
|
||||
result = SelectMBox(msg, &type);
|
||||
switch (result) {
|
||||
case NWC24_OK:
|
||||
break;
|
||||
default:
|
||||
return result;
|
||||
}
|
||||
if (privateMsg->fromData.size == 0)
|
||||
if (privateMsg->unk_0x30.size == 0)
|
||||
return NWC24_ERR_NULL;
|
||||
result = NWC24iMBoxOpenStoredMsg(type, privateMsg->msgId, &file);
|
||||
switch (result) {
|
||||
@@ -300,9 +303,9 @@ NWC24Err NWC24ReadMsgFromAddr(const NWC24MsgObj* msg, char* address, u32 capacit
|
||||
}
|
||||
result = NWC24FStreamInit(&stream, &file, 0, privateMsg->length, buffer, 1024);
|
||||
if (result == NWC24_OK) {
|
||||
result = NWC24FStreamSeek(&stream, (u32)privateMsg->fromData.ptr);
|
||||
result = NWC24FStreamSeek(&stream, (u32)privateMsg->unk_0x30.ptr);
|
||||
if (result == NWC24_OK)
|
||||
result = NWC24iExtractAddrSpec(&stream, privateMsg->fromData.size, 0, address, capacity);
|
||||
result = NWC24iExtractAddrSpec(&stream, privateMsg->unk_0x30.size, 0, address, capacity);
|
||||
}
|
||||
closeResult = NWC24iMBoxCloseMsg(&file);
|
||||
if (result != NWC24_OK)
|
||||
@@ -312,7 +315,7 @@ NWC24Err NWC24ReadMsgFromAddr(const NWC24MsgObj* msg, char* address, u32 capacit
|
||||
}
|
||||
|
||||
NWC24Err NWC24ReadMsgSubject(const NWC24MsgObj* msg, char* subject, u32 capacity) {
|
||||
NWC24MsgObjPrivate* privateMsg = (NWC24MsgObjPrivate*)msg;
|
||||
const NWC24MsgObjPrivate* privateMsg = (const NWC24MsgObjPrivate*)msg;
|
||||
NWC24MBoxType type;
|
||||
NWC24File file;
|
||||
u32 length;
|
||||
@@ -321,7 +324,8 @@ NWC24Err NWC24ReadMsgSubject(const NWC24MsgObj* msg, char* subject, u32 capacity
|
||||
return NWC24_ERR_LIB_NOT_OPENED;
|
||||
if (!(privateMsg->type & 0x200))
|
||||
return NWC24_ERR_PROTECTED;
|
||||
result = SelectMBox(privateMsg, &type);
|
||||
type = NWC24_MBOX_TYPE_SEND;
|
||||
result = SelectMBox(msg, &type);
|
||||
switch (result) {
|
||||
case NWC24_OK:
|
||||
break;
|
||||
@@ -386,21 +390,21 @@ NWC24Err NWC24ReadMsgTextEx(const NWC24MsgObj* msg, char* text, u32 capacity, ch
|
||||
}
|
||||
|
||||
static NWC24Err ReadMsgTextInternal(const NWC24MsgObj* msg, char* text, u32 capacity, char* charset, u32 charsetCapacity, NWC24Encoding* encoding) {
|
||||
u32 length;
|
||||
const NWC24MsgObjPrivate* privateMsg = (const NWC24MsgObjPrivate*)msg;
|
||||
NWC24MBoxType type;
|
||||
NWC24File file;
|
||||
NWC24Err result, closeResult;
|
||||
NWC24Err overflow = NWC24_OK;
|
||||
char* buffer;
|
||||
u32 length;
|
||||
u32 decodedSize;
|
||||
NWC24MsgObjPrivate* privateMsg = (NWC24MsgObjPrivate*)msg;
|
||||
char* buffer;
|
||||
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool())
|
||||
return NWC24_ERR_LIB_NOT_OPENED;
|
||||
if (!(privateMsg->type & 0x200))
|
||||
return NWC24_ERR_PROTECTED;
|
||||
buffer = NWC24WorkP->stringWork;
|
||||
*encoding = 0;
|
||||
result = SelectMBox(privateMsg, &type);
|
||||
result = SelectMBox(msg, &type);
|
||||
switch (result) {
|
||||
case NWC24_OK:
|
||||
break;
|
||||
@@ -408,10 +412,7 @@ static NWC24Err ReadMsgTextInternal(const NWC24MsgObj* msg, char* text, u32 capa
|
||||
return result;
|
||||
}
|
||||
length = privateMsg->textSize;
|
||||
switch (length) {
|
||||
case 0: length = privateMsg->text.size; break;
|
||||
default: break;
|
||||
}
|
||||
length = length != 0 ? length : privateMsg->text.size;
|
||||
if (length == 0)
|
||||
return NWC24_ERR_NULL;
|
||||
if (length > capacity - 1) {
|
||||
@@ -452,16 +453,15 @@ static NWC24Err ReadMsgTextInternal(const NWC24MsgObj* msg, char* text, u32 capa
|
||||
result = NWC24FRead(text, length, &file);
|
||||
text[length] = 0;
|
||||
break;
|
||||
case 2: {
|
||||
NWC24Err decodeResult;
|
||||
case 2:
|
||||
decodedSize = 0;
|
||||
decodeResult = ReadBase64Data(&file, &privateMsg->text, (u8*)text, length, &decodedSize);
|
||||
if (decodeResult == NWC24_OK && decodedSize != privateMsg->textSize)
|
||||
decodeResult = NWC24_ERR_FORMAT;
|
||||
result = decodeResult;
|
||||
result = ReadBase64Data(&file, &privateMsg->text, (u8*)text, length, &decodedSize);
|
||||
if (result == NWC24_OK) {
|
||||
if (decodedSize != privateMsg->textSize)
|
||||
result = NWC24_ERR_FORMAT;
|
||||
}
|
||||
text[length] = 0;
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
result = ReadQPText(privateMsg, &file, text, length);
|
||||
break;
|
||||
@@ -473,26 +473,27 @@ static NWC24Err ReadMsgTextInternal(const NWC24MsgObj* msg, char* text, u32 capa
|
||||
}
|
||||
close:
|
||||
closeResult = NWC24iMBoxCloseMsg(&file);
|
||||
if (result != NWC24_OK)
|
||||
closeResult = result;
|
||||
if (closeResult != NWC24_OK)
|
||||
overflow = closeResult;
|
||||
return overflow;
|
||||
if (result == NWC24_OK)
|
||||
result = closeResult;
|
||||
if (result == NWC24_OK)
|
||||
result = overflow;
|
||||
return result;
|
||||
}
|
||||
|
||||
NWC24Err NWC24ReadMsgAttached(const NWC24MsgObj* msg, u32 index, u8* output, u32 capacity) {
|
||||
NWC24MsgObjPrivate* privateMsg = (NWC24MsgObjPrivate*)msg;
|
||||
const NWC24MsgObjPrivate* privateMsg = (const NWC24MsgObjPrivate*)msg;
|
||||
NWC24File file;
|
||||
NWC24MBoxType type;
|
||||
u32 decodedSize;
|
||||
NWC24Err result, closeResult;
|
||||
u32 decodedSize;
|
||||
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool())
|
||||
return NWC24_ERR_LIB_NOT_OPENED;
|
||||
if (!(privateMsg->type & 0x200))
|
||||
return NWC24_ERR_PROTECTED;
|
||||
if (index >= privateMsg->numAttached)
|
||||
return NWC24_ERR_NOT_FOUND;
|
||||
result = SelectMBox(privateMsg, &type);
|
||||
type = NWC24_MBOX_TYPE_SEND;
|
||||
result = SelectMBox(msg, &type);
|
||||
switch (result) {
|
||||
case NWC24_OK:
|
||||
break;
|
||||
@@ -511,7 +512,8 @@ NWC24Err NWC24ReadMsgAttached(const NWC24MsgObj* msg, u32 index, u8* output, u32
|
||||
decodedSize = 0;
|
||||
result = ReadBase64Data(&file, &privateMsg->attached[index], output, capacity, &decodedSize);
|
||||
if (result == NWC24_OK) {
|
||||
if (decodedSize != ((const NWC24MsgObjPrivate*)msg)->attachedSize[index]) result = NWC24_ERR_FORMAT;
|
||||
if (decodedSize != *(u32*)((u8*)privateMsg->attachedSize + index * 4))
|
||||
result = NWC24_ERR_FORMAT;
|
||||
}
|
||||
closeResult = NWC24iMBoxCloseMsg(&file);
|
||||
if (result == NWC24_OK)
|
||||
|
||||
@@ -67,6 +67,8 @@ NWC24Err NWC24ReadMsgSubjectPublic(const NWC24MsgObj* msg, u16* subject, u32* su
|
||||
decodedCapacity = workSize - workHalf;
|
||||
result = NWC24GetMsgSubjectSize(msg, &subjectDataSize);
|
||||
switch (result) {
|
||||
default:
|
||||
goto done;
|
||||
case NWC24_OK:
|
||||
if (subjectDataSize > workHalf) {
|
||||
subjectDataSize = workHalf;
|
||||
@@ -77,7 +79,7 @@ NWC24Err NWC24ReadMsgSubjectPublic(const NWC24MsgObj* msg, u16* subject, u32* su
|
||||
if (result == NWC24_ERR_OVERFLOW) {
|
||||
truncated = TRUE;
|
||||
} else {
|
||||
goto done;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
charsetBuffer = NWC24WorkP->stringWork;
|
||||
@@ -87,7 +89,7 @@ NWC24Err NWC24ReadMsgSubjectPublic(const NWC24MsgObj* msg, u16* subject, u32* su
|
||||
if (result == NWC24_ERR_OVERFLOW) {
|
||||
truncated = TRUE;
|
||||
} else {
|
||||
goto done;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
*subjectSize = originalSize;
|
||||
@@ -104,8 +106,6 @@ NWC24Err NWC24ReadMsgSubjectPublic(const NWC24MsgObj* msg, u16* subject, u32* su
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -133,6 +133,8 @@ NWC24Err NWC24ReadMsgTextPublic(const NWC24MsgObj* msg, u16* text, u32* textSize
|
||||
} else {
|
||||
result = NWC24GetMsgTextSize(msg, &textDataSize);
|
||||
switch (result) {
|
||||
default:
|
||||
goto done;
|
||||
case NWC24_OK:
|
||||
if (textDataSize > workSize) {
|
||||
textDataSize = workSize;
|
||||
@@ -141,10 +143,11 @@ NWC24Err NWC24ReadMsgTextPublic(const NWC24MsgObj* msg, u16* text, u32* textSize
|
||||
charsetBuffer = NWC24WorkP->stringWork + 0x20;
|
||||
result = NWC24ReadMsgTextEx(msg, (char*)work, textDataSize, charsetBuffer, 0x40);
|
||||
if (result != NWC24_OK) {
|
||||
if (result != NWC24_ERR_OVERFLOW) {
|
||||
goto done;
|
||||
if (result == NWC24_ERR_OVERFLOW) {
|
||||
truncated = TRUE;
|
||||
} else {
|
||||
return result;
|
||||
}
|
||||
truncated = TRUE;
|
||||
}
|
||||
|
||||
*textSize = originalSize;
|
||||
@@ -153,8 +156,6 @@ NWC24Err NWC24ReadMsgTextPublic(const NWC24MsgObj* msg, u16* text, u32* textSize
|
||||
result = NWC24_ERR_OVERFLOW;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -230,8 +231,8 @@ done:
|
||||
|
||||
NWC24Err NWC24SetMsgSubjectAndTextPublic(NWC24MsgObj* msg, const u16* subject, u32 subjectSize, const u16* text, u32 textSize,
|
||||
NWC24EncodingRegion region, u16 alternative, u8* work, u32 workSize) {
|
||||
char* stringWork;
|
||||
NWC24MsgObjPrivate* privateMsg = (NWC24MsgObjPrivate*)msg;
|
||||
NWC24Work* nwcWork;
|
||||
u32 textSourceSize;
|
||||
u32 textWorkSize;
|
||||
BOOL is7Bit;
|
||||
@@ -262,22 +263,22 @@ NWC24Err NWC24SetMsgSubjectAndTextPublic(NWC24MsgObj* msg, const u16* subject, u
|
||||
goto done;
|
||||
}
|
||||
|
||||
nwcWork = NWC24WorkP;
|
||||
result = NWC24iDetectEncodingToSend(nwcWork->stringWork, 0x40, subject, subjectSize, text, textSize, region);
|
||||
stringWork = NWC24WorkP->stringWork;
|
||||
result = NWC24iDetectEncodingToSend(stringWork, 0x40, subject, subjectSize, text, textSize, region);
|
||||
switch (result) {
|
||||
case NWC24_OK:
|
||||
break;
|
||||
default:
|
||||
goto done;
|
||||
}
|
||||
if (NWC24ParseCharsetStr(&charset, nwcWork->stringWork) != NWC24_OK) {
|
||||
if (NWC24ParseCharsetStr(&charset, stringWork) != NWC24_OK) {
|
||||
charset = 0;
|
||||
}
|
||||
textWorkSize = (workSize * textSize) / (textSize + subjectSize * 4);
|
||||
subjectWorkSize = workSize - textWorkSize;
|
||||
subjectWork = work + textWorkSize;
|
||||
textSourceSize = textSize;
|
||||
result = NWC24iConvertFromInternalEncoding(work, &textWorkSize, text, &textSourceSize, nwcWork->stringWork, 0x40, region, alternative);
|
||||
result = NWC24iConvertFromInternalEncoding(work, &textWorkSize, text, &textSourceSize, stringWork, 0x40, region, alternative);
|
||||
switch (result) {
|
||||
case NWC24_OK:
|
||||
break;
|
||||
@@ -285,7 +286,7 @@ NWC24Err NWC24SetMsgSubjectAndTextPublic(NWC24MsgObj* msg, const u16* subject, u
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = ENCIs7BitEncoding(&is7Bit, nwcWork->stringWork);
|
||||
result = ENCIs7BitEncoding(&is7Bit, stringWork);
|
||||
if (!is7Bit || (result != ENC_OK)) {
|
||||
switch (region) {
|
||||
case 0:
|
||||
@@ -314,7 +315,7 @@ NWC24Err NWC24SetMsgSubjectAndTextPublic(NWC24MsgObj* msg, const u16* subject, u
|
||||
goto done;
|
||||
}
|
||||
if (charset == 0) {
|
||||
result = NWC24iSetMsgSubjectPlain(msg, subject, subjectSize, region, alternative, subjectWork, subjectWorkSize, charset, nwcWork->stringWork);
|
||||
result = NWC24iSetMsgSubjectPlain(msg, subject, subjectSize, region, alternative, subjectWork, subjectWorkSize, charset, stringWork);
|
||||
goto done;
|
||||
}
|
||||
switch (region) {
|
||||
@@ -334,10 +335,10 @@ NWC24Err NWC24SetMsgSubjectAndTextPublic(NWC24MsgObj* msg, const u16* subject, u
|
||||
break;
|
||||
}
|
||||
if (result == 3) {
|
||||
result = NWC24iSetMsgSubjectQP(msg, subject, subjectSize, region, alternative, subjectWork, subjectWorkSize, charset, nwcWork->stringWork);
|
||||
result = NWC24iSetMsgSubjectQP(msg, subject, subjectSize, region, alternative, subjectWork, subjectWorkSize, charset, stringWork);
|
||||
} else {
|
||||
result =
|
||||
NWC24iSetMsgSubjectBase64(msg, subject, subjectSize, region, alternative, subjectWork, subjectWorkSize, charset, nwcWork->stringWork);
|
||||
NWC24iSetMsgSubjectBase64(msg, subject, subjectSize, region, alternative, subjectWork, subjectWorkSize, charset, stringWork);
|
||||
}
|
||||
|
||||
done:
|
||||
@@ -743,16 +744,15 @@ NWC24Err NWC24iSetMsgSubjectQP(NWC24MsgObj* msg, const u16* subject, u32 subject
|
||||
u32 workSize, NWC24Charset charset, char* charsetName) {
|
||||
u32 workHalf;
|
||||
u32 sourceOffset;
|
||||
u32 charsetLength;
|
||||
u32 secondSize;
|
||||
u8* second;
|
||||
u32 subjectLength;
|
||||
u32 lineLength;
|
||||
u32 secondSize;
|
||||
u32 outputLength;
|
||||
u32 total;
|
||||
u32 combinedLength;
|
||||
u32 i;
|
||||
u32 outputLength;
|
||||
u32 firstCharsetLength;
|
||||
u32 charsetLength;
|
||||
NWC24Err result;
|
||||
|
||||
secondSize = workSize - (workSize >> 1);
|
||||
@@ -771,8 +771,8 @@ NWC24Err NWC24iSetMsgSubjectQP(NWC24MsgObj* msg, const u16* subject, u32 subject
|
||||
work[i] = ' ';
|
||||
}
|
||||
}
|
||||
firstCharsetLength = strlen(charsetName);
|
||||
NWC24iDetectBreakPoint(&lineLength, charset, work, subjectLength, (0x38 - firstCharsetLength) / 3);
|
||||
charsetLength = strlen(charsetName);
|
||||
NWC24iDetectBreakPoint(&lineLength, charset, work, subjectLength, (0x38 - charsetLength) / 3);
|
||||
result = NWC24EncodeWord(second, secondSize, &outputLength, charsetName, 0x40, 'Q', work, lineLength);
|
||||
switch (result) {
|
||||
default:
|
||||
@@ -817,72 +817,64 @@ done:
|
||||
|
||||
NWC24Err NWC24iSetMsgSubjectBase64(NWC24MsgObj* msg, const u16* subject, u32 subjectSize, NWC24EncodingRegion region, u16 alternative, u8* work,
|
||||
u32 workSize, NWC24Charset charset, char* charsetName) {
|
||||
const u8* encodedInput = work;
|
||||
u32 workHalf;
|
||||
u8* second;
|
||||
u32 secondSize;
|
||||
u32 workHalf;
|
||||
u32 convertedLength;
|
||||
u32 subjectLength;
|
||||
u32 outputLength;
|
||||
u32 lineLength;
|
||||
u32 sourceOffset;
|
||||
u32 outputLength;
|
||||
u32 total;
|
||||
u32 charsetLength;
|
||||
NWC24Err result;
|
||||
|
||||
second = work + (workSize >> 1);
|
||||
secondSize = workSize - (workSize >> 1);
|
||||
workHalf = workSize >> 1;
|
||||
second = work + workHalf;
|
||||
secondSize = workSize - workHalf;
|
||||
charsetLength = strlen(charsetName);
|
||||
lineLength = ((0x36 - charsetLength) * 3) >> 2;
|
||||
if (lineLength > (workSize >> 1)) {
|
||||
result = NWC24_ERR_OVERFLOW;
|
||||
} else {
|
||||
workHalf = lineLength + 1;
|
||||
subjectLength = subjectSize;
|
||||
result = NWC24iConvertFromInternalEncoding(work, &workHalf, subject, &subjectLength, charsetName, 0x40, region, alternative);
|
||||
if (result != NWC24_OK) {
|
||||
switch (result) {
|
||||
case NWC24_ERR_OVERFLOW: break;
|
||||
default: goto done;
|
||||
}
|
||||
}
|
||||
result = NWC24EncodeWord(second, secondSize, &outputLength, charsetName, 0x40, 'B', (u8*)encodedInput, workHalf - 1);
|
||||
switch (result) { case NWC24_OK: break; default: goto done; }
|
||||
{
|
||||
sourceOffset = subjectLength;
|
||||
if (sourceOffset == subjectSize) {
|
||||
result = NWC24SetMsgSubject(msg, (char*)second, outputLength - 1);
|
||||
} else {
|
||||
charsetLength = strlen(charsetName);
|
||||
lineLength = (((0x3E - charsetLength) * 3) >> 2) + 1;
|
||||
total = outputLength - 1;
|
||||
for (; sourceOffset < subjectSize;) {
|
||||
subjectLength = subjectSize - sourceOffset;
|
||||
workHalf = lineLength;
|
||||
if (secondSize - total < 3) {
|
||||
result = NWC24_ERR_OVERFLOW;
|
||||
goto done;
|
||||
}
|
||||
second[total++] = '\r';
|
||||
second[total++] = '\n';
|
||||
second[total++] = ' ';
|
||||
result = NWC24iConvertFromInternalEncoding(work, &workHalf, subject + sourceOffset, &subjectLength, charsetName, 0x40, region,
|
||||
alternative);
|
||||
if (result != NWC24_OK) {
|
||||
switch (result) {
|
||||
case NWC24_ERR_OVERFLOW: break;
|
||||
default: goto done;
|
||||
}
|
||||
}
|
||||
result = NWC24EncodeWord(second + total, secondSize - total, &outputLength, charsetName, 0x40, 'B', (u8*)encodedInput, workHalf - 1);
|
||||
switch (result) { case NWC24_OK: break; default: goto done; }
|
||||
sourceOffset += subjectLength;
|
||||
total = total + outputLength - 1;
|
||||
}
|
||||
result = NWC24SetMsgSubject(msg, (char*)second, total);
|
||||
}
|
||||
}
|
||||
if (lineLength > workHalf) {
|
||||
return NWC24_ERR_OVERFLOW;
|
||||
}
|
||||
convertedLength = lineLength + 1;
|
||||
subjectLength = subjectSize;
|
||||
result = NWC24iConvertFromInternalEncoding(work, &convertedLength, subject, &subjectLength, charsetName, 0x40, region, alternative);
|
||||
if (!(result == NWC24_OK || result == NWC24_ERR_OVERFLOW)) {
|
||||
return result;
|
||||
}
|
||||
result = NWC24EncodeWord(second, secondSize, &outputLength, charsetName, 0x40, 'B', work, convertedLength - 1);
|
||||
if (result != NWC24_OK) {
|
||||
return result;
|
||||
}
|
||||
sourceOffset = subjectLength;
|
||||
if (sourceOffset == subjectSize) {
|
||||
result = NWC24SetMsgSubject(msg, (char*)second, outputLength - 1);
|
||||
} else {
|
||||
charsetLength = strlen(charsetName);
|
||||
lineLength = (((0x3E - charsetLength) * 3) >> 2) + 1;
|
||||
total = outputLength - 1;
|
||||
for (; sourceOffset < subjectSize; sourceOffset += subjectLength) {
|
||||
subjectLength = subjectSize - sourceOffset;
|
||||
convertedLength = lineLength;
|
||||
if (secondSize - total < 3) {
|
||||
return NWC24_ERR_OVERFLOW;
|
||||
}
|
||||
second[total++] = '\r';
|
||||
second[total++] = '\n';
|
||||
second[total++] = ' ';
|
||||
result = NWC24iConvertFromInternalEncoding(work, &convertedLength, subject + sourceOffset, &subjectLength, charsetName, 0x40,
|
||||
region, alternative);
|
||||
if (!(result == NWC24_OK || result == NWC24_ERR_OVERFLOW)) {
|
||||
return result;
|
||||
}
|
||||
result = NWC24EncodeWord(second + total, secondSize - total, &outputLength, charsetName, 0x40, 'B', work, convertedLength - 1);
|
||||
if (result != NWC24_OK) {
|
||||
return result;
|
||||
}
|
||||
total += outputLength - 1;
|
||||
}
|
||||
result = NWC24SetMsgSubject(msg, (char*)second, total);
|
||||
}
|
||||
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -138,9 +138,9 @@ int SOGetSockName(int socket, void* address) {
|
||||
int size;
|
||||
int result;
|
||||
s32 rm;
|
||||
NameRequest* request;
|
||||
SOSockAddr* reply;
|
||||
SOSockAddr* addr;
|
||||
SOSockAddr* reply;
|
||||
NameRequest* request;
|
||||
addr=address;
|
||||
if((result=SOiPrepare(NULL,&rm))==0) {
|
||||
if(!addr || addr->len>8 || addr->len<8) result=-28;
|
||||
|
||||
@@ -47,130 +47,95 @@ s32 SOGetHostID(void) {
|
||||
return address;
|
||||
}
|
||||
|
||||
static inline int GetHostReply(const char* name, s32* rm, SOHostEnt** host) {
|
||||
SOHostEnt* SOGetHostByName(const char* name) {
|
||||
HostReply* reply;
|
||||
int length;
|
||||
char* request;
|
||||
int result;
|
||||
int size;
|
||||
if (!name) return -28;
|
||||
length = strlen(name);
|
||||
size = (length + 32) & ~31;
|
||||
request = SOiAlloc(12, size);
|
||||
reply = SOiGetSysWork()->host;
|
||||
if (!request) return -49;
|
||||
strcpy(request, name);
|
||||
result = IOS_Ioctl(*rm, 17, request, length + 1, reply, 0x460);
|
||||
if (result >= 0) {
|
||||
int displacement = (int)reply->nameStorage - (int)reply->host.name;
|
||||
u8** address = reply->addresses;
|
||||
while (*address) { *address += displacement; ++address; }
|
||||
reply->host.aliases = (char**)((u8*)reply->host.aliases + displacement);
|
||||
*host = &reply->host;
|
||||
reply->host.name += displacement;
|
||||
reply->host.addrList = (u8**)((u8*)reply->host.addrList + displacement);
|
||||
}
|
||||
SOiFree(12, request, size);
|
||||
return result;
|
||||
}
|
||||
|
||||
SOHostEnt* SOGetHostByName(const char* name) {
|
||||
SOHostEnt* host = NULL;
|
||||
int length;
|
||||
SOHostEnt* host;
|
||||
s32 rm;
|
||||
int result;
|
||||
if ((result = SOiPrepare(NULL, &rm)) == 0) {
|
||||
result = GetHostReply(name, &rm, &host);
|
||||
SOiConclude(NULL, result);
|
||||
char* request;
|
||||
host = NULL;
|
||||
if((result=SOiPrepare(NULL,&rm))==0) {
|
||||
if(!name) result=-28;
|
||||
else {
|
||||
length=strlen(name);
|
||||
size=(length+32)&~31;
|
||||
request=SOiAlloc(12,size);
|
||||
reply=SOiGetSysWork()->host;
|
||||
if(!request) result=-49;
|
||||
else {
|
||||
strcpy(request,name);
|
||||
result=IOS_Ioctl(rm,17,request,length+1,reply,0x460);
|
||||
if(result>=0) {
|
||||
int displacement=(int)reply->nameStorage-(int)reply->host.name;
|
||||
u8** address=reply->addresses;
|
||||
while(*address) { *address+=displacement; ++address; }
|
||||
reply->host.aliases=(char**)((u8*)reply->host.aliases+displacement);
|
||||
host=&reply->host;
|
||||
reply->host.name+=displacement;
|
||||
reply->host.addrList=(u8**)((u8*)reply->host.addrList+displacement);
|
||||
}
|
||||
SOiFree(12,request,size);
|
||||
}
|
||||
}
|
||||
SOiConclude(NULL,result);
|
||||
}
|
||||
return host;
|
||||
}
|
||||
|
||||
static inline int NameSize(const char* name) {
|
||||
if (name == NULL) {
|
||||
return 0;
|
||||
} else {
|
||||
return strlen(name) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
static inline int NameLength(const char* name) {
|
||||
if (name == NULL) {
|
||||
return 0;
|
||||
} else {
|
||||
return strlen(name);
|
||||
}
|
||||
}
|
||||
|
||||
static inline int ServiceSize(const char* node, const char* service) {
|
||||
if (service == NULL) {
|
||||
return 0;
|
||||
} else {
|
||||
return strlen(node) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
static inline int GetAddressReply(const char* nodeName, const char* servName, const SOAddrInfo* hints,
|
||||
SOAddrInfo** resultInfo, s32* rm) {
|
||||
SOAddrInfo* requestHints;
|
||||
AddrInfoRequest* request;
|
||||
char* service;
|
||||
int nodeLength;
|
||||
AddrInfoReply* reply;
|
||||
int size;
|
||||
char* node;
|
||||
int serviceLength;
|
||||
int result;
|
||||
serviceLength = ServiceSize(nodeName, servName);
|
||||
nodeLength = NameSize(nodeName);
|
||||
size=(((nodeLength+31)&~31)+((serviceLength+31)&~31)+95)&~31;
|
||||
request=SOiAlloc(12,size);
|
||||
if(!request) result=-49;
|
||||
else {
|
||||
reply=SOiAlloc(10,0x840);
|
||||
if(!reply) { SOiFree(12,request,size); result=-49; }
|
||||
else {
|
||||
node=(char*)request->storage;
|
||||
service=node+((NameSize(nodeName)+31)&~31);
|
||||
requestHints=(SOAddrInfo*)(service+((ServiceSize(nodeName, servName)+31)&~31));
|
||||
if(nodeName) strcpy(node,nodeName);
|
||||
request->vectors[0].base=nodeName ? (u8*)node : NULL;
|
||||
request->vectors[0].length=NameLength(nodeName);
|
||||
if(servName) strcpy(service,servName);
|
||||
request->vectors[1].base=servName ? (u8*)service : NULL;
|
||||
request->vectors[1].length=NameLength(servName);
|
||||
if(hints) memcpy(requestHints,hints,32);
|
||||
else memset(requestHints,0,32);
|
||||
if(requestHints->family==0) requestHints->family=2;
|
||||
if(requestHints->family==23) {
|
||||
*resultInfo=NULL; result=-68; SOiFree(10,reply,0x840);
|
||||
} else {
|
||||
request->vectors[2].base=(u8*)requestHints; request->vectors[2].length=32;
|
||||
request->vectors[3].base=(u8*)reply; request->vectors[3].length=0x834;
|
||||
result=IOS_Ioctlv(*rm,24,3,1,request->vectors);
|
||||
if(result>=0) {
|
||||
SOAddrInfo* entry=reply->entries;
|
||||
u8* address=reply->addresses;
|
||||
*resultInfo=entry;
|
||||
while(entry) {
|
||||
entry->addr=address;
|
||||
if(entry->next) entry->next=entry+1;
|
||||
entry=entry->next;
|
||||
address+=28;
|
||||
}
|
||||
} else { *resultInfo=NULL; SOiFree(10,reply,0x840); }
|
||||
}
|
||||
SOiFree(12,request,size);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
static int NameSize(const char* name) { return name ? strlen(name)+1 : 0; }
|
||||
|
||||
int SOGetAddrInfo(const char* nodeName, const char* servName, const SOAddrInfo* hints, SOAddrInfo** resultInfo) {
|
||||
s32 rm;
|
||||
int result;
|
||||
if ((result = SOiPrepare(NULL, &rm)) == 0) {
|
||||
result = GetAddressReply(nodeName, servName, hints, resultInfo, &rm);
|
||||
result = SOiConclude(NULL, result);
|
||||
int result,size;
|
||||
AddrInfoRequest* request;
|
||||
AddrInfoReply* reply;
|
||||
char* node;
|
||||
char* service;
|
||||
SOAddrInfo* requestHints;
|
||||
if((result=SOiPrepare(NULL,&rm))==0) {
|
||||
size=(((NameSize(nodeName)+31)&~31)+((servName ? strlen(nodeName)+32 : 31)&~31)+95)&~31;
|
||||
request=SOiAlloc(12,size);
|
||||
if(!request) result=-49;
|
||||
else {
|
||||
reply=SOiAlloc(10,0x840);
|
||||
if(!reply) { SOiFree(12,request,size); result=-49; }
|
||||
else {
|
||||
node=(char*)request->storage;
|
||||
service=node+((NameSize(nodeName)+31)&~31);
|
||||
requestHints=(SOAddrInfo*)(service+((servName ? strlen(nodeName)+32 : 31)&~31));
|
||||
if(nodeName) strcpy(node,nodeName);
|
||||
request->vectors[0].base=nodeName ? (u8*)node : NULL;
|
||||
request->vectors[0].length=nodeName ? strlen(nodeName) : 0;
|
||||
if(servName) strcpy(service,servName);
|
||||
request->vectors[1].base=servName ? (u8*)service : NULL;
|
||||
request->vectors[1].length=servName ? strlen(servName) : 0;
|
||||
if(hints) memcpy(requestHints,hints,32);
|
||||
else memset(requestHints,0,32);
|
||||
if(requestHints->family==0) requestHints->family=2;
|
||||
if(requestHints->family==23) {
|
||||
*resultInfo=NULL; result=-68; SOiFree(10,reply,0x840);
|
||||
} else {
|
||||
request->vectors[2].base=(u8*)requestHints; request->vectors[2].length=32;
|
||||
request->vectors[3].base=(u8*)reply; request->vectors[3].length=0x834;
|
||||
result=IOS_Ioctlv(rm,24,3,1,request->vectors);
|
||||
if(result>=0) {
|
||||
SOAddrInfo* entry=reply->entries;
|
||||
u8* address=reply->addresses;
|
||||
*resultInfo=entry;
|
||||
while(entry) {
|
||||
entry->addr=address;
|
||||
if(entry->next) entry->next=entry+1;
|
||||
entry=entry->next;
|
||||
address+=28;
|
||||
}
|
||||
} else { *resultInfo=NULL; SOiFree(10,reply,0x840); }
|
||||
}
|
||||
SOiFree(12,request,size);
|
||||
}
|
||||
}
|
||||
result=SOiConclude(NULL,result);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -17,19 +17,14 @@ typedef struct SocketOption {
|
||||
u8 value[20];
|
||||
} SocketOption;
|
||||
|
||||
typedef union InterfaceCommand {
|
||||
struct { int level; int option; };
|
||||
u8 bytes[32];
|
||||
} InterfaceCommand;
|
||||
|
||||
typedef union InterfaceLength {
|
||||
int length;
|
||||
u8 bytes[32];
|
||||
} InterfaceLength;
|
||||
typedef struct InterfaceCommand { int level; int option; } InterfaceCommand;
|
||||
|
||||
typedef struct InterfaceOption {
|
||||
IOSIoVector vectors[4];
|
||||
InterfaceCommand command;
|
||||
union {
|
||||
InterfaceCommand command;
|
||||
u8 commandBlock[32];
|
||||
};
|
||||
union {
|
||||
int length;
|
||||
u8 lengthBlock[32];
|
||||
@@ -39,7 +34,10 @@ typedef struct InterfaceOption {
|
||||
|
||||
typedef struct InterfaceSetting {
|
||||
IOSIoVector vectors[4];
|
||||
InterfaceCommand command;
|
||||
union {
|
||||
InterfaceCommand command;
|
||||
u8 commandBlock[32];
|
||||
};
|
||||
u8 value[1];
|
||||
} InterfaceSetting;
|
||||
|
||||
@@ -98,10 +96,10 @@ static int OptionLength(int* length) {
|
||||
int SOGetInterfaceOpt(void* interface, int level, int option, void* value, int* length) {
|
||||
s32 rm;
|
||||
int temporary;
|
||||
int size;
|
||||
int result;
|
||||
InterfaceOption* request;
|
||||
const InterfaceCommand* command;
|
||||
int result;
|
||||
int size;
|
||||
InterfaceCommand* command;
|
||||
int* returnedLength;
|
||||
u8* reply;
|
||||
if ((result=SOiPrepareTempRm(NULL,&rm,&temporary))==0) {
|
||||
@@ -112,9 +110,9 @@ int SOGetInterfaceOpt(void* interface, int level, int option, void* value, int*
|
||||
if(!request) result=-49;
|
||||
else {
|
||||
command=&request->command;
|
||||
request->command.level=level; request->command.option=option;
|
||||
returnedLength=&((InterfaceLength*)(command + 1))->length;
|
||||
reply=(u8*)((InterfaceLength*)returnedLength + 1);
|
||||
command->level=level; command->option=option;
|
||||
returnedLength=&request->length;
|
||||
reply=request->value;
|
||||
*returnedLength=OptionLength(length);
|
||||
request->vectors[0].base=(u8*)command;
|
||||
request->vectors[0].length=8;
|
||||
@@ -140,9 +138,9 @@ int SOGetInterfaceOpt(void* interface, int level, int option, void* value, int*
|
||||
int SOSetInterfaceOpt(void* interface, int level, int option, const void* value, int length) {
|
||||
s32 rm;
|
||||
int temporary;
|
||||
int size;
|
||||
int result;
|
||||
InterfaceSetting* request;
|
||||
int result;
|
||||
int size;
|
||||
InterfaceCommand* command;
|
||||
u8* reply;
|
||||
if ((result=SOiPrepareTempRm(NULL,&rm,&temporary))==0) {
|
||||
@@ -154,7 +152,7 @@ int SOSetInterfaceOpt(void* interface, int level, int option, const void* value,
|
||||
else {
|
||||
command=&request->command;
|
||||
command->level=level; command->option=option;
|
||||
reply=(u8*)(command + 1);
|
||||
reply=request->value;
|
||||
if(value) memcpy(reply,value,length);
|
||||
else memset(reply,0,length);
|
||||
request->vectors[0].base=(u8*)command; request->vectors[0].length=8;
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
#define BS2_MACH_VOLATILE_DVD_STATE
|
||||
#define BS2_MACH_FIVE_ARG_READ
|
||||
#include "BS2/BS2.h"
|
||||
#include "BS2/BS2BringUp.h"
|
||||
@@ -65,7 +64,7 @@ volatile int CacheFailed = 0;
|
||||
volatile int RegionValid = 0;
|
||||
volatile int NandPending = 0;
|
||||
vu32 CancelNand = 0;
|
||||
vu32 LowReadResult = 0;
|
||||
u32 LowReadResult = 0;
|
||||
u32 CacheCommandComplete = 0;
|
||||
u32 AudioBufferUnconfigured = 0;
|
||||
u64 ResetTime = 0;
|
||||
@@ -578,7 +577,7 @@ void BS2StartGame() {
|
||||
u32 (*entry)(void);
|
||||
|
||||
StartingGame = TRUE;
|
||||
while (CoverBlock.state != DVD_STATE_IDLE) {
|
||||
while (DVDGetCommandBlockStatus(&CoverBlock) != DVD_STATE_IDLE) {
|
||||
}
|
||||
|
||||
BS2Report("BS2StartGame(1)\n");
|
||||
@@ -678,6 +677,8 @@ void BS2StartGame() {
|
||||
LowReadResult = 0;
|
||||
DVDLowReadDiskID(&DiskID, (DVDLowCallback)callback);
|
||||
while (LowReadResult == 0) {
|
||||
BOOL enabled = OSDisableInterrupts();
|
||||
OSRestoreInterrupts(enabled);
|
||||
}
|
||||
|
||||
status = LowReadResult;
|
||||
@@ -692,6 +693,8 @@ void BS2StartGame() {
|
||||
LowReadResult = 0;
|
||||
DVDLowRequestError((DVDLowCallback)callback);
|
||||
while (LowReadResult == 0) {
|
||||
BOOL enabled = OSDisableInterrupts();
|
||||
OSRestoreInterrupts(enabled);
|
||||
}
|
||||
driveError = DVDLowGetImmBufferReg() & 0xFF000000;
|
||||
if (driveError == 0x01000000 || (driveError = DVDLowGetImmBufferReg() & 0xFF000000) == 0x03000000) {
|
||||
@@ -726,6 +729,8 @@ disk_done:
|
||||
(DVDLowCallback)callback);
|
||||
}
|
||||
while (LowReadResult == 0) {
|
||||
BOOL enabled = OSDisableInterrupts();
|
||||
OSRestoreInterrupts(enabled);
|
||||
}
|
||||
|
||||
status = LowReadResult;
|
||||
@@ -743,6 +748,8 @@ disk_done:
|
||||
LowReadResult = 0;
|
||||
DVDLowRequestError((DVDLowCallback)callback);
|
||||
while (LowReadResult == 0) {
|
||||
BOOL enabled = OSDisableInterrupts();
|
||||
OSRestoreInterrupts(enabled);
|
||||
}
|
||||
driveError = DVDLowGetImmBufferReg() & 0xFF000000;
|
||||
if (driveError == 0x01000000 || (driveError = DVDLowGetImmBufferReg() & 0xFF000000) == 0x03000000) {
|
||||
|
||||
@@ -9,10 +9,14 @@
|
||||
|
||||
#include <string.h>
|
||||
|
||||
typedef struct UpdateThreadData {
|
||||
OSThread thread;
|
||||
u8 stack[4096];
|
||||
} UpdateThreadData;
|
||||
|
||||
static u32 Flags0[BS2_UPDATE_ENTRY_COUNT] = {0};
|
||||
static u32 Flags1[BS2_UPDATE_ENTRY_COUNT] = {0};
|
||||
static OSThread Thread = {0};
|
||||
static u8 ThreadStack[4096] = {0};
|
||||
static UpdateThreadData Thread = {0};
|
||||
static BS2UpdateHeader UpdateHeader0 ALIGN32 = {0};
|
||||
static BS2UpdateHeader UpdateHeader1 ALIGN32 = {0};
|
||||
|
||||
@@ -35,7 +39,7 @@ static u32 UpdateImportResult = 0;
|
||||
u32 StartUpdate = 0;
|
||||
u32 CancelUpdate = 0;
|
||||
static u32 UpdateProgress = 0;
|
||||
static volatile s32 rc = 0;
|
||||
static s32 rc = 0;
|
||||
static u64 VersionIOS = 0;
|
||||
static u32 VersionMEM2 = 0;
|
||||
static u32 VersionES = 0;
|
||||
@@ -72,9 +76,9 @@ void BS2UpdateInit(void* allocator) {
|
||||
memset(EntriesToImport, 0, 0x40000);
|
||||
memset(Flags1, 0, sizeof(Flags1));
|
||||
BS2Report("Create update thread\n");
|
||||
OSCreateThread(&Thread, UpdateThread, NULL, ThreadStack + sizeof(ThreadStack),
|
||||
sizeof(ThreadStack), 31, 1);
|
||||
OSResumeThread(&Thread);
|
||||
OSCreateThread(&Thread.thread, UpdateThread, NULL, Thread.stack + sizeof(Thread.stack),
|
||||
sizeof(Thread.stack), 31, 1);
|
||||
OSResumeThread(&Thread.thread);
|
||||
}
|
||||
|
||||
static void* UpdateThread(void* argument) {
|
||||
|
||||
@@ -205,7 +205,7 @@ void AxAdpcmSimplePlayer::init() {
|
||||
}
|
||||
|
||||
int AxAdpcmSimplePlayer::start(void* data, u32 length, AxAdpcmHandle* handle) {
|
||||
mpBNSBuffer = (Header*)data;
|
||||
Header* head = mpBNSBuffer = (Header*)data;
|
||||
|
||||
sSysPauseFlag = false;
|
||||
|
||||
@@ -224,6 +224,7 @@ int AxAdpcmSimplePlayer::start(void* data, u32 length, AxAdpcmHandle* handle) {
|
||||
ChannelInfo* chanInfoBufB[2];
|
||||
ChannelInfo* chanInfoBufA[2];
|
||||
|
||||
AdpcmCoeffs** pCoeffsBufB = NULL;
|
||||
int i;
|
||||
u32* channelStartOffsets;
|
||||
INFOBlock* infoBlock;
|
||||
@@ -239,13 +240,13 @@ int AxAdpcmSimplePlayer::start(void* data, u32 length, AxAdpcmHandle* handle) {
|
||||
|
||||
int chanCount;
|
||||
{
|
||||
if (((Header*)data)->byteOrder != 0xFEFF) {
|
||||
if (head->byteOrder != 0xFEFF) {
|
||||
chanCount = 0;
|
||||
goto clean_up;
|
||||
}
|
||||
|
||||
infoBlock = ADD_OFFSET(INFOBlock, data, ((Header*)data)->infoHead.offset);
|
||||
dataBlock = ADD_OFFSET(DATABlock, data, ((Header*)data)->dataHead.offset);
|
||||
infoBlock = ADD_OFFSET(INFOBlock, data, head->infoHead.offset);
|
||||
dataBlock = ADD_OFFSET(DATABlock, data, head->dataHead.offset);
|
||||
if (infoBlock->head.sig != 'INFO') {
|
||||
chanCount = 0;
|
||||
goto clean_up;
|
||||
@@ -267,6 +268,8 @@ int AxAdpcmSimplePlayer::start(void* data, u32 length, AxAdpcmHandle* handle) {
|
||||
pChanInfoBufB = chanInfoBufB;
|
||||
pChanDataBuf = chanDataBuf;
|
||||
pCoeffsBufA = coeffsBufA;
|
||||
pCoeffsBufB = coeffsBufB;
|
||||
pAxvpbBuf = axVoiceBuf;
|
||||
for (i = 0; chanCount = infoBlock->channelCount, i < chanCount; i++) {
|
||||
int chanStartOffs = channelStartOffsets[i];
|
||||
ChannelInfo* chanInfo = ADD_OFFSET(ChannelInfo, infoBlockDataBase, chanStartOffs);
|
||||
@@ -275,9 +278,8 @@ int AxAdpcmSimplePlayer::start(void* data, u32 length, AxAdpcmHandle* handle) {
|
||||
pChanInfoBufB[i] = chanInfo;
|
||||
pChanDataBuf[i] = ADD_OFFSET(void, dataBlockDataBase, chanInfo->dataOff);
|
||||
pCoeffsBufA[i] = ADD_OFFSET(AdpcmCoeffs, infoBlockDataBase, chanInfo->coeffOff);
|
||||
coeffsBufB[i] = ADD_OFFSET(AdpcmCoeffs, infoBlockDataBase, chanInfo->coeffOff);
|
||||
pCoeffsBufB[i] = ADD_OFFSET(AdpcmCoeffs, infoBlockDataBase, chanInfo->coeffOff);
|
||||
|
||||
pAxvpbBuf = axVoiceBuf;
|
||||
pAxvpbBuf[i] = AXAcquireVoice(0x1f, VoiceCallback, 0);
|
||||
if (pAxvpbBuf[i] == NULL) {
|
||||
chanCount = 0;
|
||||
@@ -310,33 +312,37 @@ int AxAdpcmSimplePlayer::start(void* data, u32 length, AxAdpcmHandle* handle) {
|
||||
axAddr.currentAddressHi = (u32)currAddr >> 0x10;
|
||||
axAddr.currentAddressLo = (u32)currAddr & 0xFFFF;
|
||||
|
||||
axAdpcm.a[0][0] = coeffsBufB[i]->a[0][0];
|
||||
axAdpcm.a[0][1] = coeffsBufB[i]->a[0][1];
|
||||
axAdpcm.a[1][0] = coeffsBufB[i]->a[1][0];
|
||||
axAdpcm.a[1][1] = coeffsBufB[i]->a[1][1];
|
||||
axAdpcm.a[2][0] = coeffsBufB[i]->a[2][0];
|
||||
axAdpcm.a[2][1] = coeffsBufB[i]->a[2][1];
|
||||
axAdpcm.a[3][0] = coeffsBufB[i]->a[3][0];
|
||||
axAdpcm.a[3][1] = coeffsBufB[i]->a[3][1];
|
||||
axAdpcm.a[4][0] = coeffsBufB[i]->a[4][0];
|
||||
axAdpcm.a[4][1] = coeffsBufB[i]->a[4][1];
|
||||
axAdpcm.a[5][0] = coeffsBufB[i]->a[5][0];
|
||||
axAdpcm.a[5][1] = coeffsBufB[i]->a[5][1];
|
||||
axAdpcm.a[6][0] = coeffsBufB[i]->a[6][0];
|
||||
axAdpcm.a[6][1] = coeffsBufB[i]->a[6][1];
|
||||
axAdpcm.a[7][0] = coeffsBufB[i]->a[7][0];
|
||||
axAdpcm.a[7][1] = coeffsBufB[i]->a[7][1];
|
||||
axAdpcm.gain = coeffsBufB[i]->cfg.gain;
|
||||
axAdpcm.pred_scale = coeffsBufB[i]->cfg.predScale;
|
||||
axAdpcm.yn1 = coeffsBufB[i]->cfg.yn1;
|
||||
axAdpcm.yn2 = coeffsBufB[i]->cfg.yn2;
|
||||
axAdpcm.a[0][0] = pCoeffsBufB[i]->a[0][0];
|
||||
axAdpcm.a[0][1] = pCoeffsBufB[i]->a[0][1];
|
||||
axAdpcm.a[1][0] = pCoeffsBufB[i]->a[1][0];
|
||||
axAdpcm.a[1][1] = pCoeffsBufB[i]->a[1][1];
|
||||
axAdpcm.a[2][0] = pCoeffsBufB[i]->a[2][0];
|
||||
axAdpcm.a[2][1] = pCoeffsBufB[i]->a[2][1];
|
||||
axAdpcm.a[3][0] = pCoeffsBufB[i]->a[3][0];
|
||||
axAdpcm.a[3][1] = pCoeffsBufB[i]->a[3][1];
|
||||
axAdpcm.a[4][0] = pCoeffsBufB[i]->a[4][0];
|
||||
axAdpcm.a[4][1] = pCoeffsBufB[i]->a[4][1];
|
||||
axAdpcm.a[5][0] = pCoeffsBufB[i]->a[5][0];
|
||||
axAdpcm.a[5][1] = pCoeffsBufB[i]->a[5][1];
|
||||
axAdpcm.a[6][0] = pCoeffsBufB[i]->a[6][0];
|
||||
axAdpcm.a[6][1] = pCoeffsBufB[i]->a[6][1];
|
||||
axAdpcm.a[7][0] = pCoeffsBufB[i]->a[7][0];
|
||||
axAdpcm.a[7][1] = pCoeffsBufB[i]->a[7][1];
|
||||
axAdpcm.gain = pCoeffsBufB[i]->cfg.gain;
|
||||
axAdpcm.pred_scale = pCoeffsBufB[i]->cfg.predScale;
|
||||
axAdpcm.yn1 = pCoeffsBufB[i]->cfg.yn1;
|
||||
axAdpcm.yn2 = pCoeffsBufB[i]->cfg.yn2;
|
||||
|
||||
u32 ratio = infoBlock->sampleRate / 32000.0f * 65536.0f;
|
||||
axSrc.ratioHi = ratio >> 16;
|
||||
axSrc.ratioLo = ratio & 0xFFFF;
|
||||
axSrc.last_samples[3] = axSrc.last_samples[2] = axSrc.last_samples[1] = axSrc.last_samples[0] = axSrc.currentAddressFrac = 0;
|
||||
axSrc.currentAddressFrac = 0;
|
||||
axSrc.last_samples[0] = 0;
|
||||
axSrc.last_samples[1] = 0;
|
||||
axSrc.last_samples[2] = 0;
|
||||
axSrc.last_samples[3] = 0;
|
||||
|
||||
AXVPB* vpbA = pAxvpbBuf[i];
|
||||
AXVPB* vpbA = axVoiceBuf[i];
|
||||
AXSetVoiceType(vpbA, 0);
|
||||
AXSetVoiceAddr(vpbA, &axAddr);
|
||||
AXSetVoiceAdpcm(vpbA, &axAdpcm);
|
||||
@@ -353,7 +359,7 @@ int AxAdpcmSimplePlayer::start(void* data, u32 length, AxAdpcmHandle* handle) {
|
||||
Voices[vpbA->index].getMix()->vL = 0;
|
||||
}
|
||||
}
|
||||
AXVPB* vpbB = pAxvpbBuf[i];
|
||||
AXVPB* vpbB = axVoiceBuf[i];
|
||||
AXSetVoiceMix(vpbB, Voices[vpbA->index].getMix());
|
||||
static AXPBVE voiceVe = {32768, 0};
|
||||
AXSetVoiceVe(vpbB, &voiceVe);
|
||||
|
||||
@@ -619,7 +619,7 @@ vmFloat VmIntToFloat(vmU64 integer) {
|
||||
return result;
|
||||
}
|
||||
|
||||
static s32 CHANSVmParseInt(const CHANSVmObjHdr* obj, s32 base, u64* out) {
|
||||
static s32 CHANSVmParseInt(CHANSVmObjHdr* obj, s32 base, u64* out) {
|
||||
u8 type = obj->type;
|
||||
u32 stringLength;
|
||||
u32 charCount;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user