googlevideo/protos/generated/video_streaming/client_abr_state.ts

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.2.0
//   protoc               v5.28.0
// source: video_streaming/client_abr_state.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import {
  AudioQuality,
  NetworkMeteredState,
  PlaybackAudioRouteOutputType,
  VideoQualitySetting,
} from "../misc/common.js";

export const protobufPackage = "video_streaming";

export interface ClientAbrState {
  timeSinceLastManualFormatSelectionMs?: number | undefined;
  lastManualDirection?: number | undefined;
  lastManualSelectedResolution?: number | undefined;
  detailedNetworkType?: number | undefined;
  clientViewportWidth?: number | undefined;
  clientViewportHeight?: number | undefined;
  clientBitrateCapBytesPerSec?: number | undefined;
  stickyResolution?: number | undefined;
  clientViewportIsFlexible?: boolean | undefined;
  bandwidthEstimate?: number | undefined;
  minAudioQuality?: AudioQuality | undefined;
  maxAudioQuality?: AudioQuality | undefined;
  videoQualitySetting?: VideoQualitySetting | undefined;
  audioRoute?: PlaybackAudioRouteOutputType | undefined;
  playerTimeMs?: number | undefined;
  timeSinceLastSeek?: number | undefined;
  dataSaverMode?: boolean | undefined;
  networkMeteredState?: NetworkMeteredState | undefined;
  visibility?: number | undefined;
  playbackRate?: number | undefined;
  elapsedWallTimeMs?: number | undefined;
  mediaCapabilities?: Uint8Array | undefined;
  timeSinceLastActionMs?: number | undefined;
  enabledTrackTypesBitfield?: number | undefined;
  maxPacingRate?: number | undefined;
  playerState?: number | undefined;
  drcEnabled?: boolean | undefined;
  Jda?: number | undefined;
  qw?: number | undefined;
  Ky?: number | undefined;
  sabrReportRequestCancellationInfo?: number | undefined;
  l?: boolean | undefined;
  G7?: number | undefined;
  preferVp9?: boolean | undefined;
  qj?: number | undefined;
  Hx?: number | undefined;
  isPrefetch?: boolean | undefined;
  sabrSupportQualityConstraints?: number | undefined;
  sabrLicenseConstraint?: Uint8Array | undefined;
  allowProximaLiveLatency?: number | undefined;
  sabrForceProxima?: number | undefined;
  Tqb?: number | undefined;
  sabrForceMaxNetworkInterruptionDurationMs?: number | undefined;
  audioTrackId?: string | undefined;
}

function createBaseClientAbrState(): ClientAbrState {
  return {
    timeSinceLastManualFormatSelectionMs: 0,
    lastManualDirection: 0,
    lastManualSelectedResolution: 0,
    detailedNetworkType: 0,
    clientViewportWidth: 0,
    clientViewportHeight: 0,
    clientBitrateCapBytesPerSec: 0,
    stickyResolution: 0,
    clientViewportIsFlexible: false,
    bandwidthEstimate: 0,
    minAudioQuality: 0,
    maxAudioQuality: 0,
    videoQualitySetting: 0,
    audioRoute: 0,
    playerTimeMs: 0,
    timeSinceLastSeek: 0,
    dataSaverMode: false,
    networkMeteredState: 0,
    visibility: 0,
    playbackRate: 0,
    elapsedWallTimeMs: 0,
    mediaCapabilities: new Uint8Array(0),
    timeSinceLastActionMs: 0,
    enabledTrackTypesBitfield: 0,
    maxPacingRate: 0,
    playerState: 0,
    drcEnabled: false,
    Jda: 0,
    qw: 0,
    Ky: 0,
    sabrReportRequestCancellationInfo: 0,
    l: false,
    G7: 0,
    preferVp9: false,
    qj: 0,
    Hx: 0,
    isPrefetch: false,
    sabrSupportQualityConstraints: 0,
    sabrLicenseConstraint: new Uint8Array(0),
    allowProximaLiveLatency: 0,
    sabrForceProxima: 0,
    Tqb: 0,
    sabrForceMaxNetworkInterruptionDurationMs: 0,
    audioTrackId: "",
  };
}

