bzip2(1)                        General Commands Manual                        bzip2(1)

NÉV
       bzip2, bunzip2 - 'block-sorting' eljárással dolgozó tömörítőprogram, v0.9.0
       bzcat - stdout-ra csomagolja ki az állományt
       bzip2recover - sérült bzip2 adatait próbálja megmenteni

ÁTTEKINTÉS
       bzip2 [ -cdfkstvzVL123456789 ] [ fájlnevek ...  ]
       bunzip2 [ -fkvsVL ] [ fájlnevek ...  ]
       bzcat [ -s ] [ fájlnevek ...  ]
       bzip2recover fájlnév

LEÍRÁS
       A  bzip2  Burrows-Wheeler-féle  blokkrendező algoritmussal és Huffman-kódolással
       tömörít szöveges állományokat.  A tömörítés mértéke általában  lényegesen  jobb,
       mint  ami  a  legtöbb  hagyományos  LZ77/LZ78  alapú  tömörítővel  elérhető,  és
       megközelíti a statisztikus módszerrel dolgozó PPM család teljesítményét.

       A parancssori opciók szándékosan igen hasonlóak a GNU  Gzip  opcióihoz,  de  nem
       azonosak azokkal.

       A   bzip2   állománynevek   listáját   várja   a  hozzájuk  tartozó  parancssori
       kapcsolókkal. Minden fájlt azok "eredeti_név.bz2"  nevű  tömörített  változatára
       cserél  ki.   A  tömörített  fájlokhoz  tartozó  dátumok  és jogok az eredetivel
       megegyeznek,  így  ezek  a  tulajdonságok  kicsomagoláskor  helyesen  állíthatók
       vissza.  A fájlnevek kezelése egyszerű abban az értelemben, hogy nincs lehetőség
       az eredeti fájlnevek, jogok és dátumok megőrzésére az ezeket nem támogató,  vagy
       a    MS-DOS-hoz   hasonlóan   szigorúan   kötött   hosszúságú   neveket   kezelő
       fájlrendszerekben.

       A bzip2 és a bunzip2 alapértelmezés szerint nem írnak felül már létező fájlokat;
       erre a -f kapcsoló használatával lehet rávenni őket.

       Fájlnevek  hiányában  a  bzip2  a  szabványos  bemenetről a szabványos kimenetre
       dolgozik.  Ebben az esetben azonban a bzip2 nem fogja a  tömörített  adatokat  a
       terminálra írni, mert az feldolgozhatatlan, így értelmetlen volna.

       A  bunzip2  (vagy  a bzip2 -d ) kicsomagolja és visszaállítja a felsorolt fájlok
       közül a ".bz2"-re végződő nevűket.  A nem erre végződő nevű fájlokat  nem  veszi
       figyelembe.   Ismételten:  ha  nem  adunk  meg  fájlnevet,  a tömörítés standard
       inputról szabványos kimenetre történik.

       A bunzip2 helyesen fogja kicsomagolni azokat a fájlokat, melyek  két  vagy  több
       tömörített  fájl  összevonásával  (összemásolásával)  keletkeznek. Az eredmény a
       kicsomagolt  fájlok  egybemásolt  láncolata  lesz.  A  fájlok   sértetlenségének
       ellenőrzése (-t) az összeláncolt archívumokon is működik.

       A  szabványos kimenetre is lehet be- illetve kicsomagolni fájlokat a -c kapcsoló
       megadásával. Egyszerre több fájllal is lehet így dolgozni. A keletkező kimenetek
       sorban  a  szabványos kimenetre kerülnek. Több fájl ily módon történő tömörítése
       egy  olyan  adatfolyamot  eredményez,  melyben   az   egyes   fájlok   tömörítve
       szerepelnek.  Egy  ilyen  állomány  helyesen  csak  a  bzip2  0.9.0-s vagy újabb
       verziójával csomagolható ki. A bzip2 régebbi verziói az első fájl kibontása után
       megállnak.

       A  bzcat  (vagy  a  bzip2  -dc  )  a  megadott  fájlokat  a szabványos kimenetre
       csomagolja ki.

       A tömörítés mindig megtörténik, még akkor  is,  ha  a  tömörített  fájl  esetleg
       valamivel  nagyobb,  mint az eredeti. A kb. 100 bájtnál kisebb fájlok hajlamosak
       erre, mivel a tömörítő mechanizmus maga is hozzáad úgy 50 bájtot az archívumhoz.

       Az olyan adathalmazra, melyben az egyes elemek előfordulása véletlenszerű (ilyen
       a  legtöbb  tömörítőprogram  kimenete),  a  kódolás  kb.  8.05 bit/bájt aránnyal
       történik, ami megközelítőleg 0.5%-os méretnövekedést eredményez.

       Önellenőrzésként az  adatok  védelmére  a  bzip2  32  bites  CRC-ket  (ellenőrző
       összegeket)  használ, így biztosítva, hogy a kitömörített állomány az eredetivel
       megegyezzen.  Ez egyrészt a tömörített adatok sérülése ellen, másrészt  pedig  a
       bzip2  eddig  fel  nem derített (és remélhetőleg igen valószínűtlen) hibái ellen
       véd.  Annak az esélye, hogy a tömörített  adatban  előforduló  hiba  észrevétlen
       marad,  igen  kicsi,  megközelítőleg egy a négybillióhoz minden egyes tömörített
       fájl esetében. Lényeges azonban, hogy az ellenőrzés kicsomagoláskor történik, és
       csak  arra  hívja  fel a figyelmet, hogy valami nincs rendben, az eredeti adatot
       visszaállítani nem tudja.  A  bzip2recover  -rel  lehet  megpróbálni  az  adatok
       visszaállítását a sérült fájlból.

       Visszatérési  értékek:  0  ha  a  program  futása  rendesen  befejeződött  1  ha
       környezeti problémába futott (nem találja a fájlt, rossz kapcsolót  kapott,  I/O
       hiba esetén, stb.)  2 ha a tömörített fájl hibás 3 ha belső hiba (pl. bug) miatt
       a bzip2 azonnal felfüggesztette futását.

