Interfață de Linie de Comandă

Integrează OpenShot în fluxul tău de lucru din linia de comandă. Importă materiale video, taie și aranjează clipuri, aplică efecte, animează proprietăți cu keyframe-uri și exportă videoclipuri direct din terminal. Folosește câteva comenzi pentru a automatiza editările repetitive, scrie un script pentru un proiect recurent sau lasă un agent AI să te ajute să asamblezi și să rafinezi un videoclip.

Linia de comandă funcționează cu aceleași proiecte ca editorul. Poți controla un editor deschis și revizui modificările pe măsură ce lucrezi sau poți lucra într-o sesiune fără interfață grafică fără a deschide o fereastră. O sesiune păstrează proiectul deschis între comenzi, inclusiv editările, istoricul de anulare și joburile de export. Salvează-l ca proiect .osp ori de câte ori dorești să continui editarea mai târziu.

Începutul

Folosește executabilul OpenShot instalat urmat de --cli. Începe cu intro pentru un ghid scurt despre sesiuni, editare, animație și salvare, sau help pentru o prezentare generală a comenzilor. Aceste comenzi nu necesită o sesiune activă. Exemplele de mai jos necesită o versiune OpenShot care include editarea din linia de comandă.

Linux AppImage

Din directorul care conține AppImage-ul descărcat:

./OpenShot.AppImage --cli intro
./OpenShot.AppImage --cli help

Înlocuiește OpenShot.AppImage cu numele fișierului descărcat. Dacă AppImageLauncher afișează dialoguri de integrare desktop, setează APPIMAGELAUNCHER_DISABLE=1 înainte de a lansa comanda:

APPIMAGELAUNCHER_DISABLE=1 ./OpenShot.AppImage --cli intro

Pentru scripturi sau comenzi repetate, setează-l o singură dată în shell-ul curent:

export APPIMAGELAUNCHER_DISABLE=1
./OpenShot.AppImage --cli session start

Variabila trebuie setată înainte de lansarea AppImage: AppImageLauncher o poate intercepta înainte ca OpenShot să primească --cli. Căile relative către media și fișierele @batch.json sunt rezolvate din directorul de lucru. Păstrează fișierul AppImage disponibil în timp ce sesiunile sau exporturile rulează.

Linux Snap

Pentru OpenShot Snap, folosește:

snap run openshot-qt --cli intro
snap run openshot-qt --cli help
snap run openshot-qt --cli session start

Permisiunile fișierelor Snap se aplică și editării din linia de comandă. Păstrează media, proiectele și exporturile în locații accesibile Snap, cum ar fi folderul tău personal. Pentru a permite accesul la unități externe, conectează permisiunea removable-media:

sudo snap connect openshot-qt:removable-media

Windows

Important

Folosește openshot-qt-cmd.exe pentru editare din linia de comandă pe Windows. Acest executabil de consolă afișează rezultatele comenzilor, ajutorul și erorile în terminalul tău. Executabilul desktop, openshot-qt.exe, nu afișează ieșirea standard într-un terminal interactiv, lăsând comenzile fără feedback vizibil și făcând CLI dificil de utilizat.

În PowerShell, din directorul de instalare OpenShot:

& .\openshot-qt-cmd.exe --cli intro
& .\openshot-qt-cmd.exe --cli help
& .\openshot-qt-cmd.exe --cli session start

Dacă ești într-un alt director, folosește calea completă către openshot-qt-cmd.exe. Păstrează --cli după numele executabilului.

macOS

Pentru o instalare în Applications:

"/Applications/OpenShot Video Editor.app/Contents/MacOS/openshot-qt" --cli intro
"/Applications/OpenShot Video Editor.app/Contents/MacOS/openshot-qt" --cli help

Găsirea comenzilor

Pe tot parcursul acestui ghid, openshot-cli este o prescurtare pentru comanda instalării tale de mai sus, cum ar fi snap run openshot-qt --cli sau ./OpenShot.AppImage --cli. Unele instalări oferă și comanda openshot-cli direct. Când rulezi din sursă, folosește python3 src/launch.py --cli în mediul Python al OpenShot.

Comenzile --cli, --cli help și --cli --help afișează aceeași prezentare generală. Ajutorul devine mai specific pe măsură ce navighezi prin comenzi:

openshot-cli clip help
openshot-cli clip keyframe help
openshot-cli clip keyframe set help
openshot-cli edit help
openshot-cli text help
openshot-cli effects list
openshot-cli effects audiovisualization help
openshot-cli effects audiovisualization help --property background

Ajutorul de grup explică fluxurile de lucru cu exemple; ajutorul operațiunilor descrie argumentele și comportamentul. --help este echivalent cu adăugarea help la sfârșit. Toate comenzile de ajutor funcționează fără o sesiune de editare.

effects list afișează efectele disponibile cu descrieri scurte. Ajutorul pentru efecte explică proprietățile, valorile implicite, opțiunile și intervalele acestora. effects instances listează efectele deja atașate clipurilor, cu ID-urile clipurilor părinte. Numele claselor, denumirile afișate și aliasurile cu underscore identifică același efect.

Lucrul cu scripturi și agenți AI

Agenții AI de programare precum Codex și Claude Code pot folosi CLI pentru a inspecta și edita proiecte OpenShot prin comenzi în terminal. Oferă agentului tău calea către executabilul OpenShot, media sau proiectul cu care să lucreze și rezultatul dorit: durată, dimensiuni, stil de animație și locația de ieșire. Cere-i să citească --cli intro înainte de a începe. Aceleași comenzi funcționează atât când le tastezi tu, cât și când le rulezi dintr-un script.

Începe cu intro, apoi folosește ajutorul specific comenzilor după nevoie. Un flux de lucru util este să selectezi o sesiune, să inspectezi proiectul, să faci un set mic de modificări, să revizuiești rezultatul și să salvezi. Comenzile returnează JSON structurat astfel încât scripturile și agenții să poată folosi direct ID-urile obiectelor și rezultatele, fără a interpreta ieșirea pe ecran.

  • Inspectează înainte de a edita. Folosește ID-urile și informațiile despre proprietăți returnate în loc să ghicești nume, numere de piste sau sincronizare. Selectează explicit o sesiune când sunt deschise mai multe proiecte.

  • Gruparea editărilor repetate. Folosește edit apply pentru o secvență de modificări sau edit bulk pentru a aplica un șablon clipurilor selectate. Validează cu --dry-run înainte de a aplica un lot.

  • Verifică animația. Alege un spațiu de coordonate, începe cu câteva cadre cheie și folosește presetări de easing pentru mișcări familiare. keyframe preview eșantionează curba astfel încât să poți observa pauze sau salturi înainte de export. Revizuiește și mișcarea redată; o foaie de contact singură nu poate arăta cum se simte o animație.

  • Salvează și urmărește exporturile. Salvează proiectul în mod explicit și verifică starea jobului de export înainte de a considera un rezultat ca fiind finalizat. Dacă o cerere expiră, inspectează starea acesteia înainte de a repeta o editare.

