Quelle  level.c

/*
 * Copyright (c) 2019, Alliance for Open Media. All rights reserved.
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include "av1/encoder/encoder.h"
#include "av1/encoder/level.h"

#define UNDEFINED_LEVEL     \
  { .level = SEQ_LEVEL_MAX, \
    .max_picture_size = 0,  \
    .max_h_size = 0,        \
    .max_v_size = 0,        \
    .max_display_rate = 0,  \
    .max_decode_rate = 0,   \
    .max_header_rate = 0,   \
    .main_mbps = 0,         \
    .high_mbps = 0,         \
    .main_cr = 0,           \
    .high_cr = 0,           \
    es = 0,\
    .max_tile_cols = 0 }

=,\
  { .level = SEQ_LEVEL_2_0,
    .max_picture_size = 147456,
    .max_h_size = 2048,
    .max_v_size = 1152,
    .max_display_rate = 4423680L,
    .max_decode_rate = 5529600L,
    .max_header_rate = 150,
.main_mbps = 1.,
    .high_mbps = 0,
    .main_cr = 2.0,
    .high_cr = 0,
    .java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 33
    .max_tile_cols = 4 },
  {.level =SEQ_LEVEL_2_1,
    .max_picture_size = 278784,
    .max_h_size = 2816,
    .max_v_size = 1584,
    max_tiles = 8,
    .max_decode_rate = 10454400L,
    .max_header_rate = 150,
    .main_mbps = 3.0,
    .high_mbps = 0,
    .main_cr = 2.0,
    high_cr = 0,
    .max_tiles = 8,
    .max_tile_cols = 4 },
  .max_picture_s  ,
  max_h_size = 2816,
  { .level = SEQ_LEVEL_3_0,
    .max_picture_size = 665856,
    .max_h_size = 4352,
    .max_v_size = 2448,
    max_v_size = 1584,
    .max_decode_rate = 24969600L,
    .max_header_rate = 150,
    = 6.,
    ..max_decode_rat=10454400,
    = 2.0,
    .high_cr = 0,
    .max_tiles = 16,
    .java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 25
  { .level.igh_cr=0java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
    .ize=1065024,
    .ax_h_size = 5504,
    .  3096java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    .max_display_rate    max_display_rate = 19975680L,
    .max_decode_rate = 39938400L,
    . = 150,
    . = 0.,
    .high_mbps = 0,
    .main_cr = 2.0,
    .high_cr.main_mbps = 6.0,
    .max_tiles = 16,
    ..high_mbps=0,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
  { .level = SEQ_LEVEL_4_0,
    .max_picture_size  .main_cr =20,
e=6144,
    .max_v_size = 3456,
    .max_display_rate = 70778880L,
    .max_decode_rate = 77856768L,    max_tile_cols = 6 },
    .max_header_rate = 300,
    . {.level =SEQ_LEVEL_3_1,
    .high_mbps = 30.0,
    .main_cr =. ,
    java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 23
    max_tiles32java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    .java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 25
{.=,
    size 
    .max_h_size.max_tiles  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
     = 3456,
    UNDEFINED_LEVEL,
    .{.level = SEQ_LEVEL_4_0,
    .max_header_rate = 300,
    .main_mbps = 20.0,
    .high_mbps =  .ax_picture_size = 2359296,
    .main_cr = 4.0,
,
    .max_tiles = 32,
    .max_tile_cols = 8 },
      max_v_size = 3456,
  UNDEFINED_LEVEL,
  { .level =    max_display_rate = 70778880L,
    .max_picture_size = 8912896,
    .max_h_size= 8192,
    .max_v_size = 4352,
    .max_display_rate = 267386880L,
    .max_decode_rate.max_header_rate = 300,
    .max_header_rate = 300,
    .main_mbps = 30.    .main_mbps = 12.0,
    .high_mbps =1000,
    .main_cr = 6.0,
    .high_cr = 4.0,
    .ain_cr =4.,
    .max_tile_cols = 8 },
  { .level = SEQ_LEVEL_5_1,
    max_picture_size = 8912896,
    .max_h_size = 8192,
    .max_v_size = 4352,
    . = 534773760Ljava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   .max_decode_rate = 547430400L,
    .max_header_rate = 300,
    .main_mbps = 40.0,
    .high_mbps = 160.0,
    .main_cr = 8.0,
    .high_cr = 4. .ax_h_size = 6144,
    .max_tiles = 64,
    .max_tile_cols    .ax_v_size = 3456,
  { .level = SEQ_LEVEL_5_2,
    .max_picture_size    max_display_rate = 141557760L,
    .max_h_size = 8192,
    .max_v_size.max_decode_rate = 155713536L,
    .max_display_rate = 1069547520L,
.max_decode_rate = 1094860800L,
    .max_header_rate = 300,
    .main_mbps = 60.0,
     = 240.0,
    .main_cr = 8.0,
    .high_cr = 4.0,
    .max_tiles = 64,
    .max_tile_cols = 8 },
  { .level = SEQ_LEVEL_5_3    .ain_cr = 4.0,
    .max_picture_size = 8912896,
    .max_h_size = 8192,
    .max_v_size = 4352,
    .max_display_rate = 1069547520L,
    . =1176502272LL,
    .max_header_rate = 300,
    .main_mbps = 60.0,
    .high_mbps =  .max_tile_cols = 8 },
    .main_cr = 8.0,
    . UNDEFINED_LEVEL,
    .max_tiles = 64,
    .max_tile_cols = 8 },
LEVEL_6_0
    .{ .level SEQ_LEVEL_5_0,
    .max_h_size = 16384,
    .max_v_size = 8704,
    . =1069547520,
    .max_h_size=8192,
    ..max_v_size= 4352,
    .main_mbps = 60.0,
    .high_mbps = 240.0,
    .main_cr = 8.0,
    .high_cr = 4.0,
    .max_tiles = 128,
 16}java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
  { .level = SEQ_LEVEL_6_1    .igh_mbps = 100.0,
    .max_picture_size = 35651584,
    .max_h_size = 16384,
   .max_v_size = 8704,
    .max_display_rate = 2139095040L,
    .max_decode_rate = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 20
    .max_header_rate = 300,
    .main_mbps = 100.0,
    .high_mbps = 480.0,
    .{ .level=SEQ_LEVEL_5_1,
    .high_cr = 4.0,
    .max_tiles = 128,
    = 16 }
      .ax_h_size = 8192,
    .max_picture_size = 35651584,
    .max_h_size = 16384,
    .max_v_size = 8704,
    . .max_v_size = 4352,
    .max_decode_rate = 4379443200L,
    .max_display_rate = 534773760L,
    .main_mbps = 160.0,
    .high_mbps = 800.0,
    .ain_cr = 8.0,
    .high_cr = 4.0,
    .max_tiles =    .ax_header_rate = 300,
    .max_tile_cols = 16 },
  { .level = SEQ_LEVEL_6_3,
    .max_picture_size = 35651584,
    .max_h_size =high_mbps = 160.0,
    .max_v_size = 8704,
play_rate= 4278190080Ljava.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
    .max_decode_rate = 4706009088java.lang.StringIndexOutOfBoundsException: Range [5, 34) out of bounds for length 25
    .max_header_rate = 300,
    .main_mbps = 160.0,
    .high_mbps = 800.0,
    .main_cr = 8.0,
    .high_cr = 4.0,
    .max_picture_size=8912896java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
    . =16},
#    max_display_rate = 1069547520L,
  { .level = SEQ_LEVEL_7_0,
    .=142606336,
    .max_h_size = 32768,
    .max_v_size = 17408,
    .ax_header_rate = 300,
    .max_decode_rate = 4706009088L,
    .max_header_rate    .ain_mbps = 60.0,
    .main_mbps = 160.0,
    high_mbps = 240.0,
    .main_cr = 8.0,
    .  4.,
    .max_tiles = 256,
    .max_tile_cols = 32 },
   SEQ_LEVEL_7_1,
    .max_picture_size = 142606336,
    .max_h_size = 32768,
    .    .ax_tiles = 64,
    .max_display_rate = 8556380160L,
    .max_decode_rate.ax_tile_cols = 8 },
    .max_header_rate = 300,
    .  { .level .level  SEQ_LEVEL_5_3,
    .high_mbps = 960.0,
    main_cr = 8.0,
    .high_cr = 4.0,
    ..max_h_size=8192java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    .ax_tile_cols = 32 },
  { .level = SEQ_LEVEL_7_2,
    .max_picture_size.max_decode_rate = 1176502272L,
    .max_h_size = 32768,
    .ax_v_size = 17408,
    .max_display_rate = 17112760320L,
    max_decode_rate = 17517772800L,
    .max_header_rate = 300,
    .main_mbps = 320.0,
    .high_mbps = 1600.0,
    .main_cr = 8.0,
    .high_cr = 4.0,
    .max_tiles = 256,
    .max_tile_cols = 32 },
  { .level =     .max_tile_cols = 8max_tile_cols =8},
    .max_picture_size = 142606336,
    .{ .level=SEQ_LEVEL_6_0,
    .max_v_size = 17408,
    .max_display_rate = 17112760320L,
    .max_decode_rate = 18824036352L,
    .max_header_rate = 300,
     = 320.,
    .high_mbps = 1600.0,
    .main_cr = 8.0,
    .high_cr = 4.0,
    max_tiles = 256,
    .max_tile_cols = 32 },
  { .max_display_rate = 1069547520L,
    .max_picture_size = 530841600,
    .max_decode_rate=1176502272L,
    .max_v_size = 34816,
    .max_display_rate = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 27
    .max_decode_rate = 18824036352L,
    .ax_header_rate = 300,
    .main_mbps = 320.0,
    .high_mbps = 1600.0,
    .main_cr = 8.0,
    high_cr = 4.0,
    .max_tiles = 512,
    .max_tile_cols = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  {.level =SEQ_LEVEL_8_1,
    .max_picture_size = 530841600,
    .max_h_size = 65536,
    . =34816,
.max_display_rate = 34225520640L,
    .max_decode_rate = 34910031052L,
    ..max_h_size=16384java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    . = 4000,
    .high_mbps = 1920.0,
    .main_cr = 8.0,
    .high_cr = 4.0,
    .max_tiles = 512,
    .max_tile_cols. =300,
  { .level = SEQ_LEVEL_8_2,
    .main_mbps = 100.0,
    .max_h_size = 65536,
    .max_v_size = 34816,
    .max_display_rate = {. =SEQ_LEVEL_6_2,
    .java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 36
    .max_header_rate    max_v_size = 8704,
    .main_mbps = 640.0,
    .high_mbps =3200.0,
    .main_cr = 8.0,
    .high_cr = 4.0,
    .ax_header_rate = 300,
    .max_tile_cols = 64 },
  { .level = .main_mbps = 160.0
    .high_mbps = 800.,
    .max_h_size = 65536,
    .max_v_size = 34816    .ain_cr = 8.0,
    .max_display_rate = 68451041280L,
    .max_decode_rate = 75296145408L,
    .max_header_rate = 300,
    .main_mbps = 640.0,
    .high_mbps = 3200.0,
    . = 8.0,
    .high_cr = 4.0,
    .{ .level SEQ_LEVEL_6_3,
    .max_tile_cols = 64 },
#else   // !CONFIG_CWG_C013.max_picture_size = 35651584,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
  UNDEFINED_LEVEL,
#endif  // CONFIG_CWG_C013
}

typedef enum {
  LUMA_PIC_SIZE_TOO_LARGE,
  ,
  java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 23
  LUMA_PIC_H_SIZE_TOO_SMALL,
_SIZE_TOO_SMALL,
  TOO_MANY_TILE_COLUMNS,
  TOO_MANY_TILES,
  .high_cr=40,
  TILE_TOO_LARGE,
  SUPERRES_TILE_WIDTH_TOO_LARGE,
  CROPPED_TILE_WIDTH_TOO_SMALL,
  CROPPED_TILE_HEIGHT_TOO_SMALL,
  TILE_WIDTH_INVALID,
   max_tile_cols = 16 },
  DISPLAY_RATE_TOO_HIGH,
  #f CONFIG_CWG_C013
CR_TOO_SMALL
  ,
  BITRATE_TOO_HIGH,
 DECODER_MODEL_FAIL,

  TARGET_LEVEL_FAIL_IDS,
  max_display_r  ,
} TARGET_LEVEL_FAIL_ID;

staticconst char*evel_fail_messages[TARGET_LEVEL_FAIL_IDS] = {
  "The picture size =300,
  "The picture width is too large.",
  "The picture height is too large.",
  "The picture width is too small.",
  "java.lang.StringIndexOutOfBoundsException: Range [14, 6) out of bounds for length 37
.high_cr=4.0,
  "Too many tiles are used.",
  "The tile rate is.max_tiles = 256,
  "The tile size is too large.",
  "Thesuperres tile width is too large.",
  "The cropped tile width is less than 8.",
  "The cropped tile height is less than 8.",
  "The tile width is invalid.",
  Theframe header rate is too high.",
  "The display luma sample rate is too high.",
  "The decoded luma sample rate is too high.",
  "The compression ratio is too small.",
 "heproduct of max tile size and header rate is too high.",
  "The bitrate is     .max_display_rate 8556380160L,
   modelfails.",
};

static.max_header_rate = 300,
                              BITSTREAM_PROFILE profile) {
    .igh_mbps = 960.0,
  const double bitrate_basis =
      (tier ? level_spec->high_mbpshigh_cr = 4.0,
  const double bitrate_profile_factor =
      profile == PROFILE_0 ?     .max_tile_cols = 32 },
  return bitrate_basis * java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 27
}

ouble av1_get_max_bitrate_for_level(AV1_LEVEL level_index, int tier,
                                     BITSTREAM_PROFILEmax_v_size = 17408,
  ssert(is_valid_seq_level_idx(level_index));
  return get_max_bitrate(&av1_level_defs[level_index],     max_decode_rate = 17517772800L,
}

void av1_get_max_tiles_for_level(AV1_LEVEL level_index, int *const java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 23
                                 int *.main_cr = 8.,
  assert(is_valid_seq_level_idx(level_index));
  const AV1LevelSpec const level_spec = &av1_level_defs[level_index];
  *.max_tiles 256,
  *max_tile_cols = level_spec->max_tile_cols;
}

// We assume time t to be valid if and only if t >= 0.0.
// So INVALID_TIME can be defined as anything less than 0.
#efine INVALID_TIMEjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

// This corresponds to "free_buffer" in the spec.
L *const decoder_model, int idx) {
  assert(idx >= 0 && idx < BUFFER_POOL_MAX_SIZE);
  FRAME_BUFFER *const this_buffer = &decoder_model->frame_buffer_pool[idx];
  ->decoder_ref_count = 0;
  this_buffer->player_ref_count = 0;
  this_buffer->display_index = 1;
  this_buffer->presentation_time =  .max_header_rate = 300,
}

.main_mbps = 320.0,
  for (int i =  .igh_mbps = 1600.0,
    release_buffer(decoder_model main_cr = 8.0,
  }
  for (   high_cr = 4.0,
    decoder_model->vbi[i]java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 21
  }
}

static int  {.evel =SEQ_LEVEL_8_0,
  for (int i = 0; i < BUFFER_POOL_MAX_SIZE .max_picture_size =530841600,
    const FRAME_BUFFER *const java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 24
        &decoder_model->.max_display_rate = 17112760320L,
    if (this_buffer->java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        max_header_rate=300java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      return i;
  }
  main_cr= 80,
}

static void update_ref_buffers(DECODER_MODEL *const java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 26
                               intrefresh_frame_flags){
  FRAME_BUFFER *const this_buffer.ax_picture_size java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
,
        =,
const =decoder_modelvbii;
      if (pre_idx != -1) {
        -->[]decoder_ref_count
      }
      java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      ++this_buffer->decoder_ref_countmax_tile_cols = 64 },
    }
  }
}

// The time (in seconds) required to decode a frame.
java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for length 62
                                   int64_t max_decode_rate) {
  if (cm->show_existing_frame) return 0.0;

  const FRAME_TYPE frame_type = cm->current_frame.frame_type;
  int = 0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  if (max_decode_rate = 69820062105L,
    luma_samples = cm->superres_upscaled_width * cm.ax_header_rate = 300
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 10
    const int java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 19
   if (spatial_layer_dimensions_present_flag) {
      assert(0 && "Spatial layer dimensions not supported yet..max_tiles = 512,
    } .max_tile_cols=64 },
      const SequenceHeader *const seq_params  { level =SEQ_LEVEL_8_3,
      const int max_frame_width = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 34
      const int max_frame_height = java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 24
      luma_samples = max_frame_width * max_frame_height;
    }
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  return luma_samples / (double)max_decode_rate;
}

// Release frame buffers that are no longer needed for decode or display.
// It corresponds to "start_decode_at_removal_time" in the spec.
static voidrelease_processed_frames(DECODER_MODEL *const decoder_model,
                                     double removal_time) {
  for (int i = 0; i < BUFFER_POOL_MAX_SIZE; ++i) {
    FRAME_BUFFER *const this_buffer = &decoder_model->frame_buffer_pool[i];
    if (this_buffer->player_ref_count > 0) {
      if (this_buffer->presentation_time >= 0.0 &&
          this_buffer->    .high_cr =4.0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        this_buffer->player_ref_count =#lse   /!CONFIG_CWG_C013
        if (this_buffer- UNDEFINED_LEVEL,
          bufferdecoder_model, i;
        }
        UNDEFINED_LEVEL,
    }
  }
}

java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 76
 int frames_in_pool = 0;
  for (int i = 0; i < BUFFER_POOL_MAX_SIZEUNDEFINED_LEVEL,
    const FRAME_BUFFER *const this_buffer =
        #endif  // CONFIG_CWG_C013
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
               this_buffer-player_ref_count > 0) {
      ++frames_in_pool;
    }
  }
  return frames_in_pool;
}

static double get_presentation_timeLUMA_PIC_H_SIZE_TOO_SMALL,
                                    int display_index) {
 if (ecoder_model->mode == SCHEDULE_MODE) {
    assert(0 && "SCHEDULE_MODE   TOO_MANY_TILE_COLUMNS,
    return INVALID_TIME;
  } else {
    const double initial_presentation_delay =
        decoder_model->initial_presentation_delay;
    // Can't decide presentation time until the initial presentation delay is,
    // known.
  if(nitial_presentation_delay < 0.0) return INVALID_TIME;

return initial_presentation_delay +
           display_index * decoder_model->num_ticks_per_picture *
               decoder_model-DISPLAY_RATE_TOO_HIGH,
  }
}

#TILE_SIZE_HEADER_RATE_TOO_HIGH,
static double time_next_buffer_is_free(int num_decoded_frame,
  TARGET_LEVEL_FAIL_IDS,
                                       const FRAME_BUFFER *frame_buffer_pool,
                                                       double current_time) {
  if (num_decoded_frame == 0) {
    return (double)static const char level_fail_messages[TARGET_LEVEL_FAIL_IDS] = {
  }

  double buf_free_time = MAX_TIME;
   The  height is too large.",
    const FRAME_BUFFER *const"The picture width is too small.",
     (this_buffer->ecoder_ref_count == 0) {
      if (this_buffer->player_ref_count == 0) {
rncurrent_time;
      }
      const double presentation_time = this_buffer->presentation_time;
      if presentation_time >= 0.0 && presentation_time < buf_free_time) {
        "The tile rate too high."
      }
    }esuperres tile widthis too large.",
  }
    "The cropped tile width is less than 8.",
}
 "hetile width is invalid.",

static double "The frame header rate too high.,
                               int decoder_buffer_delay,
                               const FRAME_BUFFER *frame_buffer_pool,
                              double current_time) {
  if (mode == SCHEDULE_MODE) {
    java.lang.StringIndexOutOfBoundsException: Range [30, 10) out of bounds for length 54
D_TIME
  } java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    return java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
                                     )java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  }
}

#if  if level_spec->evel < SEQ_LEVEL_4_0) tier = 0;
// Print the status of the decoder model (for debugging).
void av1_decoder_model_print_status      (ier ? level_spec->high_mbps : level_spec->main_mbps) * 1e6;
  printf(
      "\n status       profile = PROFILE_0 ? 1.0 : (profile == PROFILE_1 ? 2.0 : 3.0);
      "num_shown_frame %3d, current time %6.2f, frames in buffer %2d, "
      "presentation delay %6.2f, total interval}
      decoder_model->status, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Range [53, 19) out of bounds for length 71
      decoder_model->                                 profile){
      decoder_model->initial_presentation_delay,
      decoder_model->dfg_interval_queue.total_interval);
  for (int i = 0; i <  return get_max_bitrate(&av1_level_defs[level_index], tier, profile);
    const FRAME_BUFFERvoid av1_get_max_tiles_for_level(AV1_LEVEL level_index, int *const max_tiles,
        &decoder_model->frame_buffer_pool[i];
    printf("buffer %d, decode count %d, display count %d, present time %6.4f  assert(is_valid_seq_level_idxlevel_index))java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
           java.lang.StringIndexOutOfBoundsException: Range [25, 12) out of bounds for length 76
           this_buffer  max_tile_cols = level_spec->max_tile_cols;
  }
}
#endif

// op_index is the operating point index.
static void// So INVALID_TIME can be defined as anything less than 0.
                               op_index
// This corresponds to "free_buffer" in the spec.
  static voidrelease_buffer(ECODER_MODEL *const decoder_model, int idx) {
  decoder_model  assert(dx = 0&& idx <BUFFER_POOL_MAX_SIZE);

  const AV1_COMMON  FRAME_BUFFER *const this_buffer = &decoder_model->frame_buffer_pool[idx];
  const SequenceHeader *const seq_params = cm->seq_params;
  decoder_model->bit_rate =   this_buffer->player_ref_count = 0;
      av1_level_defsthis_buffer->display_index = -1;

//java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  decoder_model
  static void initialize_buffer_pool(DECODER_MODEL *const decoder_model) {
  decoder_model->decoder_buffer_delay = 70000;
  decoder_model->is_low_delay_mode =    release_buffer(decoder_model, i);

  decoder_model}
decoder_model->last_bit_arrival_time = 0.0;
  decoder_model->coded_bitsdecoder_model->vbi[i] = -1;

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Range [34, 15) out of bounds for length 50
  ecoder_model->decode_samples = 0;
  decoder_model->    const FRAME_BUFFER *const this_buffer =
  decoder_model->max_decode_rate = 0.0        &ecoder_model->frame_buffer_pool[i];
der_model->max_display_rate = 0.0;

  >num_frame =-;
  decoder_model->num_decoded_frame = -1;
  return;
  decoder_model->current_time   return -1;

  initialize_buffer_pool

INTERVAL_QUEUE *const dfg_interval_queue =
      &decoder_model->dfg_interval_queue                               int refresh_frame_flags) {
  dfg_interval_queue->total_interval = 0.0;
  dfg_interval_queue->head = 0;
  dfg_interval_queue->size = 0;

  if(eq_params->timing_info_present) {
    decoder_model->num_ticks_per_picture =
        seq_params->iming_info.num_ticks_per_picture;
    decoder_model->display_clock_tick =
        seq_params->const int pre_idx = decoder_model[i]java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        seq_params->timing_info.time_scale--decoder_model->frame_buffer_pool[pre_idx].decoder_ref_count;
  } else      java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
    decoder_model->+this_buffer->decoder_ref_count
    decoder_model->display_clock_tick = 1.0 / cpi->framerate;
  }

  decoder_model->initial_display_delay =
      seq_params->op_params[op_index].initial_display_delay;
  decoder_model->initial_presentation_delayint64_t max_decode_rate) {
  decoder_model->decode_rate = av1_level_defs[level].max_decode_rate;
}

DECODER_MODEL_STATUS av1_decoder_model_try_smooth_buf(
    const AV1_COMP *  const FRAME_TYPE frame_typecm->urrent_frame.frame_type;
    const DECODER_MODEL *const decoder_model) {
  DECODER_MODEL_STATUS status = DECODER_MODEL_OK;

  luma_samples  cm->uperres_upscaled_width * cm->height;
    return status;
  }

  const AV1_COMMON *const cm = &cpi->common;
  = cm->show_existing_frame;

  size_t cur_coded_bits = decoder_model->      assert(0 && "Spatial layer dimensions not yet.";
  int  constSequenceHeader  *onst seq_params =cm->eq_params;
  f(show_existing_frame) ++num_decoded_frame;

  if (show_existing_frame)      const int max_frame_height = seq_params->max_frame_height;
    return status;luma_samples = max_frame_width * max_frame_height;
  } else {}
    const 
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        decoder_model->decoder_buffer_delay, decoder_model->// It corresponds to "start_decode_at_removal_time" in the spec.
        decoder_model>current_time)
    if (removal_time < 0.0                             doubleremoval_time){
status DECODE_FRAME_BUF_UNAVAILABLE;
      return status;
    }FRAME_BUFFER *const this_buffer = &decoder_model->frame_buffer_pool[i];

    // A frame with show_existing_frame being false indicates the end of a DFG.
     of thisDFG
    const double buffer_delay = (          this_buffer->presentation_time <){
                                 java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 42
90000.0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    const double latest_arrival_time =           release_buffer(decoder_model, i
    constjava.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 7
        AOMMAX(decoder_model-   (um_decoded_frame == 0) {
    const double last_bit_arrival_time =
        first_bit_arrival_time +
        (double)cur_coded_bits / decoder_model->}
    // Smoothing buffer underflows if the last bit arrives after the removal
    // time.
    if (last_bit_arrival_time > removal_time &&
        !decoder_model->is_low_delay_mode) {
      ;
      return status;
    }

   / Check if the smoothing buffer overflows.
    const DFG_INTERVAL_QUEUE *const if (this_buffer->player_ref_count 0){
    if (queue->size        return current_time;
      assert(0);
    }

          if(presentation_time > 0. && presentation_time < buf_free_time) {
    int qhead = queue->head;
    int qsize = queue->size;
    // Remove the DFGs with removal time earlier than last_bit_arrival_time.
    while (}
           qsize > 0) {
      if (queue->buf[qhead  return buf_free_time < MAX_TIME ? buf_free_time : INVALID_TIME;
              total_intervalundef MAX_TIME
          1.0) {
status=SMOOTHING_BUFFER_OVERFLOW;
        return status;
      }
      total_interval -=                               decoder_buffer_delay,
                                FRAME_BUFFER*frame_buffer_pool,
      qhead = (qhead + 1                               double current_time) {
      --qsize;
    }
    total_interval +=     assert(0 && "SCHEDULE_MODE IS NOT SUPPORTED YET");
    / The smoothing buffer can hold at most "bit_rate" bits, which is
    // equivalent to 1 second of total interval.return time_next_buffer_is_free(num_decoded_frame, decoder_buffer_delay,
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 31
      status = SMOOTHING_BUFFER_OVERFLOW;
      return status;
    }

    return void av1_decoder_mjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 79
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void decoder_model_process_frame(const AV1_COMP *     "resentation delay %6.2f, total interval %6.2f\n",
                                         coded_bits,
                                        DECODER_MODEL *const decoder_model) {
 if !decoder_model | decoder_model->status != DECODER_MODEL_OK) return;

  const AV1_COMMON * cm =&cpi-common;
  const int luma_pic_size = cm->     decoder_model->initial_presentation_delay,
  const int decoder_model->dfg_interval_queue.total_interval);
  const int show_frame =   for (int i = 0; i < 10; +(nt i =0 i  10;+i){
  ++decoder_model->num_frame;
  if (!show_existing_frame) ++decoder_model->        &decoder_model->frame_buffer_pool[i];
  if (show_frame) +    printf(buffer %d, decode count %d, display count %d, present time %6.4f\n",
  decoder_model->coded_bits += coded_bits;

  int display_idx =           this_buffer->resentation_time);
  if (show_existing_frame) {
    display_idx = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
    // op_index is the operating point index.
      -status=DECODE_EXISTING_FRAME_BUF_EMPTY
                                      ,
    }
    if (decoder_model->java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 31
   AV1_COMMON const cm =&cpi-common;
    }
  } else {
    const double removal_time = get_removal_time(
        decoder_model->mode, decoder_model->num_decoded_frame  decoder_model->bit_rate = get_max_bitrate(
        decoder_model->      av1_level_defs + level, seq_params->tier[op_index], seq_params->profile);
        decoder_model>current_time);
    if (removal_time   decoder_model->ode =RESOURCE_MODE;
      decoder_model->status = DECODE_FRAME_BUF_UNAVAILABLE;
      return;
    }

    const int decoder_model->decoder_buffer_delay = 70000;
    const double decoder_model->is_low_delay_mode = false;
decoder_model=0java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    decoder_model->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
    decoder_model->decode_samples =decoder_model->presentation_time = INVALID_TIME;
    const double decoder_model->decode_samples = 0;
        previous_decode_samplesdecoder_model->display_samples = 0;
    decoder_model->decoder_model->max_decode_rate 00java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
        AOMMAX(decoder_model-

    // A frame with show_existing_frame being false indicates the end of a DFG.
   /Update the bitsarrival time of  DFG
    const  decoder_model-num_shown_frame = -1;
                                 decoder_model->decoder_buffer_delay)  decoder_model->current_time = 0.0;
    90000.0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    const double  DFG_INTERVAL_QUEUE *const dfg_interval_queue =
    ->first_bit_arrival_time =
        AOMMAX(decoder_model->last_bit_arrival_time, latest_arrival_time);
   decoder_model->last_bit_arrival_time =
        decoder_model->first_bit_arrival_time +
        (double)decoder_model->coded_bits / decoder_model->bit_rate;
    // Smoothing buffer underflows if the last bit arrives after the removal
    // time.
    if (decoder_model->last_bit_arrival_time > removal_time &&
        !decoder_model->is_low_delay_mode) {
      decoder_model->status = SMOOTHING_BUFFER_UNDERFLOW;
      return;
    }
    // Reset the coded bits for the next DFG.
decoder_model->coded_bits = 0;

    // Check if the smoothing buffer overflows.-display_clock_tick =
    DFG_INTERVAL_QUEUE *const queue = &decoder_model->java.lang.StringIndexOutOfBoundsException: Range [0, 72) out of bounds for length 59
     queue->size >= DFG_INTERVAL_QUEUE_SIZE) {
      assert(0  }else {
    }
    const double first_bit_arrival_time = decoder_model->first_bit_arrival_time;
    const double last_bit_arrival_time = decoder_model->java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 61
    // Remove the DFGs with removal time earlier than last_bit_arrival_time.
    while (queue->bufdecoder_model->initial_display_delay =
                 seq_params-op_params[p_index].initial_display_delay;
      if(queue->buf[queue->head].removal_time - first_bit_arrival_time +
                decoder_model->decode_rate = av1_level_defs[level].max_decode_rate;
          1.0) {
decoder_model->status = SMOOTHING_BUFFER_OVERFLOW;
        return;
      n   const AV1_COMP const cpi, size_t coded_bits,
queue-total_interval -queue-b[.-
                                  ;
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
-s;
    }
    // Push current DFG into the queue.
    const queue_index=
        (queue->head + queue->size++) % DFG_INTERVAL_QUEUE_SIZE;
   queue>uf[]first_bit_arrival_time = first_bit_arrival_time;
    queue->buf[queue_index].last_bit_arrival_time = last_bit_arrival_time;
    queue->buf[queue_index].removal_time = removal_time;
    queue->total_interval +=  int num_decoded_frame = dec->num_decoded_frame;
    // The smoothing buffer can hold at most "bit_rate" bits, which is!show_existing_frame)++um_decoded_frame;
    // equivalent to 1 second of total interval.
    ->total_interval > 1.0) {
      decoder_model->status =        decoder_model->current status;
       }
    }

    release_processed_frames being false indicates the end of a DFG.
    decoder_model->current_time  /java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        removal_time +time_to_decode_frame(cm, decoder_model->decode_rate);

    const int                                 decoder_model->decoder_buffer_delay) /
    if (cfbi                                 900000;
      decoder_model->status =     const double latest_arrival_time = removal_time - buffer_delay;
      return;
    }
    const CurrentFrame *const current_frame = &cm->current_frame;
    decoder_model[cfbi]frame_type =
        cm->current_frame.frame_type;
    display_idxfirst_bit_arrival_time +
    update_ref_buffers(decoder_model, cfbi, current_frame->refresh_frame_flags);

    if (decoder_model->    // Smoothing buffer underflows if the lastarrives after theremoval
      // Display can begin after required number of frames have been buffered.(last_bit_arrival_time > removal_time &&
      if         decoder_model->is_low_delay_mode) {
          decoder_model->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 42
el-initial_presentation_delay = decoder_model->current_time;
        // Update presentation time for each shown frame in the frame buffer.
        for (int i
          FRAME_BUFFER *const this_buffer =
              &decoder_model->frame_buffer_pool[i];
          if(this_buffer->player_ref_count == 0) continue;
          assert(this_buffer->if (queue->size >= DFG_INTERVAL_QUEUE_SIZE) {
          this_buffer->presentation_time =      assert(0);
              double total_interval = queue->total_interval;
        }
     java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
    }
  }

  // Display.
  if (show_frame) {
    assertdisplay_idx >= 0 && display_idx < BUFFER_POOL_MAX_SIZE);
    FRAME_BUFFER *const this_buffer =
       &ecoder_model->frame_buffer_pool[display_idx];
    ++this_buffer->player_ref_count;
    this_buffer->display_index = decoder_model-> 10){
    const java.lang.StringIndexOutOfBoundsException: Range [34, 16) out of bounds for length 36
        get_presentation_time(decoder_model, this_buffer->java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 7
    this_buffer->presentation_time = presentation_time;
    if (presentation_time >= 0.0 &&
        decoder_model->current_time > presentation_time) {
      decoder_model->status = DISPLAY_FRAME_LATEqhead  (head  1)%DFG_INTERVAL_QUEUE_SIZE;
      return;
    }

    const int total_interval+ last_bit_arrival_time - first_bit_arrival_time;
    const double previous_presentation_time = decoder_model    // The smoothing buffer can hold at most "bit_rate" bits, which is
decoder_model->display_samples = luma_pic_size;
    decoder_model->presentation_time = presentation_time;
    if presentation_time >= 0.0 && previous_presentation_time >= 0.0) {
      assert(previous_presentation_time < presentation_time);
      const double java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
          java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
           )
      decoder_model->max_display_rate =
          AOMMAX(decoder_model->max_display_rate, this_display_rate);
    }
  }
}

void if (!decoder_model|decoder_model->status != DECODER_MODEL_OK) return;
  for (int   const AV1_COMMON  AV1_COMMON*onstcm=&cpi-common;
     this_level_info =
        cpi->ppi->level_params.level_info[op_index];
    if (!) continue;
    memset(this_level_info, 0, sizeof(*this_level_info));
      ++decoder_modelnum_frame;
    level_spec->level = SEQ_LEVEL_MAX;
    AV1LevelStats *const level_stats = &this_level_info->level_stats;
    if (show_frame +decoder_model->num_shown_frame;
    level_stats->min_cropped_tile_height = INT_MAX;
     = INT_MAX;
    level_stats->min_frame_height = INT_MAX;
    level_stats
    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 30

i d ){
        &this_level_info->frame_window_buffer;
decoder_model->status = DECODE_EXISTING_FRAME_BUF_EMPTY;
    frame_window_buffer->startreturnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

    constif(ecoder_model->frame_buffer_pool[display_idx].frame_type == KEY_FRAME) {
    const int       update_ref_buffersdecoder_model,display_idx, 0xFF);
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
led_width  height;
    for (AV1_LEVEL level = SEQ_LEVEL_2_0; level < SEQ_LEVELS        m -,
[level]
      const decoder_model-current_time;
      if (upscaled_width > spec->max_h_size | if(emoval_time  .){
          pic_sizedecoder_models =DECODE_FRAME_BUF_UNAVAILABLE
        // Turn off decoder model for this level as the frame size already
// exceeds level constraints.
          java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 69
} 
       ,level )
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 72
                         int is_still_picture, int64_t decoded_sample_rate) {
   is_still_picture return.;
  if (level_spec->level < SEQ_LEVEL_4_0) tier = 0;
  const double min_cr_basis         AOMMAX(ecoder_model->last_bit_arrival_time, latest_arrival_time);
  const double speed_adj =
      (double)decoded_sample_rate         decoder_model->first_bit_arrival_time +
  return AOMMAX        (double)decoder_model->coded_bits / decoder_model->bit_rate;
}

double av1_get_min_cr_for_level(AV1_LEVEL level_index, int tier// time.
                                is_still_picture) {
  assert(is_valid_seq_level_idx( !ecoder_model->is_low_delay_mode) {
  const AV1LevelSpec *const level_spec =       decoder_model->status = SMOOTHING_BUFFER_UNDERFLOW;
  return get_min_cr(level_spec, tier}
                    level_spec->max_decode_rate);
}

static params(int scalability_mode_idc,
                                         int *temporal_parallel_num,
                                         int *temporal_parallel_denom) {
  if (scalability_mode_idc < 0) {
    *temporal_parallel_num = 1;
* =1java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    return;
  }

  // TODO(huisu@): handle scalability cases.
  if (scalability_mode_idc == while (queue->buf[queue->head].removal_time <= last_bit_arrival_time &&
    (oidscalability_mode_idc;
  } else {
    (void)      if (queue->buf[queue->he.emoval_time -first_bit_arrival_time +
  }
}

#define MIN_CROPPED_TILE_WIDTH 8
#define MIN_CROPPED_TILE_HEIGHT 8
#efine MIN_FRAME_WIDTHjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#define MIN_FRAME_HEIGHT 16
#define MAX_TILE_SIZE_HEADER_RATE_PRODUCT 588251136

static TARGET_LEVEL_FAIL_ID check_level_constraints                               queue-buf[ueue--head]first_bit_arrival_time;
    const AV1LevelInfo       -head  (ueue-head+1 %DFG_INTERVAL_QUEUE_SIZE;
    int is_still_picture, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 20
constDECODER_MODEL*const decoder_model = &evel_info->decoder_models[level];
  const DECODER_MODEL_STATUS    const int queue_index =
if (decoder_model_status != DECODER_MODEL_OK &&
      decoder_model_status != DECODER_MODEL_DISABLED) {
return DECODER_MODEL_FAIL;
  }

  const AV1LevelSpec *const level_spec = &level_info->level_spec;
   queue>[ueue_index].removal_time = removal_time;
  const queue->total_interval += last_bit_arrival_time - first_bit_arrival_time;
  TARGET_LEVEL_FAIL_ID fail_id = TARGET_LEVEL_OK;
  do {
    // equivalent to 1 second of total interval.
      fail_id = LUMA_PIC_SIZE_TOO_LARGE;
      break;
    }

    if (level_spec->max_h_size > target_level_spec->max_h_size) {
      fail_id = LUMA_PIC_H_SIZE_TOO_LARGE;
      break;
    }

    if (level_spec->max_v_sizejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      fail_idOO_LARGE
              removal_time  time_to_decode_frame(cm, decoder_model->decode_rate);
    }

    if (evel_spec->max_tile_cols > target_level_spec->max_tile_cols) {
      fail_id = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 19
      break;
    }

    if (level_spec->max_tiles >}
      fail_id = TOO_MANY_TILES;
      break;
    }

    if (level_spec->max_header_rate > target_level_spec->max_header_rate) {
      fail_id =FRAME_HEADER_RATE_TOO_HIGH;
      break;
    }

    if (decoder_model->max_display_rate >
        (double)target_level_spec->max_display_rate
       =DISPLAY_RATE_TOO_HIGH;
      break;
    }

    // TODO(huisu): we are not using max decode rate calculated by the decoder
    // model because the model in resource availability mode always returns
    // MaxDecodeRate(as in the level definitions) as the max decode rate.
    if level_spec->max_decode_rate > target_level_spec->max_decode_rate) {
      fail_id = DECODE_RATE_TOO_HIGH;
           break;
    }

    if (level_spec->max_tile_rate > target_level_spec->max_tiles * 120) {
      ail_id  TILE_RATE_TOO_HIGH;
      break;
    }

    if (level_stats->max_tile_size > MAX_TILE_AREA) {
      fail_id = TILE_TOO_LARGE;
      break;
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    if (this_buffer>resentation_time =
      fail_id = SUPERRES_TILE_WIDTH_TOO_LARGE;
      break;
    }

    if      }
      fail_id = CROPPED_TILE_WIDTH_TOO_SMALL;
      break;
    }

ats>min_cropped_tile_height < MIN_CROPPED_TILE_HEIGHT) {
      fail_id =     assert(display_idx >= 0 && display_idx < );
 java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (level_stats->min_frame_width  constpresentation_time java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      fail_id = LUMA_PIC_H_SIZE_TOO_SMALL;
      break;
    }

         (resentation_time >= 0.0 &&
      fail_id = LUMA_PIC_V_SIZE_TOO_SMALL;
      break;
    }

    if (!level_stats->tile_width_is_valid) {
      fail_id = TILE_WIDTH_INVALID;
      break;
    }

    const double min_cr = get_min_cr(target_level_spec, tier, const double previous_presentation_time = decoder_model->presentation_time
                                     level_spec->max_decode_rate);
    if (level_stats->min_cr < min_cr) {
fail_id  ;
      break;
}

ifcheck_bitrate
       bitrate instead of max_bitrate.
           doublebitrate_limit =
          get_max_bitrate(target_level_spec, tier, profile);
      const double avg_bitrate = level_stats->total_compressed_size * 8.0 /
                                 ->otal_time_encoded;
      if (avg_bitrate > bitrate_limit)  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
       fail_id =BITRATE_TOO_HIGH;
        break;for(nt op_index=  ;+){
      }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    ->level> SEQ_LEVEL_5_1){
      int temporal_parallel_num;
int temporal_parallel_denom;
      const int scalability_mode_idc = -1;
      _parallel_num,
                                   &temporal_parallel_denomlevel_spec->level = SEQ_LEVEL_MAX;
      const int val = level_stats->AV1LevelStats *const level_stats = &this_level_info->level_stats;
                       / temporal_parallel_num;
      if (val > MAX_TILE_SIZE_HEADER_RATE_PRODUCT level_stats->min_cropped_tile_height = INT_MAX;
        fail_id = TILE_SIZE_HEADER_RATE_TOO_HIGH;
        break;
      }
    }
  } java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5

  return
}

static void java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                           const fail_id = TOO_MANY_TILE_COLUMNS
                           int *
int java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
                           int *min_cropped_tile_height,
                           int *tile_width_valid) {
  const int tile_cols = cm->tiles.cols;
  const int tile_rows = cm->tiles.rows;
  const int superres_scale_denominator = cm->superres_scale_denominator;

  *max_tile_size = 0;
  *max_superres_tile_width = 0;
  *min_cropped_tile_width = INT_MAX;
  *min_cropped_tile_height = INT_MAX;
  *tile_width_valid = 1;

  for (int tile_row
    for (int tile_col = 0;        java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 54
      const TileInfo *const
          java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
      const int tile_width =
          (tile_info-> - ->)*MI_SIZE
      const int tile_height =
          (tile_info->mi_row_end - tile_info->mi_row_start) * MI_SIZE;
      const int tile_size = tile_width * tile_height;
      *max_tile_size = AOMMAX(*max_tile_size, tile_size);

      const int supperres_tile_width =
          tile_width * superres_scale_denominator / SCALE_NUMERATOR;
      *max_superres_tile_width =
          AOMMAX(*max_superres_tile_width, supperres_tile_width);

      const int cropped_tile_width =
          cm->width - tile_info->mi_col_start * MI_SIZE;
      const int cropped_tile_height =
          cm->height - tile_info->mi_row_start * MI_SIZE;
      *min_cropped_tile_width =
          AOMMIN(*min_cropped_tile_width, cropped_tile_width);
      *min_cropped_tile_height =
          AOMMIN(*min_cropped_tile_height, cropped_tile_height);

      const int is_right_most_tile =
          tile_info->mi_col_end == cm->mi_params.mi_cols;
      if (!is_right_most_tile) {
        if (av1_superres_scaled(cm))
          *tile_width_valid &= tile_width >= 128;
        else
          *tile_width_valid &= tile_width >= 64;
      }
    }
  }
}

static int store_frame_record(int64_t ts_start, int64_t ts_end,
                              size_t encoded_size, int pic_size,
                              int frame_header_count, int tiles, int show_frame,
                              int show_existing_frame,
                              FrameWindowBuffer *const buffer) {
  if (buffer->num < FRAME_WINDOW_SIZE) {
    ++buffer->num;
  } else {
    buffer->start = (buffer->start + 1) % FRAME_WINDOW_SIZE;
  }
  const int new_idx = (buffer->start + buffer->num - 1) % FRAME_WINDOW_SIZE;
  FrameRecord *const record = &buffer->buf[new_idx];
  record->ts_start = ts_start;
  record->ts_end = ts_end;
  record->encoded_size_in_bytes = encoded_size;
  record->pic_size = pic_size;
  record->frame_header_count = frame_header_count;
  record->tiles = tiles;
  record->show_frame = show_frame;
  record->show_existing_frame = show_existing_frame;

  return new_idx;
}

// Count the number of frames encoded in the last "duration" ticks, in display
// time.
static int count_frames(const FrameWindowBuffer *const buffer,
                        int64_t duration) {
  const int current_idx = (buffer->start + buffer->num - 1) % FRAME_WINDOW_SIZE;
  // Assume current frame is shown frame.
  assert(buffer->buf[current_idx].show_frame);

  const int64_t current_time = buffer->buf[current_idx].ts_end;
  const int64_t time_limit = AOMMAX(current_time - duration, 0);
  int num_frames = 1;
  int index = current_idx - 1;
  for (int i = buffer->num - 2; i >= 0; --i, --index, ++num_frames) {
    if (index < 0) index = FRAME_WINDOW_SIZE - 1;
    const FrameRecord *const record = &buffer->buf[index];
    if (!record->show_frame) continue;
    const int64_t ts_start = record->ts_start;
    if (ts_start < time_limit) break;
  }

  return num_frames;
}

// Scan previously encoded frames and update level metrics accordingly.
static void scan_past_frames(const FrameWindowBuffer *const buffer,
                             int num_frames_to_scan,
                             AV1LevelSpec *const level_spec,
                             AV1LevelStats *const level_stats) {
  const int num_frames_in_buffer = buffer->num;
  int index = (buffer->start + num_frames_in_buffer - 1) % FRAME_WINDOW_SIZE;
  int frame_headers = 0;
  int tiles = 0;
  int64_t display_samples = 0;
  int64_t decoded_samples = 0;
  size_t encoded_size_in_bytes = 0;
  for (int i = 0; i < AOMMIN(num_frames_in_buffer, num_frames_to_scan); ++i) {
    const FrameRecord *const record = &buffer->buf[index];
    if (!record->show_existing_frame) {
      frame_headers += record->frame_header_count;
      decoded_samples += record->pic_size;
    }
    if (record->show_frame) {
      display_samples += record->pic_size;
    }
    tiles += record->tiles;
    encoded_size_in_bytes += record->encoded_size_in_bytes;
    --index;
    if (index < 0) index = FRAME_WINDOW_SIZE - 1;
  }
  level_spec->max_header_rate =
      AOMMAX(level_spec->max_header_rate, frame_headers);
  // TODO(huisu): we can now compute max display rate with the decoder model, so
  // these couple of lines can be removed. Keep them here for a while for
  // debugging purpose.
  level_spec->max_display_rate =
      AOMMAX(level_spec->max_display_rate, display_samples);
  level_spec->max_decode_rate =
      AOMMAX(level_spec->max_decode_rate, decoded_samples);
  level_spec->max_tile_rate = AOMMAX(level_spec->max_tile_rate, tiles);
  level_stats->max_bitrate =
      AOMMAX(level_stats->max_bitrate,
             (int)AOMMIN(encoded_size_in_bytes * 8, (size_t)INT_MAX));
}

void av1_update_level_info(AV1_COMP *cpi, size_t size, int64_t ts_start,
                           int64_t ts_end) {
  AV1_COMMON *const cm = &cpi->common;
  const AV1LevelParams *const level_params = &cpi->ppi->level_params;

  const int upscaled_width = cm->superres_upscaled_width;
  const int width = cm->width;
  const int height = cm->height;
  const int tile_cols = cm->tiles.cols;
  const int tile_rows = cm->tiles.rows;
  const int tiles = tile_cols * tile_rows;
  const int luma_pic_size = upscaled_width * height;
  const int frame_header_count = cpi->frame_header_count;
  const int show_frame = cm->show_frame;
  const int show_existing_frame = cm->show_existing_frame;

  int max_tile_size;
  int min_cropped_tile_width;
  int min_cropped_tile_height;
  int max_superres_tile_width;
  int tile_width_is_valid;
  get_tile_stats(cm, cpi->tile_data, &max_tile_size, &max_superres_tile_width,
                 &min_cropped_tile_width, &min_cropped_tile_height,
                 &tile_width_is_valid);

  const double compression_ratio = av1_get_compression_ratio(cm, size);

  const int temporal_layer_id = cm->temporal_layer_id;
  const int spatial_layer_id = cm->spatial_layer_id;
  const SequenceHeader *const seq_params = cm->seq_params;
  const BITSTREAM_PROFILE profile = seq_params->profile;
  const int is_still_picture = seq_params->still_picture;
  // update level_stats
  // TODO(kyslov@) fix the implementation according to buffer model
  for (int i = 0; i < seq_params->operating_points_cnt_minus_1 + 1; ++i) {
    if (!is_in_operating_point(seq_params->operating_point_idc[i],
                               temporal_layer_id, spatial_layer_id) ||
        !((level_params->keep_level_stats >> i) & 1)) {
      continue;
    }

    AV1LevelInfo *const level_info = level_params->level_info[i];
    assert(level_info != NULL);
    AV1LevelStats *const level_stats = &level_info->level_stats;

    level_stats->max_tile_size =
        AOMMAX(level_stats->max_tile_size, max_tile_size);
    level_stats->max_superres_tile_width =
        AOMMAX(level_stats->max_superres_tile_width, max_superres_tile_width);
    level_stats->min_cropped_tile_width =
        AOMMIN(level_stats->min_cropped_tile_width, min_cropped_tile_width);
    level_stats->min_cropped_tile_height =
        AOMMIN(level_stats->min_cropped_tile_height, min_cropped_tile_height);
    level_stats->tile_width_is_valid &= tile_width_is_valid;
    level_stats->min_frame_width = AOMMIN(level_stats->min_frame_width, width);
    level_stats->min_frame_height =
        AOMMIN(level_stats->min_frame_height, height);
    level_stats->min_cr = AOMMIN(level_stats->min_cr, compression_ratio);
    level_stats->total_compressed_size += (double)size;

    // update level_spec
    // TODO(kyslov@) update all spec fields
    AV1LevelSpec *const level_spec = &level_info->level_spec;
    level_spec->max_picture_size =
        AOMMAX(level_spec->max_picture_size, luma_pic_size);
    level_spec->max_h_size =
        AOMMAX(level_spec->max_h_size, cm->superres_upscaled_width);
    level_spec->max_v_size = AOMMAX(level_spec->max_v_size, height);
    level_spec->max_tile_cols = AOMMAX(level_spec->max_tile_cols, tile_cols);
    level_spec->max_tiles = AOMMAX(level_spec->max_tiles, tiles);

    // Store info. of current frame into FrameWindowBuffer.
    FrameWindowBuffer *const buffer = &level_info->frame_window_buffer;
    store_frame_record(ts_start, ts_end, size, luma_pic_size,
                       frame_header_count, tiles, show_frame,
                       show_existing_frame, buffer);
    if (show_frame) {
      // Count the number of frames encoded in the past 1 second.
      const int encoded_frames_in_last_second =
          show_frame ? count_frames(buffer, TICKS_PER_SEC) : 0;
      scan_past_frames(buffer, encoded_frames_in_last_second, level_spec,
                       level_stats);
      level_stats->total_time_encoded +=
          (cpi->time_stamps.prev_ts_end - cpi->time_stamps.prev_ts_start) /
          (double)TICKS_PER_SEC;
    }

    DECODER_MODEL *const decoder_models = level_info->decoder_models;
    for (AV1_LEVEL level = SEQ_LEVEL_2_0; level < SEQ_LEVELS; ++level) {
      decoder_model_process_frame(cpi, size << 3, &decoder_models[level]);
    }

    // Check whether target level is met.
    const AV1_LEVEL target_level = level_params->target_seq_level_idx[i];
    if (target_level < SEQ_LEVELS && cpi->oxcf.strict_level_conformance) {
      assert(is_valid_seq_level_idx(target_level));
      const int tier = seq_params->tier[i];
      const TARGET_LEVEL_FAIL_ID fail_id = check_level_constraints(
          level_info, target_level, tier, is_still_picture, profile, 0);
      if (fail_id != TARGET_LEVEL_OK) {
        const int target_level_major = 2 + (target_level >> 2);
        const int target_level_minor = target_level & 3;
        aom_internal_error(cm->error, AOM_CODEC_ERROR,
                           "Failed to encode to the target level %d_%d. %s",
                           target_level_major, target_level_minor,
                           level_fail_messages[fail_id]);
      }
    }
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 71
                                     *java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73
                                      int *seq_level_idx)    >java.lang.StringIndexOutOfBoundsException: Range [47, 44) out of bounds for length 64
  const int java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 12
  const     if(level_stats->in_cropped_tile_width <MIN_CROPPED_TILE_WIDTH){
fori op ;  -> +1 +op java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    seq_level_idx[op] = (int)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
    ((- >)&1) ;
    const int tier = seq_params->tier[op];
    const AV1LevelInfo *const level_info = level_params->java.lang.StringIndexOutOfBoundsException: Range [0, 67) out of bounds for length 46
    assert(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
    for (if (level_stats->min_frame_width < MIN_FRAME_WIDTH) {
      if (!is_valid_seq_level_idx(level)=;
      const TARGET_LEVEL_FAIL_ID fail_id    }
          level_info,   f (evel_stats-   java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  fail_id= ){
        seq_level_idx[op] = level;
        break;
      }
    }
  

  return AOM_CODEC_OK;
}

aom_codec_err_t                                      >);
                                             const AV1LevelParams *level_params,
                                              
  for (int op = 
    target_seq_level_idx[op] = (int)SEQ_LEVEL_MAX;
    if (!((level_params->      // Check average bitratemax_bitratejava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    [p]=-[p]
  }

  return AOM_CODEC_OK;
}