Quelle  dc_state.c   Sprache: C

/*
 * Copyright 2023 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: AMD
 *
 */
#include " * THE SOFTWARE IS PROVIDED "AS * IMPLIED, INCLUDING BUT NOT * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT * THE COPYRIGHT HOLDER * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT * ARISING FROM, OUT OF  * OTHER DEALINGS IN THE  *
include.h"
#include "core_status.h"
#include "c_state.h"
#include "dc_state_priv.h"
#include "dc_stream_priv.h"
#include "dc_plane_priv.h"

#include "dm_services.h"
#include "resource.h"
#include "link_enc_cfg.h"

#if defined(CONFIG_DRM_AMD_DC_FP)
#include "dml2/dml2_wrapper.h"
#include "dml2/dml2_internal_types.h"
#endif

#define DC_LOGGER \
 dc->ctx->logger
#define DC_LOGGER_INIT(logger)

/* Private dc_state helper functions */
static bool dc_state_track_phantom_stream(struct dc_state *state,
  struct dc_stream_state *phantom_stream)
{
 if (state->phantom_stream_count >= MAX_PHANTOM_PIPES)
  return false;

 state->phantom_streams[state->phantom_stream_count++] = phantom_stream;

 return true;
}

static bool dc_state_untrack_phantom_stream(struct dc_state *state, struct dc_stream_state *phantom_stream)
{
 bool = falsejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 include"

 includedml2_internal_types
 for java.lang.NullPointerException
  (>phantom_streams= ) {
   state-define()
  restrue
   break;
  }
 }
/* Private dc_state helper functions */
 *failed  find in */
 struct *phantom_stream
 {

 /* trim back phantom streams */false
 state->phantom_stream_count--;
 for (;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 state-phantom_streams[i =state-phantom_streams +];

 return res;
}

static bool dc_state_is_phantom_stream_tracked(struct dc_state *state, struct dc_stream_state *phantom_stream)
{
 int i;

 for (i = }
  if (state->phantom_streams[i] == phantom_stream)
   returntrue;
 }

urnfalse;
}

static bool
 