Secțiunile de mai jos explică aceste fluxuri de lucru și convențiile lor de sincronizare.

Sesiuni și rezultate

Pornirea sau găsirea unei sesiuni

Pornește o sesiune headless (fără fereastră de editor):

openshot-cli session start

Pentru a deschide un proiect existent la pornire, adaugă --project "/cale/proiect.osp". Răspunsul JSON de succes conține result.session_id. Copiază acea valoare. Dacă OpenShot este deja pornit sau ai uitat ID-ul, găsește sesiunile disponibile cu:

openshot-cli session list

Alege sesiunea pentru proiectul pe care intenționezi să îl editezi. Nu este necesar să pornești o sesiune nouă pentru fiecare comandă.

Selectarea unei sesiuni

Sfat

Setează OPENSHOT_SESSION o singură dată, apoi rulează comenzile normal. Terminalul tău reține sesiunea selectată, deci nu trebuie să folosești --session la fiecare comandă. Folosește exemplul PowerShell sau Bash de mai jos.

Înlocuiește SESSION_ID de mai jos cu session_id returnat de session start sau session list.

Windows PowerShell:

$env:OPENSHOT_SESSION = "SESSION_ID"
& .\openshot-qt-cmd.exe --cli timeline view
& .\openshot-qt-cmd.exe --cli export start "C:\path\test.mp4" --wait

Linux Bash:

export OPENSHOT_SESSION="SESSION_ID"
./OpenShot.AppImage --cli timeline view
./OpenShot.AppImage --cli export start "/path/test.mp4" --wait

Pe macOS, folosește aceeași sintaxă export. Pentru comenzile macOS sau Snap, înlocuiește cu executabilul instalării tale din Ghidul de început. Selectarea durează pentru acest terminal și comenzile lansate din el. Setează din nou într-un terminal nou sau actualizează când schimbi sesiunea.

Exemplele rămase de editare și export presupun că OPENSHOT_SESSION este setat. Subsecțiunea următoare arată cum să capturezi automat ID-ul pentru scripturi.

Pentru a viza o sesiune diferită doar pentru o comandă, folosește --session. Aceasta suprascrie OPENSHOT_SESSION fără a schimba selecția terminalului tău:

openshot-cli --session OTHER_SESSION_ID project get

Cu un executabil pachetat, pune această suprascriere după --cli și înaintea grupului de comenzi: --cli --session OTHER_SESSION_ID project get.

Selecția automată funcționează doar când există exact o sesiune accesibilă. Dacă vezi session_required, rulează session list și selectează explicit sesiunea dorită. Dacă nu mai este listată, pornește-o din nou și folosește noul ID. Ajutorul, intro și descoperirea sesiunilor nu necesită o sesiune selectată.

Capturarea automată a ID-ului sesiunii

Scripturile pot citi result.session_id direct din JSON-ul returnat de session start și pot seta OPENSHOT_SESSION pentru comenzile următoare. Nu este nevoie să copiezi manual ID-ul sau să citești un fișier jurnal. Verifică dacă pornirea a reușit înainte de a folosi ID-ul returnat.

Windows PowerShell (setează calea executabilului pentru instalarea ta):

$openshot = "C:\Program Files\OpenShot Video Editor\openshot-qt-cmd.exe"
$reply = & $openshot --cli session start
if ($LASTEXITCODE -ne 0) { throw "OpenShot session startup failed" }
$session = $reply | ConvertFrom-Json
if (-not $session.ok -or -not $session.result.session_id) {
    throw "OpenShot did not return a session ID"
}
$env:OPENSHOT_SESSION = $session.result.session_id
& $openshot --cli timeline view

Linux Bash (necesită jq pentru a citi JSON):

openshot="/full/path/to/OpenShot.AppImage"
export APPIMAGELAUNCHER_DISABLE=1
if reply=$("$openshot" --cli session start) &&
   session_id=$(printf '%s' "$reply" | jq -er 'select(.ok == true) | .result.session_id | strings | select(length > 0)'); then
    export OPENSHOT_SESSION="$session_id"
    "$openshot" --cli timeline view
else
    echo "OpenShot session startup failed" >&2
fi

Variabila de mediu selectează o sesiune pentru comenzile lansate din acest terminal; nu schimbă o setare la nivel de sistem. Pornirea unei sesiuni nu setează variabila automat. După oprirea sesiunii, șterge selecția cu Remove-Item Env:OPENSHOT_SESSION în PowerShell sau unset OPENSHOT_SESSION în Bash.

Afișarea și oprirea unei sesiuni

Pentru a afișa sesiunea selectată în editor:

openshot-cli session show

Pe desktop, session show creează editorul în același proces și păstrează proiectul live, ID-urile, istoricul, joburile de export și conexiunea. Apelurile repetate aduc în prim-plan fereastra existentă. session start --show o deschide imediat. Sesiunile pornite fără afișaj sau cu QT_QPA_PLATFORM=offscreen/minimal nu pot afișa ulterior o fereastră desktop. Pentru aceste sesiuni, salvează și deschide proiectul într-o sesiune desktop nouă. Odată afișată, închide sesiunea prin fereastra editorului.

Opțiunile globale (--session, --timeout) se plasează înaintea comenzii. session serve rămâne în prim-plan pentru supraveghetori; session start revine după ce un host de fundal se înregistrează. session stop refuză modificările nesalvate și exporturile active. Folosește --discard doar pentru a renunța intenționat la editările nesalvate.

Ieșirea comenzii

Rezultatele sunt JSON pe stdout, cu excepția vizualizării implicite a timeline-ului text. Erorile sunt JSON pe stderr cu cod de ieșire 1; erorile parserului de argumente ies cu cod 2. Mutările returnează rezumate compacte cu comanda inspect. get returnează JSON al obiectului nativ. Răspunsurile proiectului includ o revizie; răspunsurile catalogului de efecte nu necesită sesiune. Jurnalele sesiunilor headless se află lângă înregistrările lor din registru. OPENSHOT_SESSION_DIR suprascrie directorul implicit ~/.openshot_qt/sessions.

Sesiunile acceptă comenzi local pe calculatorul dumneavoastră. Păstrați registrul sesiunilor privat, deoarece conține acreditările folosite pentru a accesa sesiunile de editare. Exporturile funcționează dintr-o captură instantanee, astfel încât puteți continua editarea în timp ce un job rulează.