MEMÓRIAKEZELÉS
       A Bzip2 a nagy fájlokat blokkokban kezeli. A  blokkméret  meghatározza  mind  az
       elérhető  tömörítési  arányt,  mind  pedig  a  be-  és kicsomagoláshoz szükséges
       memória mennyiségét. A -1 ... -9 kapcsolók az egyes blokkméreteket  100,000  ...
       900,000  bájt  értékekre  állítják.  Kibontáskor a program az arhívum fejlécéből
       olvassa ki a tömörítéskor használt blokkméretet, és a bunzip2 ennek  megfelelően
       éppen annyi memóriát foglal le magának, amennyi a kibontáshoz szükséges. Mivel a
       blokkméret a tömörített fájlban van, a -1 ... -9 kapcsolóknak nincs jelentőségük
       és azokat a program kibontáskor figyelmen kívül hagyja.

       A be- és kicsomagolás memóriaigénye bájtban megközelítőleg a

             Tömörítés:     400k + ( 7 x blokkméret)

             Kibontás:      100k + ( 4 x blokkméret), vagy
                            100k + ( 2.5 x blokkméret) képletekkel becsülhető meg,

       Nagyobb blokkméret gyorsan csökkenő mellékes nyereséget ad; a tömörítés jelentős
       részét a blokkméret első 2-300k-ja adja.  Ezt érdemes fejben tartani a bzip2 kis
       gépeken  történő használatakor.  Arról sem szabad megfeledkezni, hogy a kibontás
       memóriaigényét a tömörítéskor választott blokkméret határozza meg.

       Az alapértelmezett 900k méretű blokkokkal tömörített fájlok esetében a bunzip2 a
       kibontáshoz  kb.  3700k  memóriát  fog  használni.   Hogy minden fájl kibontható
       legyen még egy 4 megabájtos gépen is, a bunzip2 lehetővé teszi a  kibontást  kb.
       feleennyi,  megközelítőleg  2300k  memória felhasználásával is. Ezzel a kibontás
       sebessége is feleződik, így csak akkor  érdemes  használni  ezt  a  lehetőséget,
       amikor valóban szükséges.  Az idevonatkozó kapcsoló a -s.

       Általában,   ha   a   rendelkezésre  álló  memória  mennyisége  engedi,  érdemes
       megpróbálkozni a legnagyobb blokkméret használatával,  mivel  így  érhető  el  a
       legjobb  tömörítési  arány.  A  tömörítés  és  kibontás  sebességét a blokkméret
       gyakorlatilag nem befolyásolja.

       Másik lényeges pont azoknak  a  fájloknak  az  esete,  melyek  egyetlen  blokkba
       beleférnek  -  nagy  blokkméret  használatakor  ez  a legtöbb fájlra fennáll.  A
       ténylegesen felhasznált memória mennyisége a fájl  méretével  arányos,  mivel  a
       fájl  kisebb, mint egy blokk. Egy 20,000 bájt hosszú fájl -9 kapcsolóval történő
       tömörítésekor például kb. 6700k memóriát foglal le a  tömörítőprogram,  de  csak
       400k  +  20000 * 7 = 540k-t használ belőle.  Kibontáskor ehhez hasonlóan 3700k-t
       foglal le, de csak 100k + 20000 * 4 = 180k-t használ.

       A   következő   táblázat   a   különböző   blokkméretekhez   tartozó   maximális
       memóriafelhasználást,  valamint  a Calgary Szövegtömörítés Dokumentáció összesen
       3,141,622 bájtos 14 fájljának tömörített méretét tartalmazza.  Ez az oszlop némi
       áttekintést   ad  arról,  hogyan  változik  a  tömörítés  mértéke  a  blokkméret
       függvényében. Ezek a számok nem  igazán  mutatják  a  nagy  blokkméret  előnyeit
       nagyobb fájlokra, mivel a Dokumentációban a kisméretű fájlok túlsúlyban vannak.

                    Tömörítés    Kibontás    Kibontás    Dokumentáció
           Kapcsoló mem.haszn.  mem.haszn.   -s -sel        mérete

            -1         1100k       500k        350k         914704
            -2         1800k       900k        600k         877703
            -3         2500k      1300k        850k         860338
            -4         3200k      1700k       1100k         846899
            -5         3900k      2100k       1350k         845160
            -6         4600k      2500k       1600k         838626
            -7         5400k      2900k       1850k         834096
            -8         6000k      3300k       2100k         828642
            -9         6700k      3700k       2350k         828642

