void decodeLayer3Frame()

in pedalboard/juce_overrides/juce_PatchedMP3AudioFormat.cpp [2249:2339]
76 lines of code
28 McCabe index (conditional complexity)

  void decodeLayer3Frame(float *pcm0, float *pcm1, int &samplesDone) noexcept {
    if (!rollBackBufferPointer((int)sideinfo.mainDataStart))
      return;

    const int single = frame.numChannels == 1 ? 0 : frame.single;
    const int numChans = (frame.numChannels == 1 || single >= 0) ? 1 : 2;
    const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;
    const bool iStereo = (frame.mode == 1) && (frame.modeExt & 1) != 0;
    const int granules = frame.lsf ? 1 : 2;
    int scaleFactors[2][39];

    for (int gr = 0; gr < granules; ++gr) {
      {
        auto &granule = sideinfo.ch[0].gr[gr];
        auto part2bits =
            frame.lsf ? getLayer3ScaleFactors2(scaleFactors[0], granule, 0)
                      : getLayer3ScaleFactors1(scaleFactors[0], granule);

        if (layer3DequantizeSample(hybridIn[0], scaleFactors[0], granule,
                                   frame.sampleRateIndex, part2bits))
          return;
      }

      if (frame.numChannels == 2) {
        auto &granule = sideinfo.ch[1].gr[gr];
        auto part2bits =
            frame.lsf
                ? getLayer3ScaleFactors2(scaleFactors[1], granule, iStereo)
                : getLayer3ScaleFactors1(scaleFactors[1], granule);

        if (layer3DequantizeSample(hybridIn[1], scaleFactors[1], granule,
                                   frame.sampleRateIndex, part2bits))
          return;

        if (msStereo) {
          for (int i = 0; i < 32 * 18; ++i) {
            auto tmp0 = ((const float *)hybridIn[0])[i];
            auto tmp1 = ((const float *)hybridIn[1])[i];
            ((float *)hybridIn[1])[i] = tmp0 - tmp1;
            ((float *)hybridIn[0])[i] = tmp0 + tmp1;
          }
        }

        if (iStereo)
          granule.doIStereo(hybridIn, scaleFactors[1], frame.sampleRateIndex,
                            msStereo, frame.lsf);

        if (msStereo || iStereo || single == 3) {
          if (granule.maxb > sideinfo.ch[0].gr[gr].maxb)
            sideinfo.ch[0].gr[gr].maxb = granule.maxb;
          else
            granule.maxb = sideinfo.ch[0].gr[gr].maxb;
        }

        switch (single) {
        case 3: {
          auto *in0 = (float *)hybridIn[0];
          auto *in1 = (const float *)hybridIn[1];

          for (int i = 0; i < (int)(18 * granule.maxb); ++i, ++in0)
            *in0 = (*in0 + *in1++);
        } break;

        case 1: {
          auto *in0 = (float *)hybridIn[0];
          auto *in1 = (const float *)hybridIn[1];

          for (int i = 0; i < (int)(18 * granule.maxb); ++i)
            *in0++ = *in1++;
        } break;

        default:
          break;
        }
      }

      for (int ch = 0; ch < numChans; ++ch) {
        auto &granule = sideinfo.ch[ch].gr[gr];
        granule.doAntialias(hybridIn[ch]);
        layer3Hybrid(hybridIn[ch], hybridOut[ch], ch, granule);
      }

      for (int ss = 0; ss < 18; ++ss) {
        if (single >= 0)
          synthesise(hybridOut[0][ss], 0, pcm0, samplesDone);
        else
          synthesiseStereo(hybridOut[0][ss], hybridOut[1][ss], pcm0, pcm1,
                           samplesDone);
      }
    }
  }