linux/drivers/gpu/drm/amd/display/dc/dsc/dc_dsc.c
<<
>>
Prefs
   1/*
   2 * Copyright 2019 Advanced Micro Devices, Inc.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice shall be included in
  12 * all copies or substantial portions of the Software.
  13 *
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 * OTHER DEALINGS IN THE SOFTWARE.
  21 *
  22 * Author: AMD
  23 */
  24
  25#include <drm/drm_dsc.h>
  26#include "dc_hw_types.h"
  27#include "dsc.h"
  28#include <drm/drm_dp_helper.h>
  29#include "dc.h"
  30#include "rc_calc.h"
  31
  32/* This module's internal functions */
  33
  34/* default DSC policy target bitrate limit is 16bpp */
  35static uint32_t dsc_policy_max_target_bpp_limit = 16;
  36
  37/* default DSC policy enables DSC only when needed */
  38static bool dsc_policy_enable_dsc_when_not_needed;
  39
  40static bool dsc_policy_disable_dsc_stream_overhead;
  41
  42static bool dsc_buff_block_size_from_dpcd(int dpcd_buff_block_size, int *buff_block_size)
  43{
  44
  45        switch (dpcd_buff_block_size) {
  46        case DP_DSC_RC_BUF_BLK_SIZE_1:
  47                *buff_block_size = 1024;
  48                break;
  49        case DP_DSC_RC_BUF_BLK_SIZE_4:
  50                *buff_block_size = 4 * 1024;
  51                break;
  52        case DP_DSC_RC_BUF_BLK_SIZE_16:
  53                *buff_block_size = 16 * 1024;
  54                break;
  55        case DP_DSC_RC_BUF_BLK_SIZE_64:
  56                *buff_block_size = 64 * 1024;
  57                break;
  58        default: {
  59                        dm_error("%s: DPCD DSC buffer size not recognized.\n", __func__);
  60                        return false;
  61                }
  62        }
  63
  64        return true;
  65}
  66
  67
  68static bool dsc_line_buff_depth_from_dpcd(int dpcd_line_buff_bit_depth, int *line_buff_bit_depth)
  69{
  70        if (0 <= dpcd_line_buff_bit_depth && dpcd_line_buff_bit_depth <= 7)
  71                *line_buff_bit_depth = dpcd_line_buff_bit_depth + 9;
  72        else if (dpcd_line_buff_bit_depth == 8)
  73                *line_buff_bit_depth = 8;
  74        else {
  75                dm_error("%s: DPCD DSC buffer depth not recognized.\n", __func__);
  76                return false;
  77        }
  78
  79        return true;
  80}
  81
  82
  83static bool dsc_throughput_from_dpcd(int dpcd_throughput, int *throughput)
  84{
  85        switch (dpcd_throughput) {
  86        case DP_DSC_THROUGHPUT_MODE_0_UNSUPPORTED:
  87                *throughput = 0;
  88                break;
  89        case DP_DSC_THROUGHPUT_MODE_0_170:
  90                *throughput = 170;
  91                break;
  92        case DP_DSC_THROUGHPUT_MODE_0_340:
  93                *throughput = 340;
  94                break;
  95        case DP_DSC_THROUGHPUT_MODE_0_400:
  96                *throughput = 400;
  97                break;
  98        case DP_DSC_THROUGHPUT_MODE_0_450:
  99                *throughput = 450;
 100                break;
 101        case DP_DSC_THROUGHPUT_MODE_0_500:
 102                *throughput = 500;
 103                break;
 104        case DP_DSC_THROUGHPUT_MODE_0_550:
 105                *throughput = 550;
 106                break;
 107        case DP_DSC_THROUGHPUT_MODE_0_600:
 108                *throughput = 600;
 109                break;
 110        case DP_DSC_THROUGHPUT_MODE_0_650:
 111                *throughput = 650;
 112                break;
 113        case DP_DSC_THROUGHPUT_MODE_0_700:
 114                *throughput = 700;
 115                break;
 116        case DP_DSC_THROUGHPUT_MODE_0_750:
 117                *throughput = 750;
 118                break;
 119        case DP_DSC_THROUGHPUT_MODE_0_800:
 120                *throughput = 800;
 121                break;
 122        case DP_DSC_THROUGHPUT_MODE_0_850:
 123                *throughput = 850;
 124                break;
 125        case DP_DSC_THROUGHPUT_MODE_0_900:
 126                *throughput = 900;
 127                break;
 128        case DP_DSC_THROUGHPUT_MODE_0_950:
 129                *throughput = 950;
 130                break;
 131        case DP_DSC_THROUGHPUT_MODE_0_1000:
 132                *throughput = 1000;
 133                break;
 134        default: {
 135                        dm_error("%s: DPCD DSC throughput mode not recognized.\n", __func__);
 136                        return false;
 137                }
 138        }
 139
 140        return true;
 141}
 142
 143
 144static bool dsc_bpp_increment_div_from_dpcd(uint8_t bpp_increment_dpcd, uint32_t *bpp_increment_div)
 145{
 146        // Mask bpp increment dpcd field to avoid reading other fields
 147        bpp_increment_dpcd &= 0x7;
 148
 149        switch (bpp_increment_dpcd) {
 150        case 0:
 151                *bpp_increment_div = 16;
 152                break;
 153        case 1:
 154                *bpp_increment_div = 8;
 155                break;
 156        case 2:
 157                *bpp_increment_div = 4;
 158                break;
 159        case 3:
 160                *bpp_increment_div = 2;
 161                break;
 162        case 4:
 163                *bpp_increment_div = 1;
 164                break;
 165        default: {
 166                dm_error("%s: DPCD DSC bits-per-pixel increment not recognized.\n", __func__);
 167                return false;
 168        }
 169        }
 170
 171        return true;
 172}
 173
 174static void get_dsc_enc_caps(
 175        const struct display_stream_compressor *dsc,
 176        struct dsc_enc_caps *dsc_enc_caps,
 177        int pixel_clock_100Hz)
 178{
 179        // This is a static HW query, so we can use any DSC
 180
 181        memset(dsc_enc_caps, 0, sizeof(struct dsc_enc_caps));
 182        if (dsc) {
 183                if (!dsc->ctx->dc->debug.disable_dsc)
 184                        dsc->funcs->dsc_get_enc_caps(dsc_enc_caps, pixel_clock_100Hz);
 185                if (dsc->ctx->dc->debug.native422_support)
 186                        dsc_enc_caps->color_formats.bits.YCBCR_NATIVE_422 = 1;
 187        }
 188}
 189
 190/* Returns 'false' if no intersection was found for at least one capablity.
 191 * It also implicitly validates some sink caps against invalid value of zero.
 192 */
 193static bool intersect_dsc_caps(
 194        const struct dsc_dec_dpcd_caps *dsc_sink_caps,
 195        const struct dsc_enc_caps *dsc_enc_caps,
 196        enum dc_pixel_encoding pixel_encoding,
 197        struct dsc_enc_caps *dsc_common_caps)
 198{
 199        int32_t max_slices;
 200        int32_t total_sink_throughput;
 201
 202        memset(dsc_common_caps, 0, sizeof(struct dsc_enc_caps));
 203
 204        dsc_common_caps->dsc_version = min(dsc_sink_caps->dsc_version, dsc_enc_caps->dsc_version);
 205        if (!dsc_common_caps->dsc_version)
 206                return false;
 207
 208        dsc_common_caps->slice_caps.bits.NUM_SLICES_1 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_1 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_1;
 209        dsc_common_caps->slice_caps.bits.NUM_SLICES_2 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_2 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_2;
 210        dsc_common_caps->slice_caps.bits.NUM_SLICES_4 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_4 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_4;
 211        dsc_common_caps->slice_caps.bits.NUM_SLICES_8 = dsc_sink_caps->slice_caps1.bits.NUM_SLICES_8 && dsc_enc_caps->slice_caps.bits.NUM_SLICES_8;
 212        if (!dsc_common_caps->slice_caps.raw)
 213                return false;
 214
 215        dsc_common_caps->lb_bit_depth = min(dsc_sink_caps->lb_bit_depth, dsc_enc_caps->lb_bit_depth);
 216        if (!dsc_common_caps->lb_bit_depth)
 217                return false;
 218
 219        dsc_common_caps->is_block_pred_supported = dsc_sink_caps->is_block_pred_supported && dsc_enc_caps->is_block_pred_supported;
 220
 221        dsc_common_caps->color_formats.raw = dsc_sink_caps->color_formats.raw & dsc_enc_caps->color_formats.raw;
 222        if (!dsc_common_caps->color_formats.raw)
 223                return false;
 224
 225        dsc_common_caps->color_depth.raw = dsc_sink_caps->color_depth.raw & dsc_enc_caps->color_depth.raw;
 226        if (!dsc_common_caps->color_depth.raw)
 227                return false;
 228
 229        max_slices = 0;
 230        if (dsc_common_caps->slice_caps.bits.NUM_SLICES_1)
 231                max_slices = 1;
 232
 233        if (dsc_common_caps->slice_caps.bits.NUM_SLICES_2)
 234                max_slices = 2;
 235
 236        if (dsc_common_caps->slice_caps.bits.NUM_SLICES_4)
 237                max_slices = 4;
 238
 239        total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_0_mps;
 240        if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420)
 241                total_sink_throughput = max_slices * dsc_sink_caps->throughput_mode_1_mps;
 242
 243        dsc_common_caps->max_total_throughput_mps = min(total_sink_throughput, dsc_enc_caps->max_total_throughput_mps);
 244
 245        dsc_common_caps->max_slice_width = min(dsc_sink_caps->max_slice_width, dsc_enc_caps->max_slice_width);
 246        if (!dsc_common_caps->max_slice_width)
 247                return false;
 248
 249        dsc_common_caps->bpp_increment_div = min(dsc_sink_caps->bpp_increment_div, dsc_enc_caps->bpp_increment_div);
 250
 251        // TODO DSC: Remove this workaround for N422 and 420 once it's fixed, or move it to get_dsc_encoder_caps()
 252        if (pixel_encoding == PIXEL_ENCODING_YCBCR422 || pixel_encoding == PIXEL_ENCODING_YCBCR420)
 253                dsc_common_caps->bpp_increment_div = min(dsc_common_caps->bpp_increment_div, (uint32_t)8);
 254
 255        dsc_common_caps->is_dp = dsc_sink_caps->is_dp;
 256        return true;
 257}
 258
 259static inline uint32_t dsc_div_by_10_round_up(uint32_t value)
 260{
 261        return (value + 9) / 10;
 262}
 263
 264static struct fixed31_32 compute_dsc_max_bandwidth_overhead(
 265                const struct dc_crtc_timing *timing,
 266                const int num_slices_h,
 267                const bool is_dp)
 268{
 269        struct fixed31_32 max_dsc_overhead;
 270        struct fixed31_32 refresh_rate;
 271
 272        if (dsc_policy_disable_dsc_stream_overhead || !is_dp)
 273                return dc_fixpt_from_int(0);
 274
 275        /* use target bpp that can take entire target bandwidth */
 276        refresh_rate = dc_fixpt_from_int(timing->pix_clk_100hz);
 277        refresh_rate = dc_fixpt_div_int(refresh_rate, timing->h_total);
 278        refresh_rate = dc_fixpt_div_int(refresh_rate, timing->v_total);
 279        refresh_rate = dc_fixpt_mul_int(refresh_rate, 100);
 280
 281        max_dsc_overhead = dc_fixpt_from_int(num_slices_h);
 282        max_dsc_overhead = dc_fixpt_mul_int(max_dsc_overhead, timing->v_total);
 283        max_dsc_overhead = dc_fixpt_mul_int(max_dsc_overhead, 256);
 284        max_dsc_overhead = dc_fixpt_div_int(max_dsc_overhead, 1000);
 285        max_dsc_overhead = dc_fixpt_mul(max_dsc_overhead, refresh_rate);
 286
 287        return max_dsc_overhead;
 288}
 289
 290static uint32_t compute_bpp_x16_from_target_bandwidth(
 291                const uint32_t bandwidth_in_kbps,
 292                const struct dc_crtc_timing *timing,
 293                const uint32_t num_slices_h,
 294                const uint32_t bpp_increment_div,
 295                const bool is_dp)
 296{
 297        struct fixed31_32 overhead_in_kbps;
 298        struct fixed31_32 effective_bandwidth_in_kbps;
 299        struct fixed31_32 bpp_x16;
 300
 301        overhead_in_kbps = compute_dsc_max_bandwidth_overhead(
 302                                timing, num_slices_h, is_dp);
 303        effective_bandwidth_in_kbps = dc_fixpt_from_int(bandwidth_in_kbps);
 304        effective_bandwidth_in_kbps = dc_fixpt_sub(effective_bandwidth_in_kbps,
 305                        overhead_in_kbps);
 306        bpp_x16 = dc_fixpt_mul_int(effective_bandwidth_in_kbps, 10);
 307        bpp_x16 = dc_fixpt_div_int(bpp_x16, timing->pix_clk_100hz);
 308        bpp_x16 = dc_fixpt_from_int(dc_fixpt_floor(dc_fixpt_mul_int(bpp_x16, bpp_increment_div)));
 309        bpp_x16 = dc_fixpt_div_int(bpp_x16, bpp_increment_div);
 310        bpp_x16 = dc_fixpt_mul_int(bpp_x16, 16);
 311        return dc_fixpt_floor(bpp_x16);
 312}
 313
 314/* Get DSC bandwidth range based on [min_bpp, max_bpp] target bitrate range, and timing's pixel clock
 315 * and uncompressed bandwidth.
 316 */
 317static void get_dsc_bandwidth_range(
 318                const uint32_t min_bpp_x16,
 319                const uint32_t max_bpp_x16,
 320                const uint32_t num_slices_h,
 321                const struct dsc_enc_caps *dsc_caps,
 322                const struct dc_crtc_timing *timing,
 323                struct dc_dsc_bw_range *range)
 324{
 325        /* native stream bandwidth */
 326        range->stream_kbps = dc_bandwidth_in_kbps_from_timing(timing);
 327
 328        /* max dsc target bpp */
 329        range->max_kbps = dc_dsc_stream_bandwidth_in_kbps(timing,
 330                        max_bpp_x16, num_slices_h, dsc_caps->is_dp);
 331        range->max_target_bpp_x16 = max_bpp_x16;
 332        if (range->max_kbps > range->stream_kbps) {
 333                /* max dsc target bpp is capped to native bandwidth */
 334                range->max_kbps = range->stream_kbps;
 335                range->max_target_bpp_x16 = compute_bpp_x16_from_target_bandwidth(
 336                                range->max_kbps, timing, num_slices_h,
 337                                dsc_caps->bpp_increment_div,
 338                                dsc_caps->is_dp);
 339        }
 340
 341        /* min dsc target bpp */
 342        range->min_kbps = dc_dsc_stream_bandwidth_in_kbps(timing,
 343                        min_bpp_x16, num_slices_h, dsc_caps->is_dp);
 344        range->min_target_bpp_x16 = min_bpp_x16;
 345        if (range->min_kbps > range->max_kbps) {
 346                /* min dsc target bpp is capped to max dsc bandwidth*/
 347                range->min_kbps = range->max_kbps;
 348                range->min_target_bpp_x16 = range->max_target_bpp_x16;
 349        }
 350}
 351
 352/* Decides if DSC should be used and calculates target bpp if it should, applying DSC policy.
 353 *
 354 * Returns:
 355 *     - 'true' if DSC was required by policy and was successfully applied
 356 *     - 'false' if DSC was not necessary (e.g. if uncompressed stream fits 'target_bandwidth_kbps'),
 357 *        or if it couldn't be applied based on DSC policy.
 358 */
 359static bool decide_dsc_target_bpp_x16(
 360                const struct dc_dsc_policy *policy,
 361                const struct dsc_enc_caps *dsc_common_caps,
 362                const int target_bandwidth_kbps,
 363                const struct dc_crtc_timing *timing,
 364                const int num_slices_h,
 365                int *target_bpp_x16)
 366{
 367        bool should_use_dsc = false;
 368        struct dc_dsc_bw_range range;
 369
 370        memset(&range, 0, sizeof(range));
 371
 372        get_dsc_bandwidth_range(policy->min_target_bpp * 16, policy->max_target_bpp * 16,
 373                        num_slices_h, dsc_common_caps, timing, &range);
 374        if (!policy->enable_dsc_when_not_needed && target_bandwidth_kbps >= range.stream_kbps) {
 375                /* enough bandwidth without dsc */
 376                *target_bpp_x16 = 0;
 377                should_use_dsc = false;
 378        } else if (policy->preferred_bpp_x16 > 0 &&
 379                        policy->preferred_bpp_x16 <= range.max_target_bpp_x16 &&
 380                        policy->preferred_bpp_x16 >= range.min_target_bpp_x16) {
 381                *target_bpp_x16 = policy->preferred_bpp_x16;
 382                should_use_dsc = true;
 383        } else if (target_bandwidth_kbps >= range.max_kbps) {
 384                /* use max target bpp allowed */
 385                *target_bpp_x16 = range.max_target_bpp_x16;
 386                should_use_dsc = true;
 387        } else if (target_bandwidth_kbps >= range.min_kbps) {
 388                /* use target bpp that can take entire target bandwidth */
 389                *target_bpp_x16 = compute_bpp_x16_from_target_bandwidth(
 390                                target_bandwidth_kbps, timing, num_slices_h,
 391                                dsc_common_caps->bpp_increment_div,
 392                                dsc_common_caps->is_dp);
 393                should_use_dsc = true;
 394        } else {
 395                /* not enough bandwidth to fulfill minimum requirement */
 396                *target_bpp_x16 = 0;
 397                should_use_dsc = false;
 398        }
 399
 400        return should_use_dsc;
 401}
 402
 403#define MIN_AVAILABLE_SLICES_SIZE  4
 404
 405static int get_available_dsc_slices(union dsc_enc_slice_caps slice_caps, int *available_slices)
 406{
 407        int idx = 0;
 408
 409        memset(available_slices, -1, MIN_AVAILABLE_SLICES_SIZE);
 410
 411        if (slice_caps.bits.NUM_SLICES_1)
 412                available_slices[idx++] = 1;
 413
 414        if (slice_caps.bits.NUM_SLICES_2)
 415                available_slices[idx++] = 2;
 416
 417        if (slice_caps.bits.NUM_SLICES_4)
 418                available_slices[idx++] = 4;
 419
 420        if (slice_caps.bits.NUM_SLICES_8)
 421                available_slices[idx++] = 8;
 422
 423        return idx;
 424}
 425
 426
 427static int get_max_dsc_slices(union dsc_enc_slice_caps slice_caps)
 428{
 429        int max_slices = 0;
 430        int available_slices[MIN_AVAILABLE_SLICES_SIZE];
 431        int end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
 432
 433        if (end_idx > 0)
 434                max_slices = available_slices[end_idx - 1];
 435
 436        return max_slices;
 437}
 438
 439
 440// Increment sice number in available sice numbers stops if possible, or just increment if not
 441static int inc_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices)
 442{
 443        // Get next bigger num slices available in common caps
 444        int available_slices[MIN_AVAILABLE_SLICES_SIZE];
 445        int end_idx;
 446        int i;
 447        int new_num_slices = num_slices;
 448
 449        end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
 450        if (end_idx == 0) {
 451                // No available slices found
 452                new_num_slices++;
 453                return new_num_slices;
 454        }
 455
 456        // Numbers of slices found - get the next bigger number
 457        for (i = 0; i < end_idx; i++) {
 458                if (new_num_slices < available_slices[i]) {
 459                        new_num_slices = available_slices[i];
 460                        break;
 461                }
 462        }
 463
 464        if (new_num_slices == num_slices) // No biger number of slices found
 465                new_num_slices++;
 466
 467        return new_num_slices;
 468}
 469
 470
 471// Decrement sice number in available sice numbers stops if possible, or just decrement if not. Stop at zero.
 472static int dec_num_slices(union dsc_enc_slice_caps slice_caps, int num_slices)
 473{
 474        // Get next bigger num slices available in common caps
 475        int available_slices[MIN_AVAILABLE_SLICES_SIZE];
 476        int end_idx;
 477        int i;
 478        int new_num_slices = num_slices;
 479
 480        end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
 481        if (end_idx == 0 && new_num_slices > 0) {
 482                // No numbers of slices found
 483                new_num_slices++;
 484                return new_num_slices;
 485        }
 486
 487        // Numbers of slices found - get the next smaller number
 488        for (i = end_idx - 1; i >= 0; i--) {
 489                if (new_num_slices > available_slices[i]) {
 490                        new_num_slices = available_slices[i];
 491                        break;
 492                }
 493        }
 494
 495        if (new_num_slices == num_slices) {
 496                // No smaller number of slices found
 497                new_num_slices--;
 498                if (new_num_slices < 0)
 499                        new_num_slices = 0;
 500        }
 501
 502        return new_num_slices;
 503}
 504
 505
 506// Choose next bigger number of slices if the requested number of slices is not available
 507static int fit_num_slices_up(union dsc_enc_slice_caps slice_caps, int num_slices)
 508{
 509        // Get next bigger num slices available in common caps
 510        int available_slices[MIN_AVAILABLE_SLICES_SIZE];
 511        int end_idx;
 512        int i;
 513        int new_num_slices = num_slices;
 514
 515        end_idx = get_available_dsc_slices(slice_caps, &available_slices[0]);
 516        if (end_idx == 0) {
 517                // No available slices found
 518                new_num_slices++;
 519                return new_num_slices;
 520        }
 521
 522        // Numbers of slices found - get the equal or next bigger number
 523        for (i = 0; i < end_idx; i++) {
 524                if (new_num_slices <= available_slices[i]) {
 525                        new_num_slices = available_slices[i];
 526                        break;
 527                }
 528        }
 529
 530        return new_num_slices;
 531}
 532
 533
 534/* Attempts to set DSC configuration for the stream, applying DSC policy.
 535 * Returns 'true' if successful or 'false' if not.
 536 *
 537 * Parameters:
 538 *
 539 * dsc_sink_caps       - DSC sink decoder capabilities (from DPCD)
 540 *
 541 * dsc_enc_caps        - DSC encoder capabilities
 542 *
 543 * target_bandwidth_kbps  - Target bandwidth to fit the stream into.
 544 *                          If 0, do not calculate target bpp.
 545 *
 546 * timing              - The stream timing to fit into 'target_bandwidth_kbps' or apply
 547 *                       maximum compression to, if 'target_badwidth == 0'
 548 *
 549 * dsc_cfg             - DSC configuration to use if it was possible to come up with
 550 *                       one for the given inputs.
 551 *                       The target bitrate after DSC can be calculated by multiplying
 552 *                       dsc_cfg.bits_per_pixel (in U6.4 format) by pixel rate, e.g.
 553 *
 554 *                       dsc_stream_bitrate_kbps = (int)ceil(timing->pix_clk_khz * dsc_cfg.bits_per_pixel / 16.0);
 555 */
 556static bool setup_dsc_config(
 557                const struct dsc_dec_dpcd_caps *dsc_sink_caps,
 558                const struct dsc_enc_caps *dsc_enc_caps,
 559                int target_bandwidth_kbps,
 560                const struct dc_crtc_timing *timing,
 561                int min_slice_height_override,
 562                int max_dsc_target_bpp_limit_override_x16,
 563                struct dc_dsc_config *dsc_cfg)
 564{
 565        struct dsc_enc_caps dsc_common_caps;
 566        int max_slices_h;
 567        int min_slices_h;
 568        int num_slices_h;
 569        int pic_width;
 570        int slice_width;
 571        int target_bpp;
 572        int sink_per_slice_throughput_mps;
 573        int branch_max_throughput_mps = 0;
 574        bool is_dsc_possible = false;
 575        int pic_height;
 576        int slice_height;
 577        struct dc_dsc_policy policy;
 578
 579        memset(dsc_cfg, 0, sizeof(struct dc_dsc_config));
 580
 581        dc_dsc_get_policy_for_timing(timing, max_dsc_target_bpp_limit_override_x16, &policy);
 582        pic_width = timing->h_addressable + timing->h_border_left + timing->h_border_right;
 583        pic_height = timing->v_addressable + timing->v_border_top + timing->v_border_bottom;
 584
 585        if (!dsc_sink_caps->is_dsc_supported)
 586                goto done;
 587
 588        if (dsc_sink_caps->branch_max_line_width && dsc_sink_caps->branch_max_line_width < pic_width)
 589                goto done;
 590
 591        // Intersect decoder with encoder DSC caps and validate DSC settings
 592        is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, dsc_enc_caps, timing->pixel_encoding, &dsc_common_caps);
 593        if (!is_dsc_possible)
 594                goto done;
 595
 596        sink_per_slice_throughput_mps = 0;
 597
 598        // Validate available DSC settings against the mode timing
 599
 600        // Validate color format (and pick up the throughput values)
 601        dsc_cfg->ycbcr422_simple = false;
 602        switch (timing->pixel_encoding) {
 603        case PIXEL_ENCODING_RGB:
 604                is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.RGB;
 605                sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
 606                branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps;
 607                break;
 608        case PIXEL_ENCODING_YCBCR444:
 609                is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_444;
 610                sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
 611                branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_0_mps;
 612                break;
 613        case PIXEL_ENCODING_YCBCR422:
 614                is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_422;
 615                sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps;
 616                branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps;
 617                if (!is_dsc_possible) {
 618                        is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_SIMPLE_422;
 619                        dsc_cfg->ycbcr422_simple = is_dsc_possible;
 620                        sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_0_mps;
 621                }
 622                break;
 623        case PIXEL_ENCODING_YCBCR420:
 624                is_dsc_possible = (bool)dsc_common_caps.color_formats.bits.YCBCR_NATIVE_420;
 625                sink_per_slice_throughput_mps = dsc_sink_caps->throughput_mode_1_mps;
 626                branch_max_throughput_mps = dsc_sink_caps->branch_overall_throughput_1_mps;
 627                break;
 628        default:
 629                is_dsc_possible = false;
 630        }
 631
 632        // Validate branch's maximum throughput
 633        if (branch_max_throughput_mps && dsc_div_by_10_round_up(timing->pix_clk_100hz) > branch_max_throughput_mps * 1000)
 634                is_dsc_possible = false;
 635
 636        if (!is_dsc_possible)
 637                goto done;
 638
 639        // Color depth
 640        switch (timing->display_color_depth) {
 641        case COLOR_DEPTH_888:
 642                is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_8_BPC;
 643                break;
 644        case COLOR_DEPTH_101010:
 645                is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_10_BPC;
 646                break;
 647        case COLOR_DEPTH_121212:
 648                is_dsc_possible = (bool)dsc_common_caps.color_depth.bits.COLOR_DEPTH_12_BPC;
 649                break;
 650        default:
 651                is_dsc_possible = false;
 652        }
 653
 654        if (!is_dsc_possible)
 655                goto done;
 656
 657        // Slice width (i.e. number of slices per line)
 658        max_slices_h = get_max_dsc_slices(dsc_common_caps.slice_caps);
 659
 660        while (max_slices_h > 0) {
 661                if (pic_width % max_slices_h == 0)
 662                        break;
 663
 664                max_slices_h = dec_num_slices(dsc_common_caps.slice_caps, max_slices_h);
 665        }
 666
 667        is_dsc_possible = (dsc_common_caps.max_slice_width > 0);
 668        if (!is_dsc_possible)
 669                goto done;
 670
 671        min_slices_h = pic_width / dsc_common_caps.max_slice_width;
 672        if (pic_width % dsc_common_caps.max_slice_width)
 673                min_slices_h++;
 674
 675        min_slices_h = fit_num_slices_up(dsc_common_caps.slice_caps, min_slices_h);
 676
 677        while (min_slices_h <= max_slices_h) {
 678                int pix_clk_per_slice_khz = dsc_div_by_10_round_up(timing->pix_clk_100hz) / min_slices_h;
 679                if (pix_clk_per_slice_khz <= sink_per_slice_throughput_mps * 1000)
 680                        break;
 681
 682                min_slices_h = inc_num_slices(dsc_common_caps.slice_caps, min_slices_h);
 683        }
 684
 685        if (pic_width % min_slices_h != 0)
 686                min_slices_h = 0; // DSC TODO: Maybe try increasing the number of slices first?
 687
 688        is_dsc_possible = (min_slices_h <= max_slices_h);
 689        if (!is_dsc_possible)
 690                goto done;
 691
 692        if (policy.use_min_slices_h) {
 693                if (min_slices_h > 0)
 694                        num_slices_h = min_slices_h;
 695                else if (max_slices_h > 0) { // Fall back to max slices if min slices is not working out
 696                        if (policy.max_slices_h)
 697                                num_slices_h = min(policy.max_slices_h, max_slices_h);
 698                        else
 699                                num_slices_h = max_slices_h;
 700                } else
 701                        is_dsc_possible = false;
 702        } else {
 703                if (max_slices_h > 0) {
 704                        if (policy.max_slices_h)
 705                                num_slices_h = min(policy.max_slices_h, max_slices_h);
 706                        else
 707                                num_slices_h = max_slices_h;
 708                } else if (min_slices_h > 0) // Fall back to min slices if max slices is not possible
 709                        num_slices_h = min_slices_h;
 710                else
 711                        is_dsc_possible = false;
 712        }
 713
 714        if (!is_dsc_possible)
 715                goto done;
 716
 717        dsc_cfg->num_slices_h = num_slices_h;
 718        slice_width = pic_width / num_slices_h;
 719
 720        is_dsc_possible = slice_width <= dsc_common_caps.max_slice_width;
 721        if (!is_dsc_possible)
 722                goto done;
 723
 724        // Slice height (i.e. number of slices per column): start with policy and pick the first one that height is divisible by.
 725        // For 4:2:0 make sure the slice height is divisible by 2 as well.
 726        if (min_slice_height_override == 0)
 727                slice_height = min(policy.min_slice_height, pic_height);
 728        else
 729                slice_height = min(min_slice_height_override, pic_height);
 730
 731        while (slice_height < pic_height && (pic_height % slice_height != 0 ||
 732                (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420 && slice_height % 2 != 0)))
 733                slice_height++;
 734
 735        if (timing->pixel_encoding == PIXEL_ENCODING_YCBCR420) // For the case when pic_height < dsc_policy.min_sice_height
 736                is_dsc_possible = (slice_height % 2 == 0);
 737
 738        if (!is_dsc_possible)
 739                goto done;
 740
 741        dsc_cfg->num_slices_v = pic_height/slice_height;
 742
 743        if (target_bandwidth_kbps > 0) {
 744                is_dsc_possible = decide_dsc_target_bpp_x16(
 745                                &policy,
 746                                &dsc_common_caps,
 747                                target_bandwidth_kbps,
 748                                timing,
 749                                num_slices_h,
 750                                &target_bpp);
 751                dsc_cfg->bits_per_pixel = target_bpp;
 752        }
 753        if (!is_dsc_possible)
 754                goto done;
 755
 756        // Final decission: can we do DSC or not?
 757        if (is_dsc_possible) {
 758                // Fill out the rest of DSC settings
 759                dsc_cfg->block_pred_enable = dsc_common_caps.is_block_pred_supported;
 760                dsc_cfg->linebuf_depth = dsc_common_caps.lb_bit_depth;
 761                dsc_cfg->version_minor = (dsc_common_caps.dsc_version & 0xf0) >> 4;
 762                dsc_cfg->is_dp = dsc_sink_caps->is_dp;
 763        }
 764
 765done:
 766        if (!is_dsc_possible)
 767                memset(dsc_cfg, 0, sizeof(struct dc_dsc_config));
 768
 769        return is_dsc_possible;
 770}
 771
 772bool dc_dsc_parse_dsc_dpcd(const struct dc *dc, const uint8_t *dpcd_dsc_basic_data, const uint8_t *dpcd_dsc_branch_decoder_caps, struct dsc_dec_dpcd_caps *dsc_sink_caps)
 773{
 774        if (!dpcd_dsc_basic_data)
 775                return false;
 776
 777        dsc_sink_caps->is_dsc_supported = (dpcd_dsc_basic_data[DP_DSC_SUPPORT - DP_DSC_SUPPORT] & DP_DSC_DECOMPRESSION_IS_SUPPORTED) != 0;
 778        if (!dsc_sink_caps->is_dsc_supported)
 779                return false;
 780
 781        dsc_sink_caps->dsc_version = dpcd_dsc_basic_data[DP_DSC_REV - DP_DSC_SUPPORT];
 782
 783        {
 784                int buff_block_size;
 785                int buff_size;
 786
 787                if (!dsc_buff_block_size_from_dpcd(dpcd_dsc_basic_data[DP_DSC_RC_BUF_BLK_SIZE - DP_DSC_SUPPORT], &buff_block_size))
 788                        return false;
 789
 790                buff_size = dpcd_dsc_basic_data[DP_DSC_RC_BUF_SIZE - DP_DSC_SUPPORT] + 1;
 791                dsc_sink_caps->rc_buffer_size = buff_size * buff_block_size;
 792        }
 793
 794        dsc_sink_caps->slice_caps1.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_1 - DP_DSC_SUPPORT];
 795        if (!dsc_line_buff_depth_from_dpcd(dpcd_dsc_basic_data[DP_DSC_LINE_BUF_BIT_DEPTH - DP_DSC_SUPPORT], &dsc_sink_caps->lb_bit_depth))
 796                return false;
 797
 798        dsc_sink_caps->is_block_pred_supported =
 799                (dpcd_dsc_basic_data[DP_DSC_BLK_PREDICTION_SUPPORT - DP_DSC_SUPPORT] & DP_DSC_BLK_PREDICTION_IS_SUPPORTED) != 0;
 800
 801        dsc_sink_caps->edp_max_bits_per_pixel =
 802                dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_LOW - DP_DSC_SUPPORT] |
 803                dpcd_dsc_basic_data[DP_DSC_MAX_BITS_PER_PIXEL_HI - DP_DSC_SUPPORT] << 8;
 804
 805        dsc_sink_caps->color_formats.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_FORMAT_CAP - DP_DSC_SUPPORT];
 806        dsc_sink_caps->color_depth.raw = dpcd_dsc_basic_data[DP_DSC_DEC_COLOR_DEPTH_CAP - DP_DSC_SUPPORT];
 807
 808        {
 809                int dpcd_throughput = dpcd_dsc_basic_data[DP_DSC_PEAK_THROUGHPUT - DP_DSC_SUPPORT];
 810
 811                if (!dsc_throughput_from_dpcd(dpcd_throughput & DP_DSC_THROUGHPUT_MODE_0_MASK, &dsc_sink_caps->throughput_mode_0_mps))
 812                        return false;
 813
 814                dpcd_throughput = (dpcd_throughput & DP_DSC_THROUGHPUT_MODE_1_MASK) >> DP_DSC_THROUGHPUT_MODE_1_SHIFT;
 815                if (!dsc_throughput_from_dpcd(dpcd_throughput, &dsc_sink_caps->throughput_mode_1_mps))
 816                        return false;
 817        }
 818
 819        dsc_sink_caps->max_slice_width = dpcd_dsc_basic_data[DP_DSC_MAX_SLICE_WIDTH - DP_DSC_SUPPORT] * 320;
 820        dsc_sink_caps->slice_caps2.raw = dpcd_dsc_basic_data[DP_DSC_SLICE_CAP_2 - DP_DSC_SUPPORT];
 821
 822        if (!dsc_bpp_increment_div_from_dpcd(dpcd_dsc_basic_data[DP_DSC_BITS_PER_PIXEL_INC - DP_DSC_SUPPORT], &dsc_sink_caps->bpp_increment_div))
 823                return false;
 824
 825        if (dc->debug.dsc_bpp_increment_div) {
 826                /* dsc_bpp_increment_div should onl be 1, 2, 4, 8 or 16, but rather than rejecting invalid values,
 827                 * we'll accept all and get it into range. This also makes the above check against 0 redundant,
 828                 * but that one stresses out the override will be only used if it's not 0.
 829                 */
 830                if (dc->debug.dsc_bpp_increment_div >= 1)
 831                        dsc_sink_caps->bpp_increment_div = 1;
 832                if (dc->debug.dsc_bpp_increment_div >= 2)
 833                        dsc_sink_caps->bpp_increment_div = 2;
 834                if (dc->debug.dsc_bpp_increment_div >= 4)
 835                        dsc_sink_caps->bpp_increment_div = 4;
 836                if (dc->debug.dsc_bpp_increment_div >= 8)
 837                        dsc_sink_caps->bpp_increment_div = 8;
 838                if (dc->debug.dsc_bpp_increment_div >= 16)
 839                        dsc_sink_caps->bpp_increment_div = 16;
 840        }
 841
 842        /* Extended caps */
 843        if (dpcd_dsc_branch_decoder_caps == NULL) { // branch decoder DPCD DSC data can be null for non branch device
 844                dsc_sink_caps->branch_overall_throughput_0_mps = 0;
 845                dsc_sink_caps->branch_overall_throughput_1_mps = 0;
 846                dsc_sink_caps->branch_max_line_width = 0;
 847                return true;
 848        }
 849
 850        dsc_sink_caps->branch_overall_throughput_0_mps = dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_OVERALL_THROUGHPUT_0 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0];
 851        if (dsc_sink_caps->branch_overall_throughput_0_mps == 0)
 852                dsc_sink_caps->branch_overall_throughput_0_mps = 0;
 853        else if (dsc_sink_caps->branch_overall_throughput_0_mps == 1)
 854                dsc_sink_caps->branch_overall_throughput_0_mps = 680;
 855        else {
 856                dsc_sink_caps->branch_overall_throughput_0_mps *= 50;
 857                dsc_sink_caps->branch_overall_throughput_0_mps += 600;
 858        }
 859
 860        dsc_sink_caps->branch_overall_throughput_1_mps = dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_OVERALL_THROUGHPUT_1 - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0];
 861        if (dsc_sink_caps->branch_overall_throughput_1_mps == 0)
 862                dsc_sink_caps->branch_overall_throughput_1_mps = 0;
 863        else if (dsc_sink_caps->branch_overall_throughput_1_mps == 1)
 864                dsc_sink_caps->branch_overall_throughput_1_mps = 680;
 865        else {
 866                dsc_sink_caps->branch_overall_throughput_1_mps *= 50;
 867                dsc_sink_caps->branch_overall_throughput_1_mps += 600;
 868        }
 869
 870        dsc_sink_caps->branch_max_line_width = dpcd_dsc_branch_decoder_caps[DP_DSC_BRANCH_MAX_LINE_WIDTH - DP_DSC_BRANCH_OVERALL_THROUGHPUT_0] * 320;
 871        ASSERT(dsc_sink_caps->branch_max_line_width == 0 || dsc_sink_caps->branch_max_line_width >= 5120);
 872
 873        dsc_sink_caps->is_dp = true;
 874        return true;
 875}
 876
 877
 878/* If DSC is possbile, get DSC bandwidth range based on [min_bpp, max_bpp] target bitrate range and
 879 * timing's pixel clock and uncompressed bandwidth.
 880 * If DSC is not possible, leave '*range' untouched.
 881 */
 882bool dc_dsc_compute_bandwidth_range(
 883                const struct display_stream_compressor *dsc,
 884                uint32_t dsc_min_slice_height_override,
 885                uint32_t min_bpp_x16,
 886                uint32_t max_bpp_x16,
 887                const struct dsc_dec_dpcd_caps *dsc_sink_caps,
 888                const struct dc_crtc_timing *timing,
 889                struct dc_dsc_bw_range *range)
 890{
 891        bool is_dsc_possible = false;
 892        struct dsc_enc_caps dsc_enc_caps;
 893        struct dsc_enc_caps dsc_common_caps;
 894        struct dc_dsc_config config;
 895
 896        get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz);
 897
 898        is_dsc_possible = intersect_dsc_caps(dsc_sink_caps, &dsc_enc_caps,
 899                        timing->pixel_encoding, &dsc_common_caps);
 900
 901        if (is_dsc_possible)
 902                is_dsc_possible = setup_dsc_config(dsc_sink_caps, &dsc_enc_caps, 0, timing,
 903                                dsc_min_slice_height_override, max_bpp_x16, &config);
 904
 905        if (is_dsc_possible)
 906                get_dsc_bandwidth_range(min_bpp_x16, max_bpp_x16,
 907                                config.num_slices_h, &dsc_common_caps, timing, range);
 908
 909        return is_dsc_possible;
 910}
 911
 912bool dc_dsc_compute_config(
 913                const struct display_stream_compressor *dsc,
 914                const struct dsc_dec_dpcd_caps *dsc_sink_caps,
 915                uint32_t dsc_min_slice_height_override,
 916                uint32_t max_target_bpp_limit_override,
 917                uint32_t target_bandwidth_kbps,
 918                const struct dc_crtc_timing *timing,
 919                struct dc_dsc_config *dsc_cfg)
 920{
 921        bool is_dsc_possible = false;
 922        struct dsc_enc_caps dsc_enc_caps;
 923
 924        get_dsc_enc_caps(dsc, &dsc_enc_caps, timing->pix_clk_100hz);
 925        is_dsc_possible = setup_dsc_config(dsc_sink_caps,
 926                        &dsc_enc_caps,
 927                        target_bandwidth_kbps,
 928                        timing, dsc_min_slice_height_override,
 929                        max_target_bpp_limit_override * 16, dsc_cfg);
 930        return is_dsc_possible;
 931}
 932
 933uint32_t dc_dsc_stream_bandwidth_in_kbps(const struct dc_crtc_timing *timing,
 934                uint32_t bpp_x16, uint32_t num_slices_h, bool is_dp)
 935{
 936        struct fixed31_32 overhead_in_kbps;
 937        struct fixed31_32 bpp;
 938        struct fixed31_32 actual_bandwidth_in_kbps;
 939
 940        overhead_in_kbps = compute_dsc_max_bandwidth_overhead(
 941                        timing, num_slices_h, is_dp);
 942        bpp = dc_fixpt_from_fraction(bpp_x16, 16);
 943        actual_bandwidth_in_kbps = dc_fixpt_from_fraction(timing->pix_clk_100hz, 10);
 944        actual_bandwidth_in_kbps = dc_fixpt_mul(actual_bandwidth_in_kbps, bpp);
 945        actual_bandwidth_in_kbps = dc_fixpt_add(actual_bandwidth_in_kbps, overhead_in_kbps);
 946        return dc_fixpt_ceil(actual_bandwidth_in_kbps);
 947}
 948
 949void dc_dsc_get_policy_for_timing(const struct dc_crtc_timing *timing, uint32_t max_target_bpp_limit_override_x16, struct dc_dsc_policy *policy)
 950{
 951        uint32_t bpc = 0;
 952
 953        policy->min_target_bpp = 0;
 954        policy->max_target_bpp = 0;
 955
 956        /* DSC Policy: Use minimum number of slices that fits the pixel clock */
 957        policy->use_min_slices_h = true;
 958
 959        /* DSC Policy: Use max available slices
 960         * (in our case 4 for or 8, depending on the mode)
 961         */
 962        policy->max_slices_h = 0;
 963
 964        /* DSC Policy: Use slice height recommended
 965         * by VESA DSC Spreadsheet user guide
 966         */
 967        policy->min_slice_height = 108;
 968
 969        /* DSC Policy: follow DP specs with an internal upper limit to 16 bpp
 970         * for better interoperability
 971         */
 972        switch (timing->display_color_depth) {
 973        case COLOR_DEPTH_888:
 974                bpc = 8;
 975                break;
 976        case COLOR_DEPTH_101010:
 977                bpc = 10;
 978                break;
 979        case COLOR_DEPTH_121212:
 980                bpc = 12;
 981                break;
 982        default:
 983                return;
 984        }
 985        switch (timing->pixel_encoding) {
 986        case PIXEL_ENCODING_RGB:
 987        case PIXEL_ENCODING_YCBCR444:
 988        case PIXEL_ENCODING_YCBCR422: /* assume no YCbCr422 native support */
 989                /* DP specs limits to 8 */
 990                policy->min_target_bpp = 8;
 991                /* DP specs limits to 3 x bpc */
 992                policy->max_target_bpp = 3 * bpc;
 993                break;
 994        case PIXEL_ENCODING_YCBCR420:
 995                /* DP specs limits to 6 */
 996                policy->min_target_bpp = 6;
 997                /* DP specs limits to 1.5 x bpc assume bpc is an even number */
 998                policy->max_target_bpp = bpc * 3 / 2;
 999                break;
1000        default:
1001                return;
1002        }
1003
1004        policy->preferred_bpp_x16 = timing->dsc_fixed_bits_per_pixel_x16;
1005
1006        /* internal upper limit, default 16 bpp */
1007        if (policy->max_target_bpp > dsc_policy_max_target_bpp_limit)
1008                policy->max_target_bpp = dsc_policy_max_target_bpp_limit;
1009
1010        /* apply override */
1011        if (max_target_bpp_limit_override_x16 && policy->max_target_bpp > max_target_bpp_limit_override_x16 / 16)
1012                policy->max_target_bpp = max_target_bpp_limit_override_x16 / 16;
1013
1014        /* enable DSC when not needed, default false */
1015        if (dsc_policy_enable_dsc_when_not_needed)
1016                policy->enable_dsc_when_not_needed = dsc_policy_enable_dsc_when_not_needed;
1017        else
1018                policy->enable_dsc_when_not_needed = false;
1019}
1020
1021void dc_dsc_policy_set_max_target_bpp_limit(uint32_t limit)
1022{
1023        dsc_policy_max_target_bpp_limit = limit;
1024}
1025
1026void dc_dsc_policy_set_enable_dsc_when_not_needed(bool enable)
1027{
1028        dsc_policy_enable_dsc_when_not_needed = enable;
1029}
1030
1031void dc_dsc_policy_set_disable_dsc_stream_overhead(bool disable)
1032{
1033        dsc_policy_disable_dsc_stream_overhead = disable;
1034}
1035