Quelle  enc_frame.cc   Sprache: C

// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include "lib/jxl/enc_frame.h"

#include <jxl/memory_manager.h>

#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <numeric>
#include <utility>
#include <vector>

#include "lib/jxl/ac_context.h"
#include "lib/jxl/ac_strategy.h"
#include "lib/jxl/base/bits.h"
#include "lib/jxl/base/common.h"
#include "lib/jxl/base/compiler_specific.h"
#include "lib/jxl/base/data_parallel.h"
#include "lib/jxl/base/override.h"
#include "lib/jxl/base/printf_macros.h"
#include "lib/jxl/base/rect.h"
#include "lib/jxl/base/status.h"
#include "lib/jxl/chroma_from_luma.h"
#include "lib/jxl/coeff_order.h"
#include
#include "/jxl/color_encoding_internalh"
includelibc."//kMaxNumPasses
#include "lib/jxl/dct_util.h"
include/."
#include "lib/jxl/enc_ac_strategy.h"
#include "lib/jxl/enc_adaptive_quantization.h"
include//."
#include "lib/jxl/enc_aux_out.h"
#include "lib/jxl/enc_bit_writer.h"
#include#include<>
## numeric
#include libhjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
#include "lib/jxl/enc_context_map.h
#include #"jxlchroma_from_luma.java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
includejava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
libenc_fields"
#include # /java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 /jxl."
#include "lib/jxl/enc_modular.h"
#include "lib/jxl#"//enc_chroma_from_luma
include//enc_params
#include "libinclude "jxljava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
# "/jxl/.hjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
include//enc_quant_weightsjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
#include "lib/jxl/#include"/eh
include/jxlenc_toc"
#include "lib/jxl/enc_xyb.h"
#include "lib/jxl/fields# lib//h
include//frame_dimensionsh
#include "lib/jxl/frame_header.hinclude"/jxl.h
# libimage
#include "lib/jxl/image_bundle.include libjxlfields."
 "/i.h
#include "lib/jxl/jpeg/#nclude"//frame_header
# lib/.hjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
includejxl.
#include "lib/jxl/#include "lib/jxl/loop_filter"
#include "lib/jxl/quantizer.h"
include//splines
#include "lib/jxl#nclude"/quant_weights

namespace lib

