lvthn-codec 1.0.0__py3-none-any.whl

codec.py

@@ -0,0 +1,149 @@
+import sys
+import time
+from pathlib import Path
+import numpy as np
+from scipy.io import wavfile
+
+from core import container, audio, image
+
+PROFILES = {
+    'default': {'delta': 0.18, 'snr': 24.0},
+    'compact': {'delta': 0.25, 'snr': 20.0},
+    'detail':  {'delta': 0.05, 'snr': 24.0},
+    'speech':  {'delta': 0.10, 'snr': 20.0},
+    'master':  {'delta': 0.03, 'snr': 30.0},
+}
+
+IMG_PROFILES = {
+    'fast':    {'quality': 85, 'level': 1},
+    'default': {'quality': 92, 'level': 12},
+    'max':     {'quality': 98, 'level': 19},
+}
+
+def encode_pcm(pcm, sr, ch, delta, target_snr_db):
+    payload = audio.encode_audio(pcm, sr, ch, delta, target_snr_db)
+    return container.wrap(container.MEDIA_AUDIO, payload)
+
+def decode_lvn(data):
+    media_type, payload = container.unwrap(data)
+    if media_type == container.MEDIA_AUDIO:
+        return audio.decode_audio(payload)
+    elif media_type == container.MEDIA_IMAGE:
+        return image.decode_image(payload)
+    else:
+        raise ValueError(f'Unsupported media_type: 0x{media_type:02x}')
+
+def decode_lvn_info(data):
+    media_type, payload = container.unwrap(data)
+    if media_type == container.MEDIA_AUDIO:
+        info = audio.get_audio_info(payload)
+        info['media_type'] = media_type
+        info['total'] = len(data)
+        return info
+    elif media_type == container.MEDIA_IMAGE:
+        info = image.get_image_info(payload)
+        info['media_type'] = media_type
+        info['total'] = len(data)
+        return info
+    return dict(media_type=media_type, total=len(data))
+
+def read_wav(path):
+    sr, d = wavfile.read(path)
+    if d.dtype == np.int16:   d = d.astype(np.float64) / 32768.0
+    elif d.dtype == np.int32: d = d.astype(np.float64) / 2147483648.0
+    elif d.dtype == np.uint8: d = (d.astype(np.float64) - 128.0) / 128.0
+    else:                     d = d.astype(np.float64)
+    if d.ndim == 1: d = d[:, None]
+    return d, sr
+
+def write_wav(path, pcm, sr):
+    wavfile.write(path, sr, np.clip(pcm * 32767, -32768, 32767).astype(np.int16))
+
+def read_image(path):
+    from PIL import Image
+    img = Image.open(path)
+    if img.mode == 'RGBA':
+        return np.array(img), 4
+    else:
+        return np.array(img.convert('RGB')), 3
+
+def write_image(path, pixels, channels):
+    from PIL import Image
+    img = Image.fromarray(pixels)
+    img.save(path)
+
+def main():
+    if len(sys.argv) < 2:
+        print('LVTHN-CODEC')
+        print('Commands: encode | decode | info | encode-img | decode-img | profiles')
+        sys.exit(1)
+    cmd, args = sys.argv[1], sys.argv[2:]
+
+    if cmd == 'encode':
+        if len(args) < 2: sys.exit('usage: encode in.wav out.lvn [profile|delta] [target_snr_db]')
+        pcm, sr = read_wav(args[0])
+        arg2 = args[2] if len(args) > 2 else 'default'
+        if arg2 in PROFILES:
+            delta = PROFILES[arg2]['delta']
+            tsnr = PROFILES[arg2]['snr']
+            print(f'[audio profile: {arg2}]  delta={delta}  snr={tsnr}')
+        else:
+            delta = float(arg2)
+            tsnr = float(args[3]) if len(args) > 3 else 24.0
+        
+        t0 = time.time()
+        data = encode_pcm(pcm, sr, pcm.shape[1], delta, target_snr_db=tsnr)
+        Path(args[1]).write_bytes(data)
+        print(f'OK {args[1]}  {len(data)} bytes  ({pcm.size * 2 / len(data):.2f}x vs PCM)  encode={time.time() - t0:.2f}s')
+
+    elif cmd == 'decode':
+        if len(args) < 2: sys.exit('usage: decode in.lvn out.wav')
+        pcm, sr, ch, n = decode_lvn(Path(args[0]).read_bytes())
+        write_wav(args[1], pcm, sr)
+        print(f'OK {args[1]}  {n} samples, {ch} ch, {sr} Hz')
+
+    elif cmd == 'encode-img':
+        if len(args) < 2: sys.exit('usage: encode-img in.png out.lvn [profile|quality] [level]')
+        pixels, ch = read_image(args[0])
+        arg2 = args[2] if len(args) > 2 else 'default'
+        if arg2 in IMG_PROFILES:
+            q = IMG_PROFILES[arg2]['quality']
+            lvl = IMG_PROFILES[arg2]['level']
+            print(f'[image profile: {arg2}]  quality={q}  level={lvl}')
+        else:
+            q = int(arg2)
+            lvl = int(args[3]) if len(args) > 3 else 19
+            
+        t0 = time.time()
+        payload = image.encode_image(pixels, pixels.shape[1], pixels.shape[0], ch, q, lvl)
+        data = container.wrap(container.MEDIA_IMAGE, payload)
+        Path(args[1]).write_bytes(data)
+        print(f'OK {args[1]}  {len(data)} bytes  encode={time.time() - t0:.2f}s')
+
+    elif cmd == 'decode-img':
+        if len(args) < 2: sys.exit('usage: decode-img in.lvn out.png')
+        mt, payload = container.unwrap(Path(args[0]).read_bytes())
+        if mt != container.MEDIA_IMAGE: sys.exit('Not an image')
+        pixels = image.decode_image(payload)
+        write_image(args[1], pixels, pixels.shape[2] if len(pixels.shape) > 2 else 1)
+        print(f'OK {args[1]}')
+
+    elif cmd == 'info':
+        if not args: sys.exit('usage: info file.lvn')
+        info = decode_lvn_info(Path(args[0]).read_bytes())
+        if info['media_type'] == container.MEDIA_AUDIO:
+            print(f"LVTHN v1  audio  {info['sr']} Hz  {info['ch']} ch  {info['n_samples'] / info['sr']:.2f}s  delta={info['delta']:.4f}")
+            print(f"  target_snr_db: {info['target_snr_db']:.1f}  use_ms: {info['use_ms']}  total: {info['total']}")
+        elif info['media_type'] == container.MEDIA_IMAGE:
+            print(f"LVTHN v1  image  {info['width']}x{info['height']}  alpha={info['has_alpha']}  quality={info['quality']:.0f}  total: {info['total']}")
+
+    elif cmd == 'profiles':
+        print('Audio profiles:')
+        for name, p in PROFILES.items():
+            print(f'  {name:10s}  delta={p["delta"]:<6}  snr={p["snr"]}')
+        print('Image profiles:')
+        for name, p in IMG_PROFILES.items():
+            print(f'  {name:10s}  quality={p["quality"]:<4}  level={p["level"]}')
+
+if __name__ == '__main__':
+    main()

