Legal and license information

Product identity

Publisher

Bug Factory Kft.

Application license

Microsoft Standard Application License Terms

Canonical domain

playertempo.bugfactory.hu

Distribution

Distributed exclusively through the Microsoft Store.

Partner Center name reservation is not a trademark clearance opinion. Product-name and legal review remain release responsibilities.

Application terms

Store distribution is intended to use the Microsoft Standard Application License Terms. The terms shown in the final Microsoft Store listing govern the distributed application.

Models and third-party work

The bundled MediaPipe-derived model files are documented under Apache-2.0 terms. Other components retain their own notices and obligations.

Brand mnemonic

TEMPO: Translates Every Mode into Player Output. This is a brand mnemonic, limited to documented head-pose inputs and supported outputs—not a universal compatibility claim.

Names and non-affiliation

FreeTrack, opentrack, TrackIR, and NPClient identify interoperability paths and interfaces. Their mention does not imply sponsorship, endorsement, affiliation, or trademark ownership.

Software status

The software can be incomplete, incompatible, or unstable. This website does not add warranty promises beyond the terms governing the distributed app.

Third-party notices

The repository notice content is reproduced below for review with this static build.

# Third-Party Notices

PlayerTempo bundles no third-party source code. This file records the attribution
obligations of components whose **published specifications, protocols, or algorithm
descriptions** were used to build clean-room / independent reimplementations, and of
any runtime packages or bundled model files we depend on. Bundled model files carry
their own notices under `models/`.

---

## opentrack — UDP protocol (ISC License)

The Game-mode "opentrack bridge" (`HeadGazeCalib.Core.Output.OpentrackUdpSender`) speaks
opentrack's documented **"UDP over network"** input protocol: one datagram of six
native-endian IEEE-754 doubles `[x, y, z, yaw, pitch, roll]` (translation in cm, rotation
in degrees), sent by default to `127.0.0.1:4242`.

This is a **clean-room implementation from the public protocol description** — no opentrack
source code was copied. In particular, **no code** was taken from opentrack's
`npclient.c` or `freetrackclient.c` (which carry NaturalPoint copyright material / a GPL
lineage and are treated as legally out of bounds by our license review).

opentrack itself is distributed under the **ISC License**:

> Copyright (c) the opentrack contributors.
>
> Permission to use, copy, modify, and/or distribute this software for any purpose with or
> without fee is hereby granted, provided that the above copyright notice and this
> permission notice appear in all copies.
>
> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
> THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
> EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
> DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
> AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
> CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Project: https://github.com/opentrack/opentrack ·
Licensing: https://raw.githubusercontent.com/opentrack/opentrack/master/OPENTRACK-LICENSING.txt

## FreeTrack — native shared-memory sender (spec only, CLEAN-ROOM)

The native FreeTrack 2.0 sender (`src/HeadGazeCalib.Core/Output/FreetrackMmfSender.cs`) writes
the `FTHeap` struct into the shared-memory block named `FT_SharedMem`, guarded by the mutex
`FT_Mutext`, so FreeTrack/TrackIR-protocol games read our head pose directly with **no external
opentrack process**. It is implemented **clean-room from the public FreeTrack 2.0 specification
text only** (https://facetracknoir.sourceforge.net/Protocols/FreeTrack.htm and the mirrored
opentrack protocol docs). **No FreeTrack or opentrack source code was consulted or copied** — in
particular nothing from opentrack's `freetrackclient.c` (a GPL-lineage translation of the FreeTrack
Delphi source) or `npclient.c` (carries NaturalPoint copyright material). The struct layout, field
units (rotation in radians, translation in millimetres — our internal cm×10), the yaw-sign
convention (spec "positive yaw to the left" ⇒ opentrack yaw negated), the per-frame `DataID`
increment, and the `GameID`/`GameID2` handshake are all taken from the published specification.

### NPClient shim DLLs — NOT authored or bundled by us

