jpayne@68: '\" t
jpayne@68: .\" SPDX-License-Identifier: 0BSD
jpayne@68: .\"
jpayne@68: .\" Authors: Lasse Collin
jpayne@68: .\"          Jia Tan
jpayne@68: .\"
jpayne@68: .\" Romanian translation for xz-man.
jpayne@68: .\" Mesajele în limba română pentru manualul pachetului XZ Utils.
jpayne@68: .\" Remus-Gabriel Chelu <remusgabriel.chelu@disroot.org>, 2022 - 2024.
jpayne@68: .\" Cronologia traducerii fișierului „xz-man”:
jpayne@68: .\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1.
jpayne@68: .\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022.
jpayne@68: .\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023.
jpayne@68: .\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023.
jpayne@68: .\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024.
jpayne@68: .\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024.
jpayne@68: .\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul).
jpayne@68: .\"
jpayne@68: .\"*******************************************************************
jpayne@68: .\"
jpayne@68: .\" This file was generated with po4a. Translate the source file.
jpayne@68: .\"
jpayne@68: .\"*******************************************************************
jpayne@68: .TH XZ 1 2024\-12\-30 Tukaani "Utilități XZ"
jpayne@68: .
jpayne@68: .SH NUME
jpayne@68: xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprimă sau decomprimă fișiere .xz
jpayne@68: și .lzma
jpayne@68: .
jpayne@68: .SH REZUMAT
jpayne@68: \fBxz\fP [\fIopțiune...\fP] [\fIfișier...\fP]
jpayne@68: .
jpayne@68: .SH "ALIAS COMENZI"
jpayne@68: \fBunxz\fP este echivalent cu \fBxz \-\-decompress\fP.
jpayne@68: .br
jpayne@68: \fBxzcat\fP este echivalent cu \fBxz \-\-decompress \-\-stdout\fP.
jpayne@68: .br
jpayne@68: \fBlzma\fP este echivalent cu \fBxz \-\-format=lzma\fP.
jpayne@68: .br
jpayne@68: \fBunlzma\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress\fP.
jpayne@68: .br
jpayne@68: \fBlzcat\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP.
jpayne@68: .PP
jpayne@68: Când scrieți scripturi care trebuie să decomprime fișiere, este recomandat
jpayne@68: să folosiți întotdeauna comanda \fBxz\fP cu argumentele adecvate (\fBxz \-d\fP sau
jpayne@68: \fBxz \-dc\fP) în loc de comenzile \fBunxz\fP și \fBxzcat\fP.
jpayne@68: .
jpayne@68: .SH DESCRIERE
jpayne@68: \fBxz\fP este un instrument de comprimare a datelor de uz general cu sintaxă de
jpayne@68: linie de comandă similară cu \fBgzip\fP(1) și \fBbzip2\fP(1). Formatul de fișier
jpayne@68: nativ este formatul \fB.xz\fP, dar formatul vechi \fB.lzma\fP folosit de LZMA
jpayne@68: Utils și fluxurile comprimate brute fără anteturi de format container sunt
jpayne@68: de asemenea acceptate. În plus, este acceptată decomprimarea formatului
jpayne@68: \&\fB.lz\fP folosit de \fBlzip\fP.
jpayne@68: .PP
jpayne@68: \fBxz\fP comprimă sau decomprimă fiecare \fIfișier\fP în funcție de modul de
jpayne@68: operare selectat. Dacă nu sunt date \fIfișiere\fP sau \fIfișier\fP este \fB\-\fP,
jpayne@68: \fBxz\fP citește de la intrarea standard și scrie datele procesate la ieșirea
jpayne@68: standard. \fBxz\fP va refuza (afișează o eroare și omite \fIfișier\fP) să scrie
jpayne@68: date comprimate la ieșirea standard dacă este un terminal. În mod similar,
jpayne@68: \fBxz\fP va refuza să citească datele comprimate de la intrarea standard dacă
jpayne@68: este un terminal.
jpayne@68: .PP
jpayne@68: Cu excepția cazului în care este specificată opțiunea \fB\-\-stdout\fP,
jpayne@68: \fIfișierele\fP altele decât \fB\-\fP sunt scrise într\-un fișier nou al cărui nume
jpayne@68: este derivat din numele \fIfișierului\fP sursă:
jpayne@68: .IP \(bu 3
jpayne@68: La comprimare, sufixul formatului de fișier țintă (\fB.xz\fP sau \fB.lzma\fP) este
jpayne@68: atașat la numele fișierului sursă pentru a se obține numele fișierului
jpayne@68: țintă.
jpayne@68: .IP \(bu 3
jpayne@68: La decomprimare, sufixul \fB.xz\fP, \fB.lzma\fP sau \fB.lz\fP este eliminat din
jpayne@68: numele fișierului pentru a se obține numele fișierului țintă. \fBxz\fP
jpayne@68: recunoaște și sufixele \fB.txz\fP și \fB.tlz\fP și le înlocuiește cu sufixul
jpayne@68: \&\fB.tar\fP.
jpayne@68: .PP
jpayne@68: Dacă fișierul țintă există deja, este afișată o eroare și \fIfișier\fP este
jpayne@68: omis.
jpayne@68: .PP
jpayne@68: Cu excepția cazului în care scrie la ieșirea standard, \fBxz\fP va afișa un
jpayne@68: avertisment și va omite \fIfișier\fPul dacă se aplică oricare dintre
jpayne@68: următoarele:
jpayne@68: .IP \(bu 3
jpayne@68: \fIFișierul\fP nu este un fișier obișnuit. Legăturile simbolice nu sunt urmate
jpayne@68: și, prin urmare, nu sunt considerate fișiere obișnuite.
jpayne@68: .IP \(bu 3
jpayne@68: \fIFișierul\fP are mai mult de o legătură dură.
jpayne@68: .IP \(bu 3
jpayne@68: \fIFișierul\fP are activat bitul «setuid», «setgid» sau cel lipicios(sticky).
jpayne@68: .IP \(bu 3
jpayne@68: Modul de operare este stabilit la comprimare și \fIfișier\fP are deja un sufix
jpayne@68: al formatului de fișier țintă (\fB.xz\fP sau \fB.txz\fP când se comprimă în
jpayne@68: formatul \fB.xz\fP și \fB.lzma\fP sau \fB.tlz\fP când se comprimă în formatul
jpayne@68: \&\fB.lzma\fP).
jpayne@68: .IP \(bu 3
jpayne@68: Modul de operare este stabilit la decomprimare și \fIfișierul\fP nu are un
jpayne@68: sufix al niciunui format de fișier acceptat (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP,
jpayne@68: \&\fB.tlz\fP, sau \fB.lz\fP).
jpayne@68: .PP
jpayne@68: După comprimarea sau decomprimarea cu succes a \fIfișierului\fP, \fBxz\fP copiază
jpayne@68: proprietarul, grupul, permisiunile, timpul de acces și timpul de modificare
jpayne@68: din \fIfișierul\fP sursă în fișierul țintă. Dacă copierea grupului eșuează,
jpayne@68: permisiunile sunt modificate astfel încât fișierul țintă să nu devină
jpayne@68: accesibil utilizatorilor care nu aveau permisiunea de a accesa \fIfișierul\fP
jpayne@68: sursă. \fBxz\fP nu acceptă încă copierea altor metadate, cum ar fi listele de
jpayne@68: control al accesului sau atributele extinse.
jpayne@68: .PP
jpayne@68: Odată ce fișierul țintă a fost închis cu succes, \fIfișierul\fP sursă este
jpayne@68: eliminat dacă nu a fost specificată opțiunea \fB\-\-keep\fP. \fIFișierul\fP sursă nu
jpayne@68: este niciodată eliminat dacă rezultatul este scris la ieșirea standard sau
jpayne@68: dacă apare o eroare.
jpayne@68: .PP
jpayne@68: Trimiterea unui semnal \fBSIGINFO\fP sau \fBSIGUSR1\fP către procesul \fBxz\fP face
jpayne@68: ca acesta să imprime informații despre progres la ieșirea de eroare
jpayne@68: standard. Acest lucru are o utilizare limitată, deoarece atunci când ieșirea
jpayne@68: de eroare standard este un terminal, folosind opțiunea \fB\-\-verbose\fP va afișa
jpayne@68: un indicator de progres de actualizare automată.
jpayne@68: .
jpayne@68: .SS "Utilizarea memoriei"
jpayne@68: Cantitatea de memorie utilizată de \fBxz\fP variază de la câteva sute de
jpayne@68: kiloocteți la câțiva gigaocteți, în funcție de opțiunile de
jpayne@68: comprimare. Opțiunile utilizate la comprimarea unui fișier determină
jpayne@68: cerințele de memorie ale instrumentului de decomprimare. De obicei,
jpayne@68: instrumentul de decomprimare are nevoie de 5% până la 20% din cantitatea de
jpayne@68: memorie de care a avut nevoie instrumentul de comprimare la crearea
jpayne@68: fișierului. De exemplu, decomprimarea unui fișier creat cu \fBxz \-9\fP necesită
jpayne@68: în prezent 65Mio de memorie. Totuși, este posibil să aveți fișiere \fB.xz\fP
jpayne@68: care necesită câțiva gigaocteți de memorie pentru decomprimare.
jpayne@68: .PP
jpayne@68: În special utilizatorii de sisteme mai vechi pot considera deranjantă
jpayne@68: posibilitatea unei utilizări foarte mari a memoriei. Pentru a preveni
jpayne@68: surprizele neplăcute, \fBxz\fP are încorporat un limitator de utilizare a
jpayne@68: memoriei, care este dezactivat implicit. În timp ce unele sisteme de operare
jpayne@68: oferă modalități de a limita utilizarea memoriei proceselor, bazarea pe
jpayne@68: aceasta nu a fost considerată a fi suficient de flexibilă (de exemplu,
jpayne@68: utilizarea \fBulimit\fP(1) pentru a limita memoria virtuală tinde să paralizeze
jpayne@68: \fBmmap\fP(2)).
jpayne@68: .PP
jpayne@68: Limitatorul de utilizare a memoriei poate fi activat cu opțiunea din linia
jpayne@68: de comandă \fB\-\-memlimit=\fP\fIlimita\fP. Adesea este mai convenabil să activați
jpayne@68: limitatorul în mod implicit prin definirea variabilei de mediu
jpayne@68: \fBXZ_DEFAULTS\fP, de exemplu, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Este posibil
jpayne@68: să stabiliți limitele separat pentru comprimare și decomprimare folosind
jpayne@68: \fB\-\-memlimit\-compress=\fP\fIlimita\fP și
jpayne@68: \fB\-\-memlimit\-decompress=\fP\fIlimita\fP. Utilizarea acestor două opțiuni în afara
jpayne@68: \fBXZ_DEFAULTS\fP este foarte rar utilă, deoarece o singură rulare a \fBxz\fP nu
jpayne@68: poate face atât comprimarea, cât și decomprimarea și \fB\-\-memlimit=\fP\fIlimita\fP
jpayne@68: (sau \fB\-M\fP \fIlimita\fP ) este mai scurt de tastat pe linia de comandă.
jpayne@68: .PP
jpayne@68: Dacă limita de utilizare a memoriei specificată este depășită la
jpayne@68: decomprimare, \fBxz\fP va afișa o eroare și decomprimarea fișierului va
jpayne@68: eșua. Dacă limita este depășită la comprimare, \fBxz\fP va încerca să reducă
jpayne@68: valorile stabilite astfel încât limita să nu mai fie depășită (cu excepția
jpayne@68: cazului în care se utilizează opțiunea \fB\-\-format=raw\fP sau
jpayne@68: \fB\-\-no\-adjust\fP). În acest fel, operațiunea nu va eșua decât dacă limita
jpayne@68: stabilită este foarte mică. Scalarea valorilor stabilite se face în pași
jpayne@68: care nu se potrivesc cu valorile prestabilite ale nivelului de comprimare,
jpayne@68: de exemplu, dacă limita este doar puțin mai mică decât cantitatea necesară
jpayne@68: pentru \fBxz \-9\fP, valorile stabilite vor fi reduse doar puțin , nu până la
jpayne@68: valoarea prestabilită a lui \fBxz \-8\fP.
jpayne@68: .
jpayne@68: .SS "Concatenare și completare (prin umplere cu octeți nuli) cu fișiere .xz"
jpayne@68: Este posibil să concatenați fișierele \fB.xz\fP așa cum sunt. \fBxz\fP va
jpayne@68: decomprima astfel de fișiere ca și cum ar fi un singur fișier \fB.xz\fP.
jpayne@68: .PP
jpayne@68: Este posibil să se introducă umplutură între părțile concatenate sau după
jpayne@68: ultima parte.  Umplutura trebuie să fie compusă din octeți nuli, iar
jpayne@68: dimensiunea umpluturii trebuie să fie un multiplu de patru octeți. Acest
jpayne@68: lucru poate fi util, de exemplu, dacă fișierul \fB.xz\fP este stocat pe un
jpayne@68: mediu care măsoară dimensiunile fișierelor în blocuri de 512 de octeți.
jpayne@68: .PP
jpayne@68: Concatenarea și completarea nu sunt permise cu fișierele \fB.lzma\fP sau
jpayne@68: fluxurile brute.
jpayne@68: .
jpayne@68: .SH OPȚIUNI
jpayne@68: .
jpayne@68: .SS "Sufixe de numere întregi și valori speciale"
jpayne@68: În majoritatea locurilor în care este de așteptat un număr întreg ca
jpayne@68: argument, un sufix opțional este acceptat pentru a indica cu ușurință
jpayne@68: numerele întregi mari. Nu trebuie să existe spațiu între numărul întreg și
jpayne@68: sufix.
jpayne@68: .TP 
jpayne@68: \fBKiB\fP
jpayne@68: Înmulțește numărul întreg cu 1.024 (2^10).  \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP și
jpayne@68: \fBKB\fP sunt acceptate ca sinonime pentru \fBKiB\fP.
jpayne@68: .TP 
jpayne@68: \fBMiB\fP
jpayne@68: Înmulțește numărul întreg cu 1,048,576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, și \fBMB\fP
jpayne@68: sunt acceptate ca sinonime pentru \fBMiB\fP.
jpayne@68: .TP 
jpayne@68: \fBGiB\fP
jpayne@68: Înmulțește numărul întreg cu 1,073,741,824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, și
jpayne@68: \fBGB\fP sunt acceptate ca sinonime pentru \fBGiB\fP.
jpayne@68: .PP
jpayne@68: Valoarea specială \fBmax\fP poate fi utilizată pentru a indica valoarea maximă
jpayne@68: întreagă suportată de opțiune.
jpayne@68: .
jpayne@68: .SS "Mod de operare"
jpayne@68: Dacă sunt date mai multe opțiuni de mod de funcționare, ultima dintre ele,
jpayne@68: este cea care va avea efect.
jpayne@68: .TP 
jpayne@68: \fB\-z\fP, \fB\-\-compress\fP
jpayne@68: Comprimare. Acesta este modul de operare implicit atunci când nu este
jpayne@68: specificată nicio opțiune de mod de funcționare și nici un alt mod de
jpayne@68: operare nu este implicat din numele comenzii (de exemplu, \fBunxz\fP implică
jpayne@68: \fB\-\-decompress\fP).
jpayne@68: .IP ""
jpayne@68: .\" The DESCRIPTION section already says this but it's good to repeat it
jpayne@68: .\" here because the default behavior is a bit dangerous and new users
jpayne@68: .\" in a hurry may skip reading the DESCRIPTION section.
jpayne@68: After successful compression, the source file is removed unless writing to
jpayne@68: standard output or \fB\-\-keep\fP was specified.
jpayne@68: .TP 
jpayne@68: \fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP
jpayne@68: .\" The DESCRIPTION section already says this but it's good to repeat it
jpayne@68: .\" here because the default behavior is a bit dangerous and new users
jpayne@68: .\" in a hurry may skip reading the DESCRIPTION section.
jpayne@68: Decompress.  After successful decompression, the source file is removed
jpayne@68: unless writing to standard output or \fB\-\-keep\fP was specified.
jpayne@68: .TP 
jpayne@68: \fB\-t\fP, \fB\-\-test\fP
jpayne@68: Testează integritatea \fIfișierelor\fP comprimate. Această opțiune este
jpayne@68: echivalentă cu \fB\-\-decompress \-\-stdout\fP cu excepția faptului că datele
jpayne@68: decomprimate sunt înlăturate în loc să fie scrise la ieșirea standard. Nu
jpayne@68: sunt create sau eliminate fișiere.
jpayne@68: .TP 
jpayne@68: \fB\-l\fP, \fB\-\-list\fP
jpayne@68: Afișează informații despre \fIfișiere\fP comprimate. Nu are loc nicio
jpayne@68: decomprimare la ieșire și nu sunt create sau eliminate fișiere. În modul
jpayne@68: listă, programul nu poate citi datele comprimate din intrarea standard sau
jpayne@68: din alte surse care nu pot fi căutate.
jpayne@68: .IP ""
jpayne@68: Listarea implicită arată informații de bază despre \fIfișiere\fP, câte un
jpayne@68: fișier pe linie. Pentru a obține informații mai detaliate, utilizați și
jpayne@68: opțiunea \fB\-\-verbose\fP. Pentru și mai multe informații, utilizați opțiunea
jpayne@68: \fB\-\-verbose\fP de două ori, dar rețineți că acest lucru poate fi lent,
jpayne@68: deoarece obținerea tuturor informațiilor suplimentare necesită multe
jpayne@68: căutări. Lățimea ieșirii detaliate depășește 80 de caractere, deci
jpayne@68: canalizarea ieșirii către, de exemplu, \fBless\ \-S\fP poate fi convenabilă dacă
jpayne@68: terminalul nu este suficient de lat.
jpayne@68: .IP ""
jpayne@68: Ieșirea exactă poate varia între versiunile \fBxz\fP și diferitele
jpayne@68: localizări(configurările regionale). Pentru ieșiri care pot fi citite de
jpayne@68: mașină, ar trebui utilizată opțiunea \fB\-\-robot \-\-list\fP.
jpayne@68: .
jpayne@68: .SS "Modificatori de operare"
jpayne@68: .TP 
jpayne@68: \fB\-k\fP, \fB\-\-keep\fP
jpayne@68: Nu șterge fișierele de intrare.
jpayne@68: .IP ""
jpayne@68: Începând cu \fBxz\fP 5.2.6, această opțiune face ca \fBxz\fP să comprime sau să
jpayne@68: decomprime, chiar dacă intrarea este o legătură simbolică către un fișier
jpayne@68: obișnuit, are mai mult de\-o legătură dură sau are marcați biții setuid,
jpayne@68: setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu sunt
jpayne@68: copiați în fișierul țintă. În versiunile anterioare acest lucru se făcea
jpayne@68: numai cu ajutorul opțiunii \fB\-\-force\fP.
jpayne@68: .TP 
jpayne@68: \fB\-f\fP, \fB\-\-force\fP
jpayne@68: Această opțiune are mai multe efecte:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: Dacă fișierul țintă există deja, îl șterge înainte de comprimare sau
jpayne@68: decomprimare.
jpayne@68: .IP \(bu 3
jpayne@68: Comprimă sau decomprimă chiar dacă intrarea este o legătură simbolică către
jpayne@68: un fișier obișnuit, are mai mult de\-o legătură dură sau are marcați biții
jpayne@68: setuid, setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu
jpayne@68: sunt copiați în fișierul țintă.
jpayne@68: .IP \(bu 3
jpayne@68: Când este utilizată cu opțiunile \fB\-\-decompress\fP și \fB\-\-stdout\fP, comanda
jpayne@68: \fBxz\fP nu poate recunoaște tipul fișierului sursă, și copiază fișierul sursă
jpayne@68: așa cum este la ieșirea standard. Acest lucru permite comenzii \fBxzcat\fP
jpayne@68: \fB\-\-force\fP să fie folosită drept comanda \fBcat\fP(1) pentru fișierele care nu
jpayne@68: au fost comprimate cu \fBxz\fP. Rețineți că, în viitor, \fBxz\fP ar putea să
jpayne@68: accepte noi formate de fișiere comprimate, ceea ce poate face ca \fBxz\fP să
jpayne@68: decomprime mai multe tipuri de fișiere în loc să le copieze așa cum sunt la
jpayne@68: ieșirea standard. Opțiunea \fB\-\-format=\fP\fIformat\fP poate fi folosită pentru a
jpayne@68: restricționa \fBxz\fP să decomprime doar un singur format de fișier.
jpayne@68: .RE
jpayne@68: .TP 
jpayne@68: \fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP
jpayne@68: Scrie datele comprimate sau decomprimate la ieșirea standard în loc de
jpayne@68: într\-un fișier. Aceasta implică \fB\-\-keep\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-single\-stream\fP
jpayne@68: Decomprimă numai primul flux \fB.xz\fP și ignoră în tăcere posibilele date de
jpayne@68: intrare rămase în urma fluxului. În mod normal, astfel de resturi rămase
jpayne@68: face ca \fBxz\fP să afișeze o eroare.
jpayne@68: .IP ""
jpayne@68: \fBxz\fP nu decomprimă niciodată mai mult de un flux din fișierele \fB.lzma\fP sau
jpayne@68: din fluxurile brute, dar această opțiune face ca \fBxz\fP să ignore posibilele
jpayne@68: resturi de date rămase după fișierul \fB.lzma\fP sau fluxul brut.
jpayne@68: .IP ""
jpayne@68: Această opțiune nu are efect dacă modul de funcționare nu este
jpayne@68: \fB\-\-decompress\fP sau \fB\-\-test\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-no\-sparse\fP
jpayne@68: Dezactivează crearea de fișiere dispersate. În mod implicit, dacă decomprimă
jpayne@68: într\-un fișier obișnuit, \fBxz\fP încearcă să facă fișierul dispersat dacă
jpayne@68: datele decomprimate conțin secvențe lungi de zerouri binare. De asemenea,
jpayne@68: funcționează atunci când scrie la ieșirea standard, atâta timp cât ieșirea
jpayne@68: standard este conectată la un fișier obișnuit și sunt îndeplinite anumite
jpayne@68: condiții suplimentare pentru a o face în siguranță. Crearea de fișiere
jpayne@68: dispersate poate economisi spațiu pe disc și poate accelera decomprimarea
jpayne@68: prin reducerea cantității de date de In/Ieș pe disc.
jpayne@68: .TP 
jpayne@68: \fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP
jpayne@68: Când comprimă, utilizează \fI.suf\fP ca sufix pentru fișierul țintă în loc de
jpayne@68: \&\fB.xz\fP sau \fB.lzma\fP. Dacă nu scrie la ieșirea standard și fișierul sursă are
jpayne@68: deja sufixul \fI.suf\fP, este afișat un avertisment și fișierul este omis.
jpayne@68: .IP ""
jpayne@68: Când decomprimă, recunoaște fișierele cu sufixul \fI.suf\fP în plus față de
jpayne@68: fișierele cu sufixul \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP sau \fB.lz\fP. Dacă
jpayne@68: fișierul sursă are sufixul \fI.suf\fP, sufixul este eliminat pentru a obține
jpayne@68: numele fișierului țintă.
jpayne@68: .IP ""
jpayne@68: La comprimarea sau decomprimarea fluxurilor brute (\fB\-\-format=raw\fP), sufixul
jpayne@68: trebuie să fie întotdeauna specificat, cu excepția cazului în care se scrie
jpayne@68: la ieșirea standard, deoarece nu există un sufix implicit pentru fluxurile
jpayne@68: brute.
jpayne@68: .TP 
jpayne@68: \fB\-\-files\fP[\fB=\fP\fIfișier\fP]
jpayne@68: Citește numele fișierelor de procesat din \fIfișier\fP; dacă \fIfișierul\fP este
jpayne@68: omis, numele fișierelor sunt citite de la intrarea standard. Numele de
jpayne@68: fișiere trebuie să fie terminate cu caracterul de linie nouă. O liniuță
jpayne@68: (\fB\-\fP) este luată ca nume de fișier obișnuit; nu înseamnă intrarea
jpayne@68: standard. Dacă numele de fișiere sunt date și ca argumente în linia de
jpayne@68: comandă, ele sunt procesate înainte ca numele fișierelor să fie citite din
jpayne@68: \fIfișier\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-files0\fP[\fB=\fP\fIfișier\fP]
jpayne@68: Această opțiune este identică cu \fB\-\-files\fP[\fB=\fP\fIfișier\fP], cu excepția
jpayne@68: faptului că fiecare nume de fișier trebuie să fie terminat cu caracterul
jpayne@68: nul.
jpayne@68: .
jpayne@68: .SS "Formatul de bază al fișierului și opțiunile de comprimare"
jpayne@68: .TP 
jpayne@68: \fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP
jpayne@68: Specifică \fIformatul\fP fișierului pentru comprimare sau decomprimare:
jpayne@68: .RS
jpayne@68: .TP 
jpayne@68: \fBauto\fP
jpayne@68: Aceasta este valoarea implicită. La comprimare, \fBauto\fP este echivalent cu
jpayne@68: \fBxz\fP. La decomprimare, formatul fișierului de intrare este detectat
jpayne@68: automat. Rețineți că fluxurile brute (create cu \fB\-\-format=raw\fP) nu pot fi
jpayne@68: detectate automat.
jpayne@68: .TP 
jpayne@68: \fBxz\fP
jpayne@68: Comprimă în formatul de fișier \fB.xz\fP sau acceptă numai fișierele \fB.xz\fP
jpayne@68: când decomprimă.
jpayne@68: .TP 
jpayne@68: \fBlzma\fP, \fBalone\fP
jpayne@68: Comprimă în formatul de fișier \fB.lzma\fP vechi sau acceptă numai fișierele
jpayne@68: \&\fB.lzma\fP când decomprimă.  Numele alternativ \fBalone\fP este furnizat pentru
jpayne@68: compatibilitatea cu versiunile mai vechi de LZMA Utils.
jpayne@68: .TP 
jpayne@68: \fBlzip\fP
jpayne@68: Acceptă numai fișierele \fB.lz\fP când decomprimă. Comprimarea nu este
jpayne@68: acceptată.
jpayne@68: .IP ""
jpayne@68: Formatul \fB.lz\fP versiunea 0 și versiunea neextinsă 1 sunt
jpayne@68: acceptate. Fișierele versiunea 0 au fost produse de \fBlzip\fP cu versiunea 1.3
jpayne@68: sau mai veche. Astfel de fișiere nu sunt obișnuite, dar pot fi găsite în
jpayne@68: arhivele de fișiere, deoarece câteva pachete sursă au fost lansate în acest
jpayne@68: format. Oamenii ar putea avea și fișiere personale vechi în acest
jpayne@68: format. Suportul de decomprimare pentru versiunea de format 0 a fost
jpayne@68: eliminat în \fBlzip\fP 1.18.
jpayne@68: .IP ""
jpayne@68: \fBlzip\fP 1.4 și versiunile ulterioare creează fișiere în formatul versiunea
jpayne@68: 1. Extensia „sync flush marker” pentru versiunea 1 de format a fost adăugată
jpayne@68: în \fBlzip\fP 1.6. Această extensie este folosită rar și nu este acceptată de
jpayne@68: \fBxz\fP (diagnosticată ca intrare coruptă).
jpayne@68: .TP 
jpayne@68: \fBraw\fP
jpayne@68: Comprimă sau decomprimă un flux brut (fără anteturi). Acest lucru este
jpayne@68: destinat doar utilizatorilor avansați. Pentru a decodifica fluxurile brute,
jpayne@68: trebuie să utilizați opțiunea \fB\-\-format=raw\fP și să specificați în mod
jpayne@68: explicit lanțul de filtre, care în mod normal ar fi fost stocat în
jpayne@68: anteturile containerului.
jpayne@68: .RE
jpayne@68: .TP 
jpayne@68: \fB\-C\fP \fIverificarea\fP, \fB\-\-check=\fP\fIverificarea\fP
jpayne@68: Specifică tipul verificării integrității. Verificarea este calculată din
jpayne@68: datele necomprimate și stocată în fișierul \fB.xz\fP. Această opțiune are efect
jpayne@68: numai la comprimarea în format \fB.xz\fP; formatul \fB.lzma\fP nu acceptă
jpayne@68: verificări de integritate. Verificarea integrității (dacă există) este
jpayne@68: efectuată atunci când fișierul \fB.xz\fP este decomprimat.
jpayne@68: .IP ""
jpayne@68: Tipuri de \fIverificare\fP acceptate:
jpayne@68: .RS
jpayne@68: .TP 
jpayne@68: \fBnone\fP
jpayne@68: Nu calculează deloc o verificare a integrității. Aceasta este de obicei o
jpayne@68: idee proastă. Acest lucru poate fi util atunci când integritatea datelor
jpayne@68: este oricum verificată prin alte mijloace.
jpayne@68: .TP 
jpayne@68: \fBcrc32\fP
jpayne@68: Calculează CRC32 folosind polinomul din IEEE\-802.3 (Ethernet).
jpayne@68: .TP 
jpayne@68: \fBcrc64\fP
jpayne@68: Calculează CRC64 folosind polinomul din ECMA\-182. Aceasta este valoarea
jpayne@68: implicită, deoarece este ceva mai bună decât CRC32 la detectarea fișierelor
jpayne@68: deteriorate, iar diferența de viteză este neglijabilă.
jpayne@68: .TP 
jpayne@68: \fBsha256\fP
jpayne@68: Calculează SHA\-256. Acest lucru este oarecum mai lent decât CRC32 și CRC64.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Integritatea antetelor \fB.xz\fP este întotdeauna verificată cu CRC32. Nu este
jpayne@68: posibilă modificarea sau dezactivarea acesteia.
jpayne@68: .TP 
jpayne@68: \fB\-\-ignore\-check\fP
jpayne@68: Nu efectuează verificarea integrității datelor comprimate la
jpayne@68: decomprimare. Valorile CRC32 din antetele \fB.xz\fP vor fi însă verificate
jpayne@68: normal.
jpayne@68: .IP ""
jpayne@68: \fBNu utilizați această opțiune decât dacă știți ce faceți\fP. Motive posibile
jpayne@68: pentru a utiliza această opțiune:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: Încercarea de a recupera datele dintr\-un fișier .xz corupt.
jpayne@68: .IP \(bu 3
jpayne@68: Accelerarea decomprimării. Acest lucru contează mai ales cu SHA\-256 sau cu
jpayne@68: fișierele care s\-au comprimat extrem de bine. Este recomandat să nu
jpayne@68: utilizați această opțiune în acest scop decât dacă integritatea fișierului
jpayne@68: este verificată extern într\-un alt mod.
jpayne@68: .RE
jpayne@68: .TP 
jpayne@68: \fB\-0\fP ... \fB\-9\fP
jpayne@68: Selectează un nivel prestabilit de comprimare. Valoarea implicită este
jpayne@68: \fB\-6\fP. Dacă sunt specificate mai multe niveluri prestabilite, ultimul are
jpayne@68: efect. Dacă a fost deja specificat un lanț de filtre personalizat,
jpayne@68: specificarea unui nivel prestabilit de comprimare șterge lanțul de filtre
jpayne@68: personalizat.
jpayne@68: .IP ""
jpayne@68: Diferențele dintre valorile prestabilite sunt mai semnificative decât cu
jpayne@68: \fBgzip\fP(1) și \fBbzip2\fP(1). Valorile de comprimare selectate determină
jpayne@68: cerințele de memorie ale instrumentului de decomprimare, astfel încât
jpayne@68: utilizarea unui nivel prea mare prestabilit ar putea face „dureroasă”
jpayne@68: decomprimarea fișierului pe un sistem vechi cu puțină memorie RAM. Mai
jpayne@68: exact, \fBnu este o idee bună să folosiți orbește \-9 pentru tot\fP așa cum se
jpayne@68: întâmplă adesea cu \fBgzip\fP(1) și \fBbzip2\fP(1).
jpayne@68: .RS
jpayne@68: .TP 
jpayne@68: \fB\-0\fP ... \fB\-3\fP
jpayne@68: Acestea sunt valorile prestabilite oarecum rapide. \fB\-0\fP este uneori mai
jpayne@68: rapid decât \fBgzip \-9\fP în timp ce comprimă mult mai bine. Cele mai ridicate
jpayne@68: au adesea viteza comparabilă cu \fBbzip2\fP(1) cu un raport de comprimare
jpayne@68: comparabil sau mai bun, deși rezultatele depind foarte mult de tipul de date
jpayne@68: care sunt comprimate.
jpayne@68: .TP 
jpayne@68: \fB\-4\fP ... \fB\-6\fP
jpayne@68: Comprimare bună spre foarte bună, păstrând în același timp utilizarea
jpayne@68: memoriei de către instrumentul de decomprimare la un nivel rezonabil chiar
jpayne@68: și pentru sistemele vechi. \fB\-6\fP este valoarea implicită, care este de
jpayne@68: obicei o alegere bună pentru distribuirea fișierelor care trebuie să poată
jpayne@68: fi decomprimate chiar și pe sisteme cu doar 16Mio de memorie RAM. Opțiunile
jpayne@68: (\fB\-5e\fP sau \fB\-6e\fP ar putea fi demne de luat în considerare. A se vedea
jpayne@68: opțiunea \fB\-\-extreme\fP.)
jpayne@68: .TP 
jpayne@68: \fB\-7 ... \-9\fP
jpayne@68: Acestea sunt precum \fB\-6\fP, dar cu cerințe mai mari de memorie pentru
jpayne@68: comprimare și decomprimare. Acestea sunt utile numai atunci când comprimați
jpayne@68: fișiere mai mari de 8Mio, 16Mio și, respectiv, 32Mio.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Pe același hardware, viteza de decomprimare este aproximativ un număr
jpayne@68: constant de octeți de date comprimate pe secundă. Cu alte cuvinte, cu cât
jpayne@68: comprimarea este mai bună, cu atât decomprimarea va fi de obicei mai
jpayne@68: rapidă. Aceasta înseamnă, de asemenea, că valoarea de la ieșire a cantității
jpayne@68: de date necomprimate produsă pe secundă poate varia foarte mult.
jpayne@68: .IP ""
jpayne@68: Următorul tabel rezumă caracteristicile valorilor prestabilite:
jpayne@68: .RS
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .TS
jpayne@68: tab(;);
jpayne@68: c c c c c
jpayne@68: n n n n n.
jpayne@68: ValPrestab;DimDict;CPUComp;MemComp;MemDec
jpayne@68: \-0;256 KiB;0;3 MiB;1 MiB
jpayne@68: \-1;1 MiB;1;9 MiB;2 MiB
jpayne@68: \-2;2 MiB;2;17 MiB;3 MiB
jpayne@68: \-3;4 MiB;3;32 MiB;5 MiB
jpayne@68: \-4;4 MiB;4;48 MiB;5 MiB
jpayne@68: \-5;8 MiB;5;94 MiB;9 MiB
jpayne@68: \-6;8 MiB;6;94 MiB;9 MiB
jpayne@68: \-7;16 MiB;6;186 MiB;17 MiB
jpayne@68: \-8;32 MiB;6;370 MiB;33 MiB
jpayne@68: \-9;64 MiB;6;674 MiB;65 MiB
jpayne@68: .TE
jpayne@68: .RE
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Descrieri coloane:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: DimDict este dimensiunea dicționarului LZMA2. Este o risipă de memorie să
jpayne@68: folosești un dicționar mai mare decât dimensiunea fișierului necomprimat. De
jpayne@68: aceea este bine să evitați utilizarea valorilor prestabilite \fB\-7\fP ... \fB\-9\fP
jpayne@68: atunci când nu este nevoie cu adevărat de ele. Pentru valoarea prestabilită
jpayne@68: \fB\-6\fP sau alta mai mică, cantitatea de memorie irosită este de obicei
jpayne@68: suficient de mică pentru a nu conta.
jpayne@68: .IP \(bu 3
jpayne@68: CPUComp este o reprezentare simplificată a configurărilor LZMA2 care
jpayne@68: afectează viteza de comprimare. Dimensiunea dicționarului afectează și
jpayne@68: viteza, așa că, în timp ce CPUComp este aceeași pentru nivelurile \fB\-6\fP
jpayne@68: \&... \fB\-9\fP, nivelurile mai mari tind să fie puțin mai lente. Pentru a obține
jpayne@68: o comprimare și mai lentă și, astfel, posibil mai bună, consultați opțiunea
jpayne@68: \fB\-\-extreme\fP.
jpayne@68: .IP \(bu 3
jpayne@68: MemComp conține cerințele de memorie ale comprimării în modul cu un singur
jpayne@68: fir de execuție. Poate varia ușor între versiunile \fBxz\fP.
jpayne@68: .IP \(bu 3
jpayne@68: MemDec conține cerințele de memorie pentru decomprimare. Adică,
jpayne@68: configurările de comprimare determină cerințele de memorie ale
jpayne@68: decomprimării. Cantitatea exactă a memoriei utilizate la decomprimare este
jpayne@68: puțin mai mare decât dimensiunea dicționarului LZMA2, dar valorile din tabel
jpayne@68: au fost rotunjite la următorul Mio.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Cerințele de memorie ale modului cu mai multe fire de execuție sunt
jpayne@68: semnificativ mai mari decât cele ale modului cu un singur fir de
jpayne@68: execuție. Cu valoarea implicită a lui \fB\-\-block\-size\fP, fiecare fir are
jpayne@68: nevoie de 3*3*DictSize plus MemComp sau MemDec. De exemplu, patru fire de
jpayne@68: execuție cu valoarea prestabilită \fB\-6\fP au nevoie de 660\(en670\ Mio de
jpayne@68: memorie.
jpayne@68: .TP 
jpayne@68: \fB\-e\fP, \fB\-\-extreme\fP
jpayne@68: Utilizează o variantă mai lentă a nivelului prestabilit de comprimare
jpayne@68: selectat (\fB\-0\fP ... \fB\-9\fP) pentru a obține un raport de comprimare puțin mai
jpayne@68: bun, dar din nefericire, acest lucru îl poate înrăutăți. Utilizarea memoriei
jpayne@68: pentru decomprimare nu este afectată, dar utilizarea memoriei la comprimare
jpayne@68: crește puțin la nivelurile prestabilite \fB\-0\fP ... \fB\-3\fP.
jpayne@68: .IP ""
jpayne@68: Deoarece există două valori prestabilite cu dimensiuni ale dicționarului de
jpayne@68: 4Mio și 8Mio, valorile prestabilite \fB\-3e\fP și \fB\-5e\fP folosesc configurări
jpayne@68: puțin mai rapide (CPUComp mai mic) decât \fB\-4e\fP și \fB\-6e\fP, respectiv. În
jpayne@68: acest fel, nu există două nivele prestabilite identice.
jpayne@68: .RS
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .TS
jpayne@68: tab(;);
jpayne@68: c c c c c
jpayne@68: n n n n n.
jpayne@68: ValPrestab;DimDict;CPUComp;MemComp;MemDec
jpayne@68: \-0e;256 KiB;8;4 MiB;1 MiB
jpayne@68: \-1e;1 MiB;8;13 MiB;2 MiB
jpayne@68: \-2e;2 MiB;8;25 MiB;3 MiB
jpayne@68: \-3e;4 MiB;7;48 MiB;5 MiB
jpayne@68: \-4e;4 MiB;8;48 MiB;5 MiB
jpayne@68: \-5e;8 MiB;7;94 MiB;9 MiB
jpayne@68: \-6e;8 MiB;8;94 MiB;9 MiB
jpayne@68: \-7e;16 MiB;8;186 MiB;17 MiB
jpayne@68: \-8e;32 MiB;8;370 MiB;33 MiB
jpayne@68: \-9e;64 MiB;8;674 MiB;65 MiB
jpayne@68: .TE
jpayne@68: .RE
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: De exemplu, există un total de patru nivele prestabilite care folosesc
jpayne@68: dicționarul 8Mio, a căror ordine de la cel mai rapid la cel mai lent este
jpayne@68: \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP și \fB\-6e\fP .
jpayne@68: .TP 
jpayne@68: \fB\-\-fast\fP
jpayne@68: .PD 0
jpayne@68: .TP 
jpayne@68: \fB\-\-best\fP
jpayne@68: .PD
jpayne@68: Acestea sunt alias de opțiuni, oarecum înșelătoare pentru \fB\-0\fP și,
jpayne@68: respectiv, \fB\-9\fP. Acestea sunt furnizate numai pentru compatibilitatea cu
jpayne@68: LZMA Utils. Evitați utilizarea acestor opțiuni.
jpayne@68: .TP 
jpayne@68: \fB\-\-block\-size=\fP\fIdimensiunea\fP
jpayne@68: Când comprimă în formatul \fB.xz\fP, împarte datele de intrare în blocuri de
jpayne@68: \fIdimensiunea\fP octeți. Blocurile sunt comprimate independent unul de
jpayne@68: celălalt, ceea ce ajută în modul cu mai multe fire de execuție și face
jpayne@68: posibilă decomprimarea cu acces aleatoriu limitat. Această opțiune este de
jpayne@68: obicei folosită pentru a suprascrie dimensiunea implicită a blocului în
jpayne@68: modul cu mai multe fire de execuție, dar această opțiune poate fi folosită
jpayne@68: și în modul cu un singur fir de execuție.
jpayne@68: .IP ""
jpayne@68: În modul cu mai multe fire de execuție, aproximativ de trei ori
jpayne@68: \fIdimensiunea\fP de octeți vor fi alocați în fiecare fir pentru stocarea
jpayne@68: intrării și ieșirii. \fIDimensiunea\fP implicită este de trei ori dimensiunea
jpayne@68: dicționarului LZMA2 sau 1Mio, oricare dintre acestea este mai mare. În mod
jpayne@68: obișnuit, o valoare bună este de două la patru ori dimensiunea dicționarului
jpayne@68: LZMA2 sau de cel puțin 1Mio. Utilizarea unei \fIdimensiuni\fP mai mici decât
jpayne@68: dimensiunea dicționarului LZMA2 este o risipă de memorie RAM, deoarece
jpayne@68: atunci memoria tampon a dicționarului LZMA2 nu va fi niciodată utilizată pe
jpayne@68: deplin. În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt
jpayne@68: stocate în anteturile blocurilor. Aceste informații privind dimensiunea sunt
jpayne@68: necesare pentru decomprimarea cu mai multe fire.
jpayne@68: .IP ""
jpayne@68: În modul cu un singur fir de execuție, nicio divizare a blocurilor nu se
jpayne@68: face în mod implicit. Folosirea acestei opțiuni nu afectează utilizarea
jpayne@68: memoriei. Nu sunt stocate informații despre dimensiune în antetele
jpayne@68: blocurilor, astfel încât fișierele create în modul cu un singur fir de
jpayne@68: execuție nu vor fi identice cu fișierele create în modul cu mai multe fire
jpayne@68: de execuție. Lipsa informațiilor privind dimensiunea înseamnă, de asemenea,
jpayne@68: că \fBxz\fP nu va putea decomprima fișierele în modul cu mai multe fire. de
jpayne@68: execuție.
jpayne@68: .TP 
jpayne@68: \fB\-\-block\-list=\fP\fIelemente\fP
jpayne@68: Când comprimă în formatul \fB.xz\fP, începe un nou bloc cu un lanț de filtre
jpayne@68: personalizat opțional după intervalele specificate de date necomprimate.
jpayne@68: .IP ""
jpayne@68: \fIelementele\fP sunt o listă separată prin virgule. Fiecare element este
jpayne@68: format dintr\-un număr opțional de lanț de filtrare între 0 și 9, urmat de
jpayne@68: două puncte (\fB:\fP) și de o dimensiune cerută a datelor
jpayne@68: necomprimate. Omiterea unui element (două sau mai multe virgule consecutive)
jpayne@68: este o prescurtare pentru a utiliza dimensiunea și filtrele din elementul
jpayne@68: anterior.
jpayne@68: .IP ""
jpayne@68: În cazul în care fișierul de intrare este mai mare decât suma dimensiunilor
jpayne@68: din \fIelemente\fP, ultimul element se repetă până la sfârșitul fișierului. O
jpayne@68: valoare specială de \fB0\fP poate fi utilizată ca ultimă dimensiune pentru a
jpayne@68: indica faptul că restul fișierului trebuie să fie codificat ca un singur
jpayne@68: bloc.
jpayne@68: .IP ""
jpayne@68: Un lanț de filtre alternativ pentru fiecare bloc poate fi specificat în
jpayne@68: combinație cu opțiunile \fB\-\-filters1=\fP\fIfiltre\fP \&...\&
jpayne@68: \fB\-\-filters9=\fP\fIfiltre\fP. Aceste opțiuni definesc lanțuri de filtre cu un
jpayne@68: identificator cuprins între 1\(en9. Lanțul de filtre 0 poate fi utilizat
jpayne@68: pentru a se referi la lanțul de filtre implicit, ceea ce este același lucru
jpayne@68: cu a nu specifica un lanț de filtre. Identificatorul lanțului de filtre
jpayne@68: poate fi utilizat înaintea dimensiunii necomprimate, urmat de două puncte
jpayne@68: (\fB:\fP). De exemplu, dacă se specifică
jpayne@68: \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, atunci blocurile vor fi
jpayne@68: create folosind:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: Lanțul de filtre specificat de \fB\-\-filters1\fP și 2 Mio de intrare
jpayne@68: .IP \(bu 3
jpayne@68: Lanțul de filtre specificat de \fB\-\-filters3\fP și 2 Mio de intrare
jpayne@68: .IP \(bu 3
jpayne@68: Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare
jpayne@68: .IP \(bu 3
jpayne@68: Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare
jpayne@68: .IP \(bu 3
jpayne@68: Lanțul de filtre implicit și 2 MiB de intrare
jpayne@68: .IP \(bu 3
jpayne@68: Lanțul de filtre implicit și 4 MiB de intrare pentru fiecare bloc până la
jpayne@68: sfârșitul intrării.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Dacă se specifică o dimensiune care depășește dimensiunea blocului
jpayne@68: codificatorului (fie valoarea implicită în modul cu fire de execuție, fie
jpayne@68: valoarea specificată cu \fB\-\-block\-size=\fP\fIdimensiune\fP), codificatorul va
jpayne@68: crea blocuri suplimentare, păstrând limitele specificate în \fIelemente\fP. De
jpayne@68: exemplu, dacă se specifică \fB\-\-block\-size=10MiB\fP
jpayne@68: \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP și fișierul de intrare este de
jpayne@68: 80 MiB, se vor obține 11 blocuri: 5, 10, 8, 10, 10, 2, 10, 10, 10, 4, 10,
jpayne@68: 10, 10 și 1 Mio.
jpayne@68: .IP ""
jpayne@68: În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt stocate
jpayne@68: în antetele blocurilor. Acest lucru nu se face în modul cu un singur fir de
jpayne@68: execuție, astfel încât ieșirea codificată nu va fi identică cu cea a modului
jpayne@68: cu mai multe fire de execuție.
jpayne@68: .TP 
jpayne@68: \fB\-\-flush\-timeout=\fP\fItimp_limită\fP
jpayne@68: La comprimare, dacă au trecut mai mult de \fItimp_limită\fP milisecunde (un
jpayne@68: întreg pozitiv) de la curățarea anterioară și citirea mai multor intrări
jpayne@68: s\-ar bloca, toate datele de intrare în așteptare sunt eliminate din
jpayne@68: codificator și puse la dispoziție în fluxul de ieșire. Acest lucru poate să
jpayne@68: fie util dacă \fBxz\fP este utilizat pentru a comprima datele care sunt
jpayne@68: transmise în flux printr\-o rețea. Valorile mici de \fItimp_limită\fP fac datele
jpayne@68: disponibile la capătul de recepție cu o mică întârziere, dar valorile mari
jpayne@68: de \fItimp_limită\fP oferă un raport de comprimare mai bun.
jpayne@68: .IP ""
jpayne@68: Această caracteristică este dezactivată în mod implicit. Dacă această
jpayne@68: opțiune este specificată de mai multe ori, ultima este cea care se ia în
jpayne@68: considerare. Valoarea specială a lui \fItimp_limită\fP de \fB0\fP, poate fi
jpayne@68: utilizată pentru a dezactiva în mod explicit această caracteristică.
jpayne@68: .IP ""
jpayne@68: Această caracteristică nu este disponibilă în sistemele non\-POSIX.
jpayne@68: .IP ""
jpayne@68: .\" FIXME
jpayne@68: \fBAceastă caracteristică este încă experimentală\fP. În prezent, \fBxz\fP este
jpayne@68: nepotrivit pentru decomprimarea fluxului în timp real datorită modului în
jpayne@68: care \fBxz\fP utilizează memoria tampon.
jpayne@68: .TP 
jpayne@68: \fB\-\-memlimit\-compress=\fP\fIlimita\fP
jpayne@68: Stabilește o limită de utilizare a memoriei pentru comprimare. Dacă această
jpayne@68: opțiune este specificată de mai multe ori, ultima va avea efect.
jpayne@68: .IP ""
jpayne@68: Dacă parametrii de comprimare depășesc \fIlimita\fP, \fBxz\fP va încerca să
jpayne@68: ajusteze parametrii scăzând valorile acestora, astfel încât limita să nu mai
jpayne@68: fie depășită și va afișa o notificare că ajustarea automată a fost
jpayne@68: efectuată. Ajustările se fac în această ordine: reducerea numărului de fire,
jpayne@68: trecerea la modul un singur fir de execuție dacă chiar și un singur fir în
jpayne@68: modul cu mai multe fire de execuție depășește \fIlimita\fP și, în final,
jpayne@68: reducerea dimensiunii dicționarului LZMA2.
jpayne@68: .IP ""
jpayne@68: Când comprimă cu opțiunea \fB\-\-format=raw\fP sau dacă a fost specificată
jpayne@68: opțiunea \fB\-\-no\-adjust\fP, numai numărul de fire poate fi redus, deoarece se
jpayne@68: poate face fără a afecta rezultatul comprimării.
jpayne@68: .IP ""
jpayne@68: Dacă \fIlimita\fP nu poate fi îndeplinită chiar și cu ajustările descrise mai
jpayne@68: sus, este afișată o eroare și \fBxz\fP va ieși cu starea de ieșire 1.
jpayne@68: .IP ""
jpayne@68: \fILimita\fP poate fi specificata în mai multe moduri:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: \fILimita\fP poate fi o valoare absolută în octeți. Utilizarea unui sufix
jpayne@68: întreg precum \fBMiB\fP poate fi utilă. De exemplu:
jpayne@68: \fB\-\-memlimit\-compress=80MiB\fP
jpayne@68: .IP \(bu 3
jpayne@68: \fILimita\fP poate fi specificată ca procent din memoria fizică totală
jpayne@68: (RAM). Acest lucru poate fi util mai ales atunci când definiți variabila de
jpayne@68: mediu \fBXZ_DEFAULTS\fP într\-un script de inițializare shell care este partajat
jpayne@68: între diferite calculatoare. În acest fel, limita este automat mai mare pe
jpayne@68: sistemele cu mai multă memorie. De exemplu: \fB\-\-memlimit\-compress=70%\fP
jpayne@68: .IP \(bu 3
jpayne@68: \fILimita\fP poate fi restabilită la valoarea implicită dându\-i valoarea
jpayne@68: \fB0\fP. În prezent, aceasta este echivalentă cu stabilirea \fIlimitei\fP la
jpayne@68: \fBmax\fP (fără limită de utilizare a memoriei).
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Pentru \fBxz\fP pe 32 de biți există un caz special: dacă \fIlimita\fP ar fi peste
jpayne@68: \fB4020MiB\fP, \fIlimita\fP este stabilită la \fB4020MiB\fP.  Pe MIPS32 este
jpayne@68: stabilită în schimb la \fB2000MiB\fP; (valorile \fB0\fP și \fBmax\fP nu sunt afectate
jpayne@68: de acest lucru \-\- o caracteristică similară nu există pentru
jpayne@68: decomprimare). Acest lucru poate fi util atunci când un executabil pe 32 de
jpayne@68: biți are acces la un spațiu de adrese de 4Gio (2Gio pe MIPS32), se speră că
jpayne@68: nu produce daune în alte situații.
jpayne@68: .IP ""
jpayne@68: Consultați și secțiunea \fBUtilizarea memoriei\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-memlimit\-decompress=\fP\fIlimita\fP
jpayne@68: Stabilește o limită de utilizare a memoriei pentru decomprimare. Acest lucru
jpayne@68: afectează și modul \fB\-\-list\fP. Dacă operațiunea nu este posibilă fără a
jpayne@68: depăși \fIlimita\fP, \fBxz\fP va afișa o eroare și decomprimarea fișierului va
jpayne@68: eșua. Consultați \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalitățile
jpayne@68: posibile de a specifica \fIlimita\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP
jpayne@68: Stabilește o limită de utilizare a memoriei pentru decomprimarea cu mai
jpayne@68: multe fire de execuție. Acest lucru poate afecta doar numărul de fire de
jpayne@68: execuție; acest lucru nu îl va face niciodată pe \fBxz\fP să refuze
jpayne@68: decomprimarea unui fișier. Dacă \fIlimita\fP este prea scăzută pentru a permite
jpayne@68: orice mod cu mai multe fire de execuție, \fIlimita\fP este ignorată și \fBxz\fP va
jpayne@68: continua în modul cu un singur fir de execuție. Rețineți că, dacă se
jpayne@68: folosește și opțiunea \fB\-\-memlimit\-decompress\fP, se va aplica întotdeauna
jpayne@68: atât modurilor cu un singur fir de execuție, cât și modurilor cu mai multe
jpayne@68: fire de execuție și astfel \fIlimita\fP efectivă pentru modul cu mai multe fire
jpayne@68: de execuție nu va fi niciodată mai mare decât limita stabilită cu opțiunea
jpayne@68: \fB\-\-memlimit\-decompress\fP.
jpayne@68: .IP ""
jpayne@68: Spre deosebire de celelalte opțiuni de limită de utilizare a memoriei,
jpayne@68: opțiunea \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP are o \fIlimită\fP implicită
jpayne@68: specifică sistemului. Comanda \fBxz \-\-info\-memory\fP poate fi folosită pentru a
jpayne@68: vedea valoarea curentă.
jpayne@68: .IP ""
jpayne@68: Această opțiune și valoarea ei implicită există deoarece, fără nicio limită,
jpayne@68: decomprimarea cu (mai multe) fire de execuție ar putea ajunge să aloce o
jpayne@68: cantitate „nebună” de memorie cu unele fișiere de intrare. Dacă \fIlimita\fP
jpayne@68: implicită este prea scăzută pe sistemul dumneavoastră, nu ezitați să
jpayne@68: creșteți \fIlimita\fP, dar niciodată să nu o stabiliți la o valoare mai mare
jpayne@68: decât cantitatea de memorie RAM utilizabilă și cu niște fișiere de intrare
jpayne@68: adecvate, \fBxz\fP va încerca să utilizeze acea cantitate de memorie chiar și
jpayne@68: cu un număr redus de fire de execuție. Rularea lui \fBxz\fP cu depășirea
jpayne@68: cantității de memorie fizice(RAM) sau a celei de interschimb(swap) nu va
jpayne@68: îmbunătăți performanța de decomprimare.
jpayne@68: .IP ""
jpayne@68: Consultați opțiunea \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalități
jpayne@68: posibile de a specifica \fIlimita\fP. Stabilirea \fIlimitei\fP la \fB0\fP
jpayne@68: restabilește \fIlimita\fP la valoarea implicită specifică sistemului.
jpayne@68: .TP 
jpayne@68: \fB\-M\fP \fIlimita\fP, \fB\-\-memlimit=\fP\fIlimita\fP, \fB\-\-memory=\fP\fIlimita\fP
jpayne@68: Aceasta este echivalentă cu specificarea opțiunilor:
jpayne@68: \fB\-\-memlimit\-compress=\fP\fIlimita\fP \fB\-\-memlimit\-decompress=\fP\fIlimita\fP
jpayne@68: \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-no\-adjust\fP
jpayne@68: Afișează o eroare și iese dacă limita de utilizare a memoriei nu poate fi
jpayne@68: îndeplinită fără ajustarea parametrilor care afectează ieșirea
jpayne@68: comprimată. Adică, acest lucru împiedică \fBxz\fP să comute codificatorul din
jpayne@68: modul cu mai multe fire de execuție în modul cu un singur fir de execuție și
jpayne@68: să reducă dimensiunea dicționarului LZMA2. Chiar și atunci când această
jpayne@68: opțiune este utilizată, numărul de fire de execuție poate fi redus pentru a
jpayne@68: îndeplini limita de utilizare a memoriei, deoarece aceasta nu va afecta
jpayne@68: comprimarea.
jpayne@68: .IP ""
jpayne@68: Ajustarea automată este întotdeauna dezactivată la crearea fluxurilor brute
jpayne@68: (\fB\-\-format=raw\fP).
jpayne@68: .TP 
jpayne@68: \fB\-T\fP \fInumăr\fP, \fB\-\-threads=\fP\fInumăr\fP
jpayne@68: Specifică numărul de fire de execuție de utilizat. Stabilirea \fInumărului\fP
jpayne@68: la valoarea specială \fB0\fP, face ca \fBxz\fP să utilizeze până la atâtea fire de
jpayne@68: execuție câte procesoare sunt în sistem. Numărul real de fire de execuție
jpayne@68: poate fi mai mic decât \fInumăr\fP dacă fișierul de intrare nu este suficient
jpayne@68: de mare pentru a trece la modul cu mai multe fire de execuție cu parametrii
jpayne@68: dați, sau dacă folosirea mai multor fire de execuție ar depăși limita de
jpayne@68: utilizare a memoriei.
jpayne@68: .IP ""
jpayne@68: Operațiile de comprimare cu un singur fir de execuție și cele cu mai multe
jpayne@68: fire de execuție produc ieșiri diferite. Comprimarea cu un singur fir de
jpayne@68: execuție va oferi cea mai mică dimensiune a fișierului, dar numai ieșirea de
jpayne@68: la comprimarea cu mai multe fire de execuție poate fi decomprimată folosind
jpayne@68: mai multe fire. Stabilirea \fInumărului\fP la \fB1\fP va determina ca \fBxz\fP să
jpayne@68: folosească modul cu un singur fir de execuție. Stabilirea \fInumărului\fP la
jpayne@68: orice altă valoare, inclusiv \fB0\fP, va determina ca \fBxz\fP să folosească
jpayne@68: comprimarea cu mai multe fire de execuție chiar dacă sistemul acceptă doar
jpayne@68: un fir hardware; (\fBxz\fP 5.2.x folosește modul cu un singur fir de execuție
jpayne@68: în această situație).
jpayne@68: .IP ""
jpayne@68: Pentru a utiliza modul cu mai multe fire de execuție cu un singur fir,
jpayne@68: stabiliți \fInumărul\fP la \fB+1\fP. Prefixul \fB+\fP nu are efect cu alte valori
jpayne@68: decât \fB1\fP. O limită de utilizare a memoriei poate face în continuare \fBxz\fP
jpayne@68: să treacă în modul cu un singur fir, cu excepția cazului în care este
jpayne@68: utilizată opțiunea \fB\-\-no\-adjust\fP. Suportul pentru prefixul \fB+\fP a fost
jpayne@68: adăugat în \fBxz\fP 5.4.0.
jpayne@68: .IP ""
jpayne@68: Dacă a fost solicitat un număr automat de fire și nu a fost specificată
jpayne@68: nicio limită de utilizare a memoriei, atunci o limită „maleabilă” implicită
jpayne@68: specifică sistemului va fi utilizată pentru a limita eventual numărul de
jpayne@68: fire de execuție. Este o limită „maleabilă” în sensul că este ignorată dacă
jpayne@68: numărul de fire devine unul, astfel o limită „maleabilă” nu va opri
jpayne@68: niciodată \fBxz\fP să comprime sau să decomprime. Această limită „maleabilă”
jpayne@68: implicită nu va face \fBxz\fP să treacă de la modul cu mai multe fire de
jpayne@68: execuție la modul cu un singur fir de execuție. Limitele active pot fi
jpayne@68: văzute rulând comanda \fBxz \-\-info\-memory\fP.
jpayne@68: .IP ""
jpayne@68: În prezent, singura metodă de procesare cu fire de execuție este împărțirea
jpayne@68: intrării în blocuri și comprimarea lor independent unul de
jpayne@68: celălalt. Dimensiunea implicită a blocului depinde de nivelul de comprimare
jpayne@68: și poate fi înlocuită cu opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP.
jpayne@68: .IP ""
jpayne@68: Decomprimarea cu fire de execuție funcționează numai pe fișierele care
jpayne@68: conțin mai multe blocuri cu informații despre dimensiune în antetele
jpayne@68: blocurilor. Toate fișierele suficient de mari comprimate în modul cu mai
jpayne@68: multe fire de execuție îndeplinesc această condiție, dar fișierele
jpayne@68: comprimate în modul cu un singur fir de execuție nu o îndeplinesc chiar dacă
jpayne@68: a fost folosită opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP.
jpayne@68: .IP ""
jpayne@68: Valoarea implicită pentru \fIfire de execuție\fP este \fB0\fP. În \fBxz\fP 5.4.x și
jpayne@68: mai vechi, valoarea implicită este \fB1\fP.
jpayne@68: .
jpayne@68: .SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare"
jpayne@68: Un lanț de filtrare personalizat permite specificarea parametrilor de
jpayne@68: comprimare în detaliu, în loc să se bazeze pe cei asociați opțiunilor
jpayne@68: prestabilite. Când este specificat un lanț de filtrare personalizat,
jpayne@68: opțiunile prestabilite (\fB\-0\fP \&...\& \fB\-9\fP și \fB\-\-extreme\fP) de mai devreme
jpayne@68: din linia de comandă sunt uitate. Dacă o opțiune prestabilită este
jpayne@68: specificată după una sau mai multe opțiuni de lanț de filtrare personalizat,
jpayne@68: noua prestabilire intră în vigoare și opțiunile lanțului de filtrare
jpayne@68: personalizat, specificate mai devreme sunt uitate.
jpayne@68: .PP
jpayne@68: Un lanț de filtrare este comparabil cu conductele din linia de comandă. La
jpayne@68: comprimare, intrarea necomprimată merge la primul filtru, a cărui ieșire
jpayne@68: merge la următorul filtru (dacă există). Ieșirea ultimului filtru este
jpayne@68: scrisă în fișierul comprimat. Numărul maxim de filtre din lanț este de
jpayne@68: patru, dar de obicei un lanț de filtrare are doar unul sau două filtre.
jpayne@68: .PP
jpayne@68: Multe filtre au limitări în ceea ce privește locul în care se pot afla în
jpayne@68: lanțul de filtrare: unele filtre pot funcționa doar ca ultimul filtru din
jpayne@68: lanț, altele doar ca non\-ultim filtru și unele funcționează în orice poziție
jpayne@68: din lanț. În funcție de filtru, această limitare este fie inerentă
jpayne@68: proiectării filtrului, fie există pentru a preveni problemele de securitate.
jpayne@68: .PP
jpayne@68: Un lanț de filtre personalizat poate fi specificat în două moduri
jpayne@68: diferite. Opțiunile \fB\-\-filters=\fP\fIfiltre\fP și \fB\-\-filters1=\fP\fIfiltre\fP
jpayne@68: \&...\& \fB\-\-filters9=\fP\fIfiltre\fP permit specificarea unui întreg lanț de
jpayne@68: filtre într\-o singură opțiune, folosind sintaxa șirului de filtre
jpayne@68: liblzma. Alternativ, un lanț de filtre poate fi specificat prin utilizarea
jpayne@68: uneia sau mai multor opțiuni de filtrare individuale în ordinea în care sunt
jpayne@68: dorite în lanțul de filtre. Adică, ordinea opțiunilor de filtrare
jpayne@68: individuale este semnificativă! La decodificarea fluxurilor brute
jpayne@68: (\fB\-\-format=raw\fP), lanțul de filtre trebuie să fie specificat în aceeași
jpayne@68: ordine în care a fost specificat la comprimare. Orice filtru individual sau
jpayne@68: opțiuni presetate specificate înainte de opțiunea de lanț complet
jpayne@68: (\fB\-\-filters=\fP\fIfiltre\fP) vor fi uitate. Filtrele individuale specificate
jpayne@68: după opțiunea „lanț complet” vor reinițializa lanțul de filtre.
jpayne@68: .PP
jpayne@68: Atât opțiunile de filtrare completă, cât și cele de filtrare individuală
jpayne@68: acceptă \fIopțiuni\fP specifice filtrului sub forma unei liste separate prin
jpayne@68: virgule. Se ignoră virgulele suplimentare din \fIopțiuni\fP. Fiecare opțiune
jpayne@68: are o valoare implicită, deci specificați\-le pe cele pe care doriți să le
jpayne@68: modificați.
jpayne@68: .PP
jpayne@68: Pentru a vedea întregul lanț de filtre și \fIopțiuni\fP, utilizați \fBxz \-vv\fP
jpayne@68: (adică folosiți \fB\-\-verbose\fP de două ori). Acest lucru funcționează și
jpayne@68: pentru vizualizarea opțiunilor lanțului de filtre utilizate de valorile
jpayne@68: prestabilite.
jpayne@68: .TP 
jpayne@68: \fB\-\-filters=\fP\fIfiltre\fP
jpayne@68: Specificați întregul lanț de filtre sau o presetare într\-o singură
jpayne@68: opțiune. Fiecare filtru poate fi separat prin spații sau două liniuțe
jpayne@68: (\fB\-\-\fP). Este posibil să fie necesar ca \fIfiltrele\fP să fie puse între
jpayne@68: ghilimele în linia de comandă a shell\-ului pentru a fi analizate ca o
jpayne@68: singură opțiune. Pentru a indica \fIopțiuni\fP, utilizați \fB:\fP sau \fB=\fP. O
jpayne@68: presetare poate fi prefixată cu un \fB\-\fP și urmată de zero sau mai multe
jpayne@68: indicatoare. Singurul indicator suportat este \fBe\fP pentru a aplica aceleași
jpayne@68: opțiuni ca și \fB\-\-extreme\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-filters1\fP=\fIfiltre\fP ... \fB\-\-filters9\fP=\fIfiltre\fP
jpayne@68: Specifică până la nouă lanțuri de filtre suplimentare care pot fi utilizate
jpayne@68: cu \fB\-\-block\-list\fP.
jpayne@68: .IP ""
jpayne@68: De exemplu, atunci când se comprimă o arhivă cu fișiere executabile urmate
jpayne@68: de fișiere text, partea executabilă ar putea utiliza un lanț de filtre cu un
jpayne@68: filtru BCJ, iar partea de text doar filtrul LZMA2.
jpayne@68: .TP 
jpayne@68: \fB\-\-filters\-help\fP
jpayne@68: Afișează un mesaj de ajutor care descrie modul de specificare a presetărilor
jpayne@68: și a lanțurilor de filtre personalizate în opțiunile \fB\-\-filters\fP și
jpayne@68: \fB\-\-filters1=\fP\fIfiltre\fP \&...\& \fB\-\-filters9=\fP\fIfiltre\fP și iese.
jpayne@68: .TP 
jpayne@68: \fB\-\-lzma1\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .PD 0
jpayne@68: .TP 
jpayne@68: \fB\-\-lzma2\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .PD
jpayne@68: Adaugă filtrul LZMA1 sau LZMA2 la lanțul de filtre. Aceste filtre pot fi
jpayne@68: folosite doar ca ultimul filtru din lanț.
jpayne@68: .IP ""
jpayne@68: LZMA1 este un filtru vechi, care este acceptat aproape exclusiv datorită
jpayne@68: formatului de fișier vechi \fB.lzma\fP, care acceptă numai LZMA1. LZMA2 este o
jpayne@68: versiune actualizată a LZMA1 pentru a rezolva unele probleme practice ale
jpayne@68: LZMA1. Formatul \fB.xz\fP folosește LZMA2 și nu acceptă deloc LZMA1. Viteza de
jpayne@68: comprimare și rapoartele LZMA1 și LZMA2 sunt practic aceleași.
jpayne@68: .IP ""
jpayne@68: LZMA1 și LZMA2 au același set de \fIopțiuni\fP:
jpayne@68: .RS
jpayne@68: .TP 
jpayne@68: \fBpreset=\fP\fIprestabilit\fP
jpayne@68: Reconfigurează toate \fIopțiunile\fP LZMA1 sau LZMA2 la
jpayne@68: \fIprestabilit\fP. \fIprestabilit\fP constă dintr\-un număr întreg, care poate fi
jpayne@68: urmat de modificatori prestabiliți cu o singură literă.  Numărul întreg
jpayne@68: poate fi de la \fB0\fP la \fB9\fP, potrivindu\-se cu opțiunile liniei de comandă
jpayne@68: \fB\-0\fP \&...\& \fB\-9\fP. Singurul modificator acceptat în prezent este \fBe\fP,
jpayne@68: care se potrivește cu \fB\-\-extreme\fP. Dacă nu este specificat \fBprestabilit\fP,
jpayne@68: valorile implicite ale \fIopțiunilor\fP LZMA1 sau LZMA2 sunt preluate din
jpayne@68: prestabilirea \fB6\fP.
jpayne@68: .TP 
jpayne@68: \fBdict=\fP\fIdimensiunea\fP
jpayne@68: \fIDimensiunea\fP dicționarului (istoricul memoriei tampon) indică câți octeți
jpayne@68: din datele necomprimate recent procesate sunt păstrați în
jpayne@68: memorie. Algoritmul încearcă să găsească secvențe de octeți care se repetă
jpayne@68: (potriviri) în datele necomprimate și să le înlocuiască cu referințe la
jpayne@68: datele aflate în prezent în dicționar. Cu cât dicționarul este mai mare, cu
jpayne@68: atât este mai mare șansa de a găsi o potrivire. Astfel, creșterea
jpayne@68: \fIdimensiunii\fP dicționarului îmbunătățește de obicei raportul de comprimare,
jpayne@68: dar un dicționar mai mare decât fișierul necomprimat este risipă de memorie.
jpayne@68: .IP ""
jpayne@68: \fIDimensiunea\fPtipică a dicționarului este de la 64Kio până la 64Mio. Minimul
jpayne@68: este de 4Kio. Maximul pentru compresie este în prezent de 1,5Gio
jpayne@68: (1536Mio). Decomprimarea acceptă deja dicționare cu până la un octet mai
jpayne@68: puțin de 4Gio, care este maximul pentru formatele de flux LZMA1 și LZMA2.
jpayne@68: .IP ""
jpayne@68: \fIDimensiunea\fP dicționarului și găsitorul de potriviri (match finder) →
jpayne@68: (\fImf\fP) determină împreună utilizarea memoriei de către codificatorul LZMA1
jpayne@68: sau LZMA2. Aceeași \fIdimensiune\fP a dicționarului (sau mai mare) care a fost
jpayne@68: utilizată la comprimare, este necesară pentru decomprimare, astfel încât
jpayne@68: utilizarea memoriei de către decodificator este determinată de dimensiunea
jpayne@68: dicționarului utilizată la comprimare. Antetele \fB.xz\fP stochează
jpayne@68: \fIdimensiunea\fP dicționarului fie ca 2^\fIn\fP, fie ca 2^\fIn\fP + 2^(\fIn\fP\-1), deci
jpayne@68: aceste \fIdimensiuni\fP sunt oarecum preferate pentru comprimare. Alte
jpayne@68: \fIdimensiuni\fP vor fi rotunjite atunci când sunt stocate în anteturile
jpayne@68: \&\fB.xz\fP.
jpayne@68: .TP 
jpayne@68: \fBlc=\fP\fIlc\fP
jpayne@68: Specifică numărul de biți de context literal. Minimul este 0 și maximul este
jpayne@68: 4; implicit este 3.  În plus, suma \fIlc\fP și \fIlp\fP nu trebuie să depășească
jpayne@68: 4.
jpayne@68: .IP ""
jpayne@68: Toți octeții care nu pot fi codificați ca potriviri sunt codificați ca
jpayne@68: literali. Adică, literalii sunt pur și simplu octeți de 8 biți care sunt
jpayne@68: codificați unul câte unul.
jpayne@68: .IP ""
jpayne@68: Codificarea literală presupune că cei mai mari biți \fIlc\fP ai octetului
jpayne@68: anterior necomprimat se corelează cu octetul următor. De exemplu, în textul
jpayne@68: tipic englezesc, o literă mare este adesea urmată de o literă mică, iar o
jpayne@68: literă mică este urmată de obicei de o altă literă mică. În setul de
jpayne@68: caractere US\-ASCII, cei mai mari trei biți sunt 010 pentru literele mari și
jpayne@68: 011 pentru literele mici. Când \fIlc\fP este cel puțin 3, codificarea literală
jpayne@68: poate profita de această proprietate în datele necomprimate.
jpayne@68: .IP ""
jpayne@68: Valoarea implicită (3) este de obicei bună. Dacă doriți o comprimare maximă,
jpayne@68: testați \fBlc=4\fP. Uneori ajută puțin, iar uneori înrăutățește comprimarea
jpayne@68: \&. Dacă o agravează, încercați de\-asemeni cu \fBlc=2\fP.
jpayne@68: .TP 
jpayne@68: \fBlp=\fP\fIlp\fP
jpayne@68: Specifică numărul de biți de poziție literală. Minimul este 0 și maximul
jpayne@68: este 4; implicit este 0.
jpayne@68: .IP ""
jpayne@68: \fILp\fP afectează ce fel de aliniere în datele necomprimate este presupusă la
jpayne@68: codificarea literalelor. Consultați argumentul \fIpb\fP de mai jos pentru mai
jpayne@68: multe informații despre aliniere.
jpayne@68: .TP 
jpayne@68: \fBpb=\fP\fIpb\fP
jpayne@68: Specifică numărul de biți de poziție. Minimul este 0 și maximul este 4;
jpayne@68: implicit este 2.
jpayne@68: .IP ""
jpayne@68: \fIPb\fP afectează ce fel de aliniere în datele necomprimate este presupusă în
jpayne@68: general. Valoarea implicită înseamnă alinierea pe patru octeți
jpayne@68: (2^\fIpb\fP=2^2=4), care este adesea o alegere bună atunci când nu există o
jpayne@68: ipoteză mai bună.
jpayne@68: .IP ""
jpayne@68: Când alinierea este cunoscută, definirea lui \fIpb\fP în mod corespunzător
jpayne@68: poate reduce puțin dimensiunea fișierului. De exemplu, cu fișierele text cu
jpayne@68: aliniere pe un octet (US\-ASCII, ISO\-8859\-*, UTF\-8), definirea \fBpb=0\fP poate
jpayne@68: îmbunătăți ușor comprimarea. Pentru textul UTF\-16, \fBpb=1\fP este o alegere
jpayne@68: bună. Dacă alinierea este un număr impar, cum ar fi 3 octeți, \fBpb=0\fP ar
jpayne@68: putea fi cea mai bună alegere.
jpayne@68: .IP ""
jpayne@68: Chiar dacă alinierea presupusă poate fi ajustată cu \fIpb\fP și \fIlp\fP, LZMA1 și
jpayne@68: LZMA2 încă favorizează ușor alinierea pe 16 octeți. Ar putea fi demn de luat
jpayne@68: în considerare atunci când proiectați formate de fișiere care pot fi adesea
jpayne@68: comprimate cu LZMA1 sau LZMA2.
jpayne@68: .TP 
jpayne@68: \fBmf=\fP\fImf\fP
jpayne@68: Căutarea potrivirilor are un efect major asupra vitezei codificatorului,
jpayne@68: utilizării memoriei și raportului de comprimare. De obicei, găsitorii de
jpayne@68: potriviri din lanțul sumelor de control sunt mai rapizi decât găsitorii de
jpayne@68: potriviri din arborele binar. Valoarea implicită depinde de \fIprestabilit\fP:
jpayne@68: 0 folosește \fBhc3\fP, 1\(en3 folosește \fBhc4\fP, iar restul folosește \fBbt4\fP.
jpayne@68: .IP ""
jpayne@68: Sunt acceptate următoarele opțiuni de căutare de potriviri. Formulele de
jpayne@68: utilizare a memoriei de mai jos sunt aproximări estimative, care se apropie
jpayne@68: cel mai mult de realitate atunci când \fIdict\fP este o putere a lui doi.
jpayne@68: .RS
jpayne@68: .TP 
jpayne@68: \fBhc3\fP
jpayne@68: Lanț de sumă de control, cu suma de control de 2 și 3 octeți
jpayne@68: .br
jpayne@68: Valoarea minimă pentru \fInice\fP: 3
jpayne@68: .br
jpayne@68: Utilizarea memoriei:
jpayne@68: .br
jpayne@68: \fIdict\fP * 7.5 (dacă \fIdict\fP <= 16 Mio);
jpayne@68: .br
jpayne@68: \fIdict\fP * 5.5 + 64 MiB (dacă \fIdict\fP > 16 Mio)
jpayne@68: .TP 
jpayne@68: \fBhc4\fP
jpayne@68: Lanț de sumă de control, cu suma de control de 2, 3 și 4 octeți
jpayne@68: .br
jpayne@68: Valoarea minimă pentru \fInice\fP: 4
jpayne@68: .br
jpayne@68: Utilizarea memoriei:
jpayne@68: .br
jpayne@68: \fIdict\fP * 7.5 (dacă \fIdict\fP <= 32 Mio);
jpayne@68: .br
jpayne@68: \fIdict\fP * 6.5 (dacă \fIdict\fP > 32 Mio)
jpayne@68: .TP 
jpayne@68: \fBbt2\fP
jpayne@68: Arbore binar cu suma de control de 2 octeți
jpayne@68: .br
jpayne@68: Valoarea minimă pentru \fInice\fP: 2
jpayne@68: .br
jpayne@68: Utilizarea memoriei: \fIdict\fP * 9.5
jpayne@68: .TP 
jpayne@68: \fBbt3\fP
jpayne@68: Arbore binar cu suma de control de 2 și 3 octeți
jpayne@68: .br
jpayne@68: Valoarea minimă pentru \fInice\fP: 3
jpayne@68: .br
jpayne@68: Utilizarea memoriei:
jpayne@68: .br
jpayne@68: \fIdict\fP * 11.5 (dacă \fIdict\fP <= 16 Mio);
jpayne@68: .br
jpayne@68: \fIdict\fP * 9.5 + 64 MiB (dacă \fIdict\fP > 16 Mio)
jpayne@68: .TP 
jpayne@68: \fBbt4\fP
jpayne@68: Arbore binar cu suma de control de 2, 3 și 4 octeți
jpayne@68: .br
jpayne@68: Valoarea minimă pentru \fInice\fP: 4
jpayne@68: .br
jpayne@68: Utilizarea memoriei:
jpayne@68: .br
jpayne@68: \fIdict\fP * 11.5 (dacă \fIdict\fP <= 32 Mio);
jpayne@68: .br
jpayne@68: \fIdict\fP * 10.5 (dacă \fIdict\fP > 32 Mio)
jpayne@68: .RE
jpayne@68: .TP 
jpayne@68: \fBmode=\fP\fImod\fP
jpayne@68: Comprimarea \fImod\fP specifică metoda de analiză a datelor produse de
jpayne@68: găsitorul de potriviri. \fIModurile\fP acceptate sunt \fBfast\fP(rapid) și
jpayne@68: \fBnormal\fP. Valoarea implicită este \fBfast\fP pentru \fIprestabiliri\fP 0\(en3 și
jpayne@68: \fBnormal\fP pentru \fIprestabiliri\fP 4\(en9.
jpayne@68: .IP ""
jpayne@68: De obicei, \fBfast\fP este folosit cu instrumentele de căutare de potriviri ale
jpayne@68: lanțului de sume de control, și \fBnormal\fP cu instrumentele de căutare de
jpayne@68: potriviri din arborele binar. Aceasta este și ceea ce fac \fIprestabiririle\fP.
jpayne@68: .TP 
jpayne@68: \fBnice=\fP\fInice\fP
jpayne@68: Specifică ceea ce este considerat a fi o lungime bună(nice) pentru o
jpayne@68: potrivire. Odată ce este găsită o potrivire de cel puțin \fInice\fP octeți,
jpayne@68: algoritmul nu mai caută după potriviri posibile mai bune.
jpayne@68: .IP ""
jpayne@68: \fINice\fP poate fi de 2\(en273 octeți. Valorile mai mari tind să ofere un
jpayne@68: raport de comprimare mai bun în detrimentul vitezei. Valoarea implicită
jpayne@68: depinde de \fIprestabilit\fP.
jpayne@68: .TP 
jpayne@68: \fBdepth=\fP\fIadâncimea\fP
jpayne@68: Specifică adâncimea maximă de căutare în găsitorul de potriviri. Valoarea
jpayne@68: implicită este valoarea specială de 0, ceea ce face ca instrumentul de
jpayne@68: comprimare să determine o \fIadâncime\fP rezonabilă pornind de la valorile
jpayne@68: \fImf\fP și \fInice\fP.
jpayne@68: .IP ""
jpayne@68: \fIAdâncimea\fP rezonabilă pentru lanțuri de sumă de control este 4\(en100 și
jpayne@68: 16\(en1000 pentru arbori binari. Folosirea unor valori foarte mari pentru
jpayne@68: \fIadâncime\fP poate face codificatorul extrem de lent cu unele
jpayne@68: fișiere. Evitați să stabiliți \fIadâncimea\fP la valori peste 1000, cu excepția
jpayne@68: cazului în care sunteți pregătit să întrerupeți comprimarea în cazul în care
jpayne@68: durează prea mult.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: La decodificarea fluxurilor brute (\fB\-\-format=raw\fP), LZMA2 are nevoie doar
jpayne@68: de \fIdimensiunea\fP dicționarului. LZMA1 are nevoie de asemenea de \fIlc\fP,
jpayne@68: \fIlp\fP și \fIpb\fP.
jpayne@68: .TP 
jpayne@68: \fB\-\-x86\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .PD 0
jpayne@68: .TP 
jpayne@68: \fB\-\-arm\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .TP 
jpayne@68: \fB\-\-armthumb\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .TP 
jpayne@68: \fB\-\-arm64\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .TP 
jpayne@68: \fB\-\-powerpc\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .TP 
jpayne@68: \fB\-\-ia64\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .TP 
jpayne@68: \fB\-\-sparc\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .TP 
jpayne@68: \fB\-\-riscv\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: .PD
jpayne@68: Adaugă un filtru de ramură/apel/salt (branch/call/jump ⟶ „BCJ”) la lanțul de
jpayne@68: filtre. Aceste filtre pot fi utilizate numai ca un filtru care nu este
jpayne@68: ultimul din lanțul de filtrare.
jpayne@68: .IP ""
jpayne@68: Un filtru BCJ convertește adresele relative din codul mașinii în omoloagele
jpayne@68: lor absolute. Acest lucru nu modifică dimensiunea datelor, dar crește
jpayne@68: redundanța, ceea ce poate ajuta LZMA2 să producă fișier \fB.xz\fP cu 0\(en15\ %
jpayne@68: mai mic. Filtrele BCJ sunt întotdeauna reversibile, deci folosind un filtru
jpayne@68: BCJ pentru tipul greșit de date nu provoacă nicio pierdere de date, deși
jpayne@68: poate înrăutăți puțin raportul de comprimare. Filtrele BCJ sunt foarte
jpayne@68: rapide și folosesc o cantitate nesemnificativă de memorie.
jpayne@68: .IP ""
jpayne@68: Aceste filtre BCJ au probleme cunoscute legate de raportul de comprimare:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: Unele tipuri de fișiere care conțin cod executabil (de exemplu, fișiere
jpayne@68: obiect, biblioteci statice și module de kernel Linux) au adresele din
jpayne@68: instrucțiuni completate cu valori de umplere. Aceste filtre BCJ vor face în
jpayne@68: continuare conversia adresei, ceea ce va înrăutăți comprimarea cu aceste
jpayne@68: fișiere.
jpayne@68: .IP \(bu 3
jpayne@68: Dacă pe o arhivă este aplicat un filtru BCJ, este posibil ca raportul de
jpayne@68: comprimare să fie mai rău decât la neutilizarea unui filtru BCJ. De exemplu,
jpayne@68: dacă există executabile similare sau chiar identice, filtrarea va face
jpayne@68: probabil fișierele mai puțin asemănătoare și astfel comprimarea este mai
jpayne@68: proastă. Conținutul fișierelor neexecutabile din aceeași arhivă poate conta
jpayne@68: și el. În practică, trebuie să încercați cu și fără filtru BCJ pentru a
jpayne@68: vedea care rezultat este mai bun în fiecare situație.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Seturi de instrucțiuni diferite au o aliniere diferită: fișierul executabil
jpayne@68: trebuie aliniat la un multiplu al acestei valori în datele de intrare pentru
jpayne@68: ca filtrul să funcționeze.
jpayne@68: .RS
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .TS
jpayne@68: tab(;);
jpayne@68: l n l
jpayne@68: l n l.
jpayne@68: Filtru;Aliniere;Note
jpayne@68: x86;1;x86 pe 32 de biți
jpayne@68: ;;sau 64 de biți
jpayne@68: ARM;4;
jpayne@68: ARM\-Thumb;2;
jpayne@68: ARM64;4;alinierea pe 4096\-octeți
jpayne@68: ;;este cea mai bună
jpayne@68: PowerPC;4;Doar big endian
jpayne@68: IA\-64;16;Itanium
jpayne@68: SPARC;4;
jpayne@68: RISC\-V;2;
jpayne@68: .TE
jpayne@68: .RE
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Deoarece datele filtrate prin BCJ sunt de obicei comprimate cu LZMA2,
jpayne@68: raportul de comprimare poate fi ușor îmbunătățit dacă opțiunile LZMA2 sunt
jpayne@68: definite pentru a se potrivi cu alinierea filtrului BCJ selectat. Exemple:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: Filtrul IA\-64 are o aliniere de 16 octeți, astfel încât \fBpb=4,lp=4,lc=0\fP
jpayne@68: este alegere adecvată cu LZMA2 (2^4=16).
jpayne@68: .IP \(bu 3
jpayne@68: Codul RISC\-V are o aliniere pe 2 sau 4 octeți, depinzând de faptul că
jpayne@68: fișierul conține instrucțiuni comprimate pe 16 biți (extensia C) sau
jpayne@68: nu. Atunci când se utilizează instrucțiuni pe 16 biți, \fBpb=2,lp=1,lc=3\fP sau
jpayne@68: \fBpb=1,lp=1,lc=3\fP este o alegere bună. Atunci când nu sunt prezente
jpayne@68: instrucțiuni pe 16 biți, \fBpb=2,lp=2,lc=2\fP este cea mai bună
jpayne@68: alegere. \fBreadelf \-h\fP poate fi utilizată pentru a verifica dacă „RVC” apare
jpayne@68: în linia „Indicatori".
jpayne@68: .IP \(bu 3
jpayne@68: ARM64 este întotdeauna aliniat pe 4 octeți, astfel încât \fBpb=2,lp=2,lc=2\fP
jpayne@68: este cea mai bună alegere.
jpayne@68: .IP \(bu 3
jpayne@68: Filtrul x86 este o excepție. De obicei, este bine să rămâneți la valorile
jpayne@68: implicite ale LZMA2 (\fBpb=2,lp=0,lc=3\fP) atunci când comprimați executabile
jpayne@68: x86.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Toate filtrele BCJ acceptă același \fIopțiuni\fP:
jpayne@68: .RS
jpayne@68: .TP 
jpayne@68: \fBstart=\fP\fIpoziție\fP
jpayne@68: Specifică \fIpoziția\fP de pornire care este utilizată la conversia între
jpayne@68: adresele relative și absolute. \fIPoziția\fP trebuie să fie un multiplu al
jpayne@68: alinierii filtrului (consultați tabelul de mai sus).  Valoarea implicită
jpayne@68: este zero. În practică, valoarea implicită este bună; specificarea unei
jpayne@68: \fIpoziții\fP personalizate nu este aproape niciodată utilă.
jpayne@68: .RE
jpayne@68: .TP 
jpayne@68: \fB\-\-delta\fP[\fB=\fP\fIopțiuni\fP]
jpayne@68: Adaugă filtrul Delta în lanțul de filtrare. Filtrul Delta poate fi folosit
jpayne@68: doar ca un filtru care nu este ultimul în lanțul de filtrare.
jpayne@68: .IP ""
jpayne@68: În prezent, este acceptat doar calculul delta simplu de octeți. Poate fi
jpayne@68: util la comprimarea, de exemplu, a imaginilor bitmap necomprimate sau a
jpayne@68: sunetului PCM necomprimat. Cu toate acestea, algoritmii cu scop special pot
jpayne@68: da rezultate semnificativ mai bune decât Delta + LZMA2. Acest lucru este
jpayne@68: valabil mai ales în cazul audio, care se comprimă mai repede și mai bine, de
jpayne@68: exemplu, cu \fBflac\fP(1).
jpayne@68: .IP ""
jpayne@68: \fIOpțiuni\fP acceptate:
jpayne@68: .RS
jpayne@68: .TP 
jpayne@68: \fBdist=\fP\fIdistanța\fP
jpayne@68: Specifică \fIdistanța\fP calculului delta în octeți. \fIDistanța\fP trebuie să fie
jpayne@68: 1\(en256. Valoarea implicită este 1.
jpayne@68: .IP ""
jpayne@68: De exemplu, cu \fBdist=2\fP și intrare de opt octeți: A1 B1 A2 B3 A3 B5 A4 B7,
jpayne@68: ieșirea va fi: A1 B1 01 02 01 02 01 02.
jpayne@68: .RE
jpayne@68: .
jpayne@68: .SS "Alte opțiuni"
jpayne@68: .TP 
jpayne@68: \fB\-q\fP, \fB\-\-quiet\fP
jpayne@68: Suprimă avertismentele și notificările. Specificați acest lucru de două ori
jpayne@68: pentru a suprima și erorile. Această opțiune nu are niciun efect asupra
jpayne@68: stării de ieșire. Adică, chiar dacă o avertizare a fost suprimată, starea de
jpayne@68: ieșire pentru a indica o avertizare este încă utilizată.
jpayne@68: .TP 
jpayne@68: \fB\-v\fP, \fB\-\-verbose\fP
jpayne@68: Oferă informații detaliate. Dacă ieșirea de eroare standard este conectată
jpayne@68: la un terminal, \fBxz\fP va afișa un indicator de progres. Specificarea
jpayne@68: opțiunii \fB\-\-verbose\fP de două ori, va avea ca rezultat oferirea de
jpayne@68: informații și mai detaliate.
jpayne@68: .IP ""
jpayne@68: Indicatorul de progres afișează următoarele informații:
jpayne@68: .RS
jpayne@68: .IP \(bu 3
jpayne@68: Procentul de completare este afișat dacă se cunoaște dimensiunea fișierului
jpayne@68: de intrare. Adică, procentul nu poate fi afișat la procesarea fișierului
jpayne@68: prin conducte(pipe).
jpayne@68: .IP \(bu 3
jpayne@68: Cantitatea de date comprimate produse (comprimare) sau consumate
jpayne@68: (decomprimare).
jpayne@68: .IP \(bu 3
jpayne@68: Cantitatea de date necomprimate consumate (comprimare) sau produse
jpayne@68: (decomprimare).
jpayne@68: .IP \(bu 3
jpayne@68: Raportul de comprimare, care se calculează împărțind cantitatea de date
jpayne@68: comprimate procesate până acum la cantitatea de date necomprimate procesate
jpayne@68: până acum.
jpayne@68: .IP \(bu 3
jpayne@68: Viteza de comprimare sau decomprimare. Aceasta este măsurată drept
jpayne@68: cantitatea de date necomprimate consumate (comprimare) sau produse
jpayne@68: (decomprimare) pe secundă. Este afișată după ce au trecut câteva secunde de
jpayne@68: când \fBxz\fP a început procesarea fișierului.
jpayne@68: .IP \(bu 3
jpayne@68: Timpul scurs în format M:SS sau H:MM:SS.
jpayne@68: .IP \(bu 3
jpayne@68: Timpul rămas estimat este afișat numai atunci când dimensiunea fișierului de
jpayne@68: intrare este cunoscută și au trecut deja câteva secunde de când \fBxz\fP a
jpayne@68: început procesarea fișierului. Ora este afișată într\-un format mai puțin
jpayne@68: precis, care nu are niciodată două puncte, de exemplu, 2 min 30 s.
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Când ieșirea de eroare standard nu este un terminal, \fB\-\-verbose\fP va face
jpayne@68: \fBxz\fP să imprime numele fișierului, dimensiunea comprimată, dimensiunea
jpayne@68: necomprimată, raportul de comprimare și, eventual, de asemenea, viteza și
jpayne@68: timpul scurs pe o singură linie la ieșirea de eroare standard după
jpayne@68: comprimarea sau decomprimarea fișierului. Viteza și timpul scurs sunt
jpayne@68: incluse numai atunci când operațiunea a durat cel puțin câteva secunde. Dacă
jpayne@68: operațiunea nu s\-a încheiat, de exemplu, din cauza întreruperii din partea
jpayne@68: utilizatorului, se imprimă și procentul de completare dacă se cunoaște
jpayne@68: dimensiunea fișierului de intrare.
jpayne@68: .TP 
jpayne@68: \fB\-Q\fP, \fB\-\-no\-warn\fP
jpayne@68: Nu comută starea de ieșire la 2 chiar dacă a fost detectată o condiție care
jpayne@68: merită avertizată. Această opțiune nu afectează nivelul de detaliere al
jpayne@68: informațiilor, astfel încât atât \fB\-\-quiet\fP cât și \fB\-\-no\-warn\fP trebuie
jpayne@68: folosite pentru a nu afișa avertismente și pentru a nu modifica starea de
jpayne@68: ieșire.
jpayne@68: .TP 
jpayne@68: \fB\-\-robot\fP
jpayne@68: Afișează mesajele într\-un format care poate fi analizat de mașină. Acest
jpayne@68: lucru are scopul de a ușura scrierea interfețelor în care se dorește să se
jpayne@68: folosească \fBxz\fP în loc de liblzma, ceea ce poate fi cazul cu diferite
jpayne@68: scripturi. Ieșirea cu această opțiune activată este menită să fie stabilă în
jpayne@68: toate versiunile \fBxz\fP. Consultați secțiunea \fBMOD ROBOT\fP pentru detalii.
jpayne@68: .TP 
jpayne@68: \fB\-\-info\-memory\fP
jpayne@68: Afișează, într\-un format care poate fi citit de om, câtă memorie fizică
jpayne@68: (RAM) și câte fire de execuție de procesor \fBxz\fP crede că are sistemul și
jpayne@68: limitele de utilizare a memoriei pentru comprimare și decomprimare și iese
jpayne@68: cu succes.
jpayne@68: .TP 
jpayne@68: \fB\-h\fP, \fB\-\-help\fP
jpayne@68: Afișează un mesaj de ajutor care descrie opțiunile cele mai frecvent
jpayne@68: utilizate și iese cu succes.
jpayne@68: .TP 
jpayne@68: \fB\-H\fP, \fB\-\-long\-help\fP
jpayne@68: Afișează un mesaj de ajutor care descrie toate caracteristicile \fBxz\fP și
jpayne@68: iese cu succes
jpayne@68: .TP 
jpayne@68: \fB\-V\fP, \fB\-\-version\fP
jpayne@68: Afișează numărul versiunii \fBxz\fP și liblzma într\-un format care poate fi
jpayne@68: citit de om. Pentru a obține rezultate analizabile de mașină, specificați
jpayne@68: \fB\-\-robot\fP înainte de \fB\-\-version\fP.
jpayne@68: .
jpayne@68: .SH "MOD ROBOT"
jpayne@68: Modul robot este activat cu opțiunea \fB\-\-robot\fP. Face ieșirea lui \fBxz\fP mai
jpayne@68: ușor de analizat de către alte programe.  În prezent, opțiunea \fB\-\-robot\fP
jpayne@68: este acceptată numai împreună cu opțiunile \fB\-\-list\fP, \fB\-\-filters\-help\fP,
jpayne@68: \fB\-\-info\-memory\fP, și \fB\-\-version\fP. Va fi acceptată pentru comprimare și
jpayne@68: decomprimare în viitor.
jpayne@68: .
jpayne@68: .SS "Modul listă"
jpayne@68: \fBxz \-\-robot \-\-list\fP utilizează o ieșire separată de tabulatori. Prima
jpayne@68: coloană a fiecărei linii are un șir care indică tipul de informații găsite
jpayne@68: pe acea linie:
jpayne@68: .TP 
jpayne@68: \fBname\fP
jpayne@68: Aceasta este întotdeauna prima linie când începe să se listeze un fișier. A
jpayne@68: doua coloană de pe linie este numele fișierului.
jpayne@68: .TP 
jpayne@68: \fBfile\fP
jpayne@68: Această linie conține informații generale despre fișierul \fB.xz\fP. Această
jpayne@68: linie este întotdeauna tipărită după linia \fBname\fP.
jpayne@68: .TP 
jpayne@68: \fBstream\fP
jpayne@68: Acest tip de linie este utilizat numai atunci când a fost specificată
jpayne@68: opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBstream\fP câte fluxuri există
jpayne@68: în fișierul \fB.xz\fP.
jpayne@68: .TP 
jpayne@68: \fBblock\fP
jpayne@68: Acest tip de linie este utilizat numai atunci când a fost specificată
jpayne@68: opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBblock\fP câte blocuri există
jpayne@68: în fișierul \fB.xz\fP. Liniile \fBblock\fP sunt afișate după toate liniile
jpayne@68: \fBstream\fP; tipurile diferite de linii nu sunt intercalate.
jpayne@68: .TP 
jpayne@68: \fBsummary\fP
jpayne@68: Acest tip de linie este folosit numai atunci când opțiunea \fB\-\-verbose\fP a
jpayne@68: fost specificată de două ori. Această linie este afișată după toate liniile
jpayne@68: \fBblock\fP. Ca și linia \fBfile\fP, linia \fBsummary\fP conține informații generale
jpayne@68: despre fișierul \fB.xz\fP.
jpayne@68: .TP 
jpayne@68: \fBtotals\fP
jpayne@68: Această linie este întotdeauna ultima linie din lista afișată la
jpayne@68: ieșire. Aceasta arată numărul total și dimensiunile.
jpayne@68: .PP
jpayne@68: Coloanele din liniile \fBfile\fP:
jpayne@68: .PD 0
jpayne@68: .RS
jpayne@68: .IP 2. 4
jpayne@68: Numărul de fluxuri din fișier
jpayne@68: .IP 3. 4
jpayne@68: Numărul total de blocuri din fluxuri
jpayne@68: .IP 4. 4
jpayne@68: Dimensiunea comprimată a fișierului
jpayne@68: .IP 5. 4
jpayne@68: Dimensiunea necomprimată a fișierului
jpayne@68: .IP 6. 4
jpayne@68: Raportul de comprimare, de exemplu, \fB0,123\fP. Dacă raportul este peste
jpayne@68: 9,999, în locul raportului sunt afișate trei liniuțe (\fB\-\-\-\fP).
jpayne@68: .IP 7. 4
jpayne@68: Lista de nume de verificare a integrității, separate prin
jpayne@68: virgule. Următoarele șiruri sunt utilizate pentru tipurile de verificare
jpayne@68: cunoscute: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP și \fBSHA\-256\fP. Pentru tipurile de
jpayne@68: verificări necunoscute, se utilizează \fBNone\-\fP\fIN\fP, unde \fIN\fP este ID\-ul de
jpayne@68: verificare ca număr zecimal (una sau două cifre).
jpayne@68: .IP 8. 4
jpayne@68: Dimensiunea totală a umpluturii fluxului din fișier
jpayne@68: .RE
jpayne@68: .PD
jpayne@68: .PP
jpayne@68: Coloanele din liniile \fBstream\fP:
jpayne@68: .PD 0
jpayne@68: .RS
jpayne@68: .IP 2. 4
jpayne@68: Numărul fluxului (primul flux este 1)
jpayne@68: .IP 3. 4
jpayne@68: Numărul de blocuri din flux
jpayne@68: .IP 4. 4
jpayne@68: Poziția de pornire a comprimării
jpayne@68: .IP 5. 4
jpayne@68: Poziția de pornire a decomprimării
jpayne@68: .IP 6. 4
jpayne@68: Dimensiune comprimată (nu include umplutura fluxului)
jpayne@68: .IP 7. 4
jpayne@68: Dimensiune necomprimată
jpayne@68: .IP 8. 4
jpayne@68: Raport de comprimare
jpayne@68: .IP 9. 4
jpayne@68: Numele verificării de integritate
jpayne@68: .IP 10. 4
jpayne@68: Dimensiunea umpluturii fluxului
jpayne@68: .RE
jpayne@68: .PD
jpayne@68: .PP
jpayne@68: Coloanele din liniile \fBblock\fP:
jpayne@68: .PD 0
jpayne@68: .RS
jpayne@68: .IP 2. 4
jpayne@68: Numărul fluxului care conține acest bloc
jpayne@68: .IP 3. 4
jpayne@68: Numărul blocului în raport cu începutul fluxului (primul bloc este 1)
jpayne@68: .IP 4. 4
jpayne@68: Numărul blocului în raport cu începutul fișierului
jpayne@68: .IP 5. 4
jpayne@68: Poziția de pornire a comprimării în raport cu începutul fișierului
jpayne@68: .IP 6. 4
jpayne@68: Poziția de pornire necomprimată în raport cu începutul fișierului
jpayne@68: .IP 7. 4
jpayne@68: Dimensiunea totală comprimată a blocului (include antetele)
jpayne@68: .IP 8. 4
jpayne@68: Dimensiune necomprimată
jpayne@68: .IP 9. 4
jpayne@68: Raport de comprimare
jpayne@68: .IP 10. 4
jpayne@68: Numele verificării de integritate
jpayne@68: .RE
jpayne@68: .PD
jpayne@68: .PP
jpayne@68: Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, coloane
jpayne@68: suplimentare sunt incluse pe liniile \fBblock\fP. Acestea nu sunt afișate cu o
jpayne@68: singură specificare a opțiunii \fB\-\-verbose\fP, deoarece obținerea acestor
jpayne@68: informații necesită multe căutări și, prin urmare, poate fi lentă:
jpayne@68: .PD 0
jpayne@68: .RS
jpayne@68: .IP 11. 4
jpayne@68: Valoarea verificării integrității în hexazecimal
jpayne@68: .IP 12. 4
jpayne@68: Dimensiunea antetului blocului
jpayne@68: .IP 13. 4
jpayne@68: Indicatori de bloc: \fBc\fP indică faptul că este prezentă dimensiunea
jpayne@68: comprimată, iar \fBu\fP indică faptul că este prezentă dimensiunea
jpayne@68: necomprimată. Dacă indicatorul nu este determinat, este afișată o liniuță
jpayne@68: (\fB\-\fP) pentru a menține lungimea șirului fixă. Pot fi adăugate noi
jpayne@68: indicatoare la sfârșitul șirului, în viitor.
jpayne@68: .IP 14. 4
jpayne@68: Dimensiunea datelor comprimate reale din bloc (acest lucru exclude antetul
jpayne@68: blocului, umplutura blocului și câmpurile de verificare)
jpayne@68: .IP 15. 4
jpayne@68: Cantitatea de memorie (în octeți) necesară pentru a decomprima acest bloc cu
jpayne@68: această versiune \fBxz\fP
jpayne@68: .IP 16. 4
jpayne@68: Lanț de filtrare. Rețineți că majoritatea opțiunilor utilizate în timpul
jpayne@68: comprimării nu pot fi cunoscute, deoarece doar opțiunile necesare pentru
jpayne@68: decomprimare sunt stocate în anteturile \fB.xz\fP.
jpayne@68: .RE
jpayne@68: .PD
jpayne@68: .PP
jpayne@68: Coloanele din liniile \fBsummary\fP:
jpayne@68: .PD 0
jpayne@68: .RS
jpayne@68: .IP 2. 4
jpayne@68: Cantitatea de memorie (în octeți) necesară pentru a decomprima acest fișier
jpayne@68: cu această versiune \fBxz\fP
jpayne@68: .IP 3. 4
jpayne@68: \fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea
jpayne@68: comprimată, cât și dimensiunea necomprimată stocate în ele
jpayne@68: .PP
jpayne@68: \fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP
jpayne@68: .IP 4. 4
jpayne@68: Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul
jpayne@68: .RE
jpayne@68: .PD
jpayne@68: .PP
jpayne@68: Coloanele din linia \fBtotals\fP:
jpayne@68: .PD 0
jpayne@68: .RS
jpayne@68: .IP 2. 4
jpayne@68: Numărul de fluxuri
jpayne@68: .IP 3. 4
jpayne@68: Numărul de blocuri
jpayne@68: .IP 4. 4
jpayne@68: Dimensiunea comprimată
jpayne@68: .IP 5. 4
jpayne@68: Dimensiune necomprimată
jpayne@68: .IP 6. 4
jpayne@68: Raportul mediu de comprimare
jpayne@68: .IP 7. 4
jpayne@68: Lista de nume de verificare a integrității, separate prin virgule, care au
jpayne@68: fost prezente în fișiere
jpayne@68: .IP 8. 4
jpayne@68: Dimensiunea umpluturii fluxului
jpayne@68: .IP 9. 4
jpayne@68: Numărul de fișiere. Aceasta este aici pentru a păstra ordinea coloanelor
jpayne@68: anterioare la fel ca pe liniile \fBfile\fP.
jpayne@68: .PD
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, pe linia
jpayne@68: \fBtotals\fP sunt incluse coloane suplimentare:
jpayne@68: .PD 0
jpayne@68: .RS
jpayne@68: .IP 10. 4
jpayne@68: Cantitatea maximă de memorie (în octeți) necesară pentru a decomprima
jpayne@68: fișierele cu această versiune \fBxz\fP
jpayne@68: .IP 11. 4
jpayne@68: \fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea
jpayne@68: comprimată, cât și dimensiunea necomprimată stocate în ele
jpayne@68: .PP
jpayne@68: \fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP
jpayne@68: .IP 12. 4
jpayne@68: Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul
jpayne@68: .RE
jpayne@68: .PD
jpayne@68: .PP
jpayne@68: Versiunile viitoare pot adăuga noi tipuri de linii și pot fi adăugate
jpayne@68: coloane noi la tipurile de linii existente, dar coloanele existente nu vor
jpayne@68: fi modificate.
jpayne@68: .
jpayne@68: .SS "Ajutor pentru filtrare"
jpayne@68: \fBxz \-\-robot \-\-filters\-help\fP afișează filtrele acceptate în următorul
jpayne@68: format:
jpayne@68: .PP
jpayne@68: \fIfiltru\fP\fB:\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>,\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>\fP...
jpayne@68: .TP 
jpayne@68: \fBfiltru\fP
jpayne@68: Numele filtrului
jpayne@68: .TP 
jpayne@68: \fIopțiune\fP
jpayne@68: Numele unei opțiuni specifice unui filtru
jpayne@68: .TP 
jpayne@68: \fIvaloare\fP
jpayne@68: Intervalele numerice \fIvaloare\fP apar ca
jpayne@68: \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Alegerile \fIvaloare\fP de tip șir de
jpayne@68: caractere sunt afișate în cadrul \fB< >\fP și separate de un caracter
jpayne@68: \fB|\fP.
jpayne@68: .PP
jpayne@68: Fiecare filtru este afișat pe propria linie.
jpayne@68: .
jpayne@68: .SS "Informații privind limita memoriei"
jpayne@68: \fBxz \-\-robot \-\-info\-memory\fP afișează o singură linie cu multiple coloane
jpayne@68: separate prin tabulatoare:
jpayne@68: .IP 1. 4
jpayne@68: Cantitatea totală de memorie fizică (RAM) în octeți.
jpayne@68: .IP 2. 4
jpayne@68: Limita de utilizare a memoriei pentru comprimare în octeți
jpayne@68: (\fB\-\-memlimit\-compress\fP). O valoare specială de \fB0\fP indică configurarea
jpayne@68: implicită, care pentru modul cu un singur fir este la fel ca fără limită.
jpayne@68: .IP 3. 4
jpayne@68: Limita de utilizare a memoriei pentru decomprimare în octeți
jpayne@68: (\fB\-\-memlimit\-decompress\fP). O valoare specială de \fB0\fP indică configurarea
jpayne@68: implicită, care pentru modul cu un singur fir este la fel ca fără limită.
jpayne@68: .IP 4. 4
jpayne@68: Începând cu \fBxz\fP 5.3.4alpha: Utilizarea memoriei pentru decomprimarea cu
jpayne@68: mai multe fire în octeți (\fB\-\-memlimit\-mt\-decompress\fP). Acesta nu este
jpayne@68: niciodată zero, deoarece o valoare implicită specifică sistemului afișată în
jpayne@68: coloana 5 este utilizată dacă nu a fost specificată în mod explicit nicio
jpayne@68: limită. De asemenea, aceasta nu este niciodată mai mare decât valoarea din
jpayne@68: coloana 3, chiar dacă a fost specificată o valoare mai mare cu
jpayne@68: \fB\-\-memlimit\-mt\-decompress\fP.
jpayne@68: .IP 5. 4
jpayne@68: Începând cu \fBxz\fP 5.3.4alpha: o limită implicită de utilizare a memoriei
jpayne@68: specifică sistemului, care este utilizată pentru a limita numărul de fire de
jpayne@68: execuție atunci când se comprimă cu un număr automat de fire de execuție
jpayne@68: (\fB\-\-threads=0\fP) și nicio limită de utilizare a memoriei nu fost specificată
jpayne@68: cu (\fB\-\-memlimit\-compress\fP). Aceasta este, de asemenea, utilizată ca valoare
jpayne@68: implicită pentru \fB\-\-memlimit\-mt\-decompress\fP.
jpayne@68: .IP 6. 4
jpayne@68: Începând cu \fBxz\fP 5.3.4alpha: numărul de fire de execuție de procesor
jpayne@68: disponibile.
jpayne@68: .PP
jpayne@68: În viitor, rezultatul \fBxz \-\-robot \-\-info\-memory\fP poate avea mai multe
jpayne@68: coloane, dar niciodată mai mult de o singură linie.
jpayne@68: .
jpayne@68: .SS Versiunea
jpayne@68: \fBxz \-\-robot \-\-version\fP va afișa numărul versiunii \fBxz\fP și liblzma în
jpayne@68: următorul format:
jpayne@68: .PP
jpayne@68: \fBXZ_VERSION=\fP\fIXYYYZZZS\fP
jpayne@68: .br
jpayne@68: \fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP
jpayne@68: .TP 
jpayne@68: \fIX\fP
jpayne@68: Versiunea majoră.
jpayne@68: .TP 
jpayne@68: \fIYYY\fP
jpayne@68: Versiunea minoră.  Numerele pare sunt prezente în versiunile
jpayne@68: stabile. Numerele impare sunt prezente în versiunile alfa sau beta.
jpayne@68: .TP 
jpayne@68: \fIZZZ\fP
jpayne@68: Nivelul de plasture(patch) pentru versiunile stabile sau doar un contor
jpayne@68: pentru versiunile de dezvoltare.
jpayne@68: .TP 
jpayne@68: \fIS\fP
jpayne@68: Stabilitate.  0 este alfa, 1 este beta și 2 este stabil. \fIS\fP trebuie să fie
jpayne@68: întotdeauna 2 atunci când \fIAAA\fP este par.
jpayne@68: .PP
jpayne@68: \fIXYYYZZZS\fP sunt aceleași pe ambele linii dacă \fBxz\fP și liblzma sunt din
jpayne@68: aceeași versiune XZ Utils.
jpayne@68: .PP
jpayne@68: Exemple: 4.999.9beta este \fB49990091\fP și 5.0.0 este \fB50000002\fP.
jpayne@68: .
jpayne@68: .SH "STARE DE IEȘIRE"
jpayne@68: .TP 
jpayne@68: \fB0\fP
jpayne@68: Totul este bine.
jpayne@68: .TP 
jpayne@68: \fB1\fP
jpayne@68: A apărut o eroare.
jpayne@68: .TP 
jpayne@68: \fB2\fP
jpayne@68: A apărut ceva care merită să fie avertizat, dar nu au apărut erori reale.
jpayne@68: .PP
jpayne@68: Notificările (nu avertismentele sau erorile) afișate la ieșirea de eroare
jpayne@68: standard nu afectează starea de ieșire.
jpayne@68: .
jpayne@68: .SH "VARIABILE DE MEDIU"
jpayne@68: \fBxz\fP analizează liste de opțiuni separate prin spații din variabilele de
jpayne@68: mediu \fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP, în această ordine, înainte de a analiza
jpayne@68: opțiunile din linia de comandă. Rețineți că numai opțiunile sunt analizate
jpayne@68: din variabilele de mediu; toate non\-opțiunile sunt ignorate în
jpayne@68: tăcere. Analiza se face cu funcția \fBgetopt_long\fP(3) care este folosită și
jpayne@68: pentru argumentele liniei de comandă.
jpayne@68: .TP 
jpayne@68: \fBXZ_DEFAULTS\fP
jpayne@68: Opțiuni implicite specifice utilizatorului sau la nivelul întregului
jpayne@68: sistem. De obicei, acest lucru este specificat într\-un script de
jpayne@68: inițializare shell pentru a activa limitatorul de utilizare a memoriei lui
jpayne@68: \fBxz\fP implicit. Excluzând scripturile de inițializare shell și cazurile
jpayne@68: speciale similare, scripturile nu trebuie niciodată să modifice sau să
jpayne@68: dezactiveze \fBXZ_DEFAULTS\fP.
jpayne@68: .TP 
jpayne@68: \fBXZ_OPT\fP
jpayne@68: Acest lucru este pentru transmiterea opțiunilor către \fBxz\fP atunci când nu
jpayne@68: este posibil să definiți opțiunile direct în linia de comandă a
jpayne@68: \fBxz\fP. Acesta este cazul când \fBxz\fP este rulat de un script sau de un
jpayne@68: instrument, de exemplu, GNU \fBtar\fP(1):
jpayne@68: .RS
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .RE
jpayne@68: .IP ""
jpayne@68: Scripturile pot folosi \fBXZ_OPT\fP, de exemplu, pentru a configura opțiunile
jpayne@68: implicite de comprimare specifice scriptului. Se recomandă totuși să se
jpayne@68: permită utilizatorilor să înlocuiască \fBXZ_OPT\fP dacă acest lucru este
jpayne@68: rezonabil. De exemplu, în scripturile \fBsh\fP(1) se poate folosi ceva de genul
jpayne@68: acesta:
jpayne@68: .RS
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRXZ_OPT=${XZ_OPT\-"\-7e"}
jpayne@68: export XZ_OPT\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .RE
jpayne@68: .
jpayne@68: .SH "COMPATIBILITATE CU LZMA\-UTILS"
jpayne@68: Sintaxa liniei de comandă a lui \fBxz\fP este practic o super\-colecție de
jpayne@68: \fBlzma\fP, \fBunlzma\fP și \fBlzcat\fP așa cum se găsește în LZMA Utils 4.32.x. În
jpayne@68: cele mai multe cazuri, este posibil să înlocuiți LZMA Utils cu XZ Utils fără
jpayne@68: a întrerupe scripturile existente. Există totuși unele incompatibilități,
jpayne@68: care uneori pot cauza probleme.
jpayne@68: .
jpayne@68: .SS "Niveluri de comprimare prestabilite"
jpayne@68: Numerotarea nivelurilor de comprimare prestabilite nu este identică în \fBxz\fP
jpayne@68: și LZMA Utils. Cea mai importantă diferență este modul în care dimensiunile
jpayne@68: dicționarului sunt atribuite diferitelor niveluri prestabilite. Dimensiunea
jpayne@68: dicționarului este aproximativ egală cu memoria utilizată la decomprimare.
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .TS
jpayne@68: tab(;);
jpayne@68: c c c
jpayne@68: c n n.
jpayne@68: Nivel;xz;LZMA Utils
jpayne@68: \-0;256 KiB;N/A
jpayne@68: \-1;1 MiB;64 KiB
jpayne@68: \-2;2 MiB;1 MiB
jpayne@68: \-3;4 MiB;512 KiB
jpayne@68: \-4;4 MiB;1 MiB
jpayne@68: \-5;8 MiB;2 MiB
jpayne@68: \-6;8 MiB;4 MiB
jpayne@68: \-7;16 MiB;8 MiB
jpayne@68: \-8;32 MiB;16 MiB
jpayne@68: \-9;64 MiB;32 MiB
jpayne@68: .TE
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Diferențele de dimensiune a dicționarului afectează deasemenea cantitatea de
jpayne@68: memorie utilizată la comprimare dar există și alte diferențe între LZMA
jpayne@68: Utils și XZ Utils, care fac diferența și mai mare:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .TS
jpayne@68: tab(;);
jpayne@68: c c c
jpayne@68: c n n.
jpayne@68: Nivel;xz;LZMA Utils 4.32.x
jpayne@68: \-0;3 MiB;N/A
jpayne@68: \-1;9 MiB;2 MiB
jpayne@68: \-2;17 MiB;12 MiB
jpayne@68: \-3;32 MiB;12 MiB
jpayne@68: \-4;48 MiB;16 MiB
jpayne@68: \-5;94 MiB;26 MiB
jpayne@68: \-6;94 MiB;45 MiB
jpayne@68: \-7;186 MiB;83 MiB
jpayne@68: \-8;370 MiB;159 MiB
jpayne@68: \-9;674 MiB;311 MiB
jpayne@68: .TE
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Nivelul prestabilit implicit în LZMA Utils este \fB\-7\fP, în timp ce în XZ
jpayne@68: Utils este \fB\-6\fP, deci ambele folosesc un dicționar de 8Mio în mod implicit.
jpayne@68: .
jpayne@68: .SS "Fișiere .lzma transmise în flux vs. netransmise în flux"
jpayne@68: Dimensiunea necomprimată a fișierului poate fi stocată în antetul
jpayne@68: \&\fB.lzma\fP. LZMA Utils face asta atunci când comprimă fișiere
jpayne@68: obișnuite. Alternativa este să marcați că dimensiunea necomprimată este
jpayne@68: necunoscută și să folosiți marcajul de sfârșit de încărcare pentru a indica
jpayne@68: unde ar trebui să se oprească decomprimarea. LZMA Utils folosește această
jpayne@68: metodă atunci când dimensiunea necomprimată nu este cunoscută, ceea ce este
jpayne@68: cazul, de exemplu, când se folosesc conducte.
jpayne@68: .PP
jpayne@68: \fBxz\fP acceptă decomprimarea fișierelor \fB.lzma\fP cu sau fără marcaj de
jpayne@68: sfârșit de încărcare, dar toate fișierele \fB.lzma\fP create de \fBxz\fP vor
jpayne@68: folosi marcajul de sfârșit de încărcare și vor avea dimensiunea necomprimată
jpayne@68: marcată ca necunoscută în antetul \fB.lzma\fP. Aceasta poate fi o problemă în
jpayne@68: unele situații mai puțin frecvente. De exemplu, un instrument de
jpayne@68: decomprimare \fB.lzma\fP încorporat într\-un dispozitiv poate funcționa numai cu
jpayne@68: fișiere care au dimensiunea necomprimată cunoscută. Dacă întâmpinați această
jpayne@68: problemă, trebuie să utilizați LZMA Utils sau LZMA SDK pentru a crea fișiere
jpayne@68: \&\fB.lzma\fP cu dimensiunea necomprimată cunoscută.
jpayne@68: .
jpayne@68: .SS "Fișiere .lzma neacceptate"
jpayne@68: Formatul \fB.lzma\fP permite valori \fIlc\fP de până la 8 și valori \fIlp\fP de până
jpayne@68: la 4. LZMA Utils poate decomprima fișiere cu orice \fIlc\fP și \fIlp\fP, dar
jpayne@68: creează întotdeauna fișiere cu \fBlc=3\fP și \fBlp=0\fP. Crearea de fișiere cu
jpayne@68: alte \fIlc\fP și \fIlp\fP este posibilă cu \fBxz\fP și cu LZMA SDK.
jpayne@68: .PP
jpayne@68: Implementarea filtrului LZMA1 în liblzma necesită ca suma \fIlc\fP și \fIlp\fP să
jpayne@68: nu depășească 4. Altfel, fișierele \fB.lzma\fP, care depășesc această limitare,
jpayne@68: nu pot fi decomprimate cu \fBxz\fP.
jpayne@68: .PP
jpayne@68: LZMA Utils creează numai fișiere \fB.lzma\fP care au o dimensiune de dicționar
jpayne@68: de 2^\fIn\fP (o putere de 2), dar acceptă fișiere cu orice dimensiune de
jpayne@68: dicționar. liblzma acceptă numai fișierele \fB.lzma\fP care au dimensiunea de
jpayne@68: dicționar de 2^\fIn\fP sau 2^\fIn\fP + 2^(\fIn\fP\-1). Acest lucru este pentru a
jpayne@68: reduce numărul de „fals pozitiv” atunci când se detectează fișiere \fB.lzma\fP.
jpayne@68: .PP
jpayne@68: Aceste limitări nu ar trebui să fie o problemă în practică, deoarece practic
jpayne@68: toate fișierele \fB.lzma\fP au fost comprimate cu opțiuni pe care liblzma le va
jpayne@68: accepta.
jpayne@68: .
jpayne@68: .SS "Resturi rămase"
jpayne@68: Când decomprimă, LZMA Utils ignoră în tăcere totul după primul flux
jpayne@68: \&\fB.lzma\fP. În majoritatea situațiilor, aceasta este o eroare. Aceasta
jpayne@68: înseamnă, de asemenea, că LZMA Utils nu acceptă decomprimarea fișierelor
jpayne@68: \&\fB.lzma\fP concatenate.
jpayne@68: .PP
jpayne@68: Dacă au rămas date după primul flux \fB.lzma\fP, \fBxz\fP consideră că fișierul
jpayne@68: este corupt, cu excepția cazului în care a fost utilizată opțiunea
jpayne@68: \fB\-\-single\-stream\fP. Acest lucru poate rupe scripturile obscure(scrise
jpayne@68: deficitar) care presupun că resturile rămase sunt ignorate.
jpayne@68: .
jpayne@68: .SH NOTE
jpayne@68: .
jpayne@68: .SS "Rezultatul comprimării poate varia"
jpayne@68: Ieșirea exactă comprimată produsă din același fișier de intrare necomprimat
jpayne@68: poate varia între versiunile XZ Utils, chiar dacă opțiunile de comprimare
jpayne@68: sunt identice. Acest lucru se datorează faptului că instrumentul codificator
jpayne@68: poate fi îmbunătățit (comprimare mai rapidă sau mai bună) fără a afecta
jpayne@68: formatul fișierului. Ieșirea poate varia chiar și între compilările diferite
jpayne@68: ale aceleiași versiuni XZ Utils, dacă sunt utilizate opțiuni diferite de
jpayne@68: compilare.
jpayne@68: .PP
jpayne@68: Cele de mai sus înseamnă că odată ce opțiunea \fB\-\-rsyncable\fP a fost
jpayne@68: utilizată, fișierele rezultate nu vor fi neapărat sincronizate cu rsync
jpayne@68: decât dacă atât fișierele vechi, cât și cele noi au fost comprimate cu
jpayne@68: aceeași versiune xz. Această problemă poate fi remediată dacă o parte a
jpayne@68: implementării codificatorului este înghețată pentru a menține stabilă
jpayne@68: ieșirea „rsyncabilă” între versiunile xz.
jpayne@68: .
jpayne@68: .SS "Instrumente de decomprimare .xz încorporate"
jpayne@68: Implementările instrumentului de decomprimare \fB.xz\fP încorporat, cum ar fi
jpayne@68: XZ Embedded, nu acceptă neapărat fișiere create cu tipuri de \fIverificare\fP a
jpayne@68: integrității, altele decât \fBnone\fP și \fBcrc32\fP. Deoarece valoarea implicită
jpayne@68: este \fB\-\-check=crc64\fP, trebuie să utilizați \fB\-\-check=none\fP sau
jpayne@68: \fB\-\-check=crc32\fP atunci când creați fișiere pentru sistemele încorporate.
jpayne@68: .PP
jpayne@68: În afara sistemelor încorporate, toate instrumentele de decomprimare în
jpayne@68: format \fB.xz\fP acceptă toate tipurile de \fIverificare\fP sau cel puțin pot
jpayne@68: decomprima fișierul fără a efectua verificarea integrității dacă acel tip de
jpayne@68: \fIverificare\fP nu este acceptat.
jpayne@68: .PP
jpayne@68: XZ Embedded acceptă filtre BCJ, dar numai cu poziție de pornire implicită.
jpayne@68: .
jpayne@68: .SH EXEMPLE
jpayne@68: .
jpayne@68: .SS Bazice
jpayne@68: Comprimă fișierul \fIfoo\fP în \fIfoo.xz\fP folosind nivelul de comprimare
jpayne@68: implicit (\fB\-6\fP) și elimină fișierul \fIfoo\fP dacă comprimarea are succes:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz foo\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Decomprimă \fIbar.xz\fP în \fIbar\fP și nu elimină \fIbar.xz\fP chiar dacă
jpayne@68: decomprimarea este efectuată cu succes:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-dk bar.xz\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Creează \fIbaz.tar.xz\fP cu nivelul prestabilit \fB\-4e\fP (\fB\-4 \-\-extreme\fP), care
jpayne@68: este mai lent decât nivelul prestabilit implicit \fB\-6\fP, dar necesită mai
jpayne@68: puțină memorie pentru comprimare și decomprimare (48Mio și, respectiv,
jpayne@68: 5Mio):
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Un amestec de fișiere comprimate și necomprimate poate fi decomprimat la
jpayne@68: ieșirea standard cu o singură comandă:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .
jpayne@68: .SS "Comprimarea în paralel a mai multor fișiere"
jpayne@68: În sisteme GNU și *BSD, \fBfind\fP(1) și \fBxargs\fP(1) pot fi utilizate pentru a
jpayne@68: paraleliza comprimarea mai multor fișiere:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e
jpayne@68:     | xargs \-0r \-P4 \-n16 xz \-T1\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Opțiunea \fB\-P\fP pentru comanda \fBxargs\fP(1) stabilește numărul de procese
jpayne@68: paralele \fBxz\fP.  Cea mai bună valoare pentru opțiunea \fB\-n\fP depinde de câte
jpayne@68: fișiere trebuie să fie comprimate. Dacă există doar câteva fișiere, valoarea
jpayne@68: ar trebui probabil să fie 1; cu zeci de mii de fișiere, 100 sau chiar mai
jpayne@68: mult poate să fie valoarea potrivită pentru a reduce numărul de procese
jpayne@68: \fBxz\fP pe care \fBxargs\fP(1) le va crea în final.
jpayne@68: .PP
jpayne@68: Opțiunea \fB\-T1\fP pentru \fBxz\fP este acolo pentru a\-l forța să ruleze în modul
jpayne@68: cu un singur fir de execuție, deoarece \fBxargs\fP(1) este folosit pentru a
jpayne@68: controla cantitatea de paralelizare.
jpayne@68: .
jpayne@68: .SS "Modul robot"
jpayne@68: Calculează câți octeți au fost salvați în total după comprimarea mai multor
jpayne@68: fișiere:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Un script poate dori să afle dacă folosește o versiune \fBxz\fP suficient de
jpayne@68: nouă.  Următorul script \fBsh\fP(1) verifică dacă numărul versiunii
jpayne@68: instrumentului \fBxz\fP este cel puțin 5.0.0. Această metodă este compatibilă
jpayne@68: cu versiunile beta vechi, care nu acceptau opțiunea \fB\-\-robot\fP:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" ||
jpayne@68:         [ "$XZ_VERSION" \-lt 50000002 ]; then
jpayne@68:     echo "Your xz is too old."
jpayne@68: fi
jpayne@68: unset XZ_VERSION LIBLZMA_VERSION\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Stabilește o limită de utilizare a memoriei pentru decomprimare folosind
jpayne@68: variabila de mediu \fBXZ_OPT\fP, dar dacă o limită a fost deja stabilită, nu o
jpayne@68: mărește:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB
jpayne@68: OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3)
jpayne@68: if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then
jpayne@68:     XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM"
jpayne@68:     export XZ_OPT
jpayne@68: fi\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .
jpayne@68: .SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare"
jpayne@68: Cea mai simplă utilizare a lanțurilor de filtrare personalizate este
jpayne@68: personalizarea unei opțiuni prestabilite LZMA2. Acest lucru poate fi util,
jpayne@68: deoarece opțiunile prestabilite acoperă doar un subset al combinațiilor
jpayne@68: potențial utile de opțiuni de comprimare.
jpayne@68: .PP
jpayne@68: Coloanele CPUComp din tabelele de descriere a opțiunilor \fB\-0\fP ... \fB\-9\fP și
jpayne@68: \fB\-\-extreme\fP sunt utile atunci când personalizați opțiunilor prestabilite
jpayne@68: LZMA2. Iată părțile relevante colectate din aceste două tabele:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .TS
jpayne@68: tab(;);
jpayne@68: c c
jpayne@68: n n.
jpayne@68: ValPrestab;CPUComp
jpayne@68: \-0;0
jpayne@68: \-1;1
jpayne@68: \-2;2
jpayne@68: \-3;3
jpayne@68: \-4;4
jpayne@68: \-5;5
jpayne@68: \-6;6
jpayne@68: \-5e;7
jpayne@68: \-6e;8
jpayne@68: .TE
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Dacă știți că un fișier necesită un dicționar oarecum mare (de exemplu,
jpayne@68: 32Mio) pentru a se comprima bine, dar doriți să\-l comprimați mai repede
jpayne@68: decât ar face \fBxz \-8\fP, o opțiune prestabilită cu o valoare CPUComp scăzută
jpayne@68: (de exemplu, 1) poate fi modificată pentru a utiliza un dicționar mai mare:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Cu anumite fișiere, comanda de mai sus poate fi mai rapidă decât \fBxz \-6\fP în
jpayne@68: timp ce comprimă semnificativ mai bine. Cu toate acestea, trebuie subliniat
jpayne@68: că doar unele fișiere se beneficiază de un dicționar mare, păstrând în
jpayne@68: același timp valoarea CPUComp scăzută. Cea mai evidentă situație, în care un
jpayne@68: dicționar mare poate ajuta foarte mult, este o arhivă care conține fișiere
jpayne@68: foarte asemănătoare de cel puțin câțiva megaocteți fiecare. Dimensiunea
jpayne@68: dicționarului trebuie să fie semnificativ mai mare decât orice fișier
jpayne@68: individual pentru a permite LZMA2 să profite din plin de asemănările dintre
jpayne@68: fișierele consecutive.
jpayne@68: .PP
jpayne@68: Dacă utilizarea unei mari cantități de memorie pentru comprimare și
jpayne@68: decomprimare este în regulă, iar fișierul comprimat are cel puțin câteva
jpayne@68: sute de megaocteți, poate fi util să folosiți un dicționar și mai mare decât
jpayne@68: cei 64Mio pe care i\-ar folosi \fBxz \-9\fP:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Utilizarea opțiunii \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) ca în exemplul de mai
jpayne@68: sus, poate fi utilă pentru a vedea cerințele de memorie la comprimare și
jpayne@68: decomprimare. Amintiți\-vă că utilizarea unui dicționar mai mare decât
jpayne@68: dimensiunea fișierului necomprimat este risipă de memorie, de aceea, comanda
jpayne@68: de mai sus nu este utilă pentru fișiere mici.
jpayne@68: .PP
jpayne@68: Uneori, timpul de comprimare nu contează, dar utilizarea memoriei la
jpayne@68: decomprimare trebuie menținută la un nivel scăzut, de exemplu, pentru a face
jpayne@68: posibilă decomprimarea fișierului pe un sistem încorporat. Următoarea
jpayne@68: comandă folosește \fB\-6e\fP (\fB\-6 \-\-extreme\fP) ca bază și fixează dimensiunea
jpayne@68: dicționarului la doar 64Kio. Fișierul rezultat poate fi decomprimat cu XZ
jpayne@68: Embedded (de aceea există \fB\-\-check=crc32\fP) folosind aproximativ 100Kio de
jpayne@68: memorie.
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Dacă doriți să stoarceți cât mai mulți octeți posibil, ajustarea numărului
jpayne@68: de biți de context literal (\fIlc\fP) și a numărului de biți de poziție (\fIpb\fP)
jpayne@68: poate ajuta uneori. Ajustarea numărului de biți de poziție literală (\fIlp\fP)
jpayne@68: ar putea ajuta, de asemenea, dar de obicei \fIlc\fP și \fIpb\fP sunt mai
jpayne@68: importante. De exemplu, o arhivă de cod sursă conține în mare parte text
jpayne@68: US\-ASCII, așa că ceva precum comanda următoare, ar putea oferi un fișier
jpayne@68: „mai slăbuț” (aproximativ cu 0,1%) mai mic decât cu \fBxz \-6e\fP (încercați și
jpayne@68: fără \fBlc=4\fP):
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Utilizarea unui alt filtru împreună cu LZMA2 poate îmbunătăți comprimarea cu
jpayne@68: anumite tipuri de fișiere. De exemplu, pentru a comprima o bibliotecă
jpayne@68: partajată x86 pe 32 de biți sau x86 pe 64 de biți folosind filtrul BCJ x86:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Rețineți că ordinea opțiunilor de filtrare este semnificativă. Dacă \fB\-\-x86\fP
jpayne@68: este specificată după \fB\-\-lzma2\fP, \fBxz\fP va da o eroare, deoarece nu poate
jpayne@68: exista niciun filtru după LZMA2 și, de asemenea, pentru că filtrul x86 BCJ
jpayne@68: nu poate fi utilizat ca ultimul filtru din lanțul de filtrare.
jpayne@68: .PP
jpayne@68: Filtrul Delta împreună cu LZMA2 pot da rezultate bune cu imagini bitmap. De
jpayne@68: obicei, ar trebui să întreacă comprimarea PNG, care are câteva filtre mai
jpayne@68: avansate decât delta simplă, dar utilizează Deflate pentru comprimarea
jpayne@68: reală.
jpayne@68: .PP
jpayne@68: Imaginea trebuie să fie salvată în format necomprimat, de exemplu, ca TIFF
jpayne@68: necomprimat. Parametrul de distanță al filtrului Delta este fixat să se
jpayne@68: potrivească cu numărul de octeți per pixel din imagine. De exemplu,
jpayne@68: bitmap\-ul RGB pe 24 de biți necesită \fBdist=3\fP și este, de asemenea, bine să
jpayne@68: pasați \fBpb=0\fP la LZMA2 pentru a se adapta alinierii pe trei octeți:
jpayne@68: .RS
jpayne@68: .PP
jpayne@68: .nf
jpayne@68: \f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR
jpayne@68: .fi
jpayne@68: .RE
jpayne@68: .PP
jpayne@68: Dacă mai multe imagini au fost introduse într\-o singură arhivă (de exemplu,
jpayne@68: \&\fB.tar\fP), filtrul Delta va funcționa și pe aceasta atâta timp cât toate
jpayne@68: imaginile au același număr de octeți per pixel.
jpayne@68: .
jpayne@68: .SH "CONSULTAȚI ȘI"
jpayne@68: \fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1),
jpayne@68: \fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1)
jpayne@68: .PP
jpayne@68: XZ Utils: <https://tukaani.org/xz/>
jpayne@68: .br
jpayne@68: XZ Embedded: <https://tukaani.org/xz/embedded.html>
jpayne@68: .br
jpayne@68: LZMA SDK: <https://7\-zip.org/sdk.html>