# enc_av1 — AV1 Encoder with Tool Control

Wrapper na zmodyfikowany `aomenc` z pełną kontrolą narzędzi kodowania przez pliki INI.

## Wymagania

- Python 3.8+
- ffmpeg (do cropa)
- Zbudowany `aomenc` w `_ref_av1_aom/build_enc/`

### Budowanie aomenc

```bash
cd _ref_av1_aom
mkdir -p build_enc && cd build_enc
cmake .. -DCONFIG_AV1_ENCODER=1 -DENABLE_EXAMPLES=1 \
         -DCONFIG_AV1_DECODER=0 -DENABLE_TOOLS=0 -DENABLE_TESTS=0 \
         -DCMAKE_BUILD_TYPE=Release -DAOM_TARGET_CPU=generic
cmake --build . -j8
```

## Szybki start

```bash
# 1. Koduj z gotowym presetem:
./encode.py -i input.yuv -o output.ivf -cfg B1_intra.ini

# 2. Albo stwórz własny config:
./encode.py --init moj_test.ini
#    edytuj moj_test.ini ...
./encode.py -i input.yuv -o output.ivf -cfg moj_test.ini
```

## Użycie

```
./encode.py -i <input.yuv> -o <output.ivf> -cfg <config.ini> [opcje]

Opcje:
  -W WIDTH    nadpisz szerokość źródła (z INI)
  -H HEIGHT   nadpisz wysokość źródła (z INI)
  -n FRAMES   nadpisz liczbę klatek (z INI)
  --init FILE wygeneruj domyślny config ze wszystkimi narzędziami
```

## Gotowe presety

| Plik | Opis |
|------|------|
| `B0_infrastructure.ini` | Minimum: DC_PRED + DCT_DCT, brak filtrów, brak podziałów |
| `B1_intra.ini` | Wszystkie tryby intra + 7 typów TX, brak filtrów |
| `B2_intra_features.ini` | + angle delta, CfL, palette, filter intra |
| `B3_inter.ini` | + predykcja inter, compound, wszystkie referencje |
| `B4_deblocking.ini` | + deblocking ON (CDEF i LR wciąż OFF) |
| `B5_full.ini` | Wszystko włączone: deblocking + CDEF + LR |

Każdy kolejny preset dodaje narzędzia — odpowiada etapom bring-upu dekodera.

## Format pliku INI