Deschiderea și salvarea proiectelor

Un proiect OpenShot (.osp) stochează linia temporală editabilă. Exportul creează un videoclip finalizat; salvarea proiectului vă permite să reveniți la clipurile, efectele și cadrele cheie mai târziu. Salvați proiectul separat chiar și atunci când exportați un videoclip.

Deschiderea unui proiect

Porniți o sesiune cu un proiect existent:

openshot-cli session start --project "/home/me/Videos/My Project.osp"

Adăugați --show pentru a deschide și fereastra editorului. Pentru a folosi un editor deja deschis, găsiți-l cu session list. Setați OPENSHOT_SESSION la ID-ul sesiunii returnat, apoi deschideți sau inspectați un proiect:

openshot-cli project open "/home/me/Videos/My Project.osp"
openshot-cli project get

Înlocuiți calea exemplu cu a dumneavoastră și puneți între ghilimele căile care conțin spații. project open înlocuiește proiectul curent al sesiunii selectate. Refuză să elimine modificările nesalvate decât dacă adăugați explicit --discard; salvați mai întâi acele modificări dacă doriți să le păstrați. Deschiderea prin CLI nu afișează dialoguri interactive pentru media lipsă, așa că păstrați media sursă a proiectului disponibilă.

Pentru un proiect nou, gol, folosiți session start fără --project, apoi importați media și adăugați clipuri așa cum este descris la Editare.

Salvarea unui proiect sau a unei copii

Salvați într-un fișier nou sau creați o versiune separată înainte de a face mai multe modificări:

openshot-cli project save "/home/me/Videos/My Project v2.osp"

Pentru a actualiza un fișier existent, permiteți explicit înlocuirea:

openshot-cli project save "/home/me/Videos/My Project v2.osp" --overwrite

Furnizați întotdeauna calea destinației. Salvarea unui fișier .osp nu include toate materialele sursă în acel fișier; păstrați media referențiată disponibilă când mutați sau redeschideți proiectul.

Exportarea unui videoclip

Automatizați redarea și exportul din scripturi sau agenți AI, folosind setările proiectului sau alegând un profil de ieșire diferit pentru fiecare redare. Joburile de export pot rula în fundal sau pot aștepta finalizarea înainte ca scriptul dumneavoastră să continue. Pentru a reda un MP4 folosind rezoluția și rata de cadre a proiectului:

openshot-cli export start "/home/me/Videos/video.mp4" --wait

Implicit, OpenShot folosește video H.264 și audio AAC. Înlocuiți calea exemplu cu destinația dumneavoastră, folosind un folder existent și un nume de fișier nou. Fișierele de ieșire existente nu sunt niciodată suprascrise. Exportul nu salvează proiectul editabil .osp; folosiți project save separat pentru a păstra munca de editare.

Opțiunea --wait menține comanda activă până când exportul se finalizează sau raportează o eroare. Verificați videoclipul finalizat înainte de a-l distribui.

Verificarea progresului exportului

Nu folosiți --wait pentru a porni un export în fundal. Răspunsul include un ID de job pe care îl puteți folosi pentru a verifica progresul:

openshot-cli export start "/home/me/Videos/video.mp4"
openshot-cli export status JOB_ID
openshot-cli export status JOB_ID --wait
openshot-cli export list

Înlocuiți JOB_ID cu ID-ul returnat. Dacă timpul de așteptare expiră, exportul continuă să ruleze; verificați același job în loc să porniți un alt export. Pentru a opri un job, folosiți export cancel JOB_ID. Fiecare job capturează linia temporală la început, astfel încât modificările ulterioare nu schimbă un export deja în curs.

Timpul implicit de așteptare este de 600 de secunde; ajustați-l cu --wait-timeout. Acesta este separat de --timeout global pe cerere. Eșecurile exportului, anulările și expirările timpului de așteptare ies cu status 1 și includ detalii despre job.

Exportarea în mai multe profiluri

Exportați aceeași linie temporală la rezoluții sau raporturi de aspect diferite alegând un profil de export pentru fiecare ieșire. Un profil de export se aplică doar acelui job; nu schimbă profilul proiectului de editare. Un profil setează dimensiunile, rata de cadre și raportul de aspect; un preset de export selectează setările de codare, cum ar fi MP4/H.264.

Găsiți profilurile disponibile și inspectați setările acestora:

openshot-cli profile list --search 720
openshot-cli profile list --search 1080
openshot-cli profile get builtin:01280x0720p0030_16-09

De exemplu, exportați versiuni peisaj la 720p și 1080p, apoi o versiune pătrată la 1080 pe 1080. Toate aceste profiluri folosesc 30 fps:

openshot-cli export start "/home/me/Videos/video-720p.mp4" --profile builtin:01280x0720p0030_16-09 --wait
openshot-cli export start "/home/me/Videos/video-1080p.mp4" --profile builtin:01920x1080p0030_16-09 --wait
openshot-cli export start "/home/me/Videos/video-square.mp4" --profile builtin:01080x1080p0030_01-01 --wait

Folosiți un nume de fișier de ieșire diferit pentru fiecare versiune. Păstrați modificările neschimbate între joburi când doriți versiuni corespunzătoare. Schimbarea raportului de aspect poate modifica încadratura: verificați fiecare ieșire, în special titlurile și subiectele animate. Pentru o versiune pătrată sau portret compusă separat, salvați o copie a proiectului, schimbați profilul proiectului și ajustați clipurile înainte de export. Consultați Profilurile și setările de export de mai jos pentru profiluri personalizate și opțiuni de codare.

Exportarea în lot a mai multor proiecte

Refolosiți o sesiune fără interfață pentru a reda mai multe proiecte salvate în secvență. Deschideți un proiect, exportați-l cu --wait, apoi deschideți următorul proiect. Exemplele de mai jos folosesc rezoluția și rata de cadre ale fiecărui proiect și creează fișiere MP4 lângă fișierele .osp. Adăugați --profile PROFILE_ID la comanda de export pentru a folosi un profil de ieșire pentru fiecare proiect.

Rulați mai întâi cu succes exemplul de sesiune-ID automat corespunzător de mai sus, în același terminal. Acesta definește openshot și selectează noua sesiune. Înlocuiți căile proiectului de mai jos cu ale dvs. Folosiți nume de ieșire distincte care nu există deja; exemplele verifică toate destinațiile înainte de a începe lotul.

Windows PowerShell:

