Software: Apache/2.0.54 (Unix) mod_perl/1.99_09 Perl/v5.8.0 mod_ssl/2.0.54 OpenSSL/0.9.7l DAV/2 FrontPage/5.0.2.2635 PHP/4.4.0 mod_gzip/2.0.26.1a 

uname -a: Linux snow.he.net 4.4.276-v2-mono-1 #1 SMP Wed Jul 21 11:21:17 PDT 2021 i686 

uid=99(nobody) gid=98(nobody) groups=98(nobody) 

Safe-mode: OFF (not secure)

/usr/doc/libvorbis-1.0/   drwxr-xr-x
Free 318.35 GB of 458.09 GB (69.5%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    

Viewing file:     vorbis-spec-floor1.html (15.2 KB)      -rw-r--r--

Ogg Vorbis I format specification: floor type 1 setup and decode

Overview

Floor 1 format

model

• the first line segment (base case) is a logical line spanning from x_0,y_0 to x_1,y_1 where in the base case x_0=0 and x_1=[n], the full range of the spectral floor to be computed.

• the induction step chooses a point x_new within an existing logical line segment and produces a y_new value at that point computed from the existing line's y value at x_new (as plotted by the line) and a difference value decoded from the bitstream packet.

• floor computation produces two new line segments, one running from x_0,y_0 to x_new,y_new and from x_new,y_new to x_1,y_1. This step is performed logically even if y_new represents no change to the amplitude value at x_new so that later refinement is additionally bounded at x_new.

• the induction step repeats, using a list of x values specified in the codec setup header at floor 1 initialization time. Computation is completed at the end of the x value list.

For the below example, we assume a floor setup with an [n] of 128. The list of selected X values in increasing order is 0,16,32,48,64,80,96,112 and 128. In list order, the values interleave as 0, 128, 64, 32, 96, 16, 48, 80 and 112. The corresponding list-order Y values as decoded from an example packet are 110, 20, -5, -45, 0, -25, -10, 30 and -10. We compute the floor in the following way, beginning with the first line:

We now draw new logical lines to reflect the correction to new_Y, and iterate for X positions 32 and 96:

Although the new Y value at X position 96 is unchanged, it is still used later as an endpoint for further refinement. From here on, the pattern should be clear; we complete the floor computation as follows:

A more efficient algorithm with carefully defined integer rounding behavior is used for actual decode, as described later. The actual algorithm splits Y value computation and line plotting into two steps with modifications to the above algorithm to eliminate noise accumulation through integer roundoff/truncation.

header decode

A partition class consists of a representation vector width (the number of Y values which the partition class encodes at once), a 'subclass' value representing the number of alternate entropy books the partition class may use in representing Y values, the list of [subclass] books and a master book used to encode which alternate books were chosen for representation in a given packet. The master/subclass mechanism is meant to be used as a flexible representation cascade while still using codebooks only in a scalar context.

  1) [floor1_partitions] = read 5 bits as unsigned integer
  2) [maximum_class] = 0
  3) iterate [i] over the range 0 ... [floor1_partitions]-1 {
       
        4) vector [floor1_partition_class_list] element [i] = read 4 bits as unsigned integer

     }

  5) [maximum_class] = largest integer scalar value in vector [floor1_partition_class_list]
  6) iterate [i] over the range 0 ... [maximum_class] {

        7) vector [floor1_class_dimensions] element [i] = read 3 bits as unsigned integer and add 1
	8) vector [floor1_class_subclasses] element [i] = read 2 bits as unsigned integer
        9) if ( vector [floor1_class_subclasses] element [i] is nonzero ) {
            
             10) vector [floor1_class_masterbooks] element [i] = read 8 bits as unsigned integer
           
           }

       11) iterate [j] over the range 0 ... (2 exponent [floor1_class_subclasses] element [i]) - 1  {

             12) array [floor1_subclass_books] element [i],[j] = 
                 read 8 bits as unsigned integer and subtract one
           }
      }

 13) [floor1_multiplier] = read 2 bits as unsigned integer and add one
 14) [rangebits] = read 4 bits as unsigned integer
 15) vector [floor1_X_list] element [0] = 0
 16) vector [floor1_X_list] element [1] = 2 exponent [rangebits];
 17) [floor1_values] = 1
 18) iterate [i] over the range 0 ... [floor1_partitions]-1 {

       19) iterate [j] over the range 0 ... ([floor1_class_dimensions] element [i])-1 {
             20) vector [floor1_X_list] element ([j] + [floor1_values]) = 
                 read [rangebits] bits as unsigned integer
            }

       21) [floor1_values] = [floor1_values] + [floor1_class_dimensions] element [i]
     }
 
 19) done