export const ClientAbrState: MessageFns<ClientAbrState> = {
  encode(message: ClientAbrState, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (
      message.timeSinceLastManualFormatSelectionMs !== undefined && message.timeSinceLastManualFormatSelectionMs !== 0
    ) {
      writer.uint32(104).int64(message.timeSinceLastManualFormatSelectionMs);
    }
    if (message.lastManualDirection !== undefined && message.lastManualDirection !== 0) {
      writer.uint32(112).sint32(message.lastManualDirection);
    }
    if (message.lastManualSelectedResolution !== undefined && message.lastManualSelectedResolution !== 0) {
      writer.uint32(128).int32(message.lastManualSelectedResolution);
    }
    if (message.detailedNetworkType !== undefined && message.detailedNetworkType !== 0) {
      writer.uint32(136).int32(message.detailedNetworkType);
    }
    if (message.clientViewportWidth !== undefined && message.clientViewportWidth !== 0) {
      writer.uint32(144).int32(message.clientViewportWidth);
    }
    if (message.clientViewportHeight !== undefined && message.clientViewportHeight !== 0) {
      writer.uint32(152).int32(message.clientViewportHeight);
    }
    if (message.clientBitrateCapBytesPerSec !== undefined && message.clientBitrateCapBytesPerSec !== 0) {
      writer.uint32(160).int64(message.clientBitrateCapBytesPerSec);
    }
    if (message.stickyResolution !== undefined && message.stickyResolution !== 0) {
      writer.uint32(168).int32(message.stickyResolution);
    }
    if (message.clientViewportIsFlexible !== undefined && message.clientViewportIsFlexible !== false) {
      writer.uint32(176).bool(message.clientViewportIsFlexible);
    }
    if (message.bandwidthEstimate !== undefined && message.bandwidthEstimate !== 0) {
      writer.uint32(184).int64(message.bandwidthEstimate);
    }
    if (message.minAudioQuality !== undefined && message.minAudioQuality !== 0) {
      writer.uint32(192).int32(message.minAudioQuality);
    }
    if (message.maxAudioQuality !== undefined && message.maxAudioQuality !== 0) {
      writer.uint32(200).int32(message.maxAudioQuality);
    }
    if (message.videoQualitySetting !== undefined && message.videoQualitySetting !== 0) {
      writer.uint32(208).int32(message.videoQualitySetting);
    }
    if (message.audioRoute !== undefined && message.audioRoute !== 0) {
      writer.uint32(216).int32(message.audioRoute);
    }
    if (message.playerTimeMs !== undefined && message.playerTimeMs !== 0) {
      writer.uint32(224).int64(message.playerTimeMs);
    }
    if (message.timeSinceLastSeek !== undefined && message.timeSinceLastSeek !== 0) {
      writer.uint32(232).int64(message.timeSinceLastSeek);
    }
    if (message.dataSaverMode !== undefined && message.dataSaverMode !== false) {
      writer.uint32(240).bool(message.dataSaverMode);
    }
    if (message.networkMeteredState !== undefined && message.networkMeteredState !== 0) {
      writer.uint32(256).int32(message.networkMeteredState);
    }
    if (message.visibility !== undefined && message.visibility !== 0) {
      writer.uint32(272).int32(message.visibility);
    }
    if (message.playbackRate !== undefined && message.playbackRate !== 0) {
      writer.uint32(285).float(message.playbackRate);
    }
    if (message.elapsedWallTimeMs !== undefined && message.elapsedWallTimeMs !== 0) {
      writer.uint32(288).int64(message.elapsedWallTimeMs);
    }
    if (message.mediaCapabilities !== undefined && message.mediaCapabilities.length !== 0) {
      writer.uint32(306).bytes(message.mediaCapabilities);
    }
    if (message.timeSinceLastActionMs !== undefined && message.timeSinceLastActionMs !== 0) {
      writer.uint32(312).int64(message.timeSinceLastActionMs);
    }
    if (message.enabledTrackTypesBitfield !== undefined && message.enabledTrackTypesBitfield !== 0) {
      writer.uint32(320).int32(message.enabledTrackTypesBitfield);
    }
    if (message.maxPacingRate !== undefined && message.maxPacingRate !== 0) {
      writer.uint32(344).int32(message.maxPacingRate);
    }
    if (message.playerState !== undefined && message.playerState !== 0) {
      writer.uint32(352).int64(message.playerState);
    }
    if (message.drcEnabled !== undefined && message.drcEnabled !== false) {
      writer.uint32(368).bool(message.drcEnabled);
    }
    if (message.Jda !== undefined && message.Jda !== 0) {
      writer.uint32(384).int32(message.Jda);
    }
    if (message.qw !== undefined && message.qw !== 0) {
      writer.uint32(400).int32(message.qw);
    }
    if (message.Ky !== undefined && message.Ky !== 0) {
      writer.uint32(408).int32(message.Ky);
    }
    if (message.sabrReportRequestCancellationInfo !== undefined && message.sabrReportRequestCancellationInfo !== 0) {
      writer.uint32(432).int32(message.sabrReportRequestCancellationInfo);
    }
    if (message.l !== undefined && message.l !== false) {
      writer.uint32(448).bool(message.l);
    }
    if (message.G7 !== undefined && message.G7 !== 0) {
      writer.uint32(456).int64(message.G7);
    }
    if (message.preferVp9 !== undefined && message.preferVp9 !== false) {
      writer.uint32(464).bool(message.preferVp9);
    }
    if (message.qj !== undefined && message.qj !== 0) {
      writer.uint32(472).int32(message.qj);
    }
    if (message.Hx !== undefined && message.Hx !== 0) {
      writer.uint32(480).int32(message.Hx);
    }
    if (message.isPrefetch !== undefined && message.isPrefetch !== false) {
      writer.uint32(488).bool(message.isPrefetch);
    }
    if (message.sabrSupportQualityConstraints !== undefined && message.sabrSupportQualityConstraints !== 0) {
      writer.uint32(496).int32(message.sabrSupportQualityConstraints);
    }
    if (message.sabrLicenseConstraint !== undefined && message.sabrLicenseConstraint.length !== 0) {
      writer.uint32(506).bytes(message.sabrLicenseConstraint);
    }
    if (message.allowProximaLiveLatency !== undefined && message.allowProximaLiveLatency !== 0) {
      writer.uint32(512).int32(message.allowProximaLiveLatency);
    }
    if (message.sabrForceProxima !== undefined && message.sabrForceProxima !== 0) {
      writer.uint32(528).int32(message.sabrForceProxima);
    }
    if (message.Tqb !== undefined && message.Tqb !== 0) {
      writer.uint32(536).int32(message.Tqb);
    }
    if (
      message.sabrForceMaxNetworkInterruptionDurationMs !== undefined &&
      message.sabrForceMaxNetworkInterruptionDurationMs !== 0
    ) {
      writer.uint32(544).int64(message.sabrForceMaxNetworkInterruptionDurationMs);
    }
    if (message.audioTrackId !== undefined && message.audioTrackId !== "") {
      writer.uint32(554).string(message.audioTrackId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClientAbrState {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseClientAbrState();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 13:
          if (tag !== 104) {
            break;
          }

          message.timeSinceLastManualFormatSelectionMs = longToNumber(reader.int64());
          continue;
        case 14:
          if (tag !== 112) {
            break;
          }

          message.lastManualDirection = reader.sint32();
          continue;
        case 16:
          if (tag !== 128) {
            break;
          }

          message.lastManualSelectedResolution = reader.int32();
          continue;
        case 17:
          if (tag !== 136) {
            break;
          }

          message.detailedNetworkType = reader.int32();
          continue;
        case 18:
          if (tag !== 144) {
            break;
          }

          message.clientViewportWidth = reader.int32();
          continue;
        case 19:
          if (tag !== 152) {
            break;
          }

          message.clientViewportHeight = reader.int32();
          continue;
        case 20:
          if (tag !== 160) {
            break;
          }

          message.clientBitrateCapBytesPerSec = longToNumber(reader.int64());
          continue;
        case 21:
          if (tag !== 168) {
            break;
          }

          message.stickyResolution = reader.int32();
          continue;
        case 22:
          if (tag !== 176) {
            break;
          }

          message.clientViewportIsFlexible = reader.bool();
          continue;
        case 23:
          if (tag !== 184) {
            break;
          }

          message.bandwidthEstimate = longToNumber(reader.int64());
          continue;
        case 24:
          if (tag !== 192) {
            break;
          }

          message.minAudioQuality = reader.int32() as any;
          continue;
        case 25:
          if (tag !== 200) {
            break;
          }

          message.maxAudioQuality = reader.int32() as any;
          continue;
        case 26:
          if (tag !== 208) {
            break;
          }

          message.videoQualitySetting = reader.int32() as any;
          continue;
        case 27:
          if (tag !== 216) {
            break;
          }

          message.audioRoute = reader.int32() as any;
          continue;
        case 28:
          if (tag !== 224) {
            break;
          }

          message.playerTimeMs = longToNumber(reader.int64());
          continue;
        case 29:
          if (tag !== 232) {
            break;
          }

          message.timeSinceLastSeek = longToNumber(reader.int64());
          continue;
        case 30:
          if (tag !== 240) {
            break;
          }

          message.dataSaverMode = reader.bool();
          continue;
        case 32:
          if (tag !== 256) {
            break;
          }

          message.networkMeteredState = reader.int32() as any;
          continue;
        case 34:
          if (tag !== 272) {
            break;
          }

          message.visibility = reader.int32();
          continue;
        case 35:
          if (tag !== 285) {
            break;
          }

          message.playbackRate = reader.float();
          continue;
        case 36:
          if (tag !== 288) {
            break;
          }

          message.elapsedWallTimeMs = longToNumber(reader.int64());
          continue;
        case 38:
          if (tag !== 306) {
            break;
          }

          message.mediaCapabilities = reader.bytes();
          continue;
        case 39:
          if (tag !== 312) {
            break;
          }

          message.timeSinceLastActionMs = longToNumber(reader.int64());
          continue;
        case 40:
          if (tag !== 320) {
            break;
          }

          message.enabledTrackTypesBitfield = reader.int32();
          continue;
        case 43:
          if (tag !== 344) {
            break;
          }

          message.maxPacingRate = reader.int32();
          continue;
        case 44:
          if (tag !== 352) {
            break;
          }

          message.playerState = longToNumber(reader.int64());
          continue;
        case 46:
          if (tag !== 368) {
            break;
          }

          message.drcEnabled = reader.bool();
          continue;
        case 48:
          if (tag !== 384) {
            break;
          }

          message.Jda = reader.int32();
          continue;
        case 50:
          if (tag !== 400) {
            break;
          }

          message.qw = reader.int32();
          continue;
        case 51:
          if (tag !== 408) {
            break;
          }

          message.Ky = reader.int32();
          continue;
        case 54:
          if (tag !== 432) {
            break;
          }

          message.sabrReportRequestCancellationInfo = reader.int32();
          continue;
        case 56:
          if (tag !== 448) {
            break;
          }

          message.l = reader.bool();
          continue;
        case 57:
          if (tag !== 456) {
            break;
          }

          message.G7 = longToNumber(reader.int64());
          continue;
        case 58:
          if (tag !== 464) {
            break;
          }

          message.preferVp9 = reader.bool();
          continue;
        case 59:
          if (tag !== 472) {
            break;
          }

          message.qj = reader.int32();
          continue;
        case 60:
          if (tag !== 480) {
            break;
          }

          message.Hx = reader.int32();
          continue;
        case 61:
          if (tag !== 488) {
            break;
          }

          message.isPrefetch = reader.bool();
          continue;
        case 62:
          if (tag !== 496) {
            break;
          }

          message.sabrSupportQualityConstraints = reader.int32();
          continue;
        case 63:
          if (tag !== 506) {
            break;
          }

          message.sabrLicenseConstraint = reader.bytes();
          continue;
        case 64:
          if (tag !== 512) {
            break;
          }

          message.allowProximaLiveLatency = reader.int32();
          continue;
        case 66:
          if (tag !== 528) {
            break;
          }

          message.sabrForceProxima = reader.int32();
          continue;
        case 67:
          if (tag !== 536) {
            break;
          }

          message.Tqb = reader.int32();
          continue;
        case 68:
          if (tag !== 544) {
            break;
          }

          message.sabrForceMaxNetworkInterruptionDurationMs = longToNumber(reader.int64());
          continue;
        case 69:
          if (tag !== 554) {
            break;
          }

          message.audioTrackId = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function longToNumber(int64: { toString(): string }): number {
  const num = globalThis.Number(int64.toString());
  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
  }
  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
  }
  return num;
}

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
}