$projects = @(
    "C:\VideoProjects\First.osp",
    "C:\VideoProjects\Second.osp"
)
foreach ($project in $projects) {
    if (-not (Test-Path -LiteralPath $project -PathType Leaf)) {
        throw "Project not found: $project"
    }
    $output = [System.IO.Path]::ChangeExtension($project, ".mp4")
    if (Test-Path -LiteralPath $output) { throw "Output already exists: $output" }
}
foreach ($project in $projects) {
    $output = [System.IO.Path]::ChangeExtension($project, ".mp4")
    & $openshot --cli project open $project
    if ($LASTEXITCODE -ne 0) { throw "Could not open: $project" }
    & $openshot --cli export start $output --wait --wait-timeout 86400
    if ($LASTEXITCODE -ne 0) { throw "Export needs attention: $output" }
}
& $openshot --cli session stop
if ($LASTEXITCODE -ne 0) { throw "Could not stop the session" }
Remove-Item Env:OPENSHOT_SESSION

Linux Bash (parantezele păstrează gestionarea erorilor locală pentru lot):

(
    set -e
    : "${OPENSHOT_SESSION:?Run the session startup example first}"
    projects=(
        "/home/me/VideoProjects/First.osp"
        "/home/me/VideoProjects/Second.osp"
    )
    for project in "${projects[@]}"; do
        test -f "$project" || { echo "Project not found: $project" >&2; exit 1; }
        output="${project%.osp}.mp4"
        test ! -e "$output" || { echo "Output already exists: $output" >&2; exit 1; }
    done
    for project in "${projects[@]}"; do
        "$openshot" --cli project open "$project"
        "$openshot" --cli export start "${project%.osp}.mp4" --wait --wait-timeout 86400
    done
    "$openshot" --cli session stop
) && unset OPENSHOT_SESSION

Ambele rețete opresc lotul la o eroare de comandă și lasă sesiunea disponibilă pentru inspectare. Limita de așteptare aici este de 24 de ore per export. Un timeout de așteptare lasă redarea în curs: folosiți export list și export status JOB_ID --wait înainte de a încerca din nou. Videoclipurile finalizate rămân pe disc; eliminați proiectele finalizate din lot înainte de a relua. După rezolvarea unei erori, opriți sesiunea și ștergeți variabila sa de mediu când ați terminat.

Alegerea presetărilor și setărilor de codare

Descoperiți presetările de export instalate și setările suportate:

openshot-cli export preset list
openshot-cli export preset get builtin:format_mp4_x264
openshot-cli export capabilities
openshot-cli export start /tmp/reel.mp4 --preset builtin:format_mp4_x264 --quality med --wait

Exportul acceptă de asemenea --from-file FILE_ID cu opționalul --create-custom. Setările se rezolvă în această ordine: implicitul proiectului, presetarea, JSON avansat, flaguri explicite pentru profil/calitate/domeniu. JSON-ul avansat expune codecuri video/audio și bitrate, configurarea audio/rata/canalele, opțiuni native de codec, setări hardware și numărul de fire de execuție.

De exemplu, selectați o opțiune de encoder prin JSON avansat:

openshot-cli export start /tmp/small.mp4 --profile builtin:00640x0360p0030_16-09 --json '{"video_options":{"preset":"fast"}}' --wait

Validarea setărilor de export

Verificați setările înainte de a începe redarea:

openshot-cli export validate /tmp/reel.mp4 --preset builtin:format_mp4_x264

Raportul de capabilități indică disponibilitatea codec-urilor compilate, nu disponibilitatea fizică a GPU-ului. Validarea merge mai departe: deschide encoderele (inclusiv cele hardware) și containerul cu setările exacte, într-un proces separat, fără a scrie un fișier. O combinație pe care containerul nu o poate susține eșuează cu incompatible_export, explicația FFmpeg și setarea de modificat (details.cause.path):

openshot-cli export validate /tmp/song.mp3 --json '{"mode":"audio","format":"mp3","audio_codec":"aac"}'

Procesul de export efectuează aceeași verificare înainte de redare.

Redarea unui interval de cadre

Folosiți --start-frame și --end-frame pentru a reda o parte din cronologie. Intervalele sunt incluzive și numerotate de la unu la FPS-ul profilului de export. De exemplu, redați primele 90 de cadre la 30 fps (trei secunde):

openshot-cli export start /tmp/excerpt.mp4 --profile builtin:01280x0720p0030_16-09 --start-frame 1 --end-frame 90 --wait

Exporturi doar audio și secvențe de imagini

Alegeți un mod de ieșire cu JSON avansat:

openshot-cli export start /tmp/music.wav --json '{"mode":"audio","format":"wav","audio_codec":"pcm_s16le"}' --wait
openshot-cli export start /tmp/frames --json '{"mode":"image_sequence","format":"png"}' --end-frame 3 --wait

Secvențele de imagini necesită un director nou de ieșire. Ieșirile existente nu sunt niciodată suprascrise.

Editare

Adăugarea clipurilor și efectelor

Folosiți ID-urile returnate de import/add/list și descoperiți numerele de strat cu project get:

openshot-cli file import /absolute/path/video.mp4
openshot-cli clip add FILE_ID --layer 2000000 --position 3 --start 10 --end 17 --volume 0
openshot-cli clip set CLIP_ID --json '{"volume":0.5}'
openshot-cli clip keyframe set CLIP_ID --property volume --frame 301 --value 0
openshot-cli clip keyframe set CLIP_ID --property volume --frame 331 --value 1
openshot-cli effects add CLIP_ID saturation
openshot-cli effects set EFFECT_ID --json '{"saturation":1.2}'
openshot-cli project save /absolute/path/edit.osp

Alegeți profilul proiectului cât mai devreme posibil; proiectele populate suportă de asemenea schimbări de profil prin conversia FPS existentă și sistemul de anulare. --audio-only la crearea clipului suprimă video, inclusiv coperta încorporată în fișierele muzicale. Pentru a folosi acel clip pentru Vizualizarea Audio, activați video și audio și urmați ajutorul efectului pentru suprapuneri transparente și plasarea stratului.

Înțelegerea sincronizării clipului

Keyframe-urile exemplu presupun un proiect de 30fps și un clip tăiat la sursa de 10s. Poziția este în secunde pe cronologie; startul/sfârșitul sunt secunde sursă, cu sfârșitul exclusiv. Cadrele încep de la 1. Cadrele miniaturii fișierului folosesc FPS-ul sursei. Cadrele cronologiei folosesc FPS-ul proiectului. Keyframe-urile clipului folosesc coordonate sursă la FPS-ul proiectului, deci tăierea clipului nu mută primul keyframe vizibil la cadrul 1.

Modificarea proprietăților