OPCIÓK
       -c --stdout
              Tömörítés  vagy  kibontás  a  szabványos  kimenetre.  A -c -vel több fájl
              bontható ki egyszerre, de csak egyetlen fájl tömöríthető a stdout-ra.

       -d --decompress
              Kibontás. A bzip2, bunzip2 és a bzcat tulajdonképpen ugyanaz  a  program,
              ami  annak  alapján  dönti  el,  hogy  mit kell tennie, hogy melyik nevét
              használjuk. Ez  a  kapcsoló  felülbírálja  ezt  a  döntést,  és  a  bzip2
              kibontóként fog működni.

       -z --compress
              A  -d  ellentéte:  a  tömörítést  erőlteti,  függetlenül  attól,  hogy  a
              programot melyik nevével indítottuk.

       -t --test
              A megadott fájlok  sértetlenségét  ellenőrzi,  de  nem  bontja  ki  őket.
              Valójában egy "próbakibontást" végez, és az eredményt eldobja.

       -f --force
              Felülírja  a  kimeneti  állományokat. Rendes esetben a bzip2 nem ír felül
              már létező kimeneti fájlokat.

       -k --keep
              Megtartja (nem törli le) a bemenő állományokat be- és kitömörítéskor.

       -s --small
              Csökkenti   a   memóriahasználatot,   tömörítéskor,    kibontáskor,    és
              teszteléskor.    A   fájlok   kibontása   és  tesztelése  egy  módosított
              algoritmussal  történik,  amelynek  csupán  2.5   bájtra   van   szüksége
              bájtonként  a  blokkban.   Ez azt jelenti, hogy bármelyik fájl kibontható
              2300k memóriában, igaz, a normál sebességnek csaknem felével.

              Tömörítéskor a -s 200k blokkméretet állít be,  ami  a  memóriahasználatot
              megközelítőleg   ugyanezekre   az   értékekre   korlátozza,  a  tömörítés
              mértékének rovására. Röviden: kevés memóriával (8 megabájt vagy kevesebb)
              rendelkező  gép  esetében  mindig  használjuk  a -s kapcsolót.  (ld. még:
              MEMÓRIAKEZELÉS)

       -v --verbose
              Bőbeszédű mód -- megmutatja a tömörítés mértékét minden feldolgozott fájl
              esetében.  További -v-k a "bőbeszédűség" mértékét növelik, rengeteg olyan
              információt adva, melyek főként diagnosztikai célból lehetnek érdekesek.

       -L --license -V --version
              A  program  verziószámát,  felhasználói  engedélyeket   és   feltételeket
              jeleníti meg.

       -1 to -9
              Tömörítéskor  a blokkméretet állítja 100k, 200k ... 900k-ra.  Kibontáskor
              semmilyen hatása nincs.  Lásd még: MEMÓRIAKEZELÉS

       --repetitive-fast
              bzip2 Némi ál-véletlenszerű variációt visz az  erősen  ismétlődő  jellegű
              blokkokba,  hogy  tömörítéskor  csökkentse  a  "legrosszabb  eset" esetén
              előálló teljesítményromlás valószínűségét.  Ha  a  rendezés  nehézségekbe
              ütközik,  a  program  a  blokkot összekeveri, és a rendezést újraindítja.
              Durván, a bzip2 háromszor annyi ideig tart ki az  újrarendezés  előtt  az
              összekeverésig,  mint  ameddig  egy  "jó"  bemenet  feldolgozása tartana.
              Ezzel a kapcsolóval sokkal hamarabb feladja.

       --repetitive-best
              A  --repetitive-fast  ellentéte;  sokkal   keményebben   próbálkozik   az
              összekeverésig a rendezés előtt.