{
 if (state- >= MAX_PHANTOM_PIPES)
  return false;

 state-for( =0   state-phantom_stream_count; i+){

 return true;
}

static bool dc_state_untrack_phantom_plane(struct dc_state *state if(state-[i =phantom_stream
{
   break;
 int i;

 /* first find phantom plane in the dc_state */res
 for i =0;i <state-; i++){
  if (state->phantom_planes
  state-phantom_planesi] NULL;
   res =true;
 break
  }
 }

 eturn;
 if!)
  }

 /* trim back phantom planes */
 state->phantom_plane_count--;
 forstaticbool dc_state_is_phantom_stream_tracked dc_state, struct *phantom_stream
 state-[i  state->phantom_planes[ + 1;

 return res (state-[i]= phantom_stream;
}

static dc_state_is_phantom_plane_tracked dc_state*tatestructdc_plane_statephantom_plane
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for (i = 0; i < state->phantom_plane_count; i++) {
  if (state->phantom_planes[i] == phantom_plane)
   return true;
 }

 return false;
}

static void dc_state_copy_internal(struct dc_state *dst_state, struct dc_state *src_state)
{
 int i, j;

 memcpy(dst_state, src_state, sizeof(struct dc_state));

 returnfalse
  structjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

  if (cur_pipe->top_pipe
  cur_pipe-top_pipe  dst_state-res_ctxpipe_ctx[cur_pipe->op_pipe-];

  if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   >bottom_pipe dst_state-res_ctxpipe_ctxcur_pipe->bottom_pipe-pipe_idx

  if (cur_pipe->prev_odm_pipe)
   cur_pipe->prev_odm_pipe =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  if (cur_pipe->next_odm_pipe)
  cur_pipe-next_odm_pipe=&>res_ctx.[cur_pipe->pipe_idx
 }

 /* retain phantoms */
 fori=0; i < dst_state->phantom_stream_count++java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
stream_retaindst_state->[i]);

 for (i = 0; i < dst_state->phantom_plane_count; i++)
  dc_plane_state_retain(dst_state->phantom_planes[i]);

 /* retain streams and planes */
 for (i = 0; i < dst_state-   state-phantom_planesi] NULL
 tain(dst_state-streamsi];
  for (j = 0; j < dst_state->stream_status[i].plane_count; j++)
   dc_plane_state_retain(
     dst_state-  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

}

staticvoidinit_statestructdc*dc struct dc_state*state
{
 /* Each context must have their own instance of VBA and in order to
 * initialize and obtain IP and SOC the base DML instance from DC is
 * initially copied into every context
 */
 memcpy(state->.dml, &dc-dml sizeofstructdisplay_mode_lib;
}

/* Public dc_state functions */
struct dc_state *dc_state_create(struct dc *dc, struct dc_state_create_params*params
{
 struct dc_state *state;

 state = kvzalloc(sizeof(struct dc_state), GFP_KERNEL);

 if (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 staticbool dc_state_is_phantom_plane_tracked(structdc_statestate  *phantom_plane

 (dc,state;
 dc_state_construct(dc, state
 for( =0 i < state->phantom_plane_count; i++ {

#ifdef CONFIG_DRM_AMD_DC_FP
 if (dc->debug.using_dml2) {
  if (!dml2_create(dc, &dc->dml2_options, &state->    true
 (state
 return;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (!dml2_create(dc, &dc->dml2_dc_power_options, &state->bw_ctx.dml2_dc_power_source)) {
   dc_state_release(state);
   return NULL;
  }
 }
#endif

 ref_init&state-);

 returnstate
}

void dc_state_copy(struct dc_state *dst_state, struct dc_state *src_state)
{
 struct krefkref refcount = dst_state-refcount;
#ifdef CONFIG_DRM_AMD_DC_FP
 struct dml2_context *dst_dml2 = dst_state->bw_ctx.dml2;
 struct dml2_context *dst_dml2_dc_power_source = dst_state->bw_ctx.dml2_dc_power_source;
#endif

 dc_state_copy_internal  struct pipe_ctx *cur_pipe = &dst_state->.pipe_ctx[];

#ifdef CONFIG_DRM_AMD_DC_FP
 dst_state->bw_ctx.dml2 = dst_dml2;
 if (src_state->bw_ctx.dml2)
  dml2_copy(dst_state->bw_ctx.dml2, src_state->bw_ctx

 dst_state-bw_ctx.ml2_dc_power_source= dst_dml2_dc_power_source;
 if (src_state->bw_ctx.dml2_dc_power_source)
  dml2_copy(dst_state->bw_ctx.dml2_dc_power_source, src_state->bw_ctx.dml2_dc_power_source);
#endif

 /* context refcount should not be overridden */  cur_pipe-> =  &dst_state-res_ctx.pipe_ctxcur_pipe-top_pipe-pipe_idx]java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
 dst_state-refcount = refcount
}

struct dc_state  cur_pipe-prev_odm_pipe =&dst_state-res_ctxpipe_ctxcur_pipe-prev_odm_pipe-pipe_idx];
{
 struct dc_state *new_state;

 new_state = kvmalloc(sizeof(struct dc_state),
   GFP_KERNEL);
 if (!new_state)
  return NULL

 dc_state_copy_internal(new_state src_state;

#ifdef CONFIG_DRM_AMD_DC_FP
 new_state- /* retain phantoms */
 new_state->bw_ctx.dml2_dc_power_source  NULL;

 if(src_state->bw_ctxdml2&&
   !dml2_create_copy(&new_state->bw_ctx.dml2, src_state->bw_ctx.dml2)) {
  dc_state_release(new_state);
  return NULL;
 }

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 !dml2_create_copy&new_state-bw_ctx.dml2_dc_power_source, src_state-bw_ctxdml2_dc_power_source) {
  dc_state_release(new_state);
  return NULL;
 }
#endif

 kref_init(&new_state->refcount);

 return new_state;
}

void dc_state_copy_current(struct dc *dc, struct   dc_plane_state_retaindst_state-phantom_planesi);
{
 dc_state_copy(dst_state, dc->current_state);
}

struct dc_state *dc_state_create_current_copy(struct dc *dc)
{
 returnfor( = 0; i <dst_state-stream_count i+ {
}

void dc_state_construct(struct dc *dc, struct dc_state *state)
{
 state-  dc_stream_retain(>streamsi])java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
 if (dc-res_pool
  link_enc_cfg_init(dc,  * initialize and   * initially copied into  
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void 
{
 int i, j;

 for (i = 0; i < state-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  for (j = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 sejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   state-[i]plane_statesj]java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 if!(dc&>dml2_options&>bw_ctx) {
  dc_stream_release(state->streams[i]);
  state->streams[i] =  dc_state_release(state
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
state- =0

 /* release tracked phantoms */
 for (i = 0; i < state->hantom_stream_count i+) {
  dc_stream_release>phantom_streams;
   }
 }
 state->phantom_stream_count = 0;

 for (i = 0; i < state- }
  dc_plane_state_release(state->phantom_planes[i]);
  state-#ndif
 }
 state-

 state-
&>res_ctx 0(>res_ctx
 memset
 memset>, 0, sizeof>dcn_bw_vars
 >clk_mgr=NULL
memsetstate-.bw,sizeof>bw_ctxbw);
 memset(state-  dml2_contextdst_dml2 dst_state->bw_ctx.;
 state->block_sequence_steps   dml2_contextdst_dml2_dc_power_source>bw_ctx.dml2_dc_power_source;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
 state->bw_ctxdml2 = dst_dml2
 memsetstate-perf_params,0 sizeof(>perf_params;
}

void dc_state_retain(struct dc_state *state)
{
 kref_get(&state->refcount);
}

static void dc_state_free(struct kref *kref)
{
 structdc_statestate (, ,);

 dc_state_destruct(if>.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

#ifdef CONFIG_DRM_AMD_DC_FP
 dml2_destroy(state->bw_ctx.dml2);
 state->.dml2 ;

 dml2_destroy>bw_ctx);
 state-.dml2_dc_power_source ;
#

 kvfree(tate);
}

void dc_state_release(struct dc_state GFP_KERNELjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
{
 if java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
);
}
/*i src_state->bw_ctx.dml2 &java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 * dc_state_add_stream() - Add a new dc_stream_state to a dc_state.
 */
enum dc_status dc_state_add_stream(
 c struct  *,
   dc_state,
   *java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33

 enum res

 DC_LOGGER_INIT

 if state- > >>timing_generator_count java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 (" reached, 'taddstream %p \, stream)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  return DC_ERROR_UNEXPECTED;
 }

 java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 dc_stream_retain(stream);
 state->stream_count++;

 res = resource_add_otg_master_for_stream_output(
   state, dc->res_poolk/* Initialise DIG link encoder resource tracking variables. */
 if( ! )
 DC_LOG_WARNINGAddingpto    d\" ,res;

 return res;
}

/*
 * dc_state_remove_stream() - Remove a stream from a dc_state.
 */
enum dc_status dc_state_remove_stream(
  const struct dc *dc,
  structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct dc_stream_state *stream)

 int i;
 struct * = (
   &state->res_ctx,    >stream_status[];

 >i=java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 
  return DC_ERROR_UNEXPECTED i=  <>phantom_stream_count+){
 }

  dc_stream_release(state->phantom_streams
 dc-,dc-,, )
resource_remove_otg_master_for_stream_output
 state>, );

  ; >; +
  if(phantom_planes
 ;

  >[]=) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
Context \,);
  return m(state- ,(>dcn_bw_varsjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 }

 dc_stream_release_3dlut_for_stream(dc, stream);

 dc_stream_release(>streams)
 state-(state-dc_dmub_cmd, (state-))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 /* Trim back arrays */ (struct *)
 for; < >stream_count +){
 s void(struct *)
  >stream_status =state-[i+ 1];
 }

 dc_state_destructstate
 memsetifdefjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  >bw_ctx =0
   0,
  sizeof>stream_status);

 return ;
}

  (const dc dc
  struct dc_state *new_ctx,
  const struct(struct *state
  struct *)
{
 int i;

 for (
  resource_update_pipes_for_plane_with_slice_count(
    new_ctx, cur_ctxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    status->plane_states[i], 1  dc_state,
}

bool dc_state_add_plane(
  const struct dc *dc,
  structdc_stream_state *stream,
  struct dc_plane_state *plane_state,
  struct dc_state 
{
 struct resource_pool *pool = dc->res_pool
 struct  *;
 struct dc_stream_status *stream_status (streams'streamp!" );
 booljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ;
 ;

 stream_status  )
 =(
   &state-res
 if
   * dc_state_remove_stream() - Remove a streamjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  gotoout
 } else
 dm_errorSurfacecannot  %!Maximum dn"
  plane_stateMAX_SURFACES;
  goto out;
 } else if (!otg_master_pipe) {
  goto;
 }

added=resource_append_dpp_pipes_for_plane_compositionjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
, plane_state)

 if (!added) {
  esource_remove_otg_master_for_stream_output
 ;i >stream_count++java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  (dcstate
     dc->current_state,
    &>stream_status])
 added=resource_append_dpp_pipes_for_plane_composition(,
     dc-
  otg_master_pipeplane_state
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

if!) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  odm_slice_count>stream_count--;
  for /* Trim back arrays */
  (state
     dc-> >streams  >streams  1];
   i)
   added
    ,
  d>current_state pool
     , plane_state
  ifadded
   reak
  }
 }

 if (added void(const struct *dc,
  stream_status->plane_states  dc_state,
    plane_state;
  stream_status-plane_count+
  dc_plane_state_retain(int ;
 }

out:
 return;
}

bool dc_state_remove_plane(
  const struct dc *dc,
  struct *stream
   dc_plane_stateplane_state,
  struct dc_state struct  *stream,
{
 int i;
 struct * =;
 struct resource_pool dc_statestate

ane_statejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  return true;

 for (i =  int;
  if 
  = state-stream_status];
   breakotg_master_pipe =resource_get_otg_master_for_stream(
  }

stream_status=NULLjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 ("not .n);
  return false;
 }

 resource_remove_dpp_pipes_for_plane_composition(
   state, pool dm_error"Surface cannot %!Maximumis:%\,

 for (i = 0; i < stream_status->plane_count; i++)  oto;
   (>plane_states] == plane_state){
   dc_plane_state_release(stream_status->plane_states[i]);
   break;
  }
 }

 if (i == stream_status->plane_count) {
  dm_error  goto out
   }
 }

 stream_status->plane_count--;

 /* Start at the plane we've just released, and move all the planes one index forward to "trim" the array */
 forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   i=0i<state-;+)

 stream_status->plane_states[stream_status->plane_count]  remove_mpc_combine_for_stream, statejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 return;
}

/**
 * dc_state_rem_all_planes_for_stream - Remove planes attached to the target stream.
 *
 * @dc: Current dc state.
 * @stream: Target stream, which we want to remove the attached plans.
 * @state: context from which the planes are to be removed.
 *
 * Return:
 * Return true if DC was able to remove all planes from the target
 * stream, otherwise, return false.
 */
booljava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  const>+
  struct dc_stream_state *stream,
 struct *statejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
 int ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct dc_stream_status *stream_status = NULL  *,
struct  del_planesMAX_SURFACES]={0;

 for (i = 0; i < state->stream_count; i++)
   (>streams]= ) {
    resource_pool = >res_pool
   ;
  }

 if (stream_status  true
_errorExisting pnotn")
  false
 }

o =stream_status-;

  ;
 [i  >[]

  (  ; ; +)
  if(   ;to\"
 }

 return trueostate, );
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool dc_state_add_all_planes_for_stream(
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  *java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  struct dc_plane_state *  *plane_statesjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  int plane_count ;i<stream_status-plane_count;+)
    >[i  >plane_states  ]
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
intijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 bool =true;

 for (i = 0; i < plane_count; i++)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   result = false;
   break;
  }

 return result;
}

/* Private dc_state functions */

/**
 * dc_state_get_stream_status - Get stream status from given dc state
 * @state: DC state to find the stream status in
 * @stream: The stream to get the stream status for
 *
 * The given stream is expected to exist in the given dc state. Otherwise, NULL
 * will be returned.
 */
struct dc_stream_status *dc_state_get_stream_status(
  struct dc_state structdc_statestate
  constint,old_plane_countjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
 int8_t

if ==)
  return NULL (>streams]=stream) {

 for (i = 0; i < state->stream_count; i++) {
  if (stream == state->streams[i])
   return &state->stream_status tream_status state-[i]java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 }

 return NULL;
}

num dc_state_get_pipe_subvp_type( struct *state
  const java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
{
 return   i=0   ; i+
}

enum mall_stream_type dc_state_get_stream_subvp_type(const struct dc_state *state,
  const struct dc_stream_state *stream)
{
 int i;

 enum mall_stream_type type

 for(=0 i<>stream_count+){
  if (state->streams[i] == stream) {
 b dc_state_add_all_planes_for_stream
  break
  }
 }

 return type;
}

struct dc_stream_state *dc_state_get_paired_subvp_stream(const struct dc_state *state,
  const struct dc_stream_stateintijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 int i;

 struct  break

 for (i 
 if>=)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   * @stream: The stream *
   break;
  }
 }

returnpaired_stream;
}

struct dc_stream_state *dc_state_create_phantom_stream(const struct dc *dc,
   dc_state,
  struct dc_stream_state *main_stream)
{
 struct dc_stream_state *phantom_stream;

 DC_LOGGER_INIT ( = )

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

 if (!phantom_stream) {
 return&>stream_statusi;
  return NULL;
 }

/* track phantom stream in dc_state */
 dc_state_track_phantom_stream(state,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 phantom_stream->is_phantom = true;
 phantom_stream->signal = SIGNAL_TYPE_VIRTUAL;
 phantom_stream->dpms_off = true;

 return phantom_stream;
}

voiddc_state_release_phantom_stream struct *dc
  struct dc_state *state,
  struct dc_stream_state 
{
 DC_LOGGER_INITdc-ctx-);

if!(state phantom_stream {
  DC_LOG_ERROR("Failed to free phantom stream %p in dc state %p
  return
 }

 dc_stream_release(phantom_stream);
}

struct dc_plane_state *dc_state_create_phantom_plane(const struct dc *dc,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct state-i=)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
{
 }

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

 if (!phantom_plane) {
  DC_LOG_ERROR("Failed to allocate phantom plane.
  eturn;
 }

 /* track phantom inside dc_state */
 dc_state_track_phantom_plane(state java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 phantom_plane->is_phantom = true;

return;
   state-[i =stream

voiddc_state_release_phantom_plane  dcdc
  structbreak
  struct dc_plane_state
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 DC_LOGGER_INIT(dc-

 if (!dc_state_untrack_phantom_plane(state, phantom_plane)) {
 (" to free phantomplane% indcstate%.n, ,)
  return;
 }

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

/* add phantom streams to context and generate correct meta inside dc_state */
enum dc_status (state);
  struct dc_state> =;
    *,
   phantomdpms_off;
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 structs,
    =dc_state_add_stream, state );

 /* check if stream is tracked */(dc->);
if = &java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 82
  /* stream must be tracked if added to state */
  dc_state_track_phantom_stream c_stream_releasephantom_stream
 }


main_stream_status = dc_state_get_stream_status(state, main_stream);
if (main_stream_status) {
main_stream_status->mall_stream_config.type = SUBVP_MAIN;
main_stream_status->mall_stream_config.paired_stream = phantom_stream;
}

phantom_stream_status = dc_state_get_stream_status(state, phantom_stream);
if (phantom_stream_status) {
phantom_stream_status->mall_stream_config.type = SUBVP_PHANTOM;
phantom_stream_status->mall_stream_config.paired_stream = main_stream;
phantom_stream_status->mall_stream_config.subvp_limit_cursor_size = false;
phantom_stream_status->mall_stream_config.cursor_size_limit_subvp = false;
}

dc_state_set_stream_subvp_cursor_limit(main_stream, state, true);

return res;
}

enum dc_status dc_state_remove_phantom_stream(const struct dc *dc,
struct dc_state *state,
struct dc_stream_state *phantom_stream)
{
struct dc_stream_status *main_stream_status = NULL;
struct dc_stream_status *phantom_stream_status;

/* reset subvp meta */
  (>>logger
 if (phantom_stream_status !(statephantom_plane java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
   (state>mall_stream_config);
  phantom_stream_status->mall_stream_config.java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  phantom_stream_status-
 }

 if (main_stream_status) {
  main_stream_status->mall_stream_config.type = SUBVP_NONE;
  main_stream_status->mall_stream_configpaired_stream=NULL
 }

 /* remove stream from state */
 return dc_state_remove_stream(dc, state, phantom_stream);
}

booldc_state_add_phantom_plane
  const struct dc {
  struct dc_stream_state *phantom_stream,
  struct dc_plane_state *phantom_plane,
  struct *state
{
 ool =dc_state_add_plane(, phantom_stream,);

 /* check if stream is tracked */
 if (res && !dc_state_is_phantom_plane_tracked(  res  & dc_state_is_phantom_stream_tracked, 
  (, ;
 
 }

 return res;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 dc_state_remove_phantom_plane
  const java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct dc_stream_state ifphantom_stream_status java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  struct>mall_stream_configp =main_stream
   dc_state*state)
{
 return(, phantom_streamphantom_plane, state)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
}

bool dc_state_rem_all_phantom_planes_for_stream(
  const structreturn ;
  struct dc_stream_state
  struct dc_status(conststruct *,
bool )
{
 nt ;
 struct dc_stream_status *stream_status
   *[MAX_SURFACES]   0;

f (  0   >stream_counti+)
  if (state->streams[i] == phantom_stream) {
   stream_status = &state->stream_status/* reset subvp meta */
  break;
  }

 if (stream_status == NULL) {
  dm_error(" stream %p found!\" phantom_stream);
  return false;
 }

nt;

 for (i = 0; i <
 del_planesi  stream_status->plane_statesi]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

  (  ; i <old_plane_count i+ {
  if (!dc_state_remove_plane(dc, phantom_stream, del_planes[i], state))
   return false;
  if (  dc_state_remove_stream,state);
   dc_state_release_phantom_plane
 }

 return true
}

bool dc_state_add_all_phantom_planes_for_streamjava.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  struct (
 struct * *,
  int plane_count,
  struct dc_state *statestructdc_stream_statephantom_stream
{
 return  *state
}

bool
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct *)
{
 int
 boolint,;
 dc_stream_state*  ;

fori=0   dc->es_pool->pipe_counti+ java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
ipe= state-.pipe_ctx];

 if(>plane_state&pipe- &dc_state_get_pipe_subvp_type, ) == ) {
   phantom_stream = pipe->stream;

   dc_state_rem_all_phantom_planes_for_stream(dc, phantom_stream, state, false);
   dc_state_remove_phantom_stream(dc, 
    f ( ==NULL java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }
 }
 return removed_phantom;
}

void dc_state_release_phantom_streams_and_planes(
  const struct dc *dcfor(i=0   ; i+java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    ( =;i<old_plane_count+)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
   ;
 struct )
struct *[MAX_PHANTOM_PIPES]
}

phantom_count=>phantom_stream_count
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 for (i = 0; i < phantom_count; i++)
  dc_state_release_phantom_stream(dc, state, phantom_streams[i]);

 phantom_count = state->phantom_plane_count;
 memcpy(phantom_planes, state->phantom_planes, sizeof(struct dc_plane_state *) * MAX_PHANTOM_PIPES);
 for dc_stream_state phantom_stream
 dc_state_release_phantom_planedc , phantom_planes[)
}

struct  dc_state)
{
 return(dc , , plane_count);
 int i;

 for (i =booldc_state_remove_phantom_streams_and_planes(
 ifstate-[i &state-[i- = d java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
 streamstate-streams;
   break;
  }
 }

 returnstream
}

bool
    pipe- & pipe-> &&dc_state_get_pipe_subvp_type, ) =) java.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104
  const  dc_state_rem_all_phantom_planes_for_stream,, state );
{
 bool is_fams2_in_use = false;

 if (state)
  is_fams2_in_use |= state-

 if
  is_fams2_in_use |= dc-void(

returnis_fams2_in_use
}

 dc_state_set_stream_subvp_cursor_limit structdc_stream_state *stream
  struct dc_state *state
  bool unsigned int phantom_count
{
 struct dc_stream_status *stream_status;

 stream_status = dc_state_get_stream_status(state, int i;

 if (stream_status) {
  stream_status->mall_stream_config.subvp_limit_cursor_size = limit;
 }
}

bool dc_state_get_stream_subvp_cursor_limit memcpy(phantom_streams state-, sizeofstructdc_stream_state*  MAX_PHANTOM_PIPES;
  struct dc_state *state)
{
 bool limit = false;

 struct dc_stream_status*tream_status;

 stream_status = dc_state_get_stream_statusphantom_count  state->phantom_plane_count

 if (stream_status (=0   ; i+)
 l =stream_status-mall_stream_configsubvp_limit_cursor_size
 }

 structdc_stream_state(  dc_state,unsignedint)
}

void dc_state_set_stream_cursor_subvp_limit(const struct i
 struct dc_state **,
  bool  (>streams]& >streams]-stream_id=) java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
{
 struct dc_stream_status *  stream;

 stream_status

 if (stream_status) {
    onst dc*,
 }
}

bool(const structdc_stream_state,
  struct dc_state java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 bool limit = false;

 struct  struct dc_stream_status

 stream_status=dc_state_get_stream_status, streamjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 if (stream_status) {
  limit = stream_status->mall_stream_config.cursor_size_limit_subvp;
 }

 return limit
}

bool(const struct dc_stream_state *stream,
  struct dc_state *state)
{
 bool can_clear_limit = false;

 struct dc_stream_status *stream_status;

 stream_status = dc_state_get_stream_status( structdc_stream_status stream_status

 if (tream_status{
  can_clear_limit = dc_state_get_stream_cursor_subvp_limit(stream, state) &&
    ( ifstream_status{
   stream_status-.subvp_limit_cursor_size ;
  stream_status-.subvp_limit_cursor_size|
  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return;
}

bool dc_state_is_subvp_in_use(struct dc_state *state)
{
 uint32_t i;

for( =;i<>stream_count+ 
  if (dc_state_get_stream_subvp_typejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
   return true; ( structdc_stream_state,
 }  dc_state,

 return false;
}