set combină proprietățile de nivel superior. Scalarile transformă proprietățile cu keyframe în constante. O curbă imbricată furnizată înlocuiește acea curbă; folosiți keyframe set pentru a schimba doar un punct. Argumentele JSON acceptă JSON inline, @file.json sau - pentru stdin. Numele proprietăților, tipurile, enumerațiile, keyframe-urile, referințele și sincronizarea sunt validate înainte de editarea proiectului. Erorile identifică câmpul, valoarea așteptată, valoarea primită și o corecție dacă este posibilă. Intervalele slider-ului GUI sunt consultative acolo unde motorul suportă valori dincolo de ele.

Adăugarea de estompare

clip fade ID --in 0.5 --out 0.5 calculează automat coordonatele keyframe-urilor pentru tăierea sursei. Înlocuiește curba alfa; --property volume --value 0.25 creează în schimb o estompare audio cu un câștig maxim de 0.25. Duratele trebuie să se încadreze între primul și ultimul cadru vizibil; estomparea la ieșire ajunge la zero pe ultimul cadru.

Împărțirea clipurilor

clip split ID --at 6.5 folosește secunde pe cronologie, se fixează pe cadrul proiectului cel mai apropiat și păstrează ambele jumătăți. Păstrează curbele cu coordonate sursă și duplică efectele cu ID-uri noi pe jumătatea dreaptă, urmând comportamentul de tăiere al editorului. Jumătatea stângă își păstrează ID-ul. Răspunsul raportează timpii de tăiere solicitați/realizați și ambele rezumate; un rezultat de lot denumit suportă {"$ref":"cut.right.id"}. Tăierile resping capetele și pistele blocate. Anularea restaurează clipul original într-o singură tranzacție.

Presetări meniului clip

Presetările meniului clipului din editor folosesc același cod ca linia de comandă. Fiecare comandă listează presetările în ajutorul său, iar fiecare este un singur pas de anulare:

openshot-cli clip motion CLIP_ID --preset slide-in-left
openshot-cli clip motion CLIP_ID --preset pulse --at 4.5
openshot-cli clip look CLIP_ID --effect ColorGrade --preset warm_up
openshot-cli clip look CLIP_ID --effect all --preset none
openshot-cli clip speed CLIP_ID --mode forward --factor 2
openshot-cli clip speed CLIP_ID --mode freeze --at 3 --duration 2
openshot-cli clip repeat CLIP_ID --passes 3 --pattern pingpong
openshot-cli clip waveform CLIP_ID

Presetările de mișcare sunt relative la transformarea curentă a clipului. Presetările de aspect adaugă sau înlocuiesc un efect, iar none îl elimină. Viteza și repetarea reprogramă fiecare keyframe și schimbă lungimea clipului; clip speed --mode reset restaurează viteza normală. Alte acțiuni din meniu sunt editări simple: rotire și aranjare cu clip set, decupare cu effects add Crop. Comenzile funcționează și în edit apply și edit bulk.

Adăugarea și stilizarea textului

text add creează un text și îl plasează ca un clip, folosind același text ca și instrumentul Text din editor. Opțiunile pe care le omiți folosesc stilul implicit al editorului:

openshot-cli text add --text "Opening Night" --layer 5000000 --position 2 --duration 4 \
    --place lower-third --font "Noto Sans" --size 72 --bold --color "#ffffff" \
    --background "#80000000" --background-padding 16 --background-corner 12
openshot-cli text get CLIP_ID
openshot-cli text set CLIP_ID --stroke black --stroke-width 3
openshot-cli text set CLIP_ID --text $'Two\nlines' --line-spacing 1.4
openshot-cli text fonts --search noto
openshot-cli text list --search opening

Cuvintele, fontul, dimensiunea, alinierea, lățimea casetei și culorile implicite aparțin textului din Fișierele Proiectului și sunt partajate de fiecare clip care îl folosește, la fel ca în editor. text set pe un clip le schimbă pe toate și le listează în changed_clip_ids; --this-clip-only oferă mai întâi clipului o copie proprie. clip add FILE_ID plasează un alt clip de text din text list. Dimensiunile sunt în pixeli la rezoluția proiectului, iar culorile sunt #RRGGBB, #AARRGGBB (cu alfa), un nume CSS sau transparent. --place poziționează caseta în centru, pe o margine sau colț, sau în treimea inferioară. --line-spacing este un multiplu al distanței normale dintre linii (1 este normal), iar --background-corner rotunjește colțurile fundalului și ale bordurii cu atâția pixeli.

Un clip de text este un clip obișnuit. Poziția, scala, rotația, opacitatea, sincronizarea, estomparea, presetările de mișcare și efectele folosesc toate comenzile normale clip. Dimensiunea fontului, padding-ul, lățimea casetei și spațierea literelor și liniilor setează dimensiunea casetei de text, deci nu pot fi animate prin keyframe; pentru a anima dimensiunea textului, animează scala clipului. Fiecare clip poate anima propriile culori de text și contur și lățimi ale bordurii cu aceleași comenzi de keyframe ca orice altă proprietate:

openshot-cli clip keyframe list CLIP_ID
openshot-cli clip keyframe set CLIP_ID --property text_color.alpha --space clip --unit seconds --at 0 --value 0
openshot-cli clip keyframe set CLIP_ID --property text_color.alpha --space clip --unit seconds --at 1 --value 255

Proprietățile animate sunt text_color, text_background, text_stroke și text_border (culori, cu .red, .green, .blue și .alpha de la 0 la 255), plus text_stroke_width, text_border_width și text_background_corner. Animația proprie a unui clip prevalează asupra stilului partajat, iar text get listează ce stiluri animă un clip. text reset CLIP_ID readuce un clip la stilul implicit, ca în Text → Reset Style; --keyframes-only elimină doar animația proprie a clipului. Pentru a stiliza mai multe texte simultan, selectează-le cu {"text":true}:

openshot-cli edit bulk --select '{"text":true}' --json '[{"method":"text.set","params":{"font_family":"Noto Sans","stroke_width":2}}]'

Aplicarea unui lot de editări

edit apply --json @edits.json --expect-revision 12 acceptă până la 256 de comenzi de mutație ordonate, folosind nume de comenzi punctate precum clip.set și effects.add (scrierea mai veche effect.add funcționează de asemenea):

[
  {"method":"project.profile.set","params":{"id":"builtin:01280x0720p0024_16-09"}},
  {"method":"file.import","as":"media","params":{"path":"/tmp/video.mp4"}},
  {"method":"clip.add","as":"shot","params":{"file_id":{"$ref":"media.id"},"layer":1000000,"start":10,"end":15}},
  {"method":"clip.fade","params":{"id":{"$ref":"shot.id"},"fade_in":0.5,"fade_out":0.5}}
]