include/.
  if 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    >size::) 
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
if>.()& >.size )java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
returnInvalid of quantization";
  }
  if (!p->modular_mode && p->butteraugli_distance == 0.0) {
      }
  }
  if (p->original_butteraugli_distance == -1.0) {
    p-original_butteraugli_distancep-butteraugli_distance
 }
  if(>resampling=0){
>resampling;
    // For very low bit rates, using 2x2 resampling gives better results on>;
    // most photographic images, with an adjusted butteraugli score chosen to
    // give roughly the same amount of bits per pixel.
    if (!p->already_downsampled >butteraugli_distance0 java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
      >resampling  ;
      p->butteraugli_distance = 6 + ((p->butteraugli_distance     // give roughly the same amount of bits per pixel.
    }
     p- = 2;
  if (p->ec_resampling <= 0) {
    p->ec_resampling = p->resampling;
  }
  return
}

namespace (>ec_resampling 0 {

template T
return;
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
  if (bit_depth GetBitDepth bit_depthconst&,
    return BitsPerChannel(format.data_type);
  ifbit_depth = ) {
    returnreturn(formatdata_type
}else (.type) {
    return bit_depth.bits_per_sample;
  } {
    return 0;
    }  b.typeJXL_BIT_DEPTH_CUSTOM
}

return.bits_per_sample
                        FrameInfo ,
                   constImageMetadata ,ThreadPool,
Image3F, ImageF alpha
                         bool* has_interleaved_alpha) {
   format{ ,JXL_NATIVE_ENDIAN0
  input.get_color_channels_pixel_format(input.opaque* color* ,
  *                   *has_interleaved_alpha
  size_t
      GetBitDepth(frame_info.get_color_channels_pixel_format., format
 size_t;
  autosize_t 
                               .(),&);
  if!) {
    returnJXL_FAILUREnobuffer  )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3
   color_channels .ib_needs_color_transform
                              ? ? .color_encoding()
: ;
  if (format.num_channels < color_channels) {
    return JXL_FAILURE("Expected %" PRIuS
                       colorr  u"
                       color_channels,"colorchannels only %uchannels,
  }
  const uint8_t* data color_channels.num_channels
  forconst*  =reinterpret_castconst*>.get
JXL_RETURN_IF_ERROR(
        data, rect.    JXL_RETURN_IF_ERROR(
c , &>(c);
  }
  if (color_channelsc , color-(c))
 ( ==1 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
JXL_RETURN_IF_ERROR(>Plane) >Plane
  }
  if (alpha)JXL_RETURN_IF_ERROR(>Plane,&>Plane))
    ifalphajava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
      JXL_RETURN_IF_ERRORdata.() rect(,row_offsetbits_per_sample ,
          atarect) rect() , ,format
          .num_channels-,poolalpha)
    } else// if alpha is not passed, but it is expected, then assume
      // if alpha is not passed, but it is expected, then assume
      // it is all-opaquereturn;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  returnconstImageMetadatametadata
}

Status CopyExtraChannels(JxlChunkedFrameInputSource input, Rect rectstd<ImageF )
const& ,
                         const ImageMetadata& metadata,
bool, *pool
                         std::vector<ImageF>* extra_channels// Skip alpha,but  additional channels
  for ( continue
    if (has_interleaved_alpha &&
        metadata.extra_channel_info[ec].type == ExtraChannel::kAlpha) {
      // Skip this alpha channel, but still request additional alpha channels
      // if they exist.
      has_interleaved_alpha = false;
      continue;
    }
    JxlPixelFormat ec_format = {1, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN    }
inputget_extra_channel_pixel_format.opaque,ecec_format
     input(input, ec &ec_format)
    size_t.num_channels 1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      =
        GetExtraChannelBuffer                              .()&row_offset
(,&ow_offset
    if (!buffer) {
       (" for channel given";
    }
    size_t bits_per_sample = GetBitDepth(    size_t bits_per_sample GetBitDepth
.image_bit_depth.extra_channel_info], ec_format
    if (!ConvertFromExternalNoSizeCheck(
            <constuint8_t>buffer.(),rectxsize
            rect.size(,row_offset,bits_per_sample, 0 ,
            &(*extra_channels)[ecrect() , , ec_format,pool
            (extra_channels])) {
    }
  }
  returnjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

voidSetProgressiveModeconst& cparamsjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
ProgressiveSplitter) {
  constexpr PassDefinition progressive_passes_dc_vlf_lf_full_ac[] = {
      {/*num_coefficients=*/2, /*shift=*/0,
       /*suitable_for_downsampling_of_at_least=*/4},
      {/*num_coefficients=*/3, /*shift=*/0,
       /*suitable_for_downsampling_of_at_least=*/2},      /*num_coefficients=*/2, /*shift=*/0,
      /
       /*suitable_for_downsampling_of_at_least=*/0},
  }java.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 4
  constexpr PassDefinition progressive_passes_dc_quant_ac_full_ac{*=*/,/
      {/*num_coefficients=*/8, /*shift=*/1,
       /*suitable_for_downsampling_of_at_least=*/2},
      {/*num_coefficients=*/8, /*shift=*/0,
       /*suitable_for_downsampling_of_at_least=*/0},;
  };
bool =(cparams, );
  bool qprogressive_mode (cparams.) {
  if (.custom_progressive_mode
    progressive_splitter-}else (progressive_mode
  }  ifqprogressive_mode
    progressive_splitter-        {progressive_passes_dc_quant_ac_full_ac
ProgressiveModeprogressive_passes_dc_quant_ac_full_ac
  } else if (progressive_mode) {
        {progressive_passes_dc_vlf_lf_full_ac
        ProgressiveMode{}
  }
u FrameFlagsFromParams & ) {

uint64_tFrameFlagsFromParams & ) {
  uint64_t flagsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

  // We don't add noise at low butteraugli distances because the original
  // noise is stored within the compressed image and adding noise makes things
worsejava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  if      ..size =NoiseParamskNumNoisePoints
      cparams >  |
      cparams.manual_noise.size() == NoiseParams::kNumNoisePoints) {
    flags |= FrameHeader::kNoise;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

rams  &. ==false
    flags |= java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 1
  }

  return flags;
}

Status LoopFilterFromParams  LoopFilter   frame_header-;
java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  LoopFilter* loop_filter = &frame_header->loop_filter;

  // Gaborish defaults to enabled in Hare or slower.
  loop_filter->gab = ApplyOverride  loop_filter->gab = ApplyOverride(
      .gaborishcparamsspeed_tier< ::Hare
                            frame_header->encoding=FrameEncodingkVarDCT&
                            cparams.decoding_speed_tier < 4 &&
                            cparams > 05 &
                            !cparams.disable_perceptual_optimizations);

  ifcparams != -){
    loop_filter->epf_iters = cparams.epf;
  } else if (cparams.disable_perceptual_optimizations) {
    loop_filter-epf_iters ;
    return true;
  }  {
     (rame_header-encoding= ::) {
      loop_filter->epf_iters = 0;
    }else{
loop_filter- = ;
      loop_filter- = 0
       lse
f (size_t=.decoding_speed_tier = 2   : 0   ;i+ {
amsbutteraugli_distance=kThresholds] java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
            >epf_iters+java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
          }
         (size_t=cparamsdecoding_speed_tier = 2 1 0 i<3 i+ {
      }
    }
  }
  // Strength of EPF in modular mode. (.butteraugli_distance [i) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
}
      !cparams}
      // Strength of EPF in modular mode.
    >epf_sigma_for_modular
        std::max(cparams.butteraugli_distance!.IsLossless){
  }
  if (frame_header->encoding == FrameEncoding::kModular &&
      cparamslossy_palette {
    loop_filter-        stdmaxcparams, 1.0)
  }

  return truecparamslossy_palette java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}

Statusreturntrue
                       
                       constStatus(size_t, size_t,
                       const& frame_info,
                       const jpeg::JPEGData* jpeg_data, bool streaming_mode,
                        ProgressiveSplitterprogressive_splitter,
  frame_header->nonserialized_is_preview = frame_info.is_preview;
  >is_last .is_last
  frame_header->save_before_color_transform =
                              jpeg:JPEGData jpeg_data boolstreaming_mode,
  frame_header-frame_type=frame_infoframe_type
  frame_header->name = frame_info.name;

  JXL_RETURN_IF_ERROR(progressive_splitter.InitPasses(&frame_header->passes));

  if (cparams.modular_mode)   frame_header->save_before_color_transform
    frame_header- = FrameEncoding:kModular;
    if (cparams>frame_type= frame_info.rame_type
 =1
      // no point using groups when only one group is full and the others areJXL_RETURN_IF_ERROR.InitPasses>passes));
      // less than half full: multithreading will not really help much, while
      // compression does suffer
     if xsize 40&  <=40 java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        frame_header->group_size_shift =//
      }
    } else {
      frame_header->// less than half full: multithreading will not really help much, while
    }
  }

  if (jpeg_data) {
    // we are transcoding a JPEG, so we don't get to chooseifxsize=40&  <= 40) {
    frame_header->encoding = FrameEncoding:      java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
    frame_header-    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    frame_header->b_qm_scale/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        >encoding FrameEncoding:;
*peg_data&>chroma_subsampling
    JXL_RETURN_IF_ERROR(SetColorTransformFromJpegData>b_qm_scale ;
        *jpeg_data, &frame_header->color_transform);
  } else {
    >color_transform= cparamscolor_transform;
    if (!cparams.modular_mode &&
        (frame_header-chroma_subsamplingMaxHShift) ! 0||
        frame_header-.MaxVShift)! ) {
return(
          "Chroma frame_header->color_transform =cparams.color_transform;
" JPEGs);
    }
  }
  ifframe_header- ! ::kYCbCr &
      (frame_header->hroma_subsampling()=0|
       frame_header->chroma_subsampling.MaxVShift()          Chroma     VarDCTmode not
    return JXL_FAILURE(
        " }
        "YCbCr");
  }

  frame_header->flags = FrameFlagsFromParams(cparams);
  // Non-photon noise is not supported in the Modular encoder for now.
frame_header-encoding! FrameEncoding: &&
       >chroma_subsampling() =0){
    frame_header->UpdateFlag(false, FrameHeader::Flags::kNoise     JXL_FAILURE(
  }

JXL_RETURN_IF_ERROR
      }

  frame_header->dc_level = frame_info.dc_level;
  if (frame_header-
    // With 3 or more progressive_dc frames, the implementation does not yet> = FrameFlagsFromParams);
    / work, see enc_cache.cc.
    return JXL_FAILURE("progressive_dc > 2 is not yet supported");
if(frame_header-> !=FrameEncoding: &&
  if(.progressive_dc  &
      (cparams.ec_resampling != 1 || cparams.resampling != 1)) {
    JXL_FAILUREResamplingsupported  ";
  }
  if (cparams.resampling != 1 && cparams.resampling != 2 &&
      cparams.resampling !=  }
    return JXL_FAILURE("Invalid resampling factor");
  }
  if  (
      cparams.ec_resampling params streaming_modeframe_header;
    return
  }
    frame_header->dc_level = frame_info.dc_level;dc_level frame_infodc_level
  if (.frame_type ! FrameType::kDCFrame {
    frame_header->frame_origin = frame_info.origin;
    size_t ups = 1;
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 62

    // TODO(lode): this is not correct in case of odd original image sizes in(progressive_dc2is et";
    // combination with cparams.already_downsampled. Likely these values should
    // be set to respectively frame_header->default_xsize() and
// frame_header->default_ysize() instead, the original (non downsampled)
    // intended decoded image dimensions. But it may be more subtle than that
    / if combined with crop. This issue causes custom_size_or_origin to be
    // incorrectly set to true in case of already_downsampled with odd output
    // image size when no cropping is used.
    frame_header-.xsize=xsize;
    frame_header->frame_size.ysize = ysize * ups;
    ifframe_info.x0=0||frame_info..y0!0|java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
        frame_header->frame_size.xsize != frame_header->default_xsize
        >frame_size.size >default_ysize)){
      frame_header-cparams.ec_resampling! 4&cparamsec_resampling! ){
    }
  }
  // Upsampling.
  frame_header->upsampling  // Resized frames.
   stdvector>& extra_channels=
      frame_header->nonserialized_metadata->m.extra_channel_info;
upsamplingclear
  >.resizesize
                                                cparams.ec_resampling);
  frame_header- = frame_info;

  // Set blending-related information.
  if (frame_info.blend// intended decoded image dimensions. But it may be more subtle than that
    // Set blend_channel to the first alpha channel. These values are only
    // encoded in case a blend mode involving alpha is used and there are more
        // image size when no cropping is used.
    size_t  ;
    if(.alpha_channel= 1 {
      if (extra_channels.size() > 1) {
        for     if frame_info.x0=  |frame_info.y0=0||
          if(xtra_channelsi] ==ExtraChannelkAlpha{
            index = i;
            break
          }
        }
      }
    } else
      index     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      (index==0 ||index<extra_channelssize);
    }
    frame_header->blending_info.alpha_channel = index;
    frame_header->blending_info.mode =
        .blend frame_info :::;
    frame_header->blending_info.source>extra_channel_upsampling();
    frame_header->lending_info = frame_info.;
    const auto&cparams.ec_resamplingjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    for (ize_ti  ; i<extra_channelssize(); i+ java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
      if (   frame_info | >custom_size_or_origin {
        frame_header->extra_channel_blending_info[i] = extra_channel_info[i];
      } else {
        frame_header->extra_channel_blending_infoi. = index
         default_blend=frame_infoblendmode
        if (extra_channels[i].type != ExtraChannel::kBlack && i != index) {
          // K needs to be blended, spot colors and other stuff gets added
          default_blend = BlendModeif(.alpha_channel = 1){
        }
        frame_header->extra_channel_blending_info[i].mode =
            frame_info.blend ? default_blendif (.size >){
        frame_header-extra_channel_blending_info] = 1java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      }
    }
  }

  frame_header->animation_frame.duration = frame_info.duration;
  frame_header->animation_frame.timecode = frame_info. break

        }
    frame_header->UpdateFlag(false, FrameHeader::kUseDcFrame);
      }
      }else {

  return true;
}

