<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>

<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15"/>
<title>Ogg Vorbis Documentation</title>

<style type="text/css">
body {
  margin: 0 18px 0 18px;
  padding-bottom: 30px;
  font-family: Verdana, Arial, Helvetica, sans-serif;
  color: #333333;
  font-size: .8em;
}

a {
  color: #3366cc;
}

img {
  border: 0;
}

#xiphlogo {
  margin: 30px 0 16px 0;
}

#content p {
  line-height: 1.4;
}

h1, h1 a, h2, h2 a, h3, h3 a {
  font-weight: bold;
  color: #ff9900;
  margin: 1.3em 0 8px 0;
}

h1 {
  font-size: 1.3em;
}

h2 {
  font-size: 1.2em;
}

h3 {
  font-size: 1.1em;
}

li {
  line-height: 1.4;
}

#copyright {
  margin-top: 30px;
  line-height: 1.5em;
  text-align: center;
  font-size: .8em;
  color: #888888;
  clear: both;
}
</style>

</head>

<body>

<div id="xiphlogo">
  <a href="http://www.xiph.org/"><img src="fish_xiph_org.png" alt="Fish Logo and Xiph.org"/></a>
</div>

<h1>Ogg Vorbis: Fidelity measurement and terminology discussion</h1>

<p>Terminology discussed in this document is based on common terminology
associated with contemporary codecs such as MPEG I audio layer 3
(mp3). However, some differences in terminology are useful in the
context of Vorbis as Vorbis functions somewhat differently than most
current formats. For clarity, then, we describe a common terminology
for discussion of Vorbis's and other formats' audio quality.</p>

<h2>Subjective and Objective</h2>

<p><em>Objective</em> fidelity is a measure, based on a computable,
mechanical metric, of how carefully an output matches an input. For
example, a stereo amplifier may claim to introduce less that .01%
total harmonic distortion when amplifying an input signal; this claim
is easy to verify given proper equipment, and any number of testers are
likely to arrive at the same, exact results. One need not listen to
the equipment to make this measurement.</p>

<p>However, given two amplifiers with identical, verifiable objective
specifications, listeners may strongly prefer the sound quality of one
over the other. This is actually the case in the decades old debate
[some would say jihad] among audiophiles involving vacuum tube versus
solid state amplifiers. There are people who can tell the difference,
and strongly prefer one over the other despite seemingly identical,
measurable quality. This preference is <em>subjective</em> and
difficult to measure but nonetheless real.</p>

<p>Individual elements of subjective differences often can be qualified,
but overall subjective quality generally is not measurable. Different
observers are likely to disagree on the exact results of a subjective
test as each observer's perspective differs. When measuring
subjective qualities, the best one can hope for is average, empirical
results that show statistical significance across a group.</p>

<p>Perceptual codecs are most concerned with subjective, not objective,
quality. This is why evaluating a perceptual codec via distortion
measures and sonograms alone is useless; these objective measures may
provide insight into the quality or functioning of a codec, but cannot
answer the much squishier subjective question, "Does it sound
good?". The tube amplifier example is perhaps not the best as very few
people can hear, or care to hear, the minute differences between tubes
and transistors, whereas the subjective differences in perceptual
codecs tend to be quite large even when objective differences are
not.</p>

<h2>Fidelity, Artifacts and Differences</h2>

<p>Audio <em>artifacts</em> and loss of fidelity or more simply
put, audio <em>differences</em> are not the same thing.</p>

<p>A loss of fidelity implies differences between the perceived input and
output signal; it does not necessarily imply that the differences in
output are displeasing or that the output sounds poor (although this
is often the case). Tube amplifiers are <em>not</em> higher fidelity
than modern solid state and digital systems. They simply produce a
form of distortion and coloring that is either unnoticeable or actually
pleasing to many ears.</p>

<p>As compared to an original signal using hard metrics, all perceptual
codecs [ASPEC, ATRAC, MP3, WMA, AAC, TwinVQ, AC3 and Vorbis included]
lose objective fidelity in order to reduce bitrate. This is fact. The
idea is to lose fidelity in ways that cannot be perceived. However,
most current streaming applications demand bitrates lower than what
can be achieved by sacrificing only objective fidelity; this is also
fact, despite whatever various company press releases might claim.
Subjective fidelity eventually must suffer in one way or another.</p>

<p>The goal is to choose the best possible tradeoff such that the
fidelity loss is graceful and not obviously noticeable. Most listeners
of FM radio do not realize how much lower fidelity that medium is as
compared to compact discs or DAT. However, when compared directly to
source material, the difference is obvious. A cassette tape is lower
fidelity still, and yet the degradation, relatively speaking, is
graceful and generally easy not to notice. Compare this graceful loss
of quality to an average 44.1kHz stereo mp3 encoded at 80 or 96kbps.
The mp3 might actually be higher objective fidelity but subjectively
sounds much worse.</p>

<p>Thus, when a CODEC <em>must</em> sacrifice subjective quality in order
to satisfy a user's requirements, the result should be a
<em>difference</em> that is generally either difficult to notice
without comparison, or easy to ignore. An <em>artifact</em>, on the
other hand, is an element introduced into the output that is
immediately noticeable, obviously foreign, and undesired. The famous
'underwater' or 'twinkling' effect synonymous with low bitrate (or
poorly encoded) mp3 is an example of an <em>artifact</em>. This
working definition differs slightly from common usage, but the coined
distinction between differences and artifacts is useful for our
discussion.</p>

<p>The goal, when it is absolutely necessary to sacrifice subjective
fidelity, is obviously to strive for differences and not artifacts.
The vast majority of codecs today fail at this task miserably,
predictably, and regularly in one way or another. Avoiding such
failures when it is necessary to sacrifice subjective quality is a
fundamental design objective of Vorbis and that objective is reflected
in Vorbis's design and tuning.</p>

<div id="copyright">
  The Xiph Fish Logo is a
  trademark (&trade;) of Xiph.Org.<br/>

  These pages &copy; 1994 - 2005 Xiph.Org. All rights reserved.
</div>

</body>
</html>