packet decode

  1) [nonzero] = read 1 bit as boolean

  1) [range] = vector { 256, 128, 86, 64 } element ([floor1_multiplier]-1)
  2) vector [floor1_Y] element [0] = read ilog([range]-1) bits as unsigned integer
  3) vector [floor1_Y] element [1] = read ilog([range]-1) bits as unsigned integer
  4) [offset] = 2;
  5) iterate [i] over the range 0 ... [floor1_partitions]-1 {

       6) [class] = vector [floor1_partition_class]  element [i]
       7) [cdim]  = vector [floor1_class_dimensions] element [class]
       8) [cbits] = vector [floor1_class_subclasses] element [class]
       9) [csub]  = (2 exponent [cbits])-1
      10) [cval]  = 0
      11) if ( [cbits] is greater than zero ) {
 
             12) [cval] = read from packet using codebook number
                 (vector [floor1_class_masterbooks] element [class]) in scalar context
          }
      
      13) iterate [j] over the range 0 ... [cdim]-1 {
       
             14) [book] = array [floor1_subclass_books] element [class],([cval] bitwise AND [csub])
	     15) if ( [book] is not less than zero ) {
	     
	           16) vector [floor1_Y] element ([j]+[offset]) = read from packet using codebook 
                       [book] in scalar context

                 } else [book] is less than zero {

	           17) vector [floor1_Y] element ([j]+[offset]) = 0

                 }
          }
             
      18) [offset] = [offset] + [cdim]
         
     }
  
 19) done

curve computation

Although some aspects of the below algorithm look like inconsequential optimizations, implementors are warned to follow the details closely. Deviation from implementing a strictly equivalent algorithm can result in serious decoding errors.

step 1: amplitude value synthesis

  1) [range] = vector { 256, 128, 86, 64 } element ([floor1_multiplier]-1)
  2) iterate [i] over the range 2 ... [floor1_values]-1 {
    
       3) [low_neighbor_offset] = low_neighbor([floor1_X_list],[i])
       4) [high_neighbor_offset] = high_neighbor([floor1_X_list],[i])

       5) [predicted] = render_point( vector [floor1_X_list] element [low_neighbor_offset],
                                      vector [floor1_X_list] element [high_neighbor_offset],
				      vector [floor1_Y] element [low_neighbor_offset],
				      vector [floor1_Y] element [high_neighbor_offset],
                                      vector [floor1_X_list] element [i] )

       6) [val] = vector [floor1_Y] element [i]
       7) [highroom] = [range] - [predicted]
       8) [lowroom]  = [predicted]
       9) if ( [highroom] is less than [lowroom] ) {

            10) [room] = [highroom] * 2
         
          } else [highroom] is not less than [lowroom] {
		      
            11) [root] = [lowroom] * 2
        
          }

      12) if ( [val] is nonzero ) {

            13) vector [floor1_step2_flag] element [low_neighbor_offset] = set
            14) vector [floor1_step2_flag] element [high_neighbor_offset] = set
            15) vector [floor1_step2_flag] element [i] = set
            16) if ( [val] is greater than or equal to [room] ) {
 
                  17) if ( [hiroom] is greater than [lowroom] ) {

                        18) vector [floor1_final_Y] element [i] = [val] - [lowroom] + [predicted]
		     
		      } else [hiroom] is not greater than [lowroom] {
              
                        19) vector [floor1_final_Y] element [i] = [predicted] - ([val] - [lowroom]) - 1
                   
                      }
               
                } else [val] is less than [room] {
		 
		  20) if ([val] is odd) {
                 
                        21) vector [floor1_final_Y] element [i] = 
                            [predicted] - (([val] - 1) divided by  2 using integer division)

                      } else [val] is even {

                        22) vector [floor1_final_Y] element [i] = 
                            [predicted] + ([val] / 2 using integer division)
                          
                      }

                }      

          } else [val] is zero {

            23) vector [floor1_step2_flag] element [i] = unset
            24) vector [floor1_final_Y] element [i] = [predicted]

          }

     }

 25) vector [floor1_step2_flag] element [0] = set
 26) vector [floor1_step2_flag] element [1] = set
 27) vector [floor1_final_Y] element [0] = vector [floor1_Y] element [0]
 28) vector [floor1_final_Y] element [1] = vector [floor1_Y] element [1]
 29) done

step 2: curve synthesis

Decode begins by sorting the scalars from vectors [floor1_X_list], [floor1_final_Y] and [floor1_step2_flag] together into new vectors [floor1_X_list]', [floor1_final_Y]' and [floor1_step2_flag]' according to ascending sort order of the values in [floor1_X_list]. That is, sort the values of [floor1_X_list] and then apply the same permutation to elements of the other two vectors so that the X, Y and step2_flag values still match.

Then compute the final curve in one pass:

  1) [hx] = 0
  2) [lx] = 0
  3) [ly] = vector [floor1_final_Y]' element [0] * [floor1_multiplier]
  4) iterate [i] over the range 1 ... [floor1_values]-1 {

       5) if ( [floor1_step2_flag]' is set ) {

             6) [hy] = [floor1_final_Y]' element [i] * [floor1_multiplier]
 	     7) [hx] = [floor1_X_list]' element [i]
             8) render_line( [lx], [hx], [ly], [hy], [floor] )
             9) [lx] = [hx]
	    10) [ly] = [hy]
          }
 
      11) if ( [hx] is less than [n] ) {

            12) render_line( [hx], [hy], [n], [hy], [floor] )

          }

      13) if ( [hx] is greater than [n] ) {

            14) truncate vector [floor] to [n] elements

          }
     }
 
 15) for each scalar in vector [floor], perform a lookup substitution using 
     the scalar value from [floor] as an offset into the vector [floor1_inverse_dB_static_table]

 16) done