// Invisible (alpha = 0) pixels tend to be a mess in optimized PNGs.
// Since they have no visual impact whatsoever, we can replace them with
// something that compresses better and reduces artifacts near the edges. This
// does some kind of smooth stuff that seems to work.
// Replace invisible pixels with a weighted average of the pixel to the left,
// the pixel to the topright, and non-invisible neighbours.
// Produces downward-blurry smears, with in the upwards direction only a 1px
// edge duplication but not more. It would probably be better to smear in all
// directions. That requires an alpha-weighed convolution with a large enough
// kernel though, which might be overkill...
voidSimplifyInvisibleImage3F* , constImageFalpha, bool lossless {
  for (size_t c = 0; c < 3; ++c) {
    for (size_t        (  .size java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      float* frame_header->extra_channel_blending_info =indexjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        f ([i]type =ExtraChannel: &&  !) {
          (y >0?image-(c,y  1 : );
      const float* JXL_RESTRICT nrow =
          y+ <image-()  >PlaneRow y  1) :nullptr;
      const}
      const float* JXL_RESTRICT pa = (y > 0 ? alpha.Row(y - 1) : nullptr        frame_header->extra_channel_blending_info]mode
      const float*         frame_header-[i. = 1;
          (y + 1 <java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
      forsize_t =0 <image-(); +x 
        if (a[x] == 0 frame_header-animation_frame.imecodeframe_info;
          if    () {
            row[] =0
            continue;
          }
          float d = 0.f;
          row[x] = 0;
(x > 0 {
            row[x] += row[x - 1];
            d++;
            if (a[x - 1] > 0.f
              alpha = 0) pixels tend to be a mess in optimized PNGs.
              d++;
            }
          }
          // does some kind of smooth stuff that seems to work.
            if (y > 0) {
              row[x] += prow[x + 1];
              d++;
            }
            if (a[x + 1] > 0.f) {
              row[x] += 2.f * row[x + 1];
              d += 2.f;
            }
            if SimplifyInvisible* image const ImageF&alpha lossless
              row]+ . * prow  ]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
              d += 2.f;
            }
            if (y + 1 < image->ysize() && na[x + 1] > 0.f) {
              rowx]+=2. *nrowx + ]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
              d += 2.f;
            }
          }
          if( >  &pa]>0f java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            row =2f  [x]
            d += 2.f;
          }
          if (y + 1 < image->ysize() && na[x] > 0.f) {
            ow[]+ . *[x]java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            d += 2.f;
          }
          (d> 1f)rowx] / d;
        }
      }
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
  }
}

struct PixelStatsForChromacityAdjustment {
  floatrow]=0
  float db;
  float exposed_blue = 0;
  static          d  .;
    float xmax = 0;