core/audio.py

@@ -0,0 +1,330 @@
+import struct
+import numpy as np
+from numba import njit
+
+FRAME_SIZE = 1024
+HOP = FRAME_SIZE // 2
+N_COEFFS = FRAME_SIZE // 2
+
+DEFAULT_DELTA = 0.18
+DEFAULT_TARGET_SNR_DB = 24.0
+DEFAULT_DELTA_CURVE = np.array([1.0, 1.0, 1.1, 1.3, 1.6, 2.0, 2.5, 3.0], dtype=np.float32)
+MIN_BAND_SIZE = 3
+SCALE_MIN = -32
+SCALE_MAX = 31
+SCALE_BITS = 6
+ATH_OFFSET_DB = 96.0
+
+AUDIO_HDR_FMT = '<IBHQf8ffBI'
+AUDIO_HDR_SIZE = struct.calcsize(AUDIO_HDR_FMT)
+
+_WINDOW = np.sin(np.pi * (np.arange(FRAME_SIZE) + 0.5) / FRAME_SIZE).astype(np.float64)
+_n = np.arange(FRAME_SIZE, dtype=np.float64)[:, None]
+_k = np.arange(N_COEFFS, dtype=np.float64)[None, :]
+_MDCT_MATRIX = np.cos(np.pi / N_COEFFS * (_n + 0.5 + N_COEFFS / 2) * (_k + 0.5))
+_IMDCT_MATRIX = (_MDCT_MATRIX.T * (2.0 / N_COEFFS)).astype(np.float64)
+
+@njit(cache=True, inline='always')
+def _get_bit(buf, pos):
+    return (buf[pos >> 3] >> (7 - (pos & 7))) & 1
+
+@njit(cache=True, inline='always')
+def _set_bit(buf, pos, val):
+    if val:
+        buf[pos >> 3] |= (1 << (7 - (pos & 7)))
+
+@njit(cache=True)
+def _encode_frame_channel(quantized, band_starts, band_ends, scales, out_buf, bit_pos):
+    n_bands = len(band_starts)
+    n_coeffs = len(quantized)
+    last_nz = 0
+    for i in range(n_coeffs):
+        if quantized[i] != 0:
+            last_nz = i + 1
+    for i in range(9, -1, -1):
+        _set_bit(out_buf, bit_pos, (last_nz >> i) & 1)
+        bit_pos += 1
+    if last_nz == 0:
+        return bit_pos
+
+    band_present = np.zeros(n_bands, dtype=np.int32)
+    band_rice_k = np.zeros(n_bands, dtype=np.int32)
+    for b in range(n_bands):
+        s = band_starts[b]
+        e = band_ends[b]
+        if s >= last_nz:
+            break
+        be = min(e, last_nz)
+        any_nz = False
+        total_zz = 0
+        for i in range(s, be):
+            v = quantized[i]
+            if v != 0:
+                any_nz = True
+            total_zz += (v << 1) if v >= 0 else ((-v) << 1) - 1
+        if any_nz:
+            band_present[b] = 1
+            mean = total_zz / (be - s)
+            k = 0
+            m = mean
+            while m > 2.0 and k < 15:
+                m /= 2.0
+                k += 1
+            band_rice_k[b] = k
+
+    for b in range(n_bands):
+        s = band_starts[b]
+        if s >= last_nz:
+            break
+        _set_bit(out_buf, bit_pos, band_present[b])
+        bit_pos += 1
+
+    for b in range(n_bands):
+        s = band_starts[b]
+        e = band_ends[b]
+        if s >= last_nz:
+            break
+        if band_present[b] == 0:
+            continue
+        scale_enc = scales[b] - SCALE_MIN
+        for i in range(SCALE_BITS - 1, -1, -1):
+            _set_bit(out_buf, bit_pos, (scale_enc >> i) & 1)
+            bit_pos += 1
+        k = band_rice_k[b]
+        for i in range(3, -1, -1):
+            _set_bit(out_buf, bit_pos, (k >> i) & 1)
+            bit_pos += 1
+        be = min(e, last_nz)
+        for i in range(s, be):
+            v = quantized[i]
+            zz = (v << 1) if v >= 0 else ((-v) << 1) - 1
+            q = zz >> k
+            r = zz - (q << k)
+            for _ in range(q):
+                bit_pos += 1
+            _set_bit(out_buf, bit_pos, 1)
+            bit_pos += 1
+            for i2 in range(k - 1, -1, -1):
+                _set_bit(out_buf, bit_pos, (r >> i2) & 1)
+                bit_pos += 1
+    return bit_pos
+
+@njit(cache=True)
+def _decode_frame_channel(in_buf, bit_pos, quantized, scales, band_starts, band_ends):
+    n_bands = len(band_starts)
+    n_coeffs = len(quantized)
+    for i in range(n_coeffs):
+        quantized[i] = 0
+    for i in range(n_bands):
+        scales[i] = 0
+
+    last_nz = 0
+    for i in range(10):
+        last_nz = (last_nz << 1) | _get_bit(in_buf, bit_pos)
+        bit_pos += 1
+    if last_nz == 0:
+        return bit_pos
+
+    present = np.zeros(n_bands, dtype=np.int32)
+    for b in range(n_bands):
+        s = band_starts[b]
+        if s >= last_nz:
+            break
+        present[b] = _get_bit(in_buf, bit_pos)
+        bit_pos += 1
+
+    for b in range(n_bands):
+        s = band_starts[b]
+        e = band_ends[b]
+        if s >= last_nz:
+            break
+        if present[b] == 0:
+            continue
+        scale_enc = 0
+        for i in range(SCALE_BITS):
+            scale_enc = (scale_enc << 1) | _get_bit(in_buf, bit_pos)
+            bit_pos += 1
+        scales[b] = scale_enc + SCALE_MIN
+        k = 0
+        for i in range(4):
+            k = (k << 1) | _get_bit(in_buf, bit_pos)
+            bit_pos += 1
+        be = min(e, last_nz)
+        for i in range(s, be):
+            q = 0
+            while _get_bit(in_buf, bit_pos) == 0:
+                q += 1
+                bit_pos += 1
+            bit_pos += 1
+            r = 0
+            for i2 in range(k):
+                r = (r << 1) | _get_bit(in_buf, bit_pos)
+                bit_pos += 1
+            zz = (q << k) | r
+            quantized[i] = (zz >> 1) if (zz & 1) == 0 else -((zz + 1) >> 1)
+    return bit_pos
+
+@njit(cache=True)
+def _encode_body_njit(q_flat, band_starts, band_ends, scales_flat, out_buf):
+    bit_pos = 0
+    for fc in range(q_flat.shape[0]):
+        bit_pos = _encode_frame_channel(q_flat[fc], band_starts, band_ends, scales_flat[fc], out_buf, bit_pos)
+    return bit_pos
+
+@njit(cache=True)
+def _decode_body_njit(body_arr, q_flat, scales_flat, band_starts, band_ends):
+    bit_pos = 0
+    for fc in range(q_flat.shape[0]):
+        bit_pos = _decode_frame_channel(body_arr, bit_pos, q_flat[fc], scales_flat[fc], band_starts, band_ends)
+    return bit_pos
+
+def _make_bark_bands(sr, n_coeffs, min_size=MIN_BAND_SIZE):
+    bark_hz = np.array([0, 100, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2000, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12000, 15500, sr / 2], dtype=np.float64)
+    bin_centers = (np.arange(n_coeffs) + 0.5) * (sr / (2 * n_coeffs))
+    raw = []
+    for i in range(len(bark_hz) - 1):
+        start = int(np.searchsorted(bin_centers, bark_hz[i], side='left'))
+        end = int(np.searchsorted(bin_centers, bark_hz[i + 1], side='left'))
+        if end > start:
+            raw.append((start, end))
+    if raw:
+        if raw[0][0] > 0: raw[0] = (0, raw[0][1])
+        if raw[-1][1] < n_coeffs: raw[-1] = (raw[-1][0], n_coeffs)
+    merged = []
+    acc = None
+    for s, e in raw:
+        if acc is None:
+            acc = [s, e]
+        elif acc[1] - acc[0] < min_size:
+            acc[1] = e
+        else:
+            merged.append((acc[0], acc[1]))
+            acc = [s, e]
+    if acc is not None:
+        merged.append((acc[0], acc[1]))
+    return merged
+
+def _ath_thresholds(sr, n_coeffs, offset_db=ATH_OFFSET_DB):
+    freqs = np.maximum(np.arange(n_coeffs) * sr / FRAME_SIZE, 20.0)
+    f_khz = freqs / 1000.0
+    ath_db = np.minimum(3.64 * f_khz ** (-0.8) - 6.5 * np.exp(-0.6 * (f_khz - 3.3) ** 2) + 1e-3 * f_khz ** 4, 75.0)
+    return (10.0 ** ((ath_db - offset_db) / 10.0)).astype(np.float64)
+
+def _encode_body(coeffs, sr, delta, curve_bands, band_starts, band_ends, target_snr_db):
+    n_frames, _, ch = coeffs.shape
+    n_bands = len(band_starts)
+    
+    ath_band = np.array([np.mean(_ath_thresholds(sr, N_COEFFS)[s:e]) for s, e in zip(band_starts, band_ends)])
+    
+    energies = np.zeros((n_frames, n_bands, ch), dtype=np.float64)
+    for b in range(n_bands):
+        energies[:, b, :] = np.mean(coeffs[:, band_starts[b]:band_ends[b], :] ** 2, axis=1)
+
+    mask_smooth = energies.copy()
+    for shift in (1, 2, 3):
+        mask_smooth = np.maximum(mask_smooth, np.roll(energies, shift, axis=0))
+        mask_smooth = np.maximum(mask_smooth, np.roll(energies, -shift, axis=0))
+
+    spread = np.zeros_like(mask_smooth)
+    for b in range(n_bands):
+        acc = np.zeros((n_frames, ch), dtype=np.float64)
+        for db in range(-4, 5):
+            b2 = b + db
+            if 0 <= b2 < n_bands:
+                acc += mask_smooth[:, b2, :] * (1.0 - abs(db) / 5.0)
+        spread[:, b, :] = acc
+
+    mask = spread + ath_band[None, :, None]
+    base_deltas = delta * curve_bands.astype(np.float64)
+    delta_max = np.sqrt(mask / 20.0)
+    delta_floor = base_deltas[None, :, None] / np.geomspace(4.0, 0.5, n_bands)[None, :, None]
+    deltas = np.maximum(delta_floor, np.minimum(base_deltas[None, :, None], delta_max))
+
+    with np.errstate(divide='ignore', invalid='ignore'):
+        scale = np.round(2 * np.log2(deltas / base_deltas[None, :, None])).astype(np.int32)
+    np.clip(scale, SCALE_MIN, SCALE_MAX, out=scale)
+    deltas = base_deltas[None, :, None] * (2.0 ** (scale / 2.0))
+
+    quantized = np.zeros_like(coeffs, dtype=np.int32)
+    for b in range(n_bands):
+        d = deltas[:, b, :]
+        quantized[:, band_starts[b]:band_ends[b], :] = np.round(coeffs[:, band_starts[b]:band_ends[b], :] / d[:, None, :])
+    np.clip(quantized, -32767, 32767, out=quantized)
+
+    q_flat = np.ascontiguousarray(quantized.transpose(0, 2, 1).reshape(n_frames * ch, N_COEFFS))
+    scales_flat = np.ascontiguousarray(scale.transpose(0, 2, 1).reshape(n_frames * ch, n_bands))
+    
+    out_buf = np.zeros(n_frames * ch * 3072, dtype=np.uint8)
+    bit_pos = _encode_body_njit(q_flat, band_starts, band_ends, scales_flat, out_buf)
+    return out_buf[:(bit_pos + 7) // 8].tobytes(), bit_pos
+
+def encode_audio(pcm, sr, ch, delta, target_snr_db):
+    if pcm.ndim == 1:
+        pcm = pcm[:, None]
+    n_samples = pcm.shape[0]
+    n_frames = (n_samples + HOP - 1) // HOP + 1
+    
+    pcm_padded = np.zeros(((n_frames + 1) * HOP, ch), dtype=np.float64)
+    pcm_padded[HOP:HOP + n_samples] = pcm
+
+    idx = np.arange(n_frames)[:, None] * HOP + np.arange(FRAME_SIZE)[None, :]
+    coeffs_L = (pcm_padded[idx, 0] * _WINDOW[None, :]) @ _MDCT_MATRIX
+
+    if ch == 2:
+        coeffs_R = (pcm_padded[idx, 1] * _WINDOW[None, :]) @ _MDCT_MATRIX
+        coeffs_lr = np.stack([coeffs_L, coeffs_R], axis=2)
+        coeffs_ms = np.stack([(coeffs_L + coeffs_R) * 0.5, (coeffs_L - coeffs_R) * 0.5], axis=2)
+    else:
+        coeffs_lr, coeffs_ms = coeffs_L[:, :, None], None
+
+    bark_bands = _make_bark_bands(sr, N_COEFFS)
+    band_starts = np.array([s for s, _ in bark_bands], dtype=np.int32)
+    band_ends = np.array([e for _, e in bark_bands], dtype=np.int32)
+    curve_bands = np.interp(np.linspace(0, 1, len(bark_bands)), np.linspace(0, 1, 8), DEFAULT_DELTA_CURVE).astype(np.float32)
+
+    body_lr, bits_lr = _encode_body(coeffs_lr, sr, delta, curve_bands, band_starts, band_ends, target_snr_db)
+    
+    if ch == 2:
+        body_ms, bits_ms = _encode_body(coeffs_ms, sr, delta, curve_bands, band_starts, band_ends, target_snr_db)
+        use_ms, body = (1, body_ms) if bits_ms < bits_lr else (0, body_lr)
+    else:
+        use_ms, body = 0, body_lr
+
+    hdr = struct.pack(AUDIO_HDR_FMT, sr, ch, FRAME_SIZE, n_samples, float(delta), *[float(x) for x in DEFAULT_DELTA_CURVE], float(target_snr_db), use_ms, len(body))
+    return hdr + body
+
+def decode_audio(payload):
+    (sr, ch, fs, n_samples, delta, c0, c1, c2, c3, c4, c5, c6, c7, target_snr_db, use_ms, body_len) = struct.unpack_from(AUDIO_HDR_FMT, payload, 0)
+    
+    body = payload[AUDIO_HDR_SIZE:AUDIO_HDR_SIZE + body_len]
+    n_frames = (n_samples + HOP - 1) // HOP + 1
+    
+    bark_bands = _make_bark_bands(sr, N_COEFFS)
+    band_starts = np.array([s for s, _ in bark_bands], dtype=np.int32)
+    band_ends = np.array([e for _, e in bark_bands], dtype=np.int32)
+    
+    curve_orig = np.array([c0, c1, c2, c3, c4, c5, c6, c7], dtype=np.float32)
+    curve_bands = np.interp(np.linspace(0, 1, len(bark_bands)), np.linspace(0, 1, 8), curve_orig).astype(np.float32)
+
+    q_flat = np.zeros((n_frames * ch, N_COEFFS), dtype=np.int32)
+    scales_flat = np.zeros((n_frames * ch, len(bark_bands)), dtype=np.int32)
+    _decode_body_njit(np.frombuffer(body, dtype=np.uint8), q_flat, scales_flat, band_starts, band_ends)
+
+    coeffs = np.zeros((n_frames, N_COEFFS, ch), dtype=np.float64)
+    for b in range(len(bark_bands)):
+        d = delta * curve_bands[b] * (2.0 ** (scales_flat[:, b].reshape(n_frames, ch) / 2.0))
+        q_band = q_flat[:, band_starts[b]:band_ends[b]].reshape(n_frames, ch, band_ends[b] - band_starts[b]).transpose(0, 2, 1)
+        coeffs[:, band_starts[b]:band_ends[b], :] = q_band * d[:, None, :]
+
+    frames = (coeffs.transpose(0, 2, 1).reshape(-1, N_COEFFS) @ _IMDCT_MATRIX).reshape(n_frames, ch, FRAME_SIZE).transpose(0, 2, 1) * _WINDOW[None, :, None]
+    
+    pcm_enc = np.zeros(((n_frames + 1) * HOP, ch), dtype=np.float64)
+    for f in range(n_frames):
+        pcm_enc[f * HOP : f * HOP + FRAME_SIZE] += frames[f]
+
+    pcm_padded = np.stack([pcm_enc[:, 0] + pcm_enc[:, 1], pcm_enc[:, 0] - pcm_enc[:, 1]], axis=1) if use_ms and ch == 2 else pcm_enc
+    return np.clip(pcm_padded[HOP:HOP + n_samples], -1.0, 1.0), sr, ch, n_samples
+
+def get_audio_info(payload):
+    (sr, ch, _, n_samples, delta, _, _, _, _, _, _, _, _, target_snr_db, use_ms, body_len) = struct.unpack_from(AUDIO_HDR_FMT, payload, 0)
+    return dict(sr=sr, ch=ch, n_samples=n_samples, delta=delta, target_snr_db=target_snr_db, use_ms=use_ms, body_len=body_len)

core/container.py

@@ -0,0 +1,25 @@
+import struct
+
+MAGIC = b'LVTHN'
+VERSION = 1
+
+MEDIA_AUDIO = 0x01
+MEDIA_IMAGE = 0x02
+MEDIA_VIDEO = 0x03
+
+HDR_FMT = '<5sHB'
+HDR_SIZE = struct.calcsize(HDR_FMT)
+
+def wrap(media_type, payload):
+    header = struct.pack(HDR_FMT, MAGIC, VERSION, media_type)
+    return header + payload
+
+def unwrap(data):
+    if len(data) < HDR_SIZE:
+        raise ValueError('File too small')
+    magic, version, media_type = struct.unpack_from(HDR_FMT, data, 0)
+    if magic != MAGIC:
+        raise ValueError('Not a Leviathan file')
+    if version != VERSION:
+        raise ValueError(f'Unsupported version {version}')
+    return media_type, data[HDR_SIZE:]

core/image.py

@@ -0,0 +1,267 @@
+import struct
+import numpy as np
+from scipy.fft import dctn, idctn
+import zstandard as zstd
+from numba import njit
+
+IMG_HDR_FMT = '<IIBBf'
+IMG_HDR_SIZE = struct.calcsize(IMG_HDR_FMT)
+
+ZIGZAG_ORDER = np.array([
+    0,  1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63
+], dtype=np.int32)
+
+@njit(cache=True)
+def _rgb_to_oklab_njit(rgb, out):
+    h, w = rgb.shape[0], rgb.shape[1]
+    for i in range(h):
+        for j in range(w):
+            r = rgb[i, j, 0] / 255.0
+            g = rgb[i, j, 1] / 255.0
+            b = rgb[i, j, 2] / 255.0
+            
+            if r > 0.04045: r = ((r + 0.055) / 1.055) ** 2.4
+            else: r = r / 12.92
+            if g > 0.04045: g = ((g + 0.055) / 1.055) ** 2.4
+            else: g = g / 12.92
+            if b > 0.04045: b = ((b + 0.055) / 1.055) ** 2.4
+            else: b = b / 12.92
+            
+            l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b
+            m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b
+            s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b
+            
+            l = (l ** (1.0/3.0)) if l > 0 else 0.0
+            m = (m ** (1.0/3.0)) if m > 0 else 0.0
+            s = (s ** (1.0/3.0)) if s > 0 else 0.0
+            
+            L = 0.2104542553 * l + 0.7936177850 * m - 0.0040720468 * s
+            a = 1.9779984951 * l - 2.4285922050 * m + 0.4505937099 * s
+            bb = 0.0259040371 * l + 0.7827717662 * m - 0.8086757660 * s
+            
+            out[i, j, 0] = L * 255.0
+            out[i, j, 1] = a * 255.0 + 128.0
+            out[i, j, 2] = bb * 255.0 + 128.0
+
+@njit(cache=True)
+def _oklab_to_rgb_njit(oklab, out):
+    h, w = oklab.shape[0], oklab.shape[1]
+    for i in range(h):
+        for j in range(w):
+            L = oklab[i, j, 0] / 255.0
+            a = (oklab[i, j, 1] - 128.0) / 255.0
+            b = (oklab[i, j, 2] - 128.0) / 255.0
+            
+            l = L + 0.3963377774 * a + 0.2158037573 * b
+            m = L - 0.1055613458 * a - 0.0638541728 * b
+            s = L - 0.0894841775 * a - 1.2914855480 * b
+            
+            l = l ** 3
+            m = m ** 3
+            s = s ** 3
+            
+            r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s
+            g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s
+            bb = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
+            
+            if r > 0.0031308: r = 1.055 * (r ** (1.0/2.4)) - 0.055
+            else: r = 12.92 * r
+            if g > 0.0031308: g = 1.055 * (g ** (1.0/2.4)) - 0.055
+            else: g = 12.92 * g
+            if bb > 0.0031308: bb = 1.055 * (bb ** (1.0/2.4)) - 0.055
+            else: bb = 12.92 * bb
+            
+            r = max(0.0, min(1.0, r))
+            g = max(0.0, min(1.0, g))
+            bb = max(0.0, min(1.0, bb))
+            
+            out[i, j, 0] = int(r * 255.0 + 0.5)
+            out[i, j, 1] = int(g * 255.0 + 0.5)
+            out[i, j, 2] = int(bb * 255.0 + 0.5)
+
+@njit(cache=True)
+def _rle_encode_all_fast(zigzag_blocks, out_pairs_1d):
+    n_blocks = zigzag_blocks.shape[0]
+    out_pos = 0
+    for b in range(n_blocks):
+        run = 0
+        for k in range(64):
+            v = zigzag_blocks[b, k]
+            if v == 0:
+                run += 1
+            else:
+                while run > 15:
+                    out_pairs_1d[out_pos] = 15
+                    out_pairs_1d[out_pos+1] = 0
+                    out_pos += 2
+                    run -= 16
+                out_pairs_1d[out_pos] = run
+                out_pairs_1d[out_pos+1] = v
+                out_pos += 2
+                run = 0
+        if run > 0:
+            out_pairs_1d[out_pos] = 0
+            out_pairs_1d[out_pos+1] = 0
+            out_pos += 2
+    return out_pos // 2
+
+@njit(cache=True)
+def _rle_decode_all_fast(pairs_1d, n_pairs, n_blocks, out_zigzag):
+    idx = 0
+    for b in range(n_blocks):
+        for k in range(64):
+            out_zigzag[b, k] = 0
+        pos = 0
+        while pos < 64 and idx < n_pairs:
+            run = pairs_1d[idx*2]
+            val = pairs_1d[idx*2+1]
+            idx += 1
+            if val == 0 and run == 0:
+                break
+            pos += run
+            if pos < 64:
+                out_zigzag[b, pos] = val
+                pos += 1
+    return idx
+
+def _get_q_matrix(quality, is_chroma):
+    q = np.clip(quality, 1, 100)
+    step = (100 - q) / 2.0 + 1.0
+    if is_chroma:
+        step *= 1.5
+    return np.ones((8, 8), dtype=np.float32) * step
+
+def _encode_channel_fast(channel, q_matrix):
+    h, w = channel.shape
+    pad_h = (8 - h % 8) % 8
+    pad_w = (8 - w % 8) % 8
+    padded = np.pad(channel, ((0, pad_h), (0, pad_w)), mode='edge') if (pad_h or pad_w) else channel
+        
+    h_blocks = padded.shape[0] // 8
+    w_blocks = padded.shape[1] // 8
+    
+    blocks = np.ascontiguousarray(padded.reshape(h_blocks, 8, w_blocks, 8).transpose(0, 2, 1, 3))
+    dct_blocks = dctn(blocks, type=2, norm='ortho', axes=(-2, -1))
+    quantized = np.round(dct_blocks / q_matrix).astype(np.int32)
+    
+    flat = quantized.reshape(-1, 64)
+    zigzag = np.ascontiguousarray(flat[:, ZIGZAG_ORDER])
+    
+    n_blocks = zigzag.shape[0]
+    max_pairs = n_blocks * 65
+    out_pairs = np.zeros(max_pairs * 2, dtype=np.int32)
+    n_pairs = _rle_encode_all_fast(zigzag, out_pairs)
+    
+    return out_pairs[:n_pairs * 2]
+
+def _decode_channel_fast(pairs_1d, q_matrix, h, w):
+    pad_h = (8 - h % 8) % 8
+    pad_w = (8 - w % 8) % 8
+    h_blocks = (h + pad_h) // 8
+    w_blocks = (w + pad_w) // 8
+    n_blocks = h_blocks * w_blocks
+    
+    zigzag = np.zeros((n_blocks, 64), dtype=np.int32)
+    n_pairs = len(pairs_1d) // 2
+    _rle_decode_all_fast(pairs_1d, n_pairs, n_blocks, zigzag)
+    
+    flat = np.zeros((n_blocks, 64), dtype=np.int32)
+    flat[:, ZIGZAG_ORDER] = zigzag
+    
+    blocks = flat.reshape(h_blocks, w_blocks, 8, 8).astype(np.float32) * q_matrix
+    spatial_blocks = idctn(blocks, type=2, norm='ortho', axes=(-2, -1))
+    
+    padded = spatial_blocks.transpose(0, 2, 1, 3).reshape(h_blocks * 8, w_blocks * 8)
+    return padded[:h, :w]
+
+def encode_image(pixels, width, height, channels=3, quality=90, level=19):
+    has_alpha = (channels == 4)
+    flags = 1 if has_alpha else 0
+    
+    if has_alpha:
+        rgb_pixels = pixels[:, :, :3]
+        alpha_channel = pixels[:, :, 3].astype(np.float32)
+    else:
+        rgb_pixels = pixels
+
+    oklab = np.zeros((height, width, 3), dtype=np.float32)
+    _rgb_to_oklab_njit(rgb_pixels, oklab)
+    
+    q_luma = _get_q_matrix(quality, is_chroma=False)
+    q_chroma = _get_q_matrix(quality, is_chroma=True)
+    q_alpha = _get_q_matrix(quality, is_chroma=False)
+
+    raw_pairs = []
+    raw_pairs.append(_encode_channel_fast(oklab[:, :, 0], q_luma))
+    raw_pairs.append(_encode_channel_fast(oklab[:, :, 1], q_chroma))
+    raw_pairs.append(_encode_channel_fast(oklab[:, :, 2], q_chroma))
+    if has_alpha:
+        raw_pairs.append(_encode_channel_fast(alpha_channel, q_alpha))
+
+    compressed_channels = []
+    cctx = zstd.ZstdCompressor(level=level, threads=-1, write_content_size=True)
+    for pairs in raw_pairs:
+        compressed_channels.append(cctx.compress(pairs.tobytes()))
+
+    comp_lens = [len(c) for c in compressed_channels]
+    
+    header = struct.pack(IMG_HDR_FMT, width, height, channels, flags, float(quality))
+    meta = struct.pack(f'<{channels}I', *comp_lens)
+    
+    body = b''.join(compressed_channels)
+    return header + meta + body
+
+def decode_image(payload):
+    if len(payload) < IMG_HDR_SIZE:
+        raise ValueError("Image payload too small")
+
+    width, height, channels, flags, quality = struct.unpack_from(IMG_HDR_FMT, payload, 0)
+    has_alpha = bool(flags & 1)
+    
+    pos = IMG_HDR_SIZE
+    comp_lens = struct.unpack_from(f'<{channels}I', payload, pos)
+    pos += channels * 4
+    
+    compressed_channels = []
+    for l in comp_lens:
+        compressed_channels.append(payload[pos:pos+l])
+        pos += l
+
+    raw_pairs = []
+    dctx = zstd.ZstdDecompressor()
+    for comp in compressed_channels:
+        packed = dctx.decompress(comp, max_output_size=width*height*64*4)
+        raw_pairs.append(np.frombuffer(packed, dtype='<i4').astype(np.int32))
+
+    q_luma = _get_q_matrix(quality, is_chroma=False)
+    q_chroma = _get_q_matrix(quality, is_chroma=True)
+    q_alpha = _get_q_matrix(quality, is_chroma=False)
+
+    oklab = np.zeros((height, width, 3), dtype=np.float32)
+    oklab[:, :, 0] = _decode_channel_fast(raw_pairs[0], q_luma, height, width)
+    oklab[:, :, 1] = _decode_channel_fast(raw_pairs[1], q_chroma, height, width)
+    oklab[:, :, 2] = _decode_channel_fast(raw_pairs[2], q_chroma, height, width)
+    
+    rgb = np.zeros((height, width, 3), dtype=np.uint8)
+    _oklab_to_rgb_njit(oklab, rgb)
+
+    if has_alpha:
+        alpha_channel = _decode_channel_fast(raw_pairs[3], q_alpha, height, width)
+        alpha = np.clip(alpha_channel, 0, 255).astype(np.uint8)
+        return np.dstack((rgb, alpha))
+    
+    return rgb
+
+def get_image_info(payload):
+    width, height, channels, flags, quality = struct.unpack_from(IMG_HDR_FMT, payload, 0)
+    return dict(
+        width=width, height=height, channels=channels, 
+        has_alpha=bool(flags & 1), quality=quality
+    )

lvthn_codec-1.0.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: lvthn-codec
+Version: 1.0.0
+Summary: Universal LVTHN media codec: audio (MDCT + Bark + Psy) and images (Oklab + DCT + zstd)
+Author: FreshGame
+Maintainer: FreshLend Studio
+License-Expression: MIT
+Keywords: audio,codec,image,compression,mdct,dct,psychoacoustics,oklab,lvn,patent-free
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: PATENTS
+Requires-Dist: numpy==2.2.6
+Requires-Dist: scipy==1.15.3
+Requires-Dist: numba==0.68.1
+Requires-Dist: zstandard==0.25.0
+Requires-Dist: Pillow==12.3.0
+Dynamic: license-file
+
+# LVTHN-CODEC [RU](README.md) | **EN**
+
+A modular, patent-clean, and highly efficient media codec written in Python. 
+It uses a universal container (`.lvn`) that supports both **Audio** and **Images**, applying modern psychoacoustic and psychovisual models to outperform industry standards like MP3 and PNG.
+
+## Features
+
+*   **Universal container (`.lvn`):** One format for everything. The decoder automatically detects what is inside.
+*   **Audio codec:** MDCT + Mid/Side stereo + Bark scale bands + Absolute Threshold of Hearing (ATH) + Adaptive quantization.
+*   **Image codec:** Oklab color space + Block DCT + RLE + Zstandard.
+*   **Performance:** 
+    *   Audio outperforms MP3 in size by **~15%** at the same perceived quality.
+    *   Images outperform PNG in size by **6 to 7 times** with visually indistinguishable quality.
+    *   High speed: Audio RTF < 0.02, 4K image decoding takes about 3 seconds.
+
+## Installation
+
+Ensure you have Python 3.10+ installed.
+
+```bash
+pip install numpy scipy numba zstandard Pillow sounddevice PySide6
+```
+*(Note: For `converter.py` to work with formats like MP3 or JPG, you need to install `ffmpeg` and add it to the system PATH environment variable).*
+
+## Usage
+
+### 1. Codec CLI (`codec.py`)
+Direct encoding and decoding to and from the `.lvn` format.
+```bash
+# Audio
+python codec.py encode track.wav track.lvn compact
+python codec.py decode track.lvn out.wav
+
+# Images
+python codec.py encode-img image.png image.lvn fast
+python codec.py decode-img image.lvn out.png
+
+# File info
+python codec.py info track.lvn
+```
+
+### 2. Converter (`converter.py`)
+Converts any supported format (via ffmpeg) to `.lvn` and back.
+```bash
+python converter.py to-lvn track.mp3 track.lvn --profile default
+python converter.py from-lvn track.lvn track_out.mp3 --bitrate 192k
+```
+
+### 3. Player (`player.py`)
+Modern GUI player and image viewer based on PySide6.
+```bash
+python player.py track.lvn
+python player.py image.lvn
+```
+
+### 4. Benchmark (`benchmark.py`)
+Testing speed and compression ratio on your files.
+```bash
+python benchmark.py --audio audio.wav --image image.png --image-profiles fast max
+```
+
+## Profiles
+
+### Audio Profiles
+| Profile | Description | SNR | Best for |
+|---|---|---|---|
+| `compact` | Maximum compression | 20.0 | Everyday listening, saving space |
+| `default` | Balanced | 24.0 | High-quality music |
+| `speech` | Voice optimized | 20.0 | Podcasts, audiobooks |
+| `detail` | Preserves quiet details | 24.0 | Lo-Fi, acoustic, vinyl |
+| `master` | Archival quality | 30.0 | Mastering, studio archives |
+
+### Image Profiles
+| Profile | Quality | Zstd Level | Best for |
+|---|---|---|---|
+| `fast` | 85 | 1 | Quick preview, game textures |
+| `default` | 92 | 12 | Web images, everyday use |
+| `max` | 98 | 19 | Archiving, professional photography |
+
+## Benchmarks
+
+### Audio (179 sec track)
+| File | Profile | Bitrate | SNR | Enc RTF | Dec RTF | Compression |
+|---|---|---|---|---|---|---|
+| acoustic.wav | compact | 113 kbps | 27.5 dB | 0.022 | 0.009 | 13.5x |
+| acoustic.wav | master | 225 kbps | 40.8 dB | 0.020 | 0.010 | 6.8x |
+
+### Images (4K 8.29 MP)
+| File | Profile | PSNR | Enc Time | Dec Time | Compression |
+|---|---|---|---|---|---|
+| 4k_image.png | fast | 42.1 dB | 4.10s | 3.14s | 7.1x |
+| 4k_image.png | max | 48.3 dB | 29.32s | 3.14s | 4.3x |
+
+*(PSNR > 40 dB is considered visually indistinguishable from the original. RTF < 1.0 means faster than real time).*
+
+## Architecture
+
+*   `codec.py` - Main CLI and API.
+*   `core/container.py` - Universal LVTHN wrapper.
+*   `core/audio.py` - Audio math (MDCT, Bark, Psy).
+*   `core/image.py` - Image math (Oklab, DCT).
+*   `player.py` - GUI (PySide6).
+*   `converter.py` - FFmpeg wrapper.
+*   `benchmark.py` - Performance testing tool.
+
+## License and Patents
+
+The project is distributed under the **MIT** license. 
+It is built exclusively on patent-free algorithms (MDCT, Oklab, DCT, Rice coding, Zstandard). See the `PATENTS` file for a detailed breakdown.

lvthn_codec-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+codec.py,sha256=qBczZSDoOPzLqAMz49N1lIM6PHV7GBkhh_qaBBp1s3c,6001
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/audio.py,sha256=5CBFQAiHg9zUQRjVkMbf9RcWzEYXmAoblXdlsq7lkYM,13277
+core/container.py,sha256=tis5Y-BpfwwAcmD5_HlXI6NQJ98UhvMUY8QalO0GxUc,660
+core/image.py,sha256=LgVaA_VCtEoEpVvDg8mtmlkiSQFKHydxBuZSQBVtJjQ,9684
+lvthn_codec-1.0.0.dist-info/licenses/LICENSE,sha256=oydlZ-tVSj8Dhk5n6xZTAesffEyD4P5mZCW0-gpOaKQ,1092
+lvthn_codec-1.0.0.dist-info/licenses/PATENTS,sha256=9Y191lC6dM6RvaraUMc8nust5l-j9V_tyzs793OslRQ,1300
+lvthn_codec-1.0.0.dist-info/METADATA,sha256=xQGTOE82E1TeHKkGsrdfEvweebdDxtduC8gter98IEQ,5091
+lvthn_codec-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+lvthn_codec-1.0.0.dist-info/top_level.txt,sha256=ns1lgx8tWumjOWKwOow_jNeT-5onvR86t_2TJLGw8zo,11
+lvthn_codec-1.0.0.dist-info/RECORD,,

lvthn_codec-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lvthn_codec-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FreshLend Studio
+
+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.

lvthn_codec-1.0.0.dist-info/licenses/PATENTS

@@ -0,0 +1,30 @@
+LVTHN-CODEC — Patent Notice
+
+This software is released under the MIT License.
+
+The author is not aware of any patents that cover the algorithms implemented 
+here. The core techniques used are:
+
+Audio:
+  - MDCT / IMDCT with sine window (Princen-Bradley, 1986–87; expired)
+  - TDAC (Time-Domain Aliasing Cancellation, 1986; expired)
+  - Mid/Side stereo coding (Blumlein, 1930s; classic technique)
+  - Bark-scale band partitioning (Barkhausen 1960s, public domain)
+  - Absolute Threshold of Hearing (Terhardt 1979, public domain)
+  - Rice coding (Golomb 1966, Rice 1979; expired)
+  - Adaptive per-band quantization (basic idea, expired)
+
+Images:
+  - Oklab color space (Björn Ottosson, 2020; public domain)
+  - Block DCT (discrete cosine transform; expired)
+  - Run-Length Encoding (RLE; public domain)
+  - Zstandard compression (Yann Collet, 2015; BSD/GPLv2, patent-free)
+
+This is NOT a legal guarantee of patent non-infringement. No warranty is
+provided. If you distribute binaries based on this code commercially,
+consult a patent attorney about your jurisdiction.
+
+The author has intentionally avoided:
+  - Full psychoacoustic masking models identical to MP3/AAC
+  - SBR / PS / HE-AAC extensions
+  - Any code from FFmpeg, LAME, Opus, Vorbis, or other existing codecs

lvthn_codec-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+codec
+core