Opționalul as leagă un rezultat pentru comenzile ulterioare din același lot. Un obiect {"$ref":"shot.id"} substituie câmpul acelui rezultat. Referințele rezolvă doar numele anterioare; greșelile de scriere, referințele înainte și numele duplicate eșuează înainte de actualizările live. Răspunsul include rezultate compacte ordonate și o hartă refs cu ID-urile reale. Toate modificările dintr-un lot reușit formează un singur pas de anulare/refacere. project.profile.set suportă și timeline-uri populate. Comenzile de deschidere, salvare, export și inspecție rămân în afara loturilor de editare. Ajutorul fiecărei comenzi listează numele parametrilor JSON, inclusiv scrierea cu underscore a flagurilor shell (de exemplu, --fps-num devine fps_num).

Validarea loturilor și gestionarea erorilor

Toate comenzile din loturile de editare sunt verificate preliminar pe un proiect detașat înainte de orice actualizări live. Intrarea invalidă lasă proiectul live și revizia neschimbate. Loturile valide formează un singur grup de anulare. Eșecurile neașteptate în timpul execuției pot produce totuși modificări parțiale; erorile raportează operațiunile finalizate. Un timeout nu implică anulare, deci inspectează starea înainte de a reîncerca mutațiile.

Editare precisă a keyframe-urilor

clip, transition și effects suportă keyframe list, set, remove, clear, transform, copy și paste. Căile proprietăților pot adresa curbe imbricate, cum ar fi color.red pe un efect Chroma Key. Editarea unei curbe imbricate păstrează canalele surori. Rulează keyframe list ID fără o proprietate pentru a descoperi căile curbelor și numărul de puncte. Descoperirea și listarea punctelor includ contextul de sincronizare trim/poziție; listarea punctelor raportează și coordonatele native ale cadrelor. get și properties expun obiectul nativ complet și metadatele proprietăților. Erorile identifică câmpurile invalide, sugerează nume apropiate de proprietăți și explică corecțiile de coordonate.

Alege coordonatele explicit cu --space native|clip|timeline și --unit frames|seconds. Toate cadrele folosesc FPS-ul proiectului și sunt indexate de la 1; secundele încep de la zero și se aliniază la cadrul cel mai apropiat. Native este coordonata keyframe-ului existent în motor (inclusiv decuparea sursei). Coordonatele clipului încep de la punctul de intrare vizibil al clipului; coordonatele timeline-ului încep de la timpul zero al proiectului. Efectele atașate folosesc sincronizarea clipului părinte. Aceste coordonate se referă la timpul animației, nu la cadrele media selectate de o curbă de remapare a timpului.

Pentru un clip poziționat la 5 secunde, tăiat la 2 secunde, într-un proiect de 30 fps, cadrul clipului 1, cadrul timeline-ului 151 și cadrul nativ 61 indică același punct. Poziția și tăierea se aliniază independent la grila cadrelor proiectului. Listarea unei curbe întregi poate include puncte ascunse cu coordonate clip/timeline nenegative. Opțiunea veche --frame înseamnă încă un cadru nativ și nu poate fi combinată cu --at.

Exemple:

openshot-cli clip keyframe set CLIP --property location_x --space clip --unit seconds --at 0 --value -1
openshot-cli clip keyframe set CLIP --property location_x --space clip --unit seconds --at 1 --value 0 --interpolation bezier --handles '{"handle_left":{"X":0.2,"Y":0.9}}'
openshot-cli effects keyframe set EFFECT --property color.red --space clip --at 31 --value 200
openshot-cli clip keyframe list CLIP --property location_x --space clip --unit seconds
openshot-cli clip keyframe transform CLIP --property location_x --space clip --start 1 --end 31 --scale 2 --offset 15
openshot-cli clip keyframe copy TARGET --property location_x --source-id SOURCE --space clip --start 1 --end 31 --at 1 --mode merge
openshot-cli clip keyframe remove CLIP --property location_x --space clip --at 31
openshot-cli clip keyframe clear CLIP --property location_x --value 0

Interpolare, easing și previzualizare

Interpolarea descrie segmentul până la punctul de destinație. Linear oferă o rată constantă între puncte. Constant păstrează valoarea precedentă până la destinație, apoi sare. Bezier-ul implicit nativ gestionează easing-ul la ambele capete ale fiecărui segment. Adăugarea unui punct intermediar poate introduce o încetinire neintenționată; pentru o singură mișcare easing, începeți cu două puncte finale. De obicei, lăsați mânerele nemodificate și alegeți un preset numit pentru un stil specific.

Descoperiți aceleași presetări de easing folosite în meniurile editorului, fără o sesiune:

openshot-cli clip keyframe presets

Aplicați un preset segmentului de intrare setând destinația acestuia:

openshot-cli clip keyframe set CLIP --property scale_x --space clip --unit seconds --at 0 --value 1
openshot-cli clip keyframe set CLIP --property scale_x --space clip --unit seconds --at 4 --value 1.2 --easing ease-in-out

Opțiunea easing implică Bezier. Aceasta setează împreună mânerul de ieșire al punctului anterior și mânerul de intrare al destinației, păstrând celelalte mânere și valorile punctelor. Trebuie să existe un punct anterior. Nu combinați cu mânere personalizate sau o interpolare diferită. Preseturile funcționează în loturi și șabloane în masă. Presetul GUI ease („Ease (Implicit)”) diferă de mânerele native folosite de interpolarea simplă Bezier. Preseturile back pot depăși valorile punctelor finale.

Inspectați mișcarea înainte de redare, folosind evaluatorul nativ al curbei:

openshot-cli clip keyframe preview CLIP --property scale_x --space clip --unit seconds --start 0 --end 4
openshot-cli clip keyframe preview CLIP --property scale_x --space clip --unit seconds --at 2

Previzualizarea este doar în citire și funcționează identic pentru efecte și tranziții. Returnează valori și rate semnate incoming_rate / outgoing_rate în unități de proprietate pe secundă, calculate din cadre imediat adiacente. Acestea sunt diferențe finite, nu derivate analitice. La cadrul nativ 1, rata de intrare este nulă. Ratele cadrelor adiacente pot inspecta în afara intervalului solicitat. Ratele aproape zero în jurul unui punct interior indică o pauză; ratele diferite indică o schimbare de viteză. Interpolarea constantă indică o săritură la destinație.

Fără un interval, previzualizarea acoperă primul și ultimul punct al curbei. Intervalele sunt incluzive, cu 17 eșantioane distribuite uniform implicit (–count: 2–256). Sunt incluse și cadrele cheie și vecinii lor imediat din interiorul intervalului, astfel încât un număr redus de eșantioane nu va ascunde o oprire a cadrului cheie. Maximul este de 1024 eșantioane; cererile mai mari necesită un interval mai restrâns. –at eșantionează un singur cadru. Previzualizarea raportează coordonatele în spațiul solicitat și cadrele native reale; secundele se aliniază la cadrele proiectului așa cum se întâmplă și la editare.

