# gizai:h3

giz's worker of MiniMax H3 (gizai:diffusion's D.H3): its video.generate jobs as WanGP makes them (sliding windows, a video to extend, control videos, Ref2VA references, a soundtrack) and the enhance-video and interpolate-video jobs (RTX Video and optical flow on the same GPU).

```gizlang
import * as H3 from "gizai:h3";
```

## Types

### `Serving`

```gizlang
type Serving = { fl2va: string; ref2va: string; text: string; spare: i64; state: string; host: string; port: i64; ffmpeg: string; }
```

What `serve` serves: H3 FL2VA from the model folder `fl2va` and Ref2VA from `ref2va` (either "" for none), with the
text encoder `text` ("local" or HOST:PORT), `spare` bytes of the GPU left free, its jobs under `state` and on
`host`:`port`; `ffmpeg` the program that reads and muxes the uploads.

- `fl2va`: `string`
- `ref2va`: `string`
- `text`: `string`
- `spare`: `i64`
- `state`: `string`
- `host`: `string`
- `port`: `i64`
- `ffmpeg`: `string`

### `Treatment`

```gizlang
type Treatment = { e: V.Enhance; times: i64; effort: string; }
```

What a job does to the frames: RTX Video `e`, or (`times` above 1) `times` - 1 frames made between each two (of
quality `effort`: V.interpolationQualities).

- `e`: `M42.Enhance`
- `times`: `i64`
- `effort`: `string`

### `Source`

```gizlang
type Source = { width: i64; height: i64; num: i64; den: i64; seconds: f64; frames: i64; bytes: i64; codec: string; pixels: string; turn: i64; }
```

A video file's first video stream as ffprobe sees it: its size as shown (after the turn), frame rate num / den,
length, frame count and file size (-1: unknown), codec, and the turn it asks for (degrees clockwise).

- `width`: `i64`
- `height`: `i64`
- `num`: `i64`
- `den`: `i64`
- `seconds`: `f64`
- `frames`: `i64`
- `bytes`: `i64`
- `codec`: `string`
- `pixels`: `string`
- `turn`: `i64`

## Functions

### `serve`

```gizlang
function serve(sys: System, s: Serving): Result<i64, string>
```

giz's worker for its H3 pools: video.generate of minimax_h3_fl2va_pruned (and the id giz names it by,
minimax_h3_fl2va_pruned_int8_convrot) and of Ref2VA into output.mp4 (output.2x.mp4 by RTX Video, in the process, when
the input asks upscale), and giz's enhance-video and interpolate-video models (enhanceRun). The kernels' tunings stay
in STATE/tune. One process serves both of H3's models with one transformer on the GPU at a time (H3.use swaps it for a
job of the other), as WanGP does on one card.

Effects: fail, read, write, console, io.

### `h3Upscale`

```gizlang
function h3Upscale(): V.Enhance
```

The 2x upscale of an H3 video (input upscale: true), as wgp-api's NVIDIA VSR asks it.

### `sourceOf`

```gizlang
function sourceOf(sys: System, ffmpeg: string, path: string): Result<Source, string>
```

The video stream of the file PATH as ffprobe (beside FFMPEG) reads it: its size, frame rate, length, codec and rotation.

Effects: fail, read, write, io.

### `enhanceFile`

```gizlang
function enhanceFile(sys: System, gpu: Gpu, ffmpeg: string, source: string, s: Source, how: Treatment, codec: string, dir: string, progress: (f: i64, total: i64) => bool): Result<i64, W.Failure>
```

`source` (`s`: sourceOf) through `how` into DIR/output.mp4 of `codec`, with the source's audio: NVDEC, the effect
or the interpolation, and NVENC on `gpu`, then ffmpeg times the track at the source's rate (times `how.times`)
beside the audio. `progress` takes the source frames done and expected each 8 frames and gives false to cancel.

Effects: fail, read, write, console, io.

gizai:h3

giz's worker of MiniMax H3 (gizai:diffusion's D.H3): its video.generate jobs as WanGP makes them (sliding windows, a video to extend, control videos, Ref2VA references, a soundtrack) and the enhance-video and interpolate-video jobs (RTX Video and optical flow on the same GPU).

gizlang

import * as H3 from "gizai:h3";

Types

`Serving`

gizlang

type Serving = { fl2va: string; ref2va: string; text: string; spare: i64; state: string; host: string; port: i64; ffmpeg: string; }

What serve serves: H3 FL2VA from the model folder fl2va and Ref2VA from ref2va (either "" for none), with the text encoder text ("local" or HOST:PORT), spare bytes of the GPU left free, its jobs under state and on host:port; ffmpeg the program that reads and muxes the uploads.

fl2va: string
ref2va: string
text: string
spare: i64
state: string
host: string
port: i64
ffmpeg: string

`Treatment`

gizlang

type Treatment = { e: V.Enhance; times: i64; effort: string; }

What a job does to the frames: RTX Video e, or (times above 1) times - 1 frames made between each two (of quality effort: V.interpolationQualities).

e: M42.Enhance
times: i64
effort: string

`Source`

gizlang

type Source = { width: i64; height: i64; num: i64; den: i64; seconds: f64; frames: i64; bytes: i64; codec: string; pixels: string; turn: i64; }

A video file's first video stream as ffprobe sees it: its size as shown (after the turn), frame rate num / den, length, frame count and file size (-1: unknown), codec, and the turn it asks for (degrees clockwise).

width: i64
height: i64
num: i64
den: i64
seconds: f64
frames: i64
bytes: i64
codec: string
pixels: string
turn: i64

Functions

`serve`

gizlang

function serve(sys: System, s: Serving): Result<i64, string>

giz's worker for its H3 pools: video.generate of minimax_h3_fl2va_pruned (and the id giz names it by, minimax_h3_fl2va_pruned_int8_convrot) and of Ref2VA into output.mp4 (output.2x.mp4 by RTX Video, in the process, when the input asks upscale), and giz's enhance-video and interpolate-video models (enhanceRun). The kernels' tunings stay in STATE/tune. One process serves both of H3's models with one transformer on the GPU at a time (H3.use swaps it for a job of the other), as WanGP does on one card.

Effects: fail, read, write, console, io.

`h3Upscale`

gizlang

function h3Upscale(): V.Enhance

The 2x upscale of an H3 video (input upscale: true), as wgp-api's NVIDIA VSR asks it.

`sourceOf`

gizlang

function sourceOf(sys: System, ffmpeg: string, path: string): Result<Source, string>

The video stream of the file PATH as ffprobe (beside FFMPEG) reads it: its size, frame rate, length, codec and rotation.

Effects: fail, read, write, io.

`enhanceFile`

gizlang

function enhanceFile(sys: System, gpu: Gpu, ffmpeg: string, source: string, s: Source, how: Treatment, codec: string, dir: string, progress: (f: i64, total: i64) => bool): Result<i64, W.Failure>

source (s: sourceOf) through how into DIR/output.mp4 of codec, with the source's audio: NVDEC, the effect or the interpolation, and NVENC on gpu, then ffmpeg times the track at the source's rate (times how.times) beside the audio. progress takes the source frames done and expected each 8 frames and gives false to cancel.

Effects: fail, read, write, console, io.