```ini
[source]
width = 256                ; rozmiar wejściowego YUV
height = 256
frames = 0                 ; 0 = wszystkie klatki

[crop]
enabled = false            ; true = auto-crop ffmpegiem przed kodowaniem
width = 128
height = 128
offset_x = 64
offset_y = 64

[encode]
cq_level = 30              ; jakość (niżej = lepiej, 0-63)
bit_depth = 8              ; 8 lub 10
sb_size = 64               ; superblock: 64 lub 128
cpu_used = 3               ; szybkość enkodera (0=najwolniej, 6=najszybciej)
kf_max_dist = 10           ; max odległość keyframe (1 = intra only)
extra_flags =              ; dodatkowe flagi aomenc

[filters]
deblocking = true          ; loop filter
cdef = true                ; CDEF
loop_restoration = true    ; loop restoration (Wiener/SGR)

[features]
angle_delta = true         ; kątowe warianty trybów intra
cfl_intra = true           ; chroma from luma
palette = true             ; tryb paletowy (screen content)
filter_intra = true        ; filter intra
rect_tx = true             ; prostokątne transformaty
global_motion = true       ; kompensacja ruchu globalnego
obmc = true                ; overlapped block motion comp
warped_motion = true       ; warped motion comp

[partitions]               ; typy podziału bloków
PARTITION_NONE = true      ; bez podziału (pełny SB)
PARTITION_HORZ = true      ; podział poziomy
PARTITION_VERT = true      ; podział pionowy
PARTITION_SPLIT = true     ; quad-tree (4 równe)
PARTITION_HORZ_A = true    ; T-shape góra
PARTITION_HORZ_B = true    ; T-shape dół
PARTITION_VERT_A = true    ; T-shape lewo
PARTITION_VERT_B = true    ; T-shape prawo
PARTITION_HORZ_4 = true    ; 4 paski poziome
PARTITION_VERT_4 = true    ; 4 paski pionowe

[intra_modes]              ; tryby predykcji intra
DC_PRED = true             ; średnia (domyślny)
V_PRED = true              ; pionowy
H_PRED = true              ; poziomy
D45_PRED = true            ; diagonalny 45°
D135_PRED = true           ; diagonalny 135°
D113_PRED = true           ; diagonalny 113°
D157_PRED = true           ; diagonalny 157°
D203_PRED = true           ; diagonalny 203°
D67_PRED = true            ; diagonalny 67°
SMOOTH_PRED = true         ; smooth
SMOOTH_V_PRED = true       ; smooth pionowy
SMOOTH_H_PRED = true       ; smooth poziomy
PAETH_PRED = true          ; Paeth

[inter_refs]               ; ramki referencyjne
LAST_FRAME = true          ; poprzednia
LAST2_FRAME = true         ; 2 wstecz
LAST3_FRAME = true         ; 3 wstecz
GOLDEN_FRAME = true        ; golden
BWDREF_FRAME = true        ; backward
ALTREF2_FRAME = true       ; alt ref 2
ALTREF_FRAME = true        ; alt ref
COMPOUND = true            ; bi-prediction (dwie referencje)

[inter_modes]              ; typy predykcji inter
NEARESTMV = true           ; najbliższy MV z listy
NEARMV = true              ; drugi MV z listy
GLOBALMV = true            ; globalny ruch
NEWMV = true               ; nowy MV (motion search)
NEAREST_NEARESTMV = true   ; compound: nearest+nearest
NEAR_NEARMV = true         ; compound: near+near
NEW_NEWMV = true           ; compound: new+new
NEAREST_NEWMV = true       ; compound: nearest+new
NEW_NEARESTMV = true       ; compound: new+nearest
NEAR_NEWMV = true          ; compound: near+new
NEW_NEARMV = true          ; compound: new+near
GLOBAL_GLOBALMV = true     ; compound: global+global

[compound_types]           ; typy łączenia compound
COMPOUND_AVERAGE = true    ; prosta średnia
COMPOUND_DISTWTD = true    ; ważona odległością
COMPOUND_WEDGE = true      ; maska klinowa
COMPOUND_DIFFWTD = true    ; ważona różnicą

[tx_sizes]                 ; rozmiary bloków transformaty
TX_4X4 = true
TX_8X8 = true
TX_16X16 = true
TX_32X32 = true
TX_64X64 = true

[tx_types]                 ; typy transformaty
DCT_DCT = true             ; DCT w obu kierunkach
ADST_DCT = true            ; ADST pion + DCT poz
DCT_ADST = true            ; DCT pion + ADST poz
ADST_ADST = true           ; ADST w obu
FLIPADST_DCT = true        ; odwrócony ADST + DCT
DCT_FLIPADST = true        ; DCT + odwrócony ADST
FLIPADST_FLIPADST = true   ; odwrócony ADST w obu
ADST_FLIPADST = true       ; ADST + odwrócony ADST
FLIPADST_ADST = true       ; odwrócony ADST + ADST
IDTX = true                ; identity (skip transform)
V_DCT = true               ; DCT tylko pionowo
H_DCT = true               ; DCT tylko poziomo
V_ADST = true              ; ADST tylko pionowo
H_ADST = true              ; ADST tylko poziomo
V_FLIPADST = true          ; odwrócony ADST pionowo
H_FLIPADST = true          ; odwrócony ADST poziomo
```

## Przykłady

```bash
# Zakoduj 1 klatkę intra z B0 (najprostszy):
./encode.py -i black_256x256.yuv -o test.ivf -cfg B0_infrastructure.ini

# Zakoduj 5 klatek inter z deblockingiem:
./encode.py -i motion.yuv -o test.ivf -cfg B4_deblocking.ini -n 5

# Zakoduj z cropem (256x256 -> 128x64 z offsetem):
# Edytuj crop sekcję w INI:
#   [crop]
#   enabled = true
#   width = 128
#   height = 64
#   offset_x = 64
#   offset_y = 96
./encode.py -i full_frame.yuv -o cropped.ivf -cfg moj_config.ini

# Nadpisz rozdzielczość z linii poleceń:
./encode.py -i hd_content.yuv -o out.ivf -cfg B5_full.ini -W 1920 -H 1080 -n 30

# Stwórz własny config i edytuj:
./encode.py --init custom.ini
# vim custom.ini  (pozmieniaj true/false)
./encode.py -i input.yuv -o output.ivf -cfg custom.ini
```