ADATMENTÉS SÉRÜLT FÁJLOKBÓL
       A  bzip2  a  fájlokat  rendszerint  900  kilobájtos blokkokban tömöríti.  Minden
       blokkot külön kezel. Ha az adathordozó vagy az átvitel  hibája  miatt  egy  több
       blokkból  álló .bz2 fájl megsérül, elképzelhető az adatok megmentése az állomány
       sértetlen blokkjaiból.

       Minden blokk tömörített megfelelőjét egy-egy 48 bites minta határolja, ami  elég
       jó  biztonsággal  teszi  lehetővé  a  blokkhatárok megállapítását.  Minden blokk
       tartalmazza a saját 32 bites CRC-jét,  így  a  sérült  és  a  sértetlen  blokkok
       egymástól megkülönböztethetők.

       A bzip2recover egy egyszerű program, aminek célja az egyes blokkok megtalálása a
       .bz2 archívumban, és különálló .bz2 fájlokként való kiírása. Ezek között a bzip2
       -t segítségével megkereshetők és kibonthatók a sértetlen blokkok.

       A  bzip2recover  egyetlen,  egyszerű  argumentumot  fogad  el, ez pedig a sérült
       állomány  neve,  és  a  különálló  blokkokat  tartalmazó  fájlokat   hoz   létre
       "rec0001file.bz2",  "rec0002file.bz2",  stb.  néven.  A  keletkező  fájlok nevei
       olyanok,  hogy  az  egymást   követő   feldolgozásoknál   a   joker   karakterek
       használatakor,  például  a  "bzip2  -dc  rec*file.bz2  > javított_adat" esetén a
       fájlok a helyes sorrendben jelennek meg.

       A bzip2recover nagy .bz2 fájlok esetén lehet hasznos, mivel  ezek  több  blokkot
       tartalmaznak.  Teljesen  hiábavaló a használata az egy blokkot tartalmazó sérült
       fájloknál, mivel sérült blokk nem  állítható  helyre.  Az  adathordozó  vagy  az
       átvitel   hibáiból   adódó   adatvesztés   lehetőségének  a  lehető  legkisebbre
       csökkentéséhez megfontolandó esetleg a kisebb blokkméret használata.

A TELJESÍTMÉNYRŐL
       A tömörítés rendezés fázisában a fájl hasonló részeinek összegyűjtése  történik.
       Emiatt az ismétlődő szimbólumok igen hosszú láncolatát (mint pl. a több százszor
       ismétlődő "aabaabaabaab ...") tartalmazó  fájl  tömörítése  szélsőségesen  lassú
       lehet.   Ilyenkor  a  -vvvvv  opcióval  esetleg  részletesen  nyomon követhető a
       folyamat.  A kibontás sebességét ez nem befolyásolja.

       Az ilyen beteges esetek  a  gyakorlatban  ritkának  tűnnek,  főleg  tesztcélokra
       mesterségesen  összeállított fájlokban, és alacsony szintű disk image-ekben (egy
       hajlékony- vagy merevlemez tartalma fájlba  írva)  fordulnak  elő.  Ez  utóbbiak
       bzip2 -vel történő tömörítése nem javasolt.

       Ha egy fájl tömörítésekor jelentős lassulás tapasztalható, érdemes megpróbálni a
       legkisebb blokkméret beállítását a -1 kapcsolóval.

       A bzip2 rendszerint pár megabájt memóriát foglal le magának,  amiben  dolgozhat,
       aztán  az egészet eléggé össze-vissza módon töltögeti fel.  Ez azt jelenti, hogy
       mind a tömörítés, mind pedig  a  kibontás  esetén  a  teljesítményt  nagyban  az
       határozza  meg, hogy a rendszer milyen gyorsan tudja kiszolgálni a cache-ben nem
       található  adatokra  irányuló  kéréseket.  Emiatt  a  programkód  ilyen   esetek
       arányának    csökkentését    célzó    kis   változtatására   aránytalanul   nagy
       teljesítménynövekedés figyelhető meg.  A bzip2
        így  valószínűleg  a  nagyon  nagy  cache-sel  rendelkező  gépeken  teljesít  a
       legjobban.