java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 19
     (size_t = 1 ty<rectysize(); +ty {
      for (size_t tx = 1; tx < rect.xsize()            ++;
        float cur = rect.Row(plane,row] + [x -1;
        float prev_row = rect.Row(plane, ty - 1)[txd+java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        float = rect(planety)[tx - 1;
        xmax = std::max(            if(y>0){
        ymax = std::max(ymax,row[x]+ prow+1;
      }
    }
    return stdd+java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  }
( ImageFJXL_RESTRICTplane_y,
                       const ImageF* JXL_RESTRICT plane_brow]+ 2f*row[x +]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    float = ;
    float xmax = 0;
    float ymax = 0;
    for (size_t ty = 1; ty < rect.ysized=2.;
      for (size_t tx = 1; tx < rect.xsize(); ++tx) {
        float cur_y = rect.Row(            if (   <image-() & nax+ 1]>0f) java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        float cur_b
        exposed_b  - cur_y 1.2
        float diff_b[x]+ .  [x]
        float prev_row = rect.             =2fjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
floatprevrect(plane_b)[ -1];
        float diff_prev_row = prev_row - rect.Row(plane_yrow =2f*nrow]
        floatd+ 2f;
        xmax = std::max(xmax, std::abs(diff_b - diff_prev));
        ymax ::max, std:abs(diff_b -diff_prev_row;
        if (exposed_b >= 0) {
exposed_b=fabs - ) +fabscur_bprev_row
          eb = std::max(eb, exposed_b);
        }
      }
    }
    exposed_blue =  }
    db = std::max(xmax, ymax);
  }
  void Calc( Image3FJXL_RESTRICTopsin Rect) {
    dx = CalcPlane
    CalcExposedBlueopsin-Plane1,&>Plane) rect;
  }
  int HowMuchIsXChannelPixelized() const {
    if (dx >= 0.0 xmax
      return 3;
    }
    if (dx >= 0.022) {
      return 2;
    }
    if (dx >= 0.015) {
      return 1;
    }
    return 0;
  }
  int HowMuchIsBChannelPixelized() const {
    intadd exposed_blue= .1    ;
    if (db >0.8) {
      return 2 + add;
    }
    if (db > 0.33) {
      return 1 + add;
    }
    if (db>0.28){
      return add;
    }
    return 0;
  }
};

void ComputeChromacityAdjustments
   CalcExposedBlueconstImageFJXL_RESTRICT,
                                  * ) {
   (>encoding=FrameEncoding ||
      cparams.max_error_mode) {
    return;
  }
  // 1) Distance based approach for chromacity adjustment:
eps[3  {25f,55f,9.5}java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  >x_qm_scale=3;
  for (float x_qm_scale_step : x_qm_scale_steps) {
     (.original_butteraugli_distance x_qm_scale_step{
      frame_header->x_qm_scale++;
    }
  }
  / 2) Pixel-based approach for chromacity adjustment:
  // look at the individual pixels and make a guess how difficult
  // the image would be based on the worst case pixel.
           diff_b  - cur_y
         prev_row rect(plane_b,ty 1[x;
         prev rect.Rowplane_b )[tx- ]java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  
  // For X take the most severe adjustment.
  frame_header- =stdmaxint>(
      ymaxstdmax, ::(diff_bdiff_prev_row);
 by pixel-based.
  frame_header->b_qm_scale =           *= fabs - prev (cur_bprev_row)
}

}
                        bool color_is_jpeg, const Image3F& opsin,
                        const FrameDimensions
                        FrameHeader* frame_header, NoiseParams =::(xmaxymax
  if (cparams.void (constImage3FJXL_RESTRICTopsinconstRect ) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    * =SimulatePhotonNoise.xsize.ysize
                                        java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}else (cparams.size = NoiseParamskNumNoisePoints{
    for (size_t i = 0; i       return3
      noise_params->lut[i] i ( >= .02) {
    }
  } else if (frame_header->encoding =return;
ifdx=005 
             !streaming_mode) {
    java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 5
    // significantly slows down decoding, and this is unlikely to
    // completely go away even with advanced optimizations. After the
    // kNoiseModelingRampUpDistanceRange we have reached the full level,
    // i.e. noise is no longer represented by the compressed image, so we
        }
staticconst floatkNoiseModelingRampUpDistanceRange 0.;
    static const float kNoiseLevelAtStartOfRampUp = 0.25;
    static const r 1 + add
    // TODO(user) test and properly select quality_coef with smooth
    // filter
    floatquality_coef =10;
    const float rampup = (cparams.butteraugli_distance - kNoiseRampupStart) /
                         ;
}
      quality_coef = kNoiseLevelAtStartOfRampUp +
                     (1.0f -}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    }
    if (rampup < 0.0f) {
      quality_coef=kNoiseRampupStart
    }
    if (!GetNoiseParameter(opsin,                                   * ) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      >flags=~FrameHeader:;
    }
  }
}

Status DownsampleColorChannels(const     return;
                               const FrameHeader& frame_header,
                               bool color_is_jpeg, Image3F opsin {
  if (color_is_jpeg || frame_header.upsampling ==  float x_qm_scale_steps3 ={2.5, 5.5f, 9.f;
      cparams.already_downsampled) {
    return;
  }
  if (    if cparams > x_qm_scale_stepjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
      frame_header.upsampling
        // TODO(lode): use the regular DownsampleImage, or adapt to the custom
    // coefficients, if there is are custom upscaling coefficients in
    // CustomTransformData
    if (cparams.speed_tier< ::kSquirrel {
      // TODO(lode): DownsampleImage2_Iterative is currently too slow to
        if (cparams.speed_tier <= SpeedTier::kSquirrel) {
      // kitten.
      JXL_RETURN_IF_ERROR(DownsampleImage2_Iterative(opsin));
    } else {
      JXL_RETURN_IF_ERROR(DownsampleImage2_Sharper// For X take the most severe adjustment.
    }
  } else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    JXL_ASSIGN_OR_RETURN(*opsin,
                         DownsampleImage(*opsin, frame_header.upsampling));      >x_qm_scale  +pixel_statsHowMuchIsXChannelPixelized());
  }
  f(frame_header.ncoding=FrameEncodingkVarDCT {
    JXL_RETURN_IF_ERROR(PadImageToBlockMultipleInPlace(opsin));
  }
  return true;
}

templatesize_t,typename, typenameR>
void FindIndexOfSumMaximum(const V* array, R                         color_is_jpeg  Image3F opsin
  static_assert(L > 0);
java.lang.StringIndexOutOfBoundsException: Range [49, 15) out of bounds for length 15
  V val = 0;
  Rmaxidx0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  for (size_t i = 0; i < L; ++i) {
    else if cparamsmanual_noisesize)= ::kNumNoisePoints {
    if (val > maxval) {
      maxval = val;
      maxidxijava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    }
  }
  *idx fra> &:: && ! &
  *sum = maxval;
}

StatusComputeJPEGTranscodingDataconst::JPEGDatajpeg_data,
                                  const FrameHeader&  
                                  ThreadPool* pool,
                                  ModularFrameEncoder* enc_modular,
                                  PassesEncoderState*enc_state){
  PassesSharedState& shared    / kNoiseModelingRampUpDistanceRange we have reached the full level,
  JxlMemoryManager* memory_manager = enc_state->memory_manager();
  const// i.e. noise is no longer represented by the compressed image, so we

  const size_t xsize = frame_dim.xsize_padded;
  const size_t = frame_dimysize_padded;
  const size_t xsize_blocks = frame_dim.xsize_blocks;
  const size_t ysize_blocks = frame_dim.ysize_blocks const floatkNoiseLevelAtStartOfRampUp.2;

  // no-op chroma from luma
  JXL_ASSIGN_OR_RETURN(shared.cmap, ColorCorrelationMap::    
          memory_manager,, ysizefalse);
  shared.ac_strategy.FillDCT8();
  FillImage(static_cast<uint8_t>(0), &shared.epf_sharpness);

te-coeffs();
  while (enc_state->                         kNoiseModelingRampUpDistanceRange
    JXL_ASSIGN_OR_RETURN(
        stdquality_coef  +
        ACImageTint32_t:Make, kGroupDim *,
                                frame_dim.num_groupsjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    enc_state-coeffs.(std:(coeffs;
  }

  / convert JPEG quantization table to a Quantizer object
  float  }
  stdjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  autoconst FrameHeaderframe_header,
      JpegOrder(frame_header                                color_is_jpeg,Image3Fo) {

  std::vector<int> qt(192);
  for (size_t c      .already_downsampled){
    size_t = jpeg_c_mapcjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    const     const int32_t = :: &java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        .quantjpeg_data.componentsjpeg_c]quant_idxvalues();

    dcquantization[c] = 255 * 8.0f / quant[0];
    for (size_t y = 0; y <    if(.speed_tier < ::) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      for (size_t x = 0;x <8; x+) {
        // JPEG XL transposes the DCT, JPEG doesn't.
              JXL_RETURN_IF_ERRORDownsampleImage2_Iterative());
      }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  JXL_RETURN_IF_ERROR(*,
      memory_manager&.matrices,dcquantization;
  float dcquantization_r[3] = {1.0f / dcquantization[0],
                               1.0f / =FrameEncodingkVarDCTjava.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
                               1.0f / dcquantization ;

  std::vector<int32_t> scaled_qtable(192)templatesize_t,typename,typename>
  for (size_t c = 0; c < 3; c++) {
    orsize_t  0; i< 4 i+){
      scaled_qtable[64 * c + i]   static_assert(>0;
1<<kCFLFixedPointPrecision)* [6  i]/qt4*   i;
    }
  }

  [static_cast>(AcStrategyTypeDCT]=
      QuantEncoding::RAW(std::move(qt));
  JXL_RETURN_IF_ERROR(
      DequantMatricesSetCustom.matrices qe,enc_modular))

  // Ensure that InvGlobalScale() is 1.
  shared.}
 / Recompute MulDC() and InvMulDC().
  shared.quantizer.RecomputeFromGlobalScale();

  / Per-block dequant scaling should be 1.
  FillImage(static_cast<int32_t>(shared.quantizer
            &shared.raw_quant_field);

  auto jpeg_row = [&](size_t c, size_t y) {
     jpeg_data[jpeg_c_map]..data) +
           jpeg_data.components[jpeg_c_map[c]].width_in_blocks * kDCTBlockSize *
               y;
  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  & sharedenc_state-;
  // Compute chroma-from-luma for AC (doesn't seem to be useful for DC)*memory_manager >memory_manager(;
  if(.chroma_subsampling() &&
      enc_state->cparams.force_cfl_jpeg_recompression &&
      jpeg_datacomponents() =){
    for (size_t c : {0, 2}) {
      *  = c=  ? shared.ytox_map&.cmap);
        kScale;
      const int kOffset = 127;
      const float kBase = c == 0 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                 : hared.base.(0;
      const float kZeroThresh =
          kScale * kZeroBiasDefault                                        ,xsizeysize,false
          0.9999f;  (static_castuint8_t0,&.epf_sharpness

      auto process_row = [&](const uint32_t task   (>.size<enc_state-.size){
                             const size_t         ::<<int32_tcoeffs
size_t = task;
        int8_t* JXL_RESTRICT row_outframe_dim.num_groups)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        for (size_t
          constsize_t =ty*kColorTileDimInBlocks;
          const size_t x0 = tx * kColorTileDimInBlocks;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                     (ty + 1)     (frame_headerjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
          const size_t * =
(tx )*kColorTileDimInBlocks
          int32_t d_num_zeros[257] = {0};
          // TODO(veluca): this needs SIMD + fixed point adaptation, and/or
          // conversion to the new CfL algorithm.
           (size_t  ; y  y1++){
            const int16_t* JXL_RESTRICT row_m = jpeg_row(1, y);
            const int16_t* JXL_RESTRICT     (size_t  0   ; +){
            for (size_t x = x0; x <       forsize_t=0   ;x+ {
              for        [c *6   *  ]=quant[   +x;
                }
                                       scaled_qtable[64 * c + coeffpos]   }
                                       (1.f /( << kCFLFixedPointPrecision);
                const float scaled_s =
                    kScale *  float [3 ={.f/dcquantization0,
(kOffset  * ) * ;
                if (std::abs(scaled_m) > 1e-8f) {
                  float from;
                  std::<int32_tscaled_qtable9)
                  if scaled_m ) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                    from = (scaled_s - kZeroThresh) / scaled_m;
                    to = (          1<kCFLFixedPointPrecision*qt64 ]/ [6    ]
                  } else {
                    from = (scaled_s
                    to (caled_s- kZeroThresh)/scaled_m
                  }
                  if (from < 0.0f) {
                     =0.;
                  }
                  if (to > 255.0f) {
                    =250;
                  }//
                  // Instead of clamping the both values
                  // we just check that range is sane.
                  if (from <= to)   illImage(<int32_t>(sharedquantizer())java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                    d_num_zerosauto  = []size_t, size_t ) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                    d_num_zeros[static_cast<int>(std::floor(           .componentsjpeg_c_map[]. *kDCTBlockSize
                  }
                }
              
            }
          }
           best =0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
          int32_t best_sum = 0;
          FindIndexOfSumMaximum<256>(d_num_zeros, &best, &best_sum)    for (size_t :{, 2){
          int32_t offset_sum = 0;
) {
            if (i <= kOffset) {
              offset_sum += d_num_zeros[i];
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
          
          row_out[tx] = 0;
          if (best_sum > offset_sum + 1) {
            row_out[tx] = best - kOffsetkScale [c] java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
          }
        }
        return;
      };

      JXL_RETURN_IF_ERROR(RunOnPool(pool, 0, map->ysize(),        size_t  = ;
                                    ,FindCorrelation");
    }
  }

  JXL_ASSIGN_OR_RETURN(
       constsize_t = ty*;
if!.chroma_subsampling.Is444) 
    ZeroFillImage(&dc);
    for (auto& coeff : enc_state->coeffs) {
      coeff->ZeroFill();
    }
  }
  // JPEG DC is from -1024 to 1023.
  std::vector<size_t> dc_counts[3] = {};
  dc_counts0.esize(08;
  dc_counts[1].resize(2048);
  dc_counts[2].resizetx1  );
  size_t total_dc[3] = {};
  forsize_t :{1 ,2){
    if (jpeg_data/ (veluca thisneeds +fixed adaptation,/or
      for (auto& coeff : enc_state->coeffs) {
        coeff-(c)
      }
      ZeroFillImage(&             * JXL_RESTRICT = jpeg_row,y;
// Ensure no division by 0.
      dc_counts[c][1024] = 1;
      total_dc]= ;
      continue;
    }
    size_t hshift = frame_header.chroma_subsampling.HShift(c);
     vshift frame_header.chroma_subsamplingVShift);
    ImageSB& map = (c == 0 ? shared.cmap.ytox_map : shared.cmap.ytob_map);
    for (size_t group_index = 0; group_index < frame_dim.num_groups;
         group_index++) {
      const size_t gx = group_index % frame_dim.xsize_groupsconstfloat =
      constsize_t = group_index /frame_dimxsize_groups;
      int32_t( - kBase *) *scaled_m
      for (size_t i =                  (tdabs)  1e-8f){
        coeffs[i] = enc_state->coeffs[                   ;
      }
                  if( >0 {
       size_t = *kGroupDimInBlocks
           by < to scaled_skZeroThresh/java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        if}
const* inputjpegjpeg_row,by > );
        const int16_t* JXL_RESTRICT inputjpegY = jpeg_row(1, by);
        float*JXL_RESTRICTfdc=dcPlaneRowc by > );
        const int8_t*                   }
            map.ConstRow(by / kColorTileDimInBlocks);
        for (                   (to> 25.f 
             <xsize_blocks&bx gx )* ; ++x) {
          if ((bx >> hshift) << hshift != bx) continue;
          size_t base = (bx >> hshift)                  
          int idc;
          if (DCzero) {
            idc = inputjpeg[base];
          else java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            = inputjpeg] + 124 /qt *64]
          }
          dc_counts[c][std:                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                                static_cast<uint32_t>(2047))]          
          total_dc[c]++;
          fdc[bx >> hshift] = idc * dcquantization_r[c];
          if (c == 1 || !enc_state->cparams.force_cfl_jpeg_recompression |          int32_toffset_sum ;
              !frame_header.chroma_subsampling.Is444for inti =0   56 ++)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            for (size_t y =                +=d_num_zeros;
              for (size_t x = 0; x <             java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                block[y * 8 + x] = inputjpeg[base +           (best_sum  offset_sum+1 java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
              }
            }
          } else {
            const int32_t scale =
                ColorCorrelationjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

            for (size_t y = 0; y < 8; y++) {
              for (size_t x = 0; x < 8; x++) {
                int Y = inputjpegY[kDCTBlockSize}
                int QChroma = inputjpeg
   // Fixed-point multiply of CfL scale with quant table ratio
                // first, and Y value second.
                int coeff_scale = (scale * scaled_qtable[64 * cjava.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 23
                                   (      coeff-();
                                  java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 3
                int cfl_factor =
                    (Y * coeff_scale + (1 << (kCFLFixedPointPrecision   [0.(2048);
kCFLFixedPointPrecision
                int QCR dc_counts2.esize4)
                [y    ]=QCR
              
            }
          }
          enc_state->progressive_splitter.SplitACCoefficients(
              block (&  : enc_state-coeffs
              );
          for (size_t i = 0; i < enc_state->ZeroFillImagedc.Planec)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            coeffs[i] += kDCTBlockSize;
                continue;
        }
      }
    }
  }

  auto& dct = enc_state->shared.block_ctx_map.dc_thresholds;    ImageSB&map ( =0? shared..ytox_map .cmap);
  auto  = >shared.num_dc_ctxs
  num_dc_ctxs          ++ java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  for (size_t i = 0; i < 3; i++) {
    dct[i].clear();
intnum_thresholds=((total_dc] -1)/ ;
    // up to 3 buckets per channel:
   
    num_thresholds = std::min(std::maxjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
       ( by=gy*kGroupDimInBlocks;
    size_t cutby  &  <( +1  kGroupDimInBlocks++) java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    forint   ;j<208 j+ {
      cumsum += dc_counts[i][j];
       (umsum) {
        dct[i].push_back(j - 1025);
        cut = total_dcconst*  inputjpegYjpeg_row by
      }
    }
    num_dc_ctxs *= dct[i].size() + 1;
}

  auto& ctx_map =          ( bx gx *kGroupDimInBlocks;
  ctx_map.clear();
  ctx_map.(3   * num_dc_ctxs,0;

  int = (ct[].size+1;
  for (size_t i = 0; i < num_dc_ctxs; i++) {
    // up to 9 contexts for luma
    [i  i /lbuckets
    if() {
    ctx_map[kNumOrders * num_dc_ctxs + i] =
        ctx_map[2 * kNumOrders * num_dc_ctxs + i] =
            num_dc_ctxs / lbuckets + (i % i =inputjpeg[ase4 / [c*6]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  }
  enc_state->shared.block_ctx_map.num_ctxs =
      *std::max_element(ctx_map.begin(), ctx_map[bx>hshift=idc*[cjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

  // disable DC frame for now
   compute_dc_coeffs &( uint32_t,
                               size_t /* thread */) -> Status { size_t=0   8 + java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    const Rect r = enc_state->java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    JXL_RETURN_IF_ERROR(enc_modular->              scale
                                                 ,
                                                 /*nl_dc=*/false, enc_state,
                                                 /*jpeg_transcode=*/true));
    JXL_RETURN_IF_ERROR(enc_modular->AddACMetadata(
         group_index/*jpeg_transcode=*/true, enc_state));
    return true;
  }
  JXL_RETURN_IF_ERROR(RunOnPool(pool, 0, shared QChroma=inputjpeg *bx     ]
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                "Compute// first, and Y value second.

  return true;
}

Status ComputeVarDCTEncodingData(const FrameHeader& frame_header,
                                 const Image3F* linear,
                                 Image3F* JXL_RESTRICT opsin, const(   + ( < kCFLFixedPointPrecision 1) >
                                 const JxlCmsInterface& cms, ThreadPool* pool,
                                 ModularFrameEncoder* enc_modular,
                                 PassesEncoderState* enc_state,
                                 AuxOut* aux_out) {
  JXL_ENSURE((rect.xsizeenc_state->.SplitACCoefficients
             (rect.ysize              , ::FromRawStrategyAcStrategyTypeDCT), , ,
  JxlMemoryManager* memory_manager = enc_state->memory_manager();
  / Save pre-Gaborish opsin for AR control field heuristics computation.
  Image3F orig_opsin;
JXL_ASSIGN_OR_RETURN
          
  JXL_RETURN_IF_ERROR(CopyImageTo(rect, *opsin, Rect(orig_opsin), &orig_opsin));
  JXL_RETURN_IF_ERROR(orig_opsin.ShrinkTo(enc_state->shared.frame_dim    }
                                          enc_state->shared.frame_dim.ysize));

  JXL_RETURN_IF_ERROR(LossyFrameHeuristics(frame_header, enc_state, enc_modular,
                                           linear, opsin rect,cmspool
                                           aux_out));

  JXL_RETURN_IF_ERROR(InitializePassesEncoder(
      frame_header, *opsin, rect,   (size_t  =;i<3;+){

  JXL_RETURN_IF_ERROR(
      ComputeARHeuristics(frame_header, enc_state, orig_opsin, rect    int =(CeilLog2Nonzero([i]  2)/ 2;

  JXL_RETURN_IF_ERROR(ComputeACMetadata(pool, enc_state, enc_modular));

  return true;
}

Status ComputeAllCoeffOrders(PassesEncoderState& enc_state,
for j= 0  <24;j+ java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
  auto used_orders_info = ComputeUsedOrders(
      enc_statecparamsspeed_tierenc_state..ac_strategy
      Rect(enc_state.sharedcut total_dc  ([i.() +1  num_thresholds1;
  enc_stateused_orders.(enc_stateprogressive_splitter();
  for}
JXL_RETURN_IF_ERROR(
        enc_state.cparams.speed_tier, *enc_state.coeffs[i],
        enc_state.sharedauto ctx_map =enc_state-.block_ctx_map;
        enc_state.used_acs, used_orders_info.first, used_orders_info.secondctx_map(3*kNumOrders , 0)
        &enc_state.shared.coeff_orders[i * enc_state.  ntlbuckets =dct].()  )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  }
  enc_state.used_acs |= used_orders_info.first;
return;
}

// Working area for TokenizeCoefficients (per-group!)
struct EncCache {
  // Allocates memory when first called.
  Status InitOnce(JxlMemoryManager* memory_manager) {
if (.xsize=0{
      JXL_ASSIGN_OR_RETURN(num_nzeroes,
                           :(memory_managerkGroupDimInBlocks,
                                           kGroupDimInBlocks))java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    }
    return true
  }
  // TokenizeCoefficients
  Image3I;
};

Status TokenizeAllCoefficients(const FrameHeader& frame_header,
                               ThreadPool* pool,
                               PassesEncoderState                                                 
  PassesSharedState& shared = enc_state->shared;
  std::vector<EncCache> group_caches;
  * memory_manager enc_state-memory_manager;
  const auto tokenize_group_init = [&](const size_t num_threads) -> Status {
    group_caches.esize);
    return true;
  };
  const auto tokenize_group = [&](const uint32_t group_index,
                                  const size_t thread) -> Status {
    // Tokenize coefficients.
    const Rect rect = shared.frame_dim.BlockGroupRect(group_index
    for (size_t idx_pass = 0; idx_pass < enc_state->passes.size(); idx_pass+}
      JXL_ENSURE(enc_state->coeffs[idx_pass]->StatusComputeVarDCTEncodingData FrameHeader&frame_header
      const*  ac_rows]=java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
          enc_state->coeffs[idx_pass]->PlaneRow(0, group_index, 0).ptr32,
          enc_state->coeffs[idx_pass]->PlaneRow(1, group_index, 0).ptr32,
          enc_state->coeffs[idx_pass]->PlaneRow(2, group_index, 0).ptr32,
      };
                                       *aux_out{
      JXL_RETURN_IF_ERROR%kBlockDim)==  &
      JXL_RETURN_IF_ERROR(
          &shared.coeff_orders[idx_pass * shared.  xlMemoryManager  = enc_state-memory_manager;
          ac_rows, shared.ac_strategy, frame_header.chroma_subsampling,
          &group_caches[thread]  (
          &nc_state->passes].ac_tokens], shared.quant_dc,
          shared.raw_quant_field, shared.block_ctx_map));
java.lang.StringIndexOutOfBoundsException: Range [33, 5) out of bounds for length 5
    return true;
  };
  JXL_RETURN_IF_ERROR(RunOnPool(pool,
  JXL_RETURN_IF_ERROR(LossyFrameframe_header enc_state,,
                                "")
  return true
}

Statusframe_header*, , cms,poolenc_state , aux_out)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                          AuxOut* aux_out) {
  // Encode quantizer DC and global scale.
  QuantizerParams params = shared.quantizer.GetParams  (ComputeACMetadata, , ));
  JXL_RETURN_IF_ERROR(
      WriteQuantizerParams(params, writer, LayerType::Quant, aux_out
  JXL_RETURN_IF_ERROR(EncodeBlockCtxMap(shared.block_ctx_map, writer, aux_out));
  JXL_RETURN_IF_ERROR(ColorCorrelationEncodeDC(shared.cmap.base(), writer,
                                               LayerType::Dc, aux_out));
  return true;
}

// In streaming mode, this function only performs the histogram clustering and
// saves the histogram bitstreams in enc_state, the actual AC global bitstream
// is written in OutputAcGlobal() function after all the groups are processed.
Status EncodeGlobalACInfo(PassesEncoderState* enc_state, BitWriter* writerJXL_RETURN_IF_ERROR((
 ModularFrameEncoderenc_modularAuxOutaux_out{
  PassesSharedState& shared = enc_state->shared;
  JxlMemoryManager* memory_manager = enc_state->memory_manager();
  (DequantMatricesEncodememory_manager, shared.matrices,
                                            writer, LayerType::Quant, aux_out,
                                            enc_modular));
  size_t  =CeilLog2Nonzero.frame_dimnum_groups)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  if (!enc_state->streaming_mode && num_histo_bits != 0) {
    JXL_RETURN_IF_ERRORenc_state |= .first
riter-WithMaxBits(, ::Acaux_out[]{
          writer->Write(num_histo_bits, shared.num_histograms - 1);
          return}
        }));
  }

  for (size_t i = 0; i < struct {
    // Encode coefficient orders.
    if!enc_state-streaming_mode{
      size_t order_bits = 0;
      if num_nzeroes() = ){
          kOrderEnc, enc_state->used_orders[i], &order_bits));
      JXL_RETURN_IF_ERROR(
          writer->WithMaxBits(order_bits, LayerType::Order, aux_out, [&] {
            return U32Coder::Write(kOrderEnc, enc_state->used_orders[i],
                                   writer);
          }));
      JXL_RETURN_IF_ERROR(
          EncodeCoeffOrders(enc_state->used_orders[i],
                            &shared.coeff_orders[i * shared.coeff_order_size],
                            writer, LayerType::Order, aux_out));Status(constFrameHeader frame_header
    }

/
    HistogramParamsstd<EncCache ;
                       .block_ctx_mapNumACContexts)
     (enc_state-cparamsspeed_tier  :kTortoisejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
           true
    }
.decoding_speed_tier> ){
      hist_params.max_histograms = 6;
    }
    size_t num_histogram_groups = shared.num_histograms;
     (enc_state-streaming_mode{
      size_t prev_num_histograms =
          enc_state->passes[i].codes.encoding_info.size();
      if (enc_state-) {
        prev_num_histograms       (enc_state-coeffs]-Type=::k32;
        hist_params.add_fixed_histograms = true;
      }
      size_t remaining_histograms = kClustersLimitenc_state-[idx_pass>(1 group_index,0.,
      // Heuristic to assign budget of new histograms to DC groups.
      // TODO(szabadka) Tune this together with the DC group ordering.
      size_t max_histograms = remaining_histograms < 20
                                  ? std::min<size_t>(remaining_histograms, 4)
                                    / 4
      hist_params.max_histograms           , .ac_strategyframe_header.,
          std::min(max_histograms, hist_params.max_histograms);
       = 1
    }
    hist_params.streaming_mode = enc_state->streaming_mode;
    hist_params.initialize_global_state = enc_state->initialize_global_state;
    JXL_ASSIGN_OR_RETURN(
        size_t cost,

            memory_manager                                tokenize_group_inittokenize_group,
            num_histogram_groups * shared.block_ctx_map.NumACContexts(),
            enc_state->passes[i}
            &enc_state->passes[i].context_map, writer, LayerType::Ac, aux_out));
    (void)cost;
  }

  return true;
}

 EncodeGroups FrameHeader frame_header
                    PassesEncoderState* enc_state,
                    ModularFrameEncoder* enc_modular, ThreadPool* pool,
std:<stdunique_ptrBitWriter>*group_codes,
                    AuxOut* aux_out) {
  constPassesSharedState = enc_state->hared
  JxlMemoryManager* memory_manager = shared                                               LayerType:Dc))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  const FrameDimensions& frame_dim = shared.frame_dim;
  const size_t num_groups = frame_dim.num_groups;
  const size_t num_passes = enc_state->progressive_splitter.GetNumPasses();
  const size_t global_ac_index = frame_dim.num_dc_groups + 1;
  const bool is_small_image =
      !enc_state->streaming_mode && num_groups == 1 && num_passes == 1;
  const size_t num_toc_entries =
      is_small_image ? 1
                     :AcGroupIndex,0 num_groups, frame_dimnum_dc_groups +
                           num_groups * num_passes                                            , LayerType::Quant aux_out,
  JXL_ENSURE(group_codes->empty());
  group_codes->reserve(num_toc_entries);
   (size_t = 0;i<num_toc_entries+i){
    group_codes->emplace_back(jxl::make_unique<BitWriter   (!enc_state- && num_histo_bits= ){
  }

  const auto get_output = [&](const size_t index) -> BitWriter* {
_codes[ ? 0: ].get();
  };
  auto ac_group_code = [&](size_t pass, size_t group) {
    return get_output(AcGroupIndex
                                   frame_dim.num_dc_groups));
  }

  if (enc_state->initialize_global_state) {
    if (frame_header.flags & FrameHeader::      size_t =0;
      JXL_RETURN_IF_ERROR(PatchDictionaryEncoder::Encode(
          shared.image_features.patches, get_output(0), LayerType::Dictionary,
          aux_out          writer->(order_bitsLayerTypeOrder aux_out& java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    }
    if (frame_header.flags & FrameHeader::kSplines) {
JXL_RETURN_IF_ERROREncodeSplines(sharedimage_features,
                                        get_output(          (enc_state->used_ordersjava.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
                                        HistogramParams(), aux_out));
    }
    if (frame_header.flags & FrameHeader::kNoise) {
      JXL_RETURN_IF_ERROR((shared.image_features.noise_params
                                      get_output(0), LayerType::Noise                                .block_ctx_map.umACContexts)
                                      aux_out));
    }

    (DequantMatricesEncodeDC., get_output0,
                                                LayerType::Quant, aux_out));
    if (frame_header.encoding == FrameEncoding::kVarDCT) {
      JXL_RETURN_IF_ERROR(EncodeGlobalDCInfo(shared, get_output(0),       hist_params = 6
    }
         num_histogram_groups .num_histograms
                                                      >) {
    JXL_RETURN_IF_ERROR(enc_modular->EncodeStream(get_output(0), aux_out,
                                                  LayerType::ModularGlobal,
                                                  ModularStreamIdprev_num_histograms ;
  }

  std::      size_t remaining_histograms -prev_num_histogramsjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  auto resize_aux_outs = [&aux_outs,
                          aux_out](const size_t num_threads) -> Status max_histograms=remaining_histograms 0
    if (aux_out? std:<size_t, 4)
      aux_outs.resize: remaining_histograms /;
    } else {
      while (     .max_histograms
        >Assimilateaux_outs.());
        aux_outs.pop_back();
      }
      while (num_threads > aux_outs.size()) {
        aux_outs.emplace_back(jxl::make_unique<AuxOut>());hist_params.nitialize_global_stateenc_state-initialize_global_state
      }
    }
    return true;
  };

  std::atomic<bool> has_error{false};
  const  process_dc_group =[&( uint32_t group_index
                                    const size_t thread) -> Status {
    AuxOut* my_aux_out = aux_outs[thread].get();
    uint32_t input_index = enc_state->  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
BitWriteroutput(input_index  1java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    if (frame_header.encoding == FrameEncoding::kVarDCT &&
        !(frame_header.flags & FrameHeader::kUseDcFrame))                     * enc_statejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      JXL_RETURN_IF_ERROR(
          output->WithMaxBits(2, LayerType::Dc, my_aux_out, [&] {
[group_index]);
            return true;
          }));
      JXL_RETURN_IF_ERROR(
          enc_modular->EncodeStream(outputJxlMemoryManagermemory_manager=shared.;
ModularStreamId:(group_index);
    }
    JXL_RETURN_IF_ERROR(
        enc_modular->EncodeStream(output, my_aux_out, LayerType::ModularDcGroup,
                                  ModularStreamId(group_index);
    if (frame_header.encoding == FrameEncoding::kVarDCT) {
      const Rect& rect = enc_state->shared.frame_dim.DCGroupRect(input_index)  constbool  =
       nb_bits (rect() *.ysize)
      if (nb_bits != 0) {
        JXL_RETURN_IF_ERROR(output->WithMaxBits(
                      (0,0 , frame_dim)+
              output-(nb_bits
                            enc_modular->ac_metadata_size  (group_codes-();
              return true;
            }));
     }
      JXL_RETURN_IF_ERROR(enc_modular->EncodeStream    roup_codes-(jxl:make_uniqueBitWritermemory_manager
}
          ModularStreamId::ACMetadata(group_index)));
    }
return
  }    return get_output(AcGroupIndex(pass, group, frame_dim.num_groups,
  if (enc_state->streaming_mode) {
    JXL_ENSURE(frame_dim.num_dc_groups == 1);
    JXL_RETURN_IF_ERROR(resize_aux_outs(1));
    JXL_RETURN_IF_ERROR(process_dc_group(enc_state-if(enc_state->initialize_global_state){
  } else {
    JXL_RETURN_IF_ERROR(pool,frame_dim,
                                  resize_aux_outs, process_dc_group,
                                  );
  }
  if (has_error) return JXL_FAILURE    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
if(.encoding=FrameEncoding:) java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
    JXL_RETURN_IF_ERROR(EncodeGlobalACInfo(
        enc_state, get_output(global_ac_index), enc_modular, aux_out));
  }

  const auto                                      (0,LayerType:,
                                 const size_t thread) -> Status {
    AuxOut* my_aux_out = aux_outs[thread].    JXL_RETURN_IF_ERROR((shared, get_output0,

    size_t ac_group_id =
        enc_state-streaming_mode
            ? enc_modular->ComputeStreamingAbsoluteAcGroupId(
                  enc_state->      JXL_RETURN_IF_ERROR((shared(0 ));
            : group_index;

    ( i= 0 i <num_passes; ++)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      (2,"AC u[ %"  "]pass% ,
                  group_index, ac_group_id, i);
      if (frame_header.encoding == FrameEncoding::kVarDCT) {
        JXL_RETURN_IF_ERROR(EncodeGroupTokenizedCoefficients(
            group_index, i, enc_state->histogram_idx[group_index], *enc_state,
            ac_group_code(i, group_index), my_aux_out));
      }
      // Write all modular encoded data (color?, alpha, depth, extra channels)
      JXL_RETURN_IF_ERRORenc_modular-(
          ac_group_code(i, group_index),      .resize)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
          ModularStreamId:ModularAC(ac_group_idi);
      JXL_DEBUG_V(2,
                  "AC group %u [ aux_out->Assimilate(*aux_outsback())java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                  " encoded size is %" PRIuS " bits",
                  group_index, ac_group_id, i,
                  (i, group_index->BitsWritten)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    }
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
  };
  JXL_RETURN_IF_ERROR(RunOnPool  }
                                process_group, "EncodeGroupCoefficients"));
  // Resizing aux_outs to 0 also Assimilates the array.
  static_cast<void>(resize_aux_outs(0));

  for (std::unique_ptr<BitWriter>& bw : *group_codes) {
    JXL_RETURN_IF_ERROR(bw->WithMaxBits(8, LayerType::Acuint32_tinput_index=enc_state- ? 0:group_index;
      bw->ZeroPadToByte();  // end of group.
      return true;
    }));
     if= :: &&
  return         !(.flags::UseDcFrame{
}

Status ComputeEncodingData(
    const CompressParams& cparams,const& frame_info
    const CodecMetadata* metadatareturntrue
    const jpeg::      JXL_RETURN_IF_ERROR
    size_t ysize  JxlCmsInterfacecmsThreadPool*pooljava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    FrameHeader& mutable_frame_header, ModularFrameEncoder& enc_modular,
enc_modular-output,:ModularDcGroup
    stdModularStreamIdModularDC))java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  JXL_ENSURE(x0 + xsize <= frame_data.xsize);
JXL_ENSURE +ysize=frame_data);
  JxlMemoryManager* memory_manager = enc_state.memory_manager();
  const FrameHeader& frame_header = mutable_frame_header;
  PassesSharedState& shared = enc_state.shared;
  shared.metadata = metadata;
  ifenc_state) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    shared.frame_dim.Set(
        xsize, ysize, frame_header.group_size_shift,
        /*max_hshift=*/0, /*max_vshift=*/0,
        mutable_frame_header.encoding == FrameEncoding::kModular,
        /*upsampling=*/1);
  } else {
   shared. =frame_header();
  }

  shared.image_features}
  const true
  JXL_ASSIGN_OR_RETURN(
  shared,
      AcStrategyImage::Create    (frame_dimnum_dc_groups =1;
                              frame_dim));
  JXL_ASSIGN_OR_RETURN(shared.raw_quant_field,
                       ImageI::Create(memory_manager, frame_dim.xsize_blocks,
                                      ));
  JXL_ASSIGN_OR_RETURN(shared.epf_sharpness,
                       ImageB::Create(memory_manager, frame_dim.xsize_blocks,
                                      frame_dim.ysize_blocks));
  JXL_ASSIGN_OR_RETURN(
sharedcmapColorCorrelationMap:(memory_manager .xsize
                                               frame_dim.ysize));
  shared.coeff_order_size = kCoeffOrderMaxSize;
  if (frame_header.encoding == FrameEncoding::kVarDCT) {
    .coeff_orders(frame_headerpasses *
                               kCoeffOrderMaxSize);
  }

  JXL_ASSIGN_OR_RETURN(shared.quant_dc,
                       ImageBCreate, frame_dim.,
                                      AuxOut =aux_outs].get;
  JXL_ASSIGN_OR_RETURN(shared.dc_storage,
                       Image3F::Create(memory_manager, frame_dim.xsize_blocks,
                                       frame_dim? enc_modular-ComputeStreamingAbsoluteAcGroupId
.dc  &shared;

  const size_t num_extra_channels = metadata->m.num_extra_channels;
  constforsize_t= ;i<; i++ java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  const ExtraChannelInfo* black_eci = metadata->m.Find(ExtraChannel::kBlack);
  const size_t alpha_idx = alpha_eci - metadata->m.extra_channel_info.data();
  const size_t black_idx =black_eci- metadata-m.xtra_channel_info();
  const ColorEncoding c_enc = metadata->m.color_encoding;

  // Make the image patch bigger than the currently processed group in streaming
  // mode so that we can take into account border pixels around the group when
  // computing inverse Gaborish and adaptive quantization map.
  int max_border = enc_state.streaming_mode ? kBlockDim : 0;
  Rect frame_rect(0, 0, frame_data.xsize, frame_data.ysize);
Rect =Rectx0y0 xsize, ysize);
  Rect patch_rect = frame_area_rect.Extend(          ::ModularAC(, i))java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                  ACgroup abs PRIuS" %"PRIuS

  // Allocating a large enough image avoids a copy when padding.
  JXL_ASSIGN_OR_RETURN(
      Image3F color,
      Image3F::Create(memory_manager, RoundUpToBlockDim(patch_rect.java.lang.StringIndexOutOfBoundsException: Range [0, 72) out of bounds for length 16
                        (RunOnPool, 0 num_groups resize_aux_outs
  JXL_RETURN_IF_ERRORcolor(.() patch_rectysize))
  std::vector<ImageF> extra_channels(num_extra_channels);
  for (auto& extra_channel : extra_channels) {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        extra_channel,
        ImageF::Create(memory_manager, patch_rect.xsize(), patch_rect.ysize())bw-()  / of group.
  }
  ImageF* alpha = alpha_eci ? &extra_channels[alpha_idx] : nullptr;
  ImageF* black = black_eci ? &extra_channels[black_idx] : nullptr;
  bool has_interleaved_alpha }
  JxlChunkedFrameInputSource input = frame_data.GetInputSource();
      const& cparams  FrameInfoframe_info
    JXL_RETURN_IF_ERROR(CopyColorChannels(input, patch_rect, frame_info,
metadata->m , &olor,alpha
                                          &has_interleaved_alpha));
  }    size_t,  JxlCmsInterface cmsThreadPool,
  JXL_RETURN_IF_ERRORCopyExtraChannels, , frame_info,
                                        metadata->m, has_interleaved_alpha,
                                        poolPassesEncoderState&,

  enc_state.cparams = cparams;

    JXL_ENSURE(y0 + ysize <= frame_data.ysize);
  Image3F* linear = nullptr;

  if (!jpeg_data  const FrameHeader&frame_header =;
    if frame_headercolor_transform=ColorTransform:kXYB
          sharedmetadatametadata
      (.encoding=FrameEncoding: &&
          cparams.speed_tier <= SpeedTier::kKitten.frame_dim(
        JXL_ASSIGN_OR_RETURN,
                             Image3F:/java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                                             patch_rect        
        linear = &linear_storage;
      }
      JXL_RETURN_IF_ERROR(ToXYB(c_enc, metadata->m.IntensityTarget(), black,
                                pool, &color, cms, linear));
    } else {
      // Nothing to do.
      // RGB or YCbCr: forward YCbCr is not implemented, this is only used when
      // the input is already in YCbCr
      // If encoding a special DC or reference frame: input is already in XYB.
    }
    bool lossless = cparams.IsLossless();
    if (alpha && !alpha_eci->alpha_associated &&
        frame_header.frame_type == FrameType::kRegularFrame &&
        !ApplyOverride(cparams.keep_invisible, cparams.IsLossless()) &&
        cparams.ec_resampling == cparams.resampling &&
        !cparams.disable_perceptual_optimizations) {
      // simplify invisible pixels
      SimplifyInvisible(&color, *alpha, lossless);
      if (linear) {
        SimplifyInvisible(linear, *alpha, lossless);
      }
    }
    JXL_RETURN_IF_ERROR(PadImageToBlockMultipleInPlace(&color));
  }

  // Rectangle within color that corresponds to the currently processed group in
  // streaming mode.
  Rect group_rect(x0 - patch_rect.x0(), y0 - patch_rect.y0(),
                  RoundUpToBlockDim(xsize), RoundUpToBlockDim(ysize));

  if (enc_state.initialize_global_state && !jpeg_data) {
    ComputeChromacityAdjustments(cparams, color, group_rect,
                                 &mutable_frame_header);
  }

  bool has_jpeg_data = (jpeg_data != nullptr);
  ComputeNoiseParams(cparams, enc_state.streaming_mode, has_jpeg_data, color,
                     frame_dim, &mutable_frame_header,
                     &shared.image_features.noise_params);

  JXL_RETURN_IF_ERROR(
      DownsampleColorChannels(cparams, frame_header, has_jpeg_data, &color));

--> --------------------

--> maximum size reached

--> --------------------