FreeTrack/TrackIR games load `NPClient.dll` / `NPClient64.dll` (the TrackIR API shim) whose path is
read from `HKCU\Software\NaturalPoint\NATURALPOINT\NPClient Location\Path`. **We do not author,
bundle, or redistribute these DLLs.** The TrackIR API shim is the legally-gated piece
(NaturalPoint copyright / GPL-lineage translations exist in the wild and are out of bounds).

- **Dev-phase behaviour (this build):** on a developer's own machine we auto-detect an existing
  shim already present in a folder the machine already references (the current NPClient Location
  path — e.g. Beam Eye Tracker's bundled opentrack modules — or a standard opentrack install) and
  copy those two DLLs into our `npclient\` folder, recording the source path and each DLL's SHA-256
  as provenance in the session log. This copies the **user's own** already-installed files; it does
  not redistribute them.
- **Commercial build (planned):** the shipping commercial build will bundle an **officially
  licensed shim obtained via the NaturalPoint / TrackIR SDK** (trackir.com/developers) instead of
  copying any pre-existing DLL. This dev-phase copy-assist is a convenience, not the shipping story.

The NPClient Location registry value is **saved and restored**: we point it at our shim folder only
while the freetrack-direct sender runs and put the user's previous value (e.g. their Beam entry)
back on stop/dispose.

---

## opentrack — Accela filter (ISC License)

The velocity-adaptive gain stage in
`src/HeadGazeCalib.Core/Filtering/AccelaFilter2D.cs` is an **independent
reimplementation, adapted to 2-D pixel space**, of the algorithm behind
opentrack's `filter_accela` (a response curve mapping the current tracking
error to an allowed catch-up speed, integrated per frame for
framerate-independent behaviour). It was written from the published algorithm
description (opentrack wiki / DeepWiki), not copied line-by-line, and uses a
single shared curve per axis rather than opentrack's separate rotation /
translation curves. The upstream `filter_accela` component is distributed under
the ISC License, reproduced below and satisfied by this attribution.

- Project: opentrack — <https://github.com/opentrack/opentrack>
- Component: `filter_accela`
- Reference: <https://github.com/opentrack/opentrack/wiki/Accela-in-opentrack-2.3>,
  <https://deepwiki.com/opentrack/opentrack/5.1-accela-filter>

```
ISC License

Copyright (c) opentrack contributors

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
```

---

## opentrack — Natural Movement filter (ISC License)

The Natural response path in
`src/HeadGazeCalib.Core/Filtering/NaturalRotationFilter.cs` is an independent
C# adaptation informed by opentrack's Natural Movement filter source. The
implementation here uses its own shortest-arc quaternion math, timing model,
and bounded cadence predictor; it is not a line-by-line copy. The upstream
component is ISC-licensed and carries this attribution:

```
Copyright (c) 2023 Tom Brazier

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
```

- Project: opentrack — <https://github.com/opentrack/opentrack>
- Component: Natural Movement filter

---

## 3D-Kino / Habr — Holt double-exponential prediction recipe (Unlicense / public domain)

The latency-compensating predictor in
`src/HeadGazeCalib.Core/Filtering/HoltPredictor2D.cs` (Holt level+trend
smoothing with jump threshold, velocity cap, velocity-buffer outlier rejection,
and a dynamically measured latency horizon) is reimplemented from the
public-domain 3D-Kino / Habr recipe. The source is released under the Unlicense
(public domain dedication); no attribution is legally required, but it is
recorded here for provenance.

- Article: <https://habr.com/ru/articles/1027980/>
- Reference implementation: <https://github.com/ShyDamn/3D-Kino> (Unlicense)

---

## eViacam — pixel dead-zone behaviour (behaviour reference only)

The pixel dead zone in `src/HeadGazeCalib.Core/Filtering/PixelDeadZone.cs`
follows the *behaviour* described by eViacam's options documentation (a
pixel-unit movement threshold that lets the user easily stop the cursor). No
eViacam source code was used or consulted — eViacam is GPL-licensed and is a
behaviour reference only.

- Reference: <https://eviacam.crea-si.com/help/en/options.htm>

---

## EyeTrax (MIT)

- Project: EyeTrax — https://github.com/ck-zhang/eyetrax
- License: MIT
- What was adopted: the *algorithms only*, re-implemented independently in C#
  (`netstandard2.0`). **No EyeTrax source code, binaries, or package dependency
  is used or distributed.** In particular the EyeTrax PyPI package's `pyvirtualcam`
  dependency (GPLv2) is NOT a dependency of this project — only license-clean
  algorithmic recipes were ported.
  - Lissajous smooth-pursuit calibration
    (`src/HeadGazeCalib.Core/Calibration/PursuitCalibration.cs`)
  - Adaptive eye-aspect-ratio (EAR) blink gating
    (`src/HeadGazeCalib.Core/Features/EyeAspectRatio.cs`)
  - Eye-corner orthonormal feature normalization with inter-corner-distance
    scaling (`src/HeadGazeCalib.Core/Features/EyeFrameNormalizer.cs`)
  - Gaussian-KDE mode-seeking fixation stabilizer
    (`src/HeadGazeCalib.Core/Filtering/KdeFixationStabilizer.cs`)

MIT License (EyeTrax), reproduced for attribution:

```
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

The EAR ratio itself is from Soukupová & Čech, "Real-Time Eye Blink Detection
using Facial Landmarks" (2016); the 1€ filter is Casiez, Roussel & Vogel
(CHI 2012). Both are used as published algorithms.

---

PlayerTempo redistributes the third-party model assets listed below. This file records their
attribution and license obligations. Source-code dependencies are declared in the respective
`.csproj` files and carry their own package licenses.

## Google MediaPipe models (Apache License 2.0)

Copyright 2020–2023 The MediaPipe Authors.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use these files except
in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is
distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing permissions and limitations under the
License. The full license text is committed at `models/LICENSE`.

Redistributed model files (all Apache-2.0, trained on Google's own first-party data — see the
MediaPipe model cards):

| File | Description | Provenance |
|------|-------------|------------|
| `models/blazeface_short_range.tflite` | BlazeFace short-range face detector | `https://storage.googleapis.com/mediapipe-assets/face_detection_short_range.tflite` |
| `models/face_landmark.tflite` | FaceMesh v1 468-landmark model | `https://storage.googleapis.com/mediapipe-assets/face_landmark.tflite` |
| `models/face_landmarks_detector.tflite` | Face Landmarker **v2** 478-landmark mesh (468 face + 10 iris) | extracted from Google's `face_landmarker.task` bundle (see below) |
| `models/blazeface.onnx` | ONNX export of `blazeface_short_range.tflite` | tf2onnx (opset 13), deterministic |
| `models/facemesh.onnx` | ONNX export of `face_landmark.tflite` | tf2onnx (opset 13), deterministic |
| `models/face_landmarker_478.onnx` | ONNX export of `face_landmarks_detector.tflite` | tf2onnx (opset 13), deterministic |

### Face Landmarker v2 (478-point) source note

The 478-point mesh `models/face_landmarks_detector.tflite` was obtained by unzipping **Google's own
`face_landmarker.task` bundle** (the Face Landmarker v2 solution), NOT the Qualcomm AI-Hub
HuggingFace ONNX artifact — the latter carries AI-Hub-terms risk flagged in
`docs/research-oss-landscape-2026-07.md`. The `.task` is a zip containing `face_detector.tflite`,
`face_landmarks_detector.tflite`, `face_blendshapes.tflite` and
`geometry_pipeline_metadata_landmarks.binarypb`; only the landmark mesh is used and redistributed in
this wave.

Bundle provenance and integrity:

- URL: `https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task`
- `face_landmarker.task` SHA-256: `64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff`
- `face_landmarks_detector.tflite` SHA-256: `c7d54204ce0448474c7f3fa9af494787c0965cbdd6f20fc72867e43046bd43d5`
- `face_landmarker_478.onnx` SHA-256: `513bb2354d78ae5082e4daed2cd7445c68b610f20b02bac67cc5ff34c2dfe6e5`

Conversion recipe and tensor signatures are documented in `models/README.md`.