1. Fix mild ambiguity in 15.1 (see http://goo.gl/1Uxr1)
2. Strike 15.0 text no longer germane to the dixie
reference decoder.
Change-Id: I7d20ff4325d1bd0e8718e8d7133890aac07cde0b
modified: text_src/15.00__vp8-bitstream__loop-filter.txt
modified: text_src/15.01__vp8-bitstream__filter-geometry-and-overall-procedure.txt
diff --git a/text_src/15.00__vp8-bitstream__loop-filter.txt b/text_src/15.00__vp8-bitstream__loop-filter.txt
index a315915..5a720b4 100644
--- a/text_src/15.00__vp8-bitstream__loop-filter.txt
+++ b/text_src/15.00__vp8-bitstream__loop-filter.txt
@@ -13,13 +13,7 @@
Loop filtering is one of the more computationally-intensive aspects of VP8 decoding. This is the reason for the existence of the optional, less-demanding simple filter type.
-Note carefully that loop filtering must be skipped entirely if loop_filter_level at either the frame header level or macroblock override level is `0`. In no case should the loop filter be run with a value of `0`; it should instead be skipped.
-
-To facilitate efficient implementation, the VP8 decoding algorithms generally, and the loop filter especially, were designed with SIMD ("Single Instruction Multiple Datum" or "integer vector") processors in mind. The reference decoder implementation of loop filtering (found in `loopfilter.c`) is, in effect, a portable SIMD specification of the loop filtering algorithms intended to simplify a realization on an actual SIMD processor.
-
-Unfortunately, the approach taken there does not lead to maximal efficency (restricted to the C language, that is) and, as far as a pure algorithm specification is concerned, is in places obscure. For example, various aspects of filtering are conditioned on absolute differences lying below certain thresholds. An ordinary C implementation would simply discriminate amongst these behaviors using if statements. The reference decoder instead effects this by "masking arithmetic", that is, using "and" operations to (conditionally) zero-out values to be added or subtracted to pixels. Furthermore, the structure holding the various threshold values is artificially parallelized. While this mimics closely the approach taken in vector-processor machine language, it is not how one usually programs in C.
-
-In this document, we take a different approach and present the algorithms in a more straightforward, idiomatic, and terse C style. Together with the reference version, we hope to provide the "best of both worlds", that is, a pure algorithm specification here and a strong suggestion as to an optimal actual implementation in `loopfilter.c`.
+Note carefully that loop filtering must be skipped entirely if `loop_filter_level` at either the frame header level or macroblock override level is `0`. In no case should the loop filter be run with a value of `0`; it should instead be skipped.
We begin by discussing the aspects of loop filtering that are independent of the controlling parameters and type of filter chosen.
diff --git a/text_src/15.01__vp8-bitstream__filter-geometry-and-overall-procedure.txt b/text_src/15.01__vp8-bitstream__filter-geometry-and-overall-procedure.txt
index 5a19408..a8ec9ed 100644
--- a/text_src/15.01__vp8-bitstream__filter-geometry-and-overall-procedure.txt
+++ b/text_src/15.01__vp8-bitstream__filter-geometry-and-overall-procedure.txt
@@ -3,7 +3,7 @@
#### 15.1 Filter Geometry and Overall Procedure {#h-15-01}
-The Y, U, and V planes are processed independently and, except for the values of certain control parameters (derived from the `loop_filter_level` and `sharpness_level`), identically.
+The Y, U, and V planes are processed independently and identically.
The loop filter acts on the edges between adjacent macroblocks and on the edges between adjacent subblocks of a macroblock. All such edges are horizontal or vertical. For each pixel position on an edge, a small number (two or three) of pixels adjacent to either side of the position are examined and possibly modified. The displacements of these pixels are at a right angle to the edge orientation, that is, for a horizontal edge, we treat the pixels immediately above and below the edge position, for a vertical edge, we treat the pixels immediately to the left and right of the edge.
@@ -35,7 +35,7 @@
For these macroblocks, loop filtering for edges between subblocks internal to a macroblock is effectively skipped. This skip strategy significantly reduces VP8 loop-filtering complexity.
-Edges between macroblocks and those between subblocks are treated with different control parameters (and, in the case of the normal filter, with different algorithms); luma and chroma edges are also treated with different control parameters. Except for pixel addressing, there is no distinction between the treatment of vertical and horizontal edges. Luma edges are always 16 pixels long, chroma edges are always 8 pixels long, and the segments straddling an edge are treated identically; this of course facilitates vector processing.
+Edges between macroblocks and those between subblocks are treated with different control parameters (and, in the case of the normal filter, with different algorithms). Except for pixel addressing, there is no distinction between the treatment of vertical and horizontal edges. Luma edges are always 16 pixels long, chroma edges are always 8 pixels long, and the segments straddling an edge are treated identically; this of course facilitates vector processing.
Because many pixels belong to segments straddling two or more edges, and so will be filtered more than once, the order in which edges are processed given above must be respected by any implementation. Within a single edge, however, the segments straddling that edge are disjoint and the order in which these segments are processed is immaterial.