Pentru mânere personalizate avansate, atât X cât și Y sunt normalizate la segment: X este o fracțiune din intervalul său de cadre; Y este o fracțiune din schimbarea valorii. Primul control provine de la handle_right al punctului anterior, al doilea de la handle_left al destinației. Valorile implicite native sunt right=(0.5, 0), left=(0.5, 1), cu tangente plate la capete. Schimbarea doar a handle_type nu recalculează o tangentă continuă prin punctele înconjurătoare. Mânerele existente sunt păstrate când se mută un punct.

Intervalele cadrelor cheie sunt incluzive, spre deosebire de intervalele de timp pentru selecția clipurilor. Listarea emite points ale căror valori co.X folosesc spațiul/unitatea de coordonate solicitată. Transmiteți acest array la keyframe paste --json @points.json cu același spațiu/unitate, alegând --mode merge (înlocuiește cadrele corespunzătoare, păstrează altele) sau --mode replace (înlocuiește întreaga curbă). copy acceptă o sursă de același tip de obiect, un opțional --source-property, și ancorează primul punct sursă selectat la --at pe țintă. Alte curbe și obiecte sursă rămân neschimbate.

transform aplică o scală de timp pozitivă în jurul primului punct selectat sau --pivot, urmată de un --offset semnat în unitatea aleasă. Alinierea cadrelor care creează coordonate duplicate este respinsă, inclusiv coliziunile cu puncte din afara intervalului selectat. Coordonatele native trebuie să rămână cel puțin 1. Mânerele Bézier normalizate native și interpolarea se deplasează odată cu fiecare punct; mânerele nu sunt coordonate absolute ale cadrului. set --handles modifică doar mânerele furnizate. Interpolarea aparține punctului de destinație.

clear păstrează un punct de bază constant la cadrul nativ 1: specificați --value sau eșantionați curba existentă cu --at (implicit cadrul nativ 1). Eliminarea ultimului punct păstrează de asemenea o bază constantă, astfel încât adăugările ulterioare de cadre cheie rămân valide.

Selectarea și editarea mai multor clipuri

Folosiți edit apply --dry-run pentru a valida un lot fără a modifica proiectul. Folosiți edit bulk pentru a repeta un șablon mic de comandă pentru fiecare clip selectat, cu toate modificările grupate într-un singur pas de anulare.

Previzualizați mai întâi o selecție:

openshot-cli edit select --json '{"layer":1000000,"start":5,"end":20,"effect":"Saturation"}'

Selectorii acceptă ids (array unic de ID-uri de clip), layer, start/end (secunde pe cronologie), file_id, effect (nume de clasă sau alias), și text (true selectează clipuri text). Filtrele se combină cu AND. Intervalele de timp selectează clipuri care se suprapun cu [start, end); acestea nu taie clipurile. Rezultatele sunt ordonate după poziție, strat, apoi ID, și includ ID-uri, rezumate, starea de blocare și revizia curentă. ID-urile necunoscute sunt erori. Un selector gol este respins; folosiți explicit {"all":true} pentru fiecare clip. Selecțiile sunt limitate la 256 de clipuri și nu sunt niciodată trunchiate silențios.

De exemplu, salvați acest array ca templates.json:

[
  {"method":"clip.adjust","params":{"values":{"position":{"add":2},"volume":{"multiply":0.5}}}},
  {"method":"effects.add","as":"look","params":{"type":"Saturation"}},
  {"method":"effects.keyframe.set","params":{"id":{"$ref":"look.id"},"property":"saturation","space":"clip","at":1,"value":0}},
  {"method":"effects.keyframe.set","params":{"id":{"$ref":"look.id"},"property":"saturation","space":"clip","at":31,"value":1.2}}
]

Validați-l, apoi aplicați-l asupra reviziei returnate de selecție:

openshot-cli edit bulk --select '{"ids":["CLIP_A","CLIP_B"]}' --json @templates.json --dry-run
openshot-cli edit bulk --select '{"ids":["CLIP_A","CLIP_B"]}' --json @templates.json --expect-revision 42

Comenzile pentru clipuri existente moștenesc id; effects.add moștenește clip_id. Omită acești parametri țintă în șabloane. Editările efectelor trebuie să facă referire la un rezultat anterior denumit. Numele sunt locale fiecărui clip selectat, deci look.id se referă la un efect diferit pentru fiecare clip. Pentru a modifica instanțe existente de efecte prin ID explicit, continuați să folosiți edit apply. Setul de ID-uri selectat este fix înainte de extindere; modificările poziției sau efectelor nu schimbă țintele rămase.

clip set aplică proprietăți absolute; clip adjust aplică multiply apoi add unei proprietăți numerice sau fiecărei valori dintr-o curbă, păstrând sincronizarea punctelor, interpolarea și mânerele normalizate. Validează valorile rezultate, inclusiv pozițiile nenegative și volumul. Câmpurile structurale rămân protejate.

Operațiile în masă resping selecțiile goale, pistele țintă blocate și mai mult de 256 de comenzi extinse. Fiecare operație extinsă trece printr-un preflight detașat înainte de orice editare live. Execuțiile de test nu rezervă ID-uri generate. Folosiți --expect-revision pentru a respinge selecțiile învechite. Loturile reușite sunt un pas de anulare, inclusiv după salvare/redeschidere. Reîmprospătările GUI sunt grupate. Erorile neașteptate de runtime/listener pot lăsa totuși o tranzacție parțială; eroarea raportează operațiile finalizate și anularea revine asupra acelui grup, ca la edit apply.

Profiluri

Descoperiți profiluri și potriviți videoclipuri importate fără a ghici ID-uri:

openshot-cli profile list --search 720
openshot-cli profile get builtin:01280x0720p0024_16-09
openshot-cli profile match --file FILE_ID
openshot-cli project profile get
openshot-cli project profile set --from-file FILE_ID
openshot-cli project profile set builtin:01280x0720p0024_16-09
openshot-cli project profile set --json '{"width":640,"height":352,"display_ratio":{"num":20,"den":11},"fps":{"num":24000,"den":1001}}'

Intrările din catalog includ ID-uri stabile, descrieri, dimensiuni, FPS rațional, raporturi de aspect și setări de scanare. Lista/căutarea este paginată. Potrivirea sursei returnează ID-uri exacte și alternative ordonate cu diferențe explicite. Setarea dintr-un fișier necesită o potrivire exactă, cu excepția cazului în care este specificat --create-custom; nu alege niciodată silențios un profil apropiat. Imaginile statice și sursele doar audio nu pot defini un profil video. Potrivirea folosește FPS-ul sursei declarat.

