psdparse 0.4.0__tar.gz → 0.6.0__tar.gz

{psdparse-0.4.0 → psdparse-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: psdparse
-Version: 0.4.0
+Version: 0.6.0
 Summary: Fast PSD (Photoshop) reader/writer — C++17 core with pybind11 bindings
 Keywords: psd,photoshop,parser,image,graphics
 Author-Email: wamsoft <wtnbgo@gmail.com>

{psdparse-0.4.0 → psdparse-0.6.0}/docs/PYTHON_API.md

@@ -107,6 +107,7 @@ Read-only view of one layer.
 | `blending_ranges` | `dict` \| `None` | "Blend If" ranges (`None` when absent) — see below |
 | `effects` | `dict` \| `None` | layer effects (`lfx2`) as a descriptor dict — see [Descriptor blocks](#descriptor-blocks) |
 | `fill` | `dict` \| `None` | fill-layer content (solid/gradient/pattern) — see [Descriptor blocks](#descriptor-blocks) |
+| `sheet_color` | `dict` \| `None` | layer-panel color label (`lclr`): `{"index", "name"}` — `None` when no `lclr` block |
 | `info_keys` | `list[str]` | 4cc keys of every additional-layer-info block on this layer |
 | `visible` | `bool` | flag bit 1 inverted |
 | `transparency_protected` | `bool` | flag bit 0 |
@@ -175,16 +176,24 @@ for layer in p.layers:
   "disabled": False,         # bit1: mask disabled
   "inverted": False,         # bit2: invert (obsolete)
   "from_render": False,      # bit3: mask from rendering other data
-  "has_parameters": False,   # bit4: density/feather present (not decoded yet)
+  "has_parameters": True,    # bit4: density/feather block present
+  "user_density": 128,       # 0..255, or None if not stored
+  "user_feather": 2.5,       # feather radius (px), or None
+  "vector_density": None,    # 0..255, or None
+  "vector_feather": None,    # feather radius (px), or None
   "real": None,              # or a nested dict (below) for a real/user mask
 }
 ```
 
-When the record carries a *real* (user + vector combined) mask, `real` is a dict
-with `flags`, `background`, and the enclosing `top/left/bottom/right`. The mask
-**pixels** are unchanged from before — fetch them with
+When the record carries a *real* (user + vector combined) mask (block size ≥ 36),
+`real` is a dict with `flags`, `background`, and the enclosing
+`top/left/bottom/right`. The mask **pixels** are unchanged — fetch them with
 `p.layer_image(i, "mask")`.
 
+`user_density`/`user_feather`/`vector_density`/`vector_feather` are only non-`None`
+when `has_parameters` is set and the corresponding value was stored. (Fixed in
+0.6.0: the real-mask section was previously decoded one byte off.)
+
 ### `layer.blending_ranges` — "Blend If" ranges
 
 `None` when absent. `gray` is the composite range; `channels` has one entry per
@@ -224,8 +233,37 @@ p.guides        # dict|None : {"horizontal_grid", "vertical_grid", "guides":[{"l
 p.slices        # dict|None : {"group_name", "bounding":{...}, "slices":[{...}]}
 p.layer_comps   # list[dict]: [{"id","name","comment","record_visibility","record_position","record_appearance"}]
 p.color_table   # dict|None : {"colors":[(r,g,b,a)], "valid_count", "transparency_index"} for indexed-color PSDs
+p.global_layer_mask  # dict|None : {"overlay_color_space", "color":(c1,c2,c3,c4), "opacity", "kind"}
+```
+
+### Image resources (raw)
+
+Most image resources are exposed as their raw on-disk bytes; decoding (EXIF
+tags, rendering the thumbnail, parsing the ICC profile) is left to the caller.
+
+```python
+p.image_resource_ids     # list[int]  : IDs of every resource present
+p.image_resource(id)     # bytes|None : raw bytes of the resource with that ID
+p.icc_profile            # bytes|None : ICC profile (resource 1039)
+p.exif                   # bytes|None : EXIF block (1058)
+p.xmp                    # str|None   : XMP packet (1060), UTF-8 XML
+p.thumbnail              # dict|None  : {"format","width","height","bits","resource_id","data"}
 ```
 
+- **`thumbnail`** — resource 1036 (RGB) or legacy 1033 (BGR). When
+  `format == "jpeg"`, `data` is JFIF JPEG bytes ready for `PIL.Image.open`:
+
+  ```python
+  import io
+  from PIL import Image
+  th = p.thumbnail
+  if th and th["format"] == "jpeg":
+      Image.open(io.BytesIO(th["data"])).save("thumb.png")
+  ```
+
+- **`xmp`** decodes as UTF-8 `str`; if a file's packet is not valid UTF-8, read
+  the raw bytes with `p.image_resource(1060)` instead.
+
 - **`guides`** — grid spacing (in 1/32 px) and each guide's `location` (1/32 px
   from origin) and `direction` (`"vertical"` / `"horizontal"`).
 - **`slices`** — Photoshop slices (v6). Each slice has `id`, `name`, bbox
@@ -277,9 +315,12 @@ Notes:
 - `layer.effects` is `lfx2` (object-based, Photoshop 6+). The older binary
   `lrFX` block is **not** a descriptor and returns `None` via `descriptor()`.
 - `descriptor(key, skip)` is the generic escape hatch: `skip` is the number of
-  version-prefix bytes before the descriptor (`-1` auto-detects for `lfx2` = 8
-  and `SoCo`/`GdFl`/`PtFl` = 4, otherwise 0). Use `info_keys` to discover which
-  blocks a layer carries.
+  version-prefix bytes before the descriptor (`-1` auto-detects for the known
+  descriptor keys: `lfx2` = 8, `SoCo`/`GdFl`/`PtFl`/`vstk`/`CgEd` = 4,
+  `vscg`/`vogk` = 8, `SoLd` = 12, otherwise 0). Use `info_keys` to discover which
+  blocks a layer carries. The smart-object/vector defaults (`SoLd`/`vstk`/`vscg`/
+  `vogk`) are set from the psd-tools layouts but not yet verified against a real
+  smart-object sample — override `skip` if a parse looks wrong.
 - Decoding is **lazy** — the descriptor is parsed from the block's raw bytes on
   each access, so cache the result if you read it repeatedly.
 
@@ -314,6 +355,12 @@ psdparse.LAYER_TYPE_NORMAL, LAYER_TYPE_HIDDEN, LAYER_TYPE_FOLDER,
 LAYER_TYPE_ADJUST, LAYER_TYPE_FILL
 ```
 
+Pixel extraction (`merged_image()` / `layer_image()`) supports Bitmap, Grayscale,
+RGB, Indexed, CMYK (→RGB), **Duotone** (rendered as grayscale) and **Lab**
+(standard D65 CIELAB→sRGB approximation — Photoshop uses D50, so highly saturated
+colors differ slightly). **Multichannel** has no canonical RGB mapping and is not
+rendered.
+
 ## Pixel format
 
 All `*_image()` methods return interleaved BGRA in little-endian byte order:

{psdparse-0.4.0 → psdparse-0.6.0}/docs/ROADMAP.md

@@ -83,8 +83,9 @@ This is mostly a constructor that fills `Data` with a minimal-but-valid skeleton
   - **Leading / faux bold-italic / underline / strikethrough / paragraph indent+spacing** — keys exist in EngineData but are default-valued in the current sample, so per-run extraction can't be verified yet; needs a sample authored with non-default values.
 - ✅ **Tier-1 reference metadata exposed to Python.** *Done 2026-08-02 (0.3.0).* Data the C++ core already parsed but Python couldn't reach is now bound: `layer.parent_index` (folder hierarchy), `layer.mask` (bbox / flags / real-mask dict), `layer.blending_ranges`, and document-level `PSDFile.guides` / `.slices` / `.layer_comps` / `.color_table`. All dict-shaped, matching the existing `layer.text` style. Validated against `config.psd` / `system.psd` (hierarchy, blend ranges, guides, slices) and a psd-tools-synthesized `masktest.psd` (mask bbox/flags cross-checked) — see `tests/test_metadata.py`.
 - ✅ **Tier-2 generic Descriptor → dict bridge.** *Done 2026-08-02 (0.4.0).* `layer.effects` (`lfx2`), `layer.fill` (`SoCo`/`GdFl`/`PtFl`), `layer.info_keys`, and a generic `layer.descriptor(key, skip)` escape hatch route previously-skipped tagged blocks through the existing complete descriptor parser (`psddesc.*`). A `Descriptor → py::dict` converter in the binding (dynamic_cast dispatch; UnitFloat→`{value,unit}`, Enumerated→`{type,value}`, nested Descriptor→dict, List→list, tdta→bytes) means no per-feature decoders were needed. Decoding is lazy: each access clones the block's reader (`clone()`+`init()`) and re-parses, so `save()` round-trips remain byte-identical. Cross-checked value-for-value against psd-tools 1.17 on `config.psd`'s PatternOverlay (opacity/scale/angle/blend/pattern-name all matched) — see `tests/test_descriptors.py`. **Deferred:** typed high-level effect/fill objects, smart-object `SoLd`/`lnkD` (embedded-file extraction), and binary adjustment layers (`levl`/`curv`) all still need work — the raw descriptor dict is the current interface.
+- ✅ **Image-resource raw bytes exposed.** *Done 2026-08-02 (0.5.0).* `PSDFile.image_resource(id)` / `.image_resource_ids` plus typed shortcuts `.icc_profile` (1039), `.exif` (1058), `.xmp` (1060, UTF-8 str) and `.thumbnail` (1036/1033 → dict with JPEG bytes + dimensions). Raw bytes only — decoding EXIF tags / rendering the thumbnail is left to the caller. EXIF and ICC bytes cross-checked byte-identical against psd-tools 1.17; thumbnail JPEG verified decodable with Pillow — see `tests/test_resources.py`. **Still raw-only / unexposed:** higher-level decode of these (parsed EXIF, ICC transform) and the structured `GlobalLayerMaskInfo`.
+- ✅ **Mask parameters + color label + global mask + Lab/Duotone pixels.** *Done 2026-08-02 (0.6.0).* A batch of the remaining reference gaps: `layer.mask` now decodes the density/feather `MaskParameters` (`user_density`/`user_feather`/`vector_density`/`vector_feather`) and the real/user-mask section is byte-correct again (the old parser had an off-by-one that shifted the enclosing rect — no filler byte follows `flags`, and the real section is gated on size≥36, matching psd-tools). `layer.sheet_color` exposes the `lclr` layer-panel color label (index+name). `PSDFile.global_layer_mask` exposes the document overlay color/opacity/kind. `getLayerImage`/`getMergedImage` now render **Lab** (standard D65 CIELAB→sRGB approximation; Photoshop uses D50 so saturated colors differ slightly) and **Duotone** (as grayscale per the Adobe spec). The generic `descriptor()` escape hatch gained known default skips for `SoLd`/`vstk`/`vscg`/`vogk`/`CgEd`. Validated against psd-tools-authored fixtures (`maskparams.psd`: real+params mask & lclr; `labsample.psd`: neutral/red swatches; `duosample.psd` vs `graysample.psd`) — see `tests/test_mask_extras.py` and `tests/test_colormodes.py`. **Still open:** Multichannel pixels (no canonical RGB), smart-object embedded-file extraction (`lnkD`), and the SoLd/vector default skips remain unverified against a real smart-object sample.
 - 16-bit (`Lr16`) and 32-bit-float (`Lr32`) layer data: currently captured in `layerAndMaskTrailing` for round-trip but not exposed as decoded pixels.
-- Layer mask: density / feather decoding (the `has_parameters` flag is exposed but the `MaskParameters` values are not read yet), plus re-emission for masks > 20 bytes.
-- Image resources: most are currently passed through as raw bytes. Higher-level accessors for ICC profile, EXIF, thumbnail, version info, etc. would be nice for tools.
-- CMYK / Lab / Indexed color extraction in `getLayerImage` — currently optimized for RGB.
+- Layer mask re-emission for masks > 20 bytes (the field-based save path; round-trip already preserves them via raw bytes).
+- Multichannel color extraction in `getLayerImage` (no canonical RGB representation); smart-object embedded file (`lnkD`) extraction.
 - Linux / macOS testing. mmap path uses POSIX `mmap` but hasn't been built / tested there.

{psdparse-0.4.0 → psdparse-0.6.0}/docs/SUPPORT.md

@@ -13,7 +13,7 @@ psdparse が PSD のどの機能を、どの水準で扱えるかの一覧です
 | 📦 | 生バイトのみ保持 (ラウンドトリップ用。Python へは未公開) |
 | ❌ | 未対応 — パースしていない |
 
-最終更新: 2026-08-02 (v0.4.0)。詳細な今後の計画は [ROADMAP.md](ROADMAP.md)、
+最終更新: 2026-08-02 (v0.6.0)。詳細な今後の計画は [ROADMAP.md](ROADMAP.md)、
 Python API の使い方は [PYTHON_API.md](PYTHON_API.md) を参照。
 
 ---
@@ -44,9 +44,9 @@ Python API の使い方は [PYTHON_API.md](PYTHON_API.md) を参照。
 | RGB (8/16/32) | ✅ | |
 | Indexed (8bit) | ✅ | パレットは `PSDFile.color_table` |
 | CMYK (8/16/32) | ✅ | RGB へ変換して出力 |
-| Multichannel | ❌ | `getLayerImage` 未対応 |
-| Duotone | ❌ | 同上 |
-| Lab | ❌ | 同上 |
+| Multichannel | ❌ | RGB への正準的変換が無く未対応 |
+| Duotone (8/16/32) | ✅ | grayscale として展開 (Adobe 仕様: duotone データは gray) |
+| Lab (8/16) | ✅ | 標準 D65 CIELAB→sRGB 近似で変換 (Photoshop は D50 のため彩度の高い色は差あり)。32bit Lab は非存在 |
 
 出力は常に **BGRA インターリーブ** (4 byte/px)。ICC を用いた色変換は行いません。
 
@@ -74,15 +74,15 @@ Python API の使い方は [PYTHON_API.md](PYTHON_API.md) を参照。
 | レイヤ種別 | ✅ | `layer_type` (NORMAL/HIDDEN/FOLDER/ADJUST/FILL/TEXT) |
 | **フォルダ階層 (親子)** | ✅ | `parent_index` (v0.3.0) |
 | チャンネル構成 (id/length) | ✅ | `channels[]` |
-| シートカラー (レイヤパネルの色ラベル, `lclr`) | ❌ | 未デコード |
+| シートカラー (レイヤパネルの色ラベル, `lclr`) | ✅ | `layer.sheet_color` (`{index,name}`, v0.6.0) |
 
 ## レイヤマスク / ブレンド範囲
 
 | 機能 | 状況 | API |
 |---|:---:|---|
 | マスク矩形/フラグ/既定色 | ✅ | `layer.mask` (v0.3.0) |
-| real/user mask (>20byte) | ✅ | `layer.mask["real"]` |
-| density / feather | 🟡 | `has_parameters` フラグのみ公開。値 (MaskParameters) は未デコード |
+| real/user mask (size>=36) | ✅ | `layer.mask["real"]` (v0.6.0 でオフセット 1 byte ずれを修正) |
+| density / feather | ✅ | `layer.mask` の `user_density`/`user_feather`/`vector_density`/`vector_feather` (v0.6.0) |
 | ベクタマスク / パス (`vmsk`/`vsms`) | ❌ | 未対応 |
 | ブレンディングレンジ ("Blend If") | ✅ | `layer.blending_ranges` (raw 32bit packed) |
 
@@ -118,9 +118,9 @@ Photoshop の汎用ディスクリプタで格納されるブロックを dict
 |---|:---:|---|
 | 調整レイヤの種別判定 | ✅ | `layer_type == ADJUST` |
 | 調整レイヤのパラメータ (levels/curves 等, binary) | ❌ | 未デコード。descriptor 形式のもの (`CgEd` 等) は `descriptor()` で取得可 |
-| スマートオブジェクト変換 (`SoLd`/`PlLd`) | 🟡 | `descriptor()` で試行可 (未検証、既定 skip 要調整) |
+| スマートオブジェクト変換 (`SoLd`) | 🟡 | `descriptor("SoLd")` で取得可 (既定 skip=12 を設定済。実サンプル未検証) |
 | スマートオブジェクト埋め込みデータ抽出 (`lnkD`) | ❌ | 未対応 |
-| ベクタストローク/シェイプ (`vstk`/`vscg`) | 🟡 | `descriptor()` 経由で取得可 (未検証) |
+| ベクタストローク/シェイプ (`vstk`/`vscg`/`vogk`) | 🟡 | `descriptor()` 経由で取得可 (既定 skip 設定済、実サンプル未検証) |
 | ライブシェイプ情報 (origination) | ❌ | 未対応 |
 
 ---
@@ -135,22 +135,26 @@ Photoshop の汎用ディスクリプタで格納されるブロックを dict
 | スライス (1050 v7/v8, descriptor) | ❌ | 未格納 |
 | レイヤーカンプ (1065) | ✅ | `PSDFile.layer_comps` (v0.3.0) |
 | インデックスカラーパレット (色/count/透明index) | ✅ | `PSDFile.color_table` (v0.3.0) |
-| ICC プロファイル (1039) | 📦 | 生バイト保持のみ・未公開 |
-| EXIF (1058/1059) | 📦 | 同上 |
-| XMP メタデータ (1060) | 📦 | 同上 |
-| サムネイル (1033/1036) | 📦 | 同上 |
-| バージョン情報 / アルファチャンネル名 / その他 | 📦 | 同上 |
-| Global layer mask info | 📦 | 構造体フィールドは未充填、生バイトのみ |
+| ICC プロファイル (1039) | ✅ | `PSDFile.icc_profile` (生バイト, v0.5.0) |
+| EXIF (1058) | ✅ | `PSDFile.exif` (生バイト, v0.5.0) |
+| XMP メタデータ (1060) | ✅ | `PSDFile.xmp` (UTF-8 str, v0.5.0) |
+| サムネイル (1036/1033) | ✅ | `PSDFile.thumbnail` (JPEG bytes + 寸法, v0.5.0) |
+| 任意リソースの生バイト | ✅ | `PSDFile.image_resource(id)` / `image_resource_ids` (v0.5.0) |
+| 上記の内容デコード (EXIF タグ解析等) | ❌ | 生バイトを返すのみ。解析は利用側 (Pillow 等) で |
+| バージョン情報 / アルファチャンネル名 / その他 | 📦→✅ | `image_resource(id)` で生バイト取得可 |
+| Global layer mask info | ✅ | `PSDFile.global_layer_mask` (overlay 色/opacity/kind, v0.6.0) |
 
 ---
 
 ## まとめ (一言で)
 
-- **得意**: レイヤ列挙 + 属性 + 階層、RGB/CMYK/Gray/Indexed のピクセル取得、
-  テキストのラン単位スタイル、レイヤー効果/塗りの descriptor、主要な文書
-  メタデータ (ガイド/スライス/カンプ)、そして **byte-identical なラウンドトリップ**。
-- **未対応/限定的**: Lab/Duotone/Multichannel ピクセル、調整レイヤの数値
-  パラメータ、ベクタパス、スマートオブジェクト実体、効果込みの再合成、
-  そして編集して保存。
-- 生バイトは全ブロックが保持されているので、📦 の項目は「公開するだけ」で
-  対応できるものが多い (ROADMAP 参照)。
+- **得意**: レイヤ列挙 + 属性 + 階層 + 色ラベル、RGB/CMYK/Gray/Indexed/Lab/Duotone
+  のピクセル取得、テキストのラン単位スタイル、マスクの density/feather、レイヤー
+  効果/塗りの descriptor、文書メタデータ (ガイド/スライス/カンプ/global layer
+  mask) と image resource の生バイト (ICC/EXIF/XMP/サムネイル)、そして
+  **byte-identical なラウンドトリップ**。
+- **未対応/限定的**: Multichannel ピクセル、調整レイヤの数値パラメータ、ベクタ
+  パス、スマートオブジェクト実体 (`lnkD`)、効果込みの再合成、そして編集して保存。
+- Lab は標準 D65 CIELAB→sRGB 近似 (Photoshop の D50 とは彩度の高い色でわずかに差)。
+- image resource の**中身の解釈** (EXIF タグ, サムネイル描画等) は行わず生バイトを
+  返すのみ。

{psdparse-0.4.0 → psdparse-0.6.0}/psdparse/psddata.h

@@ -277,18 +277,30 @@ namespace psd {
 	};
 	
 	struct GlobalLayerMaskInfo {
-		int overlayColorSpace;
-		int color1;
-		int color2;
-		int color3;
-		int color4;
-		int opacity;
-		int kind;
+		bool present = false;  // 空でない global layer mask info ブロックがあったか
+		int overlayColorSpace = 0;
+		int color1 = 0;
+		int color2 = 0;
+		int color3 = 0;
+		int color4 = 0;
+		int opacity = 0;
+		int kind = 0;
 	};
 
 	struct LayerMask {
     bool present = false;  // マスクブロック (size>0) が存在したか
-    bool hasReal = false;  // real/user mask (size>20) を含むか
+    bool hasReal = false;  // real/user mask (size>=36) を含むか
+    // マスクパラメータ (density/feather)。 flags bit4 (parameters_applied) が
+    // 立っているとき本体が続く。density は 0..255 (-1=不在)、feather は double。
+    bool hasParameters = false;   // パラメータブロックが実在したか
+    int  paramFlags = 0;          // パラメータ有無ビット (bit0:userDensity /
+                                  // bit1:userFeather / bit2:vecDensity / bit3:vecFeather)
+    int  userMaskDensity = -1;    // ユーザーマスク濃度 0..255 (-1=不在)
+    double userMaskFeather = 0.0; // ユーザーマスクぼかし (px)
+    bool hasUserFeather = false;
+    int  vectorMaskDensity = -1;  // ベクタマスク濃度 0..255 (-1=不在)
+    double vectorMaskFeather = 0.0;
+    bool hasVectorFeather = false;
     int width;
     int height;
 		int top;

{psdparse-0.4.0 → psdparse-0.6.0}/psdparse/psdimage.cpp

@@ -1,6 +1,7 @@
 
 #include "psdfile.h"
 #include <cstring>
+#include <cmath>
 
 #define USE_ZLIB
 #ifdef USE_ZLIB
@@ -402,6 +403,84 @@ namespace psd {
     }
   }
 
+  // CIELAB(D65) を sRGB 8bit へ変換する。 L∈[0,100], a,b∈[-128,127]。
+  // Photoshop の Lab とは参照白(D50)やレンダリング intent が厳密には異なるため
+  // 近似だが、従来 Lab は完全に未対応 (全ゼロ出力) だったのを実用値に置き換える。
+  inline void labToRgb8(double L, double a, double b,
+                        uint8_t &R, uint8_t &G, uint8_t &B)
+  {
+    double fy = (L + 16.0) / 116.0;
+    double fx = fy + a / 500.0;
+    double fz = fy - b / 200.0;
+    auto finv = [](double t) {
+      double t3 = t * t * t;
+      return (t3 > 0.008856) ? t3 : (t - 16.0 / 116.0) / 7.787;
+    };
+    // D65 reference white
+    double X = 0.95047 * finv(fx);
+    double Y = 1.00000 * finv(fy);
+    double Z = 1.08883 * finv(fz);
+    // XYZ -> linear sRGB
+    double rl =  3.2406 * X - 1.5372 * Y - 0.4986 * Z;
+    double gl = -0.9689 * X + 1.8758 * Y + 0.0415 * Z;
+    double bl =  0.0557 * X - 0.2040 * Y + 1.0570 * Z;
+    auto gamma = [](double c) {
+      c = (c <= 0.0031308) ? (12.92 * c) : (1.055 * std::pow(c, 1.0 / 2.4) - 0.055);
+      return (c < 0.0) ? 0.0 : (c > 1.0 ? 1.0 : c);
+    };
+    R = (uint8_t)(gamma(rl) * 255.0 + 0.5);
+    G = (uint8_t)(gamma(gl) * 255.0 + 0.5);
+    B = (uint8_t)(gamma(bl) * 255.0 + 0.5);
+  }
+
+  // Lab チャネルを統合し pitch byte 単位で merged にフィルする。
+  // 8bit: L=0..255→0..100, a/b=0..255→-128..127。 16bit は上位バイト近似。
+  // 32bit Lab は Photoshop に存在しないため非対応。
+  template <typename T>
+  void mergeChannelsLab(void *merged, int width, int height,
+                        std::vector<int> &ids,
+                        std::vector<uint8_t*> &decodedChannels,
+                        const ColorFormat &format, int bufPitchByte)
+  {
+    T *chL = 0, *chA = 0, *chB = 0, *chAlpha = 0;
+    for (uint32_t i = 0; i < ids.size(); i++) {
+      switch (ids[i]) {
+      case CH_ID_TRANSP: chAlpha = (T*)decodedChannels[i]; break;
+      case 0:            chL     = (T*)decodedChannels[i]; break;  // L
+      case 1:            chA     = (T*)decodedChannels[i]; break;  // a
+      case 2:            chB     = (T*)decodedChannels[i]; break;  // b
+      default: break;
+      }
+    }
+    if (!chL || !chA || !chB) return;
+
+    // T の 1 サンプルを 0..255 相当へ正規化するスケール。
+    const double norm = (sizeof(T) == 1) ? 1.0 : (255.0 / 65535.0);
+
+    int pitchPixel = std::abs(bufPitchByte) / 4;
+    int linePixel  = std::min(width, pitchPixel);
+    for (int y = 0; y < height; y++) {
+      uint32_t *pix = (uint32_t *)((uint8_t *)merged + bufPitchByte * y);
+      T *lp = chL + width * y;
+      T *ap = chA + width * y;
+      T *bp = chB + width * y;
+      T *alp = chAlpha ? chAlpha + width * y : 0;
+      for (int x = 0; x < linePixel; x++) {
+        double Lv = ((double)(*lp++) * norm) / 255.0 * 100.0;
+        double av = ((double)(*ap++) * norm) - 128.0;
+        double bv = ((double)(*bp++) * norm) - 128.0;
+        uint8_t R, G, B;
+        labToRgb8(Lv, av, bv, R, G, B);
+        if (alp) {
+          uint8_t A = (uint8_t)((double)(*alp++) * norm);
+          *pix++ = rgbaCompoToRgba32<uint8_t>(format, R, G, B, A);
+        } else {
+          *pix++ = rgbaCompoToRgba32<uint8_t>(format, R, G, B);
+        }
+      }
+    }
+  }
+
   // アルファチャネルにマスクチャネルをマージ
   template <typename T>
   void
@@ -878,6 +957,7 @@ namespace psd {
                           decodedChannels[0], format, bufPitchByte);
       break;
     case COLOR_MODE_GRAYSCALE:
+    case COLOR_MODE_DUOTONE:   // Duotone は grayscale として格納される (Adobe 仕様)
       switch (header.depth) {
       case 8:
         mergeChannelsGray<uint8_t>(buf, imageWidth, imageHeight, channelIds,
@@ -935,10 +1015,22 @@ namespace psd {
         break;
       }
       break;
-    case COLOR_MODE_MULTICHANNEL:
-    case COLOR_MODE_DUOTONE:
     case COLOR_MODE_LAB:
-      // unsuported yet
+      switch (header.depth) {
+      case 8:
+        mergeChannelsLab<uint8_t>(buf, imageWidth, imageHeight, channelIds,
+                                  decodedChannels, format, bufPitchByte);
+        break;
+      case 16:
+        mergeChannelsLab<uint16_t>(buf, imageWidth, imageHeight, channelIds,
+                                   decodedChannels, format, bufPitchByte);
+        break;
+      default:  // 32bit Lab は存在しない
+        break;
+      }
+      break;
+    case COLOR_MODE_MULTICHANNEL:
+      // 任意スポットチャネル群で RGB への正準的な変換が無いため未対応
       break;
     default:
       break;
@@ -1052,6 +1144,7 @@ namespace psd {
                           decodedChannels[0], format, bufPitchByte);
       break;
     case COLOR_MODE_GRAYSCALE:
+    case COLOR_MODE_DUOTONE:   // Duotone は grayscale として格納される (Adobe 仕様)
       switch (header.depth) {
       case 8:
         mergeChannelsGray<uint8_t>(buf, imageWidth, imageHeight, channelIds,
@@ -1112,10 +1205,22 @@ namespace psd {
         break;
       }
       break;
-    case COLOR_MODE_MULTICHANNEL:
-    case COLOR_MODE_DUOTONE:
     case COLOR_MODE_LAB:
-      // unsuported yet
+      switch (header.depth) {
+      case 8:
+        mergeChannelsLab<uint8_t>(buf, imageWidth, imageHeight, channelIds,
+                                  decodedChannels, format, bufPitchByte);
+        break;
+      case 16:
+        mergeChannelsLab<uint16_t>(buf, imageWidth, imageHeight, channelIds,
+                                   decodedChannels, format, bufPitchByte);
+        break;
+      default:  // 32bit Lab は存在しない
+        break;
+      }
+      break;
+    case COLOR_MODE_MULTICHANNEL:
+      // 任意スポットチャネル群で RGB への正準的な変換が無いため未対応
       break;
     default:
       break;

{psdparse-0.4.0 → psdparse-0.6.0}/psdparse/psdparse.cpp

@@ -443,17 +443,17 @@ void parseImageResources(IteratorBase &outer, Data &data) {
 }
 
 void parseLayerMask(IteratorBase &r, LayerMask &m, int size) {
-  if (size <= 0) { std::memset(&m, 0, sizeof(LayerMask)); return; }
+  if (size <= 0) { m = LayerMask(); return; }
+  // Field order matches psd-tools' MaskData._read_body (the Adobe spec is
+  // wrong here): rect, defaultColor, flags, [real section if size>=36],
+  // [parameters if flags bit4]. There is NO filler byte after flags.
   m.top    = r.getInt32(true);
   m.left   = r.getInt32(true);
   m.bottom = r.getInt32(true);
   m.right  = r.getInt32(true);
   m.defaultColor = r.getCh();
   m.flags        = r.getCh();
-  // The spec says one filler byte here on size==20.  At size>20 the next byte
-  // is realFlags; the original grammar consumed a byte before realFlags too.
-  (void)r.getCh();
-  if (size > 20) {
+  if (size >= 36) {
     m.hasReal                = true;
     m.realFlags              = r.getCh();
     m.realUserMaskBackground = r.getCh();
@@ -462,6 +462,20 @@ void parseLayerMask(IteratorBase &r, LayerMask &m, int size) {
     m.enclosingBottom        = r.getInt32(true);
     m.enclosingRight         = r.getInt32(true);
   }
+  if (m.flags & 0x10) {  // parameters_applied
+    m.hasParameters = true;
+    m.paramFlags    = r.getCh();
+    if (m.paramFlags & 0x01) m.userMaskDensity = r.getCh();
+    if (m.paramFlags & 0x02) {
+      pun64 v; v.i = (uint64_t)r.getInt64(true);
+      m.userMaskFeather = v.f; m.hasUserFeather = true;
+    }
+    if (m.paramFlags & 0x04) m.vectorMaskDensity = r.getCh();
+    if (m.paramFlags & 0x08) {
+      pun64 v; v.i = (uint64_t)r.getInt64(true);
+      m.vectorMaskFeather = v.f; m.hasVectorFeather = true;
+    }
+  }
   m.width  = m.right  - m.left;
   m.height = m.bottom - m.top;
   m.present = true;
@@ -580,6 +594,7 @@ void parseGlobalLayerMaskInfo(IteratorBase &r, GlobalLayerMaskInfo &g) {
   g.color4 = r.getInt16(true);
   g.opacity = r.getInt16(true);
   g.kind    = r.getCh();
+  g.present = true;
   // trailing filler bytes are ignored
 }
 

{psdparse-0.4.0 → psdparse-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "psdparse"
-version = "0.4.0"
+version = "0.6.0"
 description = "Fast PSD (Photoshop) reader/writer — C++17 core with pybind11 bindings"
 readme = "README.md"
 requires-python = ">=3.9"

{psdparse-0.4.0 → psdparse-0.6.0}/python/psdparse_module.cpp

@@ -93,8 +93,17 @@ py::object layerMask(const psd::LayerInfo &l) {
   d["disabled"]   = (bool)(m.flags & 2);  // mask disabled
   d["inverted"]   = (bool)(m.flags & 4);  // invert (obsolete)
   d["from_render"] = (bool)(m.flags & 8); // mask from rendering other data
-  d["has_parameters"] = (bool)(m.flags & 16); // density/feather present (not decoded yet)
-  if (m.hasReal) {                         // real/user mask (block size > 20)
+  d["has_parameters"] = (bool)(m.flags & 16); // density/feather block present
+  // マスクパラメータ (density 0..255 / feather px)。 未指定フィールドは None。
+  d["user_density"]   = (m.userMaskDensity >= 0) ? py::object(py::cast(m.userMaskDensity))
+                                                 : py::object(py::none());
+  d["user_feather"]   = m.hasUserFeather   ? py::object(py::cast(m.userMaskFeather))
+                                           : py::object(py::none());
+  d["vector_density"] = (m.vectorMaskDensity >= 0) ? py::object(py::cast(m.vectorMaskDensity))
+                                                   : py::object(py::none());
+  d["vector_feather"] = m.hasVectorFeather ? py::object(py::cast(m.vectorMaskFeather))
+                                           : py::object(py::none());
+  if (m.hasReal) {                         // real/user mask (block size >= 36)
     py::dict rd;
     rd["flags"]      = m.realFlags;
     rd["background"] = m.realUserMaskBackground;
@@ -123,6 +132,30 @@ py::object layerBlendingRanges(const psd::LayerInfo &l) {
   return std::move(d);
 }
 
+// Sheet (layer-panel) color label from the 'lclr' block: 2-byte index + 6
+// padding bytes. Returns {"index", "name"} or None when the layer has no
+// label (index 0 / "none" is still reported so callers can distinguish
+// "explicitly none" from "no lclr block"). Names match Photoshop's order.
+py::object layerSheetColor(const psd::LayerInfo &l) {
+  static const char *kNames[] = {
+    "none", "red", "orange", "yellow", "green", "blue", "violet", "gray",
+    "seafoam", "indigo", "magenta", "fuschia",
+  };
+  for (const auto &a : l.extraData.additionalLayers) {
+    if (a.key != 'lclr' || !a.data) continue;
+    psd::IteratorBase *rd = a.data->clone();
+    rd->init();
+    int idx = (uint16_t)rd->getInt16(true);
+    delete rd;
+    py::dict d;
+    d["index"] = idx;
+    d["name"]  = (idx >= 0 && idx < (int)(sizeof(kNames) / sizeof(kNames[0])))
+                 ? kNames[idx] : "unknown";
+    return std::move(d);
+  }
+  return py::none();
+}
+
 // Grid & guides image resource (1032) as a dict, or None when the PSD has none.
 py::object psdGuides(psd::PSDFile &self) {
   const psd::GridGuideResource &g = self.gridGuide;
@@ -213,6 +246,19 @@ py::object psdColorTable(psd::PSDFile &self) {
   return std::move(d);
 }
 
+// Global layer mask info (the document-level overlay color used to display
+// masks) as a dict, or None when the block is empty/absent.
+py::object psdGlobalLayerMask(psd::PSDFile &self) {
+  const psd::GlobalLayerMaskInfo &g = self.globalLayerMaskInfo;
+  if (!g.present) return py::none();
+  py::dict d;
+  d["overlay_color_space"] = g.overlayColorSpace;
+  d["color"]   = py::make_tuple(g.color1, g.color2, g.color3, g.color4);
+  d["opacity"] = g.opacity;   // 0..100
+  d["kind"]    = g.kind;      // 0=inverted / 1=all-masks / 128=per-layer
+  return std::move(d);
+}
+
 // -------------------------------------------------------------------------
 // Generic Descriptor -> Python bridge (Tier 2).
 //
@@ -338,14 +384,94 @@ py::object layerDescriptor(const psd::LayerInfo &l, const std::string &keyStr, i
             ((int)(uint8_t)keyStr[2] << 8)  |  (int)(uint8_t)keyStr[3];
   if (skip < 0) {
     switch (key) {
-    case 'lfx2':                             skip = 8; break;
-    case 'SoCo': case 'GdFl': case 'PtFl':   skip = 4; break;
-    default:                                 skip = 0; break;
+    case 'lfx2':                             skip = 8;  break;  // objVer + descVer
+    case 'SoCo': case 'GdFl': case 'PtFl':   skip = 4;  break;  // descVer
+    case 'SoLd': case 'SoLE':                skip = 12; break;  // 'soLD' + ver + descVer
+    case 'vstk': case 'CgEd':                skip = 4;  break;  // descVer
+    case 'vscg':                             skip = 8;  break;  // key + ver
+    case 'vogk':                             skip = 8;  break;  // ver + dataVer
+    default:                                 skip = 0;  break;
     }
   }
   return keyDescriptor(l, key, skip);
 }
 
+// -------------------------------------------------------------------------
+// Image resource raw-bytes access.
+//
+// Most image resources are kept as raw bytes internally (imageResourceList)
+// but were never reachable from Python. These helpers expose them: a generic
+// by-ID accessor plus typed shortcuts for the common ones (ICC / EXIF / XMP /
+// thumbnail). Decoding (parsing EXIF tags, rendering the thumbnail) is left to
+// the caller with e.g. Pillow.
+// -------------------------------------------------------------------------
+
+std::string resourceBytes(const psd::ImageResourceInfo &res) {
+  std::string buf((size_t)(res.size > 0 ? res.size : 0), '\0');
+  if (res.size > 0 && res.data) {
+    psd::IteratorBase *rd = res.data->clone();
+    rd->init();                       // rewind to the start of this resource
+    rd->getData(&buf[0], res.size);
+    delete rd;
+  }
+  return buf;
+}
+
+const psd::ImageResourceInfo *findResource(const psd::PSDFile &self, int id) {
+  for (const auto &res : self.imageResourceList)
+    if (res.id == id) return &res;
+  return nullptr;
+}
+
+py::list imageResourceIds(psd::PSDFile &self) {
+  py::list out;
+  for (const auto &res : self.imageResourceList) out.append((int)res.id);
+  return out;
+}
+
+py::object imageResource(psd::PSDFile &self, int id) {
+  const psd::ImageResourceInfo *res = findResource(self, id);
+  return res ? py::object(py::bytes(resourceBytes(*res))) : py::none();
+}
+
+py::object iccProfile(psd::PSDFile &self) { return imageResource(self, 1039); }
+py::object exifData(psd::PSDFile &self)   { return imageResource(self, 1058); }
+
+// XMP packet (resource 1060) is UTF-8 XML. Returned as str; use
+// image_resource(1060) for the raw bytes if the packet is not valid UTF-8.
+py::object xmpMetadata(psd::PSDFile &self) {
+  const psd::ImageResourceInfo *res = findResource(self, 1060);
+  if (!res) return py::none();
+  return py::str(resourceBytes(*res));
+}
+
+// Embedded thumbnail (resource 1036 = RGB / legacy 1033 = BGR). Header is 28
+// bytes; for format==1 the payload is a JFIF JPEG. Returns a dict with the
+// header fields and the raw payload, or None.
+py::object thumbnail(psd::PSDFile &self) {
+  const psd::ImageResourceInfo *res = findResource(self, 1036);
+  if (!res) res = findResource(self, 1033);
+  if (!res) return py::none();
+  std::string raw = resourceBytes(*res);
+  if (raw.size() < 28) return py::none();
+  auto be32 = [&](size_t o) {
+    return (uint32_t)(((uint8_t)raw[o] << 24) | ((uint8_t)raw[o+1] << 16) |
+                      ((uint8_t)raw[o+2] << 8) | (uint8_t)raw[o+3]);
+  };
+  auto be16 = [&](size_t o) {
+    return (uint16_t)(((uint8_t)raw[o] << 8) | (uint8_t)raw[o+1]);
+  };
+  py::dict d;
+  uint32_t fmt = be32(0);
+  d["format"]      = (fmt == 1) ? "jpeg" : "raw";
+  d["width"]       = be32(4);
+  d["height"]      = be32(8);
+  d["bits"]        = be16(24);
+  d["resource_id"] = (int)res->id;   // 1036 = RGB order, 1033 = BGR order
+  d["data"]        = py::bytes(raw.data() + 28, raw.size() - 28);
+  return std::move(d);
+}
+
 py::bytes layerImage(psd::PSDFile &self, int index, const std::string &mode) {
   if (!self.isLoaded) throw std::runtime_error("PSD not loaded");
   if (index < 0 || index >= (int)self.layerList.size())
@@ -461,6 +587,9 @@ PYBIND11_MODULE(psdparse, m) {
     .def_property_readonly("fill", &layerFill,
         "Fill-layer content as {'type': 'solid'|'gradient'|'pattern', "
         "'data': {...}} from SoCo/GdFl/PtFl, or None.")
+    .def_property_readonly("sheet_color", &layerSheetColor,
+        "Layer-panel color label ('lclr') as {'index', 'name'} (0/'none' .. "
+        "11/'fuschia'), or None when the layer carries no lclr block.")
     .def_property_readonly("info_keys", &layerInfoKeys,
         "List of the 4cc keys of every additional-layer-info block present.")
     .def("descriptor", &layerDescriptor,
@@ -537,7 +666,25 @@ PYBIND11_MODULE(psdparse, m) {
          "(id, name, comment, record_*). Empty list when there are none.")
     .def_property_readonly("color_table", &psdColorTable,
          "Indexed-color palette as a dict (colors[], valid_count, "
-         "transparency_index), or None for non-indexed PSDs.");
+         "transparency_index), or None for non-indexed PSDs.")
+    .def_property_readonly("global_layer_mask", &psdGlobalLayerMask,
+         "Global layer mask info as a dict (overlay_color_space, color, "
+         "opacity, kind), or None when the block is empty/absent.")
+    .def_property_readonly("image_resource_ids", &imageResourceIds,
+         "List of the integer IDs of every image resource present.")
+    .def("image_resource", &imageResource, py::arg("id"),
+         "Raw bytes of the image resource with the given integer ID, or None.")
+    .def_property_readonly("icc_profile", &iccProfile,
+         "ICC profile (resource 1039) as raw bytes, or None.")
+    .def_property_readonly("exif", &exifData,
+         "EXIF block (resource 1058) as raw bytes, or None.")
+    .def_property_readonly("xmp", &xmpMetadata,
+         "XMP metadata (resource 1060) as a UTF-8 str, or None. Use "
+         "image_resource(1060) for raw bytes if not valid UTF-8.")
+    .def_property_readonly("thumbnail", &thumbnail,
+         "Embedded thumbnail (resource 1036/1033) as a dict "
+         "(format, width, height, bits, resource_id, data), or None. "
+         "For format=='jpeg', data is JFIF JPEG bytes.");
 
   // Enum-like ints exposed as module attributes for convenience
   m.attr("LAYER_TYPE_NORMAL") = (int)psd::LAYER_TYPE_NORMAL;

{psdparse-0.4.0 → psdparse-0.6.0}/tests/conftest.py

@@ -70,6 +70,31 @@ def sample_mask_psd():
     return _find_sample("masktest.psd")
 
 
+@pytest.fixture(scope="session")
+def sample_maskparams_psd():
+    """A PSD whose layer mask carries a real/user mask section plus mask
+    parameters (density + feather) and an lclr color label (synthesized)."""
+    return _find_sample("maskparams.psd")
+
+
+@pytest.fixture(scope="session")
+def sample_lab_psd():
+    """A Lab-mode PSD with known swatches (synthesized)."""
+    return _find_sample("labsample.psd")
+
+
+@pytest.fixture(scope="session")
+def sample_gray_psd():
+    """A grayscale PSD (synthesized)."""
+    return _find_sample("graysample.psd")
+
+
+@pytest.fixture(scope="session")
+def sample_duo_psd():
+    """The grayscale PSD with its color mode flipped to Duotone (synthesized)."""
+    return _find_sample("duosample.psd")
+
+
 @pytest.fixture
 def psd_ui(sample_ui_psd):
     p = psdparse.PSDFile()
@@ -98,6 +123,34 @@ def psd_mask(sample_mask_psd):
     return p
 
 
+@pytest.fixture
+def psd_maskparams(sample_maskparams_psd):
+    p = psdparse.PSDFile()
+    assert p.load(str(sample_maskparams_psd))
+    return p
+
+
+@pytest.fixture
+def psd_lab(sample_lab_psd):
+    p = psdparse.PSDFile()
+    assert p.load(str(sample_lab_psd))
+    return p
+
+
+@pytest.fixture
+def psd_gray(sample_gray_psd):
+    p = psdparse.PSDFile()
+    assert p.load(str(sample_gray_psd))
+    return p
+
+
+@pytest.fixture
+def psd_duo(sample_duo_psd):
+    p = psdparse.PSDFile()
+    assert p.load(str(sample_duo_psd))
+    return p
+
+
 @pytest.fixture
 def psd_large(sample_large_psd):
     p = psdparse.PSDFile()

psdparse-0.6.0/tests/test_colormodes.py

@@ -0,0 +1,49 @@
+"""Tests for the 0.6.0 color-mode additions in getMergedImage / getLayerImage:
+
+- Lab (mode 9) -> sRGB via a standard D65 CIELAB conversion,
+- Duotone (mode 8) rendered as grayscale (Adobe stores duotone data as gray).
+
+labsample.psd was built from known RGB swatches [white, black, red, green]
+converted to Lab. Neutral swatches (white/black) round-trip exactly regardless
+of reference white; red is near-exact. Green diverges because the ICC Lab
+encoding of a saturated primary is reference-white dependent, so it is not
+asserted tightly here.
+"""
+import psdparse
+
+
+def _rgb_pixels(psd, n):
+    """First n pixels of the merged image as (R, G, B) tuples (from BGRA)."""
+    data = psd.merged_image()
+    return [(data[i * 4 + 2], data[i * 4 + 1], data[i * 4 + 0]) for i in range(n)]
+
+
+def test_lab_mode_is_lab(psd_lab):
+    assert psd_lab.header.mode == psdparse.COLOR_MODE_LAB
+
+
+def test_lab_neutrals_exact(psd_lab):
+    px = _rgb_pixels(psd_lab, 4)
+    # swatch 0 = white, swatch 1 = black -- reference-white independent.
+    assert px[0] == (255, 255, 255)
+    assert px[1] == (0, 0, 0)
+
+
+def test_lab_red_near(psd_lab):
+    px = _rgb_pixels(psd_lab, 4)
+    r, g, b = px[2]
+    assert r > 240 and g < 15 and b < 15  # essentially pure red
+
+
+def test_lab_not_blank(psd_lab):
+    # Regression: Lab used to render an all-zero buffer.
+    assert any(psd_lab.merged_image())
+
+
+def test_duotone_renders_as_grayscale(psd_duo, psd_gray):
+    assert psd_duo.header.mode == psdparse.COLOR_MODE_DUOTONE
+    assert psd_gray.header.mode == psdparse.COLOR_MODE_GRAYSCALE
+    duo = psd_duo.merged_image()
+    gray = psd_gray.merged_image()
+    assert any(duo)          # not blank
+    assert duo == gray       # duotone data is grayscale

{psdparse-0.4.0 → psdparse-0.6.0}/tests/test_descriptors.py

@@ -88,6 +88,14 @@ def test_descriptor_bad_key_raises(psd_group):
         psd_group.layers[0].descriptor("ab")
 
 
+def test_descriptor_absent_key_none(psd_group):
+    # A well-formed but absent 4cc key returns None (no exception). The
+    # smart-object / vector keys now carry known default skips so callers can
+    # omit `skip`; here we just confirm the absent-key path is clean.
+    for key in ("SoLd", "vstk", "vscg", "vogk", "CgEd"):
+        assert psd_group.layers[0].descriptor(key) is None
+
+
 def test_info_keys_are_4cc(psd_group):
     for l in psd_group.layers:
         keys = l.info_keys

psdparse-0.6.0/tests/test_mask_extras.py

@@ -0,0 +1,61 @@
+"""Tests for the 0.6.0 mask/label extras:
+
+- layer mask density/feather parameters and the (fixed) real-mask section,
+- the 'lclr' layer-panel color label (layer.sheet_color),
+- document-level global layer mask info.
+
+The maskparams.psd fixture was authored with psd-tools so the expected values
+(bbox, density=128, feather=2.5, real rect 0..16, lclr=5) are known exactly.
+"""
+import psdparse
+
+
+def test_mask_parameters(psd_maskparams):
+    m = psd_maskparams.layers[0].mask
+    assert m is not None
+    assert (m["top"], m["left"], m["bottom"], m["right"]) == (1, 2, 13, 14)
+    assert m["has_parameters"] is True
+    assert m["user_density"] == 128
+    assert abs(m["user_feather"] - 2.5) < 1e-9
+    # only user density/feather were authored; vector ones stay absent
+    assert m["vector_density"] is None
+    assert m["vector_feather"] is None
+
+
+def test_mask_real_section(psd_maskparams):
+    # Regression: the real/user-mask section used to be decoded one byte off.
+    m = psd_maskparams.layers[0].mask
+    real = m["real"]
+    assert real is not None
+    assert (real["top"], real["left"], real["bottom"], real["right"]) == (0, 0, 16, 16)
+    assert real["background"] == 0
+
+
+def test_plain_mask_has_no_parameters(psd_mask):
+    # masktest.psd carries a simple 20-byte mask: no params, no real section.
+    m = psd_mask.layers[0].mask
+    assert m is not None
+    assert m["has_parameters"] is False
+    assert m["user_density"] is None and m["user_feather"] is None
+    assert m["real"] is None
+
+
+def test_sheet_color(psd_maskparams):
+    sc = psd_maskparams.layers[0].sheet_color
+    assert sc == {"index": 5, "name": "blue"}
+
+
+def test_sheet_color_none_when_zero(psd_group):
+    # config.psd layers carry lclr = 0 (explicit "no color").
+    sc = psd_group.layers[0].sheet_color
+    assert sc is None or sc["index"] == 0
+
+
+def test_global_layer_mask_shape(psd_group):
+    # Most PSDs have an empty global layer mask block -> None. When present it
+    # is a dict with the documented keys.
+    g = psd_group.global_layer_mask
+    if g is None:
+        return
+    assert set(g) >= {"overlay_color_space", "color", "opacity", "kind"}
+    assert len(g["color"]) == 4

psdparse-0.6.0/tests/test_resources.py

@@ -0,0 +1,69 @@
+"""Tests for image-resource raw-bytes access (0.5.0):
+
+PSDFile.image_resource_ids / image_resource(id) and the typed shortcuts
+icc_profile / exif / xmp / thumbnail. EXIF and ICC bytes here were verified
+byte-identical against psd-tools 1.17.
+"""
+import psdparse
+import pytest
+
+
+def test_resource_ids_are_ints(psd_group):
+    ids = psd_group.image_resource_ids
+    assert isinstance(ids, list)
+    assert all(isinstance(i, int) for i in ids)
+    assert len(ids) > 0
+
+
+def test_generic_matches_typed(psd_group):
+    # image_resource(1058) is the same bytes as the exif shortcut.
+    assert psd_group.image_resource(1058) == psd_group.exif
+
+
+def test_absent_resource_is_none(psd_group):
+    # 9999 is not a real Photoshop resource id.
+    assert psd_group.image_resource(9999) is None
+
+
+def test_exif_present(psd_group):
+    exif = psd_group.exif
+    if exif is None:
+        pytest.skip("sample has no EXIF resource")
+    assert isinstance(exif, bytes) and len(exif) > 0
+
+
+def test_xmp_is_xml(psd_group):
+    xmp = psd_group.xmp
+    if xmp is None:
+        pytest.skip("sample has no XMP resource")
+    assert isinstance(xmp, str)
+    assert "xpacket" in xmp or "xmpmeta" in xmp
+
+
+def test_icc_profile(psd_text):
+    # fontsample.psd carries an ICC profile.
+    icc = psd_text.icc_profile
+    if icc is None:
+        pytest.skip("sample has no ICC profile")
+    assert isinstance(icc, bytes) and len(icc) > 0
+
+
+def test_thumbnail_header(psd_group):
+    th = psd_group.thumbnail
+    if th is None:
+        pytest.skip("sample has no thumbnail")
+    assert th["width"] > 0 and th["height"] > 0
+    assert th["format"] in ("jpeg", "raw")
+    assert isinstance(th["data"], bytes)
+    if th["format"] == "jpeg":
+        assert th["data"][:2] == b"\xff\xd8"  # JFIF/JPEG SOI marker
+
+
+def test_thumbnail_decodes(psd_group):
+    Image = pytest.importorskip("PIL.Image")
+    th = psd_group.thumbnail
+    if th is None or th["format"] != "jpeg":
+        pytest.skip("sample has no JPEG thumbnail")
+    import io
+    img = Image.open(io.BytesIO(th["data"]))
+    assert (img.width, img.height) == (th["width"], th["height"])