FIGYELMEZTETÉS
       Az I/O hibajelzések nem olyan hasznosak, amilyenek lehetnének.  A bzip2 keményen
       próbálkozik, hogy az I/O hibákat észrevegye, és tisztán lépjen ki,  de  annak  a
       részletei,  hogy  tulajdonképpen  mi  is volt a probléma, gyakran félrevezetőnek
       tűnnek.

       Ez a kézikönyvoldal a bzip2 0.9.0-ás verzióra  vonatkozik.   Az  ezen  verzióval
       készített  tömörített  adat  teljes  mértékben  kompatíbilis  az  ezt  megelőző,
       szabadon terjeszthető 0.1pl2 verzióval készítettel, egyetlen  kivétellel:  0.9.0
       helyesen bontja ki a több archívumot tartalmazó összevont fájlokat. A 0.1pl2 ezt
       nem tudja megtenni: az első fájl kibontása után megáll.

       Windows 95 és NT alatt a joker karakterek használata nem tökéletes.

       A bzip2recover 32 bites egészeket használ a tömörített fájlokban  a  bitpozíciók
       ábrázolására,  így nem képes kezelni az 512 megabájtnál nagyobb archívumokat. Ez
       a probléma egyszerűen javítható.

SZERZŐ
       Julian Seward, jseward@acm.org.

       http://www.muraroa.demon.co.uk

       A bzip2 -ben  megtestesült  ötletek  a  következőknek  tulajdoníthatók:  Michael
       Burrows  és  David  Wheeler (blokkrendező transzformáció) David Wheeler (Huffman
       kódoló) Peter Fenwick (strukturált programozási modell az eredeti bzip  -ben  és
       több finomítás) és Alistair Moffat, Radford Neal valamint Ian Witten (az eredeti
       bzip aritmetikai kódolója).  Köszönet illeti őket segítségükért,  támogatásukért
       és tanácsaikért.

       A  program  forráskódjához mellékelt dokumentációban találhatók még hivatkozások
       további dokumentációforrásokra.  Christian von Roques ösztökélt gyorsabb rendező
       algoritmus  keresésére,  és  a  tömörítés gyorsítására.  Bela Lubkin biztatott a
       tömörítő "legrosszabb eset"-i teljesítményének növelésére.  Több  ember  küldött
       hibajavításokat,  segített  hordozhatósági problémák megoldásában, adott kölcsön
       gépeket, adott tanácsot és volt általában segítségemre.

                                                                               bzip2(1)

bzip2, a block-sorting file compressor.  Version 1.0.6, 6-Sept-2010.

   usage: bzip2 [flags and input files in any order]

   -h --help           print this message
   -d --decompress     force decompression
   -z --compress       force compression
   -k --keep           keep (don't delete) input files
   -f --force          overwrite existing output files
   -t --test           test compressed file integrity
   -c --stdout         output to standard out
   -q --quiet          suppress noncritical error messages
   -v --verbose        be verbose (a 2nd -v gives more)
   -L --license        display software version & license
   -V --version        display software version & license
   -s --small          use less memory (at most 2500k)
   -1 .. -9            set block size to 100k .. 900k
   --fast              alias for -1
   --best              alias for -9

   If invoked as `bzip2', default action is to compress.
              as `bunzip2',  default action is to decompress.
              as `bzcat', default action is to decompress to stdout.

   If no file names are given, bzip2 compresses or decompresses
   from standard input to standard output.  You can combine
   short flags, so `-v -4' means the same as -v4 or -4v, &c.