Setările personalizate sunt încorporate în proiectul salvat, inclusiv rate raționale, astfel încât redeschiderea nu necesită instalarea unui fișier de profil separat. Modificările profilului proiectului folosesc conversia existentă a ratei de cadre și o singură tranzacție de anulare. Anularea/refacerea restaurează sincronizarea clipului și cadrele cheie, inclusiv pozițiile sensibile la rotunjire. Exportul poate selecta independent un profil fără a modifica proiectul.

Istoricul de anulare salvat urmează preferința editorului pentru limita de istoric. Limita este un buget moale de acțiuni: toate înregistrările aparținând tranzacțiilor reținute sunt păstrate, deci salvarea nu poate trunchia un lot mare într-o acțiune parțială de anulare. Zero dezactivează istoricul salvat. Limita separată de 256 de comenzi pentru cererile în lot se aplică în continuare.

Inspectarea media și a cronologiilor

Inspectați sincronizarea clipului și aranjamentul pistelor ca text sau JSON, sau redați imagini pentru a revizui compoziția și încadratura înainte de export.

Rezumate ale cronologiei

Folosiți o vizualizare text pentru o privire rapidă, sau JSON structurat pentru scripturi și agenți:

openshot-cli timeline view --start 5 --end 12
openshot-cli timeline view --start 5 --end 12 --format json
openshot-cli timeline overview --start 5 --end 12

timeline view are ca implicit text compact cu piste utilizate, ID-uri de obiect, intervale cronologie/sursă, stare flux, câștig și goluri/suprapuneri. Folosiți --detail summary|clips|full pentru a alege detaliul, --format json pentru context structurat, și --start/--end, --layer și paginare pentru a focaliza rezultatul.

timeline overview oferă un context structurat compact fără octeți de imagine: ID-uri ordonate, secvență pe pistă, intervale cronologie/sursă, intervale vizibile de decupare, coordonate cadre, stare audio/video, efecte și goluri sau suprapuneri vecine. Intervalele și spanurile de cadre sunt exclusive la final; numerele cadrelor sunt bazate pe unu. Cadrele sursă folosesc FPS-ul sursei; coordonatele cronologiei și ale cadrelor cheie folosesc FPS-ul proiectului. Folosiți --layer și --start/--end pentru a focaliza, și --limit/--offset pentru paginare (implicit 100, maxim 500 elemente). Clipurile cu remapare temporală rețin explicit mapările sursei inferate. Folosiți revizia returnată cu edit apply --expect-revision.

Previzualizări de cadre și foi de contact

Redați un singur cadru cu thumbnail sau eșantionați un interval cu strip. Folosiți file pentru a inspecta media sursă și timeline pentru a inspecta videoclipul compus, inclusiv efectele și clipurile stratificate:

openshot-cli file thumbnail FILE_ID --frame 301 --output /tmp/source.png
openshot-cli file strip FILE_ID --start 10 --end 20 --count 12 --output /tmp/source-strip.png
openshot-cli timeline thumbnail --frame 91 --output /tmp/timeline-frame.png
openshot-cli timeline strip --start 0 --end 20 --count 12 --output /tmp/timeline-strip.png

Imaginile cadrelor au implicit 320x180 pixeli; foile de contact au implicit 160x90 pe placă, plus etichete de timecode. Folosiți --width și --height pentru a alege pixelii de ieșire. Răspunsurile includ metadate exacte ale eșantionului/cadrului. Foile de contact ajută la revizuirea compoziției pe o secvență; folosiți previzualizări de cadre cheie și videoclip redat pentru a evalua mișcarea între acele eșantioane.

Imagini din cronologie

Capturați aspectul pistelor editorului, inclusiv rigla, miniaturi, efecte, tranziții și forme de undă:

openshot-cli timeline view --start 0 --end 20 --pixels-per-second 80 --output /tmp/tracks.png

Specificarea --output selectează formatul imaginii; --format image îl selectează explicit. Captura nu modifică vizualizarea sau proiectul editorului. Răspunsurile includ ID-urile clipurilor și sincronizarea împreună cu limitele în pixeli.

Imaginile au implicit lățimea de 1280 pixeli, iar înălțimea este ajustată la pistele utilizate. Folosiți --width, --height sau --all-tracks pentru a ajusta aspectul, și --track-size sau --track-label-width pentru a ajusta pistele și etichetele. Intervalul de început/sfârșit determină zoom-ul; --pixels-per-second derivă în schimb lățimea din intervalul de timp.

Vizualizări ale formei de undă audio

Alegeți --mode waveforms pentru a inspecta învelitorile audio pe cronologie:

openshot-cli timeline view --start 5 --end 12 --mode waveforms --output /tmp/waves.png

--mode auto folosește afișajul formei de undă din cache existent; --mode thumbnails afișează miniaturi în schimb. Formele de undă reprezintă nivelurile de vârf/RMS ale sursei cu ajustări de volum și sincronizare ale clipului, înainte de efectele audio sau mixare.

Extracția formei de undă necache-uite decodează sursele întregi, limitată la 600 de secunde per sursă și 1200 de secunde-sursă per cerere. Restrângerea intervalului vizibil nu reduce această muncă de decodare. Pentru surse mai lungi, generați formele de undă mai întâi în editor sau folosiți modul miniaturi. Cererile ulterioare pot reutiliza formele de undă din cache.

Ieșirea imaginilor și limitele

Căile imaginilor trebuie să fie fișiere PNG noi în directoare existente. Imaginile sunt limitate la 4096 pixeli pe axă, 8.388.608 pixeli total și 64 de mostre pe foaia de contact. Cererile care depășesc aceste limite eșuează înainte de redare.

Imaginile sunt scrise în fișiere; răspunsurile JSON includ căile și dimensiunile image_bytes. Inspectarea așteaptă finalizarea imaginii, iar cererile mari pot ocupa editorul pentru scurt timp.

Gestionarea expirărilor de timp ale comenzilor

Expirarea timpului unei cereri nu înseamnă că o modificare a eșuat. Folosiți ID-ul operațiunii din eroare cu operation get ID înainte de a încerca din nou. operation list descoperă modificările recente și stările, reviziile și rezultatele acestora. Operațiunile finalizate păstrează rezultatele dacă sunt suficient de mici, inclusiv ID-urile obiectelor returnate. Stocarea este limitată la 100 de operațiuni și 4 MiB, cu corpurile rezultatelor individuale omise peste 256 KiB. Aceste înregistrări durează doar pentru sesiunea curentă. Nu restaurează proiectele după o prăbușire și nu împiedică o comandă repetată să aplice aceeași modificare din nou. Joburile de export au propriile comenzi de stare/listă.