decode_residue()

static void fl::third_party::vorbis::decode_residue ( vorb * f, float * residue_buffers[], int32_t ch, int32_t n, int32_t rn, uint8 * do_not_decode )

static

Definition at line 1832 of file stb_vorbis.cpp.hpp.

{
   int32_t i,j,pass;
   Residue *r = f->residue_config + rn;
   int32_t rtype = f->residue_types[rn];
   int32_t c = r->classbook;
   int32_t classwords = f->codebooks[c].dimensions;
   uint32_t actual_size = rtype == 2 ? n*2 : n;
   uint32_t limit_r_begin = (r->begin < actual_size ? r->begin : actual_size);
   uint32_t limit_r_end   = (r->end   < actual_size ? r->end   : actual_size);
   int32_t n_read = limit_r_end - limit_r_begin;
   int32_t part_read = n_read / r->part_size;
   int32_t fl_stbv_temp_alloc_point = fl_stbv_temp_alloc_save(f);
   #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
   uint8 ***part_classdata = (uint8 ***) fl_stbv_temp_block_array(f,f->channels, part_read * sizeof(**part_classdata));
   #else
   int32_t**classifications = (int32_t**) fl_stbv_temp_block_array(f,f->channels, part_read * sizeof(**classifications));
   #endif
 
   FL_STBV_CHECK(f);
 
   for (i=0; i < ch; ++i)
      if (!do_not_decode[i])
         memset(residue_buffers[i], 0, sizeof(float) * n);
 
   if (rtype == 2 && ch != 1) {
      for (j=0; j < ch; ++j)
         if (!do_not_decode[j])
            break;
      if (j == ch)
         goto done;
 
      for (pass=0; pass < 8; ++pass) {
         int32_t pcount = 0, class_set = 0;
         if (ch == 2) {
            while (pcount < part_read) {
               int32_t z = r->begin + pcount*r->part_size;
               int32_t c_inter = (z & 1), p_inter = z>>1;
               if (pass == 0) {
                  Codebook *c = f->codebooks+r->classbook;
                  int32_t q;
                  FL_STBV_DECODE(q,f,c);
                  if (q == EOP) goto done;
                  #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
                  part_classdata[0][class_set] = r->classdata[q];
                  #else
                  for (i=classwords-1; i >= 0; --i) {
                     classifications[0][i+pcount] = q % r->classifications;
                     q /= r->classifications;
                  }
                  #endif
               }
               for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
                  int32_t z = r->begin + pcount*r->part_size;
                  #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
                  int32_t c = part_classdata[0][class_set][i];
                  #else
                  int32_t c = classifications[0][pcount];
                  #endif
                  int32_t b = r->residue_books[c][pass];
                  if (b >= 0) {
                     Codebook *book = f->codebooks + b;
                     #ifdef FL_STB_VORBIS_DIVIDES_IN_CODEBOOK
                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
                        goto done;
                     #else
                     // saves 1%
                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
                        goto done;
                     #endif
                  } else {
                     z += r->part_size;
                     c_inter = z & 1;
                     p_inter = z >> 1;
                  }
               }
               #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
               ++class_set;
               #endif
            }
         } else if (ch > 2) {
            while (pcount < part_read) {
               int32_t z = r->begin + pcount*r->part_size;
               int32_t c_inter = z % ch, p_inter = z/ch;
               if (pass == 0) {
                  Codebook *c = f->codebooks+r->classbook;
                  int32_t q;
                  FL_STBV_DECODE(q,f,c);
                  if (q == EOP) goto done;
                  #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
                  part_classdata[0][class_set] = r->classdata[q];
                  #else
                  for (i=classwords-1; i >= 0; --i) {
                     classifications[0][i+pcount] = q % r->classifications;
                     q /= r->classifications;
                  }
                  #endif
               }
               for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
                  int32_t z = r->begin + pcount*r->part_size;
                  #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
                  int32_t c = part_classdata[0][class_set][i];
                  #else
                  int32_t c = classifications[0][pcount];
                  #endif
                  int32_t b = r->residue_books[c][pass];
                  if (b >= 0) {
                     Codebook *book = f->codebooks + b;
                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
                        goto done;
                  } else {
                     z += r->part_size;
                     c_inter = z % ch;
                     p_inter = z / ch;
                  }
               }
               #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
               ++class_set;
               #endif
            }
         }
      }
      goto done;
   }
   FL_STBV_CHECK(f);
 
   for (pass=0; pass < 8; ++pass) {
      int32_t pcount = 0, class_set=0;
      while (pcount < part_read) {
         if (pass == 0) {
            for (j=0; j < ch; ++j) {
               if (!do_not_decode[j]) {
                  Codebook *c = f->codebooks+r->classbook;
                  int32_t temp;
                  FL_STBV_DECODE(temp,f,c);
                  if (temp == EOP) goto done;
                  #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
                  part_classdata[j][class_set] = r->classdata[temp];
                  #else
                  for (i=classwords-1; i >= 0; --i) {
                     classifications[j][i+pcount] = temp % r->classifications;
                     temp /= r->classifications;
                  }
                  #endif
               }
            }
         }
         for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
            for (j=0; j < ch; ++j) {
               if (!do_not_decode[j]) {
                  #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
                  int32_t c = part_classdata[j][class_set][i];
                  #else
                  int32_t c = classifications[j][pcount];
                  #endif
                  int32_t b = r->residue_books[c][pass];
                  if (b >= 0) {
                     float *target = residue_buffers[j];
                     int32_t offset = r->begin + pcount * r->part_size;
                     int32_t n = r->part_size;
                     Codebook *book = f->codebooks + b;
                     if (!residue_decode(f, book, target, offset, n, rtype))
                        goto done;
                  }
               }
            }
         }
         #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
         ++class_set;
         #endif
      }
   }
  done:
   FL_STBV_CHECK(f);
   #ifndef FL_STB_VORBIS_DIVIDES_IN_RESIDUE
   fl_stbv_temp_free(f,part_classdata);
   #else
   fl_stbv_temp_free(f,classifications);
   #endif
   fl_stbv_temp_alloc_restore(f,fl_stbv_temp_alloc_point);
}

References fl::third_party::vorbis::Residue::begin, fl::third_party::vorbis::Residue::classbook, fl::third_party::vorbis::Residue::classdata, fl::third_party::vorbis::Residue::classifications, codebook_decode_deinterleave_repeat(), done, fl::third_party::vorbis::Residue::end, EOP, FL_NOEXCEPT, FL_STBV_CHECK, FL_STBV_DECODE, fl_stbv_temp_alloc_restore, fl_stbv_temp_alloc_save, fl_stbv_temp_block_array, fl_stbv_temp_free, memset(), offset(), fl::third_party::vorbis::Residue::part_size, pcount, fl::third_party::vorbis::Residue::residue_books, residue_decode(), and z.

Referenced by vorbis_decode_packet_rest().

Here is the call graph for this function:

Here is the caller graph for this function: