PB and J
(the J is for Jesse)
The "Challenge"
- 3D in the browser
- Scientific Data
- Tight Deadline
- New + Old Technology
- Custom parser
- Needs runtime manipulation!
- Current speed? Send help.
- "Browser? Can't be done."
"Its a Visualizer"
Meet Segy
SEG-Y
- Designed for Tape
- Endian issues
- Standard yet Nonstandard
- 48 years old
1
Old
- Challenging Errors
- Scientific Domain
- Difficult to find clear examples
- Software Vendors "Spec Ball of Mud" for decades
2
Opaque
Like.
Massive.
Big honkin' files.
3
Huge
Seismic Reflection Standard
No, really.
Like. Massive.
Budget:
441.Million points + Metadata.
3
Huge
Trace
{
"textHeader": {
"C01": " CLIENT/JOB ID 0 5 5 5 2 9 3 4 7 2",
"C02": " LINE L3X",
"C03": " REEL NO 751023083601 DAY-START OF REEL 23 YEAR 1975",
"C04": " INSTRUMENT: MFG TI MODEL AS",
"C05": " DATA TRACES/RECORD0001 AUXILIARY TRACES/RECORD 0 CDP FOLD 0001",
"C06": "SAMPLE INTERNAL 0000008000 US SAMPLES/TRACE 0751BITS/IN 1600 BYTES/SAMPLE 4",
"C07": " RECORDING FORMAT STDI FORMAT THIS REEL SEG Y1",
"C08": " SAMPLE CODE: FLOATING PT",
"C09": " GAIN TYPE: FLOATING PT",
"C10": " PROCESSING:",
"C11": " PROCESSING:",
"C12": " FIELD TAPE PROCESSING MACHINE NUMBER IS: TIMAP2",
"C13": " INPUT TAPE FORMAT IS : STDI",
"C14": " TMIN REQUESTED THIS REEL 00000000 TMAX REQUESTED THIS REEL 00006000",
"C15": " INITIAL CHANNEL REQUESTED 0001 NUMBER OF CHANNELS REQUESTED 0001",
"C16": " DELTA 0008 MILLIVOLT LEVEL 000000 TYPE INPUT 0001",
"C17": " TRACE HEADER INFORMATION BY BYTE :",
"C18": " BYTES 181-182 : TMIN THIS TRACE BYTES 183-184 : TMAX THIS TRACE",
"C19": " BYTES 185-186 : TRACE FLAG 1= GOOD 2 = MISSING OR DEAD TRACE INPUT",
"C20": " 3= REQUESTED DUMMY TRACE BYTES 187-188 : TDS THIS TRACE",
"C21": "BYTES 189-192 : WATER DEPTH AT CDP BYTES 193-196 : PRENMO DATUM CORR MS T",
"C22": "BYTES 197-200 : POSTNMO DATUM CORR MS T",
"C23": "BYTES 201-204 : DATUM TIME -- TIME TO WHICH TRACES HAVE BEEN CORRECTED",
"C24": "BYTES 205-208 : DATUM VELOCITY - TO WHICH TRACES HAVE BEEN CORRECTED",
"C25": "BINARY TAPE HEADER IDENTIFICATION : JOB ID - 32 BIT FIXED POINT",
"C26": "REEL ID- 32 BIT PACKED BINARY BASE 10 BYTES 1-4 JOB ID BYTES 5-8 REEL ID",
"C27": "BYTES 95-96 SDOM: 0=SPC, 1= CDP",
"C28": "END PROCESSING: "
},
"binaryHeader": {
"JobID": 1110580000,
"LineNumber": 3,
"ReelNumber": 1110579969,
"Traces": 1,
"AuxTraces": 0,
"Interval": 8000,
"IntervalOriginal": 0,
"Samples": 751,
"SamplesOriginal": 0,
"Format": 1,
"EnsembleFold": 1,
"SortingCode": 4,
"VerticalSum": 1,
"SweepFrequencyStart": 0,
"SweepFrequencyEnd": 0,
"SweepLength": 0,
"Sweep": 0,
"SweepChannel": 0,
"SweepTaperStart": 0,
"SweepTaperEnd": 0,
"Taper": 0,
"CorrelatedTraces": 0,
"BinaryGainRecovery": 1,
"AmplitudeRecovery": 4,
"MeasurementSystem": 0,
"ImpulseSignalPolarity": 0,
"VibratoryPolarity": 0,
"SEGY_BIN_EXT_TRACES": 4294836236,
"ExtAuxTraces": 65536,
"SEGY_BIN_DT": 0,
"SEGY_BIN_NS": 0,
"SEGY_BIN_SEGY_REVISION": 0,
"SEGY_BIN_SEGY_REVISION_MINOR": 0,
"SEGY_BIN_TIME_BASIS_CODE": 0,
"SEGY_BIN_TRACE_NUMBER": 0
},
"dt": 0.008,
"ns": 751,
"traces": [
{
"TRACE_SEQUENCE_LINE": 1,
"TRACE_SEQUENCE_FILE": 1,
"FieldRecord": 11,
"TraceNumber": 0,
"EnergySourcePoint": 0,
"CDP": 1,
"CDP_TRACE": 1,
"TraceIdentificationCode": 1,
"NSummedTraces": 1,
"NStackedTraces": 1,
"DataUse": 1,
"offset": 0,
"ReceiverGroupElevation": 0,
"SourceSurfaceElevation": 0,
"SourceDepth": 0,
"ReceiverDatumElevation": 0,
"SourceDatumElevation": 0,
"SourceWaterDepth": 0,
"GroupWaterDepth": 0,
"ElevationScalar": 1,
"SourceGroupScalar": 1,
"SourceX": 0,
"SourceY": 0,
"GroupX": 0,
"GroupY": 0,
"CoordinateUnits": 0,
"WeatheringVelocity": 0,
"SubWeatheringVelocity": 0,
"SourceUpholeTime": 0,
"GroupUpholeTime": 0,
"SourceStaticCorrection": 0,
"GroupStaticCorrection": 0,
"TotalStaticApplied": 0,
"LagTimeA": 0,
"LagTimeB": 0,
"DelayRecordingTime": 0,
"MuteTimeStart": 0,
"MuteTimeEND": 0,
"TRACE_SAMPLE_COUNT": 751,
"TRACE_SAMPLE_INTERVAL": 8000,
"GainType": 0,
"InstrumentGainConstant": 0,
"InstrumentInitialGain": 0,
"Correlated": 0,
"SweepFrequencyStart": 0,
"SweepFrequencyEnd": 0,
"SweepLength": 0,
"SweepType": 0,
"SweepTraceTaperLengthStart": 0,
"SweepTraceTaperLengthEnd": 0,
"TaperType": 0,
"AliasFilterFrequency": 0,
"AliasFilterSlope": 0,
"NotchFilterFrequency": 0,
"NotchFilterSlope": 0,
"LowCutFrequency": 0,
"HighCutFrequency": 0,
"LowCutSlope": 0,
"HighCutSlope": 0,
"YearDataRecorded": 16,
"DayOfYear": 35,
"HourOfDay": 8,
"MinuteOfHour": 54,
"SecondOfMinute": 1,
"TimeBaseCode": 1,
"TraceWeightingFactor": 10,
"GeophoneGroupNumberRoll1": 0,
"GeophoneGroupNumberFirstTraceOrigField": 0,
"GeophoneGroupNumberLastTraceOrigField": 0,
"GapSize": 0,
"OverTravel": 0,
"CDP_X": 6000,
"CDP_Y": 65536,
"INLINE_3D": 0,
"CROSSLINE_3D": 0,
"ShotPoint": 0,
"ShotPointScalar": 0,
"TraceValueMeasurementUnit": 84,
"TransductionConstantMantissa": 10000,
"TransductionConstantPower": 0,
"TransductionUnit": 0,
"TraceIdentifier": 0,
"ScalarTraceHeader": 0,
"SourceType": 0,
"SourceEnergyDirectionMantissa": 0,
"SourceEnergyDirectionExponent": 0,
"SourceMeasurementMantissa": 0,
"SourceMeasurementExponent": 0,
"SourceMeasurementUnit": 0,
"UnassignedInt1": 0,
"UnassignedInt2": 0
}
]- Headers
- Slices (iline)
- Traces (cdp)
- Samples (time)
My first PB
goes
goes harder
vroom vroom 🔥
Protobuf popularity
| Repo | NPM | Stars |
|---|---|---|
| protobuf | 9,889,655 | 9,000 |
| gRPC | 5,069,593 | 3,900 |
| tRPC | 175,594 | 24,800 |
| graphql | 8,762,853 | 19,500 |
| next | 3,440,614 | 105,000 |
The Protobuf
message Boop {
optional int32 a = 1;
}-
Old. Like from 2001, and public in 2008
-
C++, C#, Java, Python, JavaScript, Ruby, Go, PHP, Dart
-
Node, Web (and Scala, Swift, R, Rust etc) came later
-
(aforementioned) used in IPFS
-
Binary Wire Format
Protocol Buffers.
Probufs.
PB.
(these mean the same thing)
1
3
Base 128 Varint Sorcery
convert to bytes
08 96 01
(small values use smaller bytes)
5
- Optional Element Culling
- Pack Repeated Items
2
4
More Shrinkage:
- Bools
- Enums
- Ints
message Boop {
optional int32 a = 1;
}10010110 00000001
^ msb ^ msbHow the Smooshification Happens
- Strong Typed
- string
- int32
- repeated string
- map<string, string>
- enum
- Schema Driven
- A lot like Poco/Pojo, or Prisma DSL
- See JSON -to- Proto converter
.proto
Performance
Faster, but for who?
And how much?
The Claim is
up to a 6-8x increase
goos: darwin
goarch: amd64
pkg: github.com/protobuf-benchmark
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
Iterations Time/Function Call Memory Allocation Rate of Malloc
MarshalJSON/Small-12 2662459 441.5 ns/op 80 B/op 1 allocs/op
MarshalJSON/Medium-12 1474044 793.8 ns/op 672 B/op 2 allocs/op
MarshalJSON/Large-12 247953 4315 ns/op 5250 B/op 2 allocs/op
MarshalProto/Small-12 6676744 178.5 ns/op 48 B/op 1 allocs/op
MarshalProto/Medium-12 4704790 235.8 ns/op 288 B/op 1 allocs/op
MarshalProto/Large-12 1983378 591.9 ns/op 3072 B/op 1 allocs/op
UnMarshalJSON/Small-12 707073 2192 ns/op 240 B/op 7 allocs/op
UnMarshalJSON/Medium-12 385875 3160 ns/op 480 B/op 7 allocs/op
UnMarshalJSON/Large-12 53250 22647 ns/op 3456 B/op 7 allocs/op
UnMarshalProto/Small-12 12717336 93.67 ns/op 0 B/op 0 allocs/op
UnMarshalProto/Medium-12 11514138 102.7 ns/op 0 B/op 0 allocs/op
UnMarshalProto/Large-12 12027140 96.40 ns/op 0 B/op 0 allocs/opJson vs Proto (marshall/unmarshall)
Json vs Proto (size in bytes)
| Format | Size |
|---|---|
| Protobuf | 46 bytes |
| JSON | 85 bytes |
| Format | Time | % change |
|---|---|---|
| Protobuf | 680ns | - |
| Microsoft JSON | 743ns | 👎 9% |
| JSON.NET | 155ns | 👎 135% |
Parse Speed
| Format | Size |
|---|---|
| Protobuf | 225ms |
| JSON | 323ms |
100 Submissions
100 Requests
(speed)
| Format | Size |
|---|---|
| Protobuf | 31.04kb |
| JSON | 51.97kb |
100 Submissions
100 Requests
(size)
XML vs JSON, vs MsgPack, vs Protobuf
Small Data Size
Large Data Size
lower is better
Vs several other Various Serializers
lower is better
benchmarking encoding performance ...
protobuf.js (reflect) x 724,119 ops/sec ±0.69% (89 runs sampled)
protobuf.js (static) x 755,818 ops/sec ±0.63% (90 runs sampled)
JSON (string) x 499,217 ops/sec ±4.02% (89 runs sampled)
JSON (buffer) x 394,685 ops/sec ±1.75% (88 runs sampled)
google-protobuf x 376,625 ops/sec ±1.05% (89 runs sampled)
protobuf.js (static) was fastest
protobuf.js (reflect) was 4.2% ops/sec slower (factor 1.0)
JSON (string) was 36.1% ops/sec slower (factor 1.6)
JSON (buffer) was 48.4% ops/sec slower (factor 1.9)
google-protobuf was 50.4% ops/sec slower (factor 2.0)benchmarking encoding performance ...
protobuf.js (reflect) x 866 ops/sec ±0.68% (92 runs sampled)
JSON (string) x 2,411 ops/sec ±0.91% (94 runs sampled)
JSON (buffer) x 1,928 ops/sec ±0.85% (94 runs sampled)
JSON (string) was fastest
JSON (buffer) was 20.0% ops/sec slower (factor 1.2)
protobuf.js (reflect) was 64.0% ops/sec slower (factor 2.8)Heterogeneous Data
Just a Bunch of Strings
(wait, what?)
The Goldilocks Zone
Wins Expected
- Segy is a lot of numbers compared to strings
- No good way to segment/paginate
- Offline processing is possible
- S3 Storage likely
3 ways to integrate (in JS)
Use the js loader and load .proto at runtime
1
Import
(Full)
(Light)
(Minimal)
rewrite .protos (or generate them) as JSON and load that
2
.proto - json
Generate code via the command line in .ts or .js and load that code normally.
3
Preproccess
"scripts": {
"gen-ts": "pbjs segy.proto --ts segy.proto.ts"
},syntax = "proto3";
package segy;
message SegyHeader {
string textHeader = 1;
BinaryHeader binaryHeader = 2;
Stats stats = 3;
}
message Stats {
double samplesDelta = 1;
int32 samplesPerTrace = 2;
int32 CDPLow = 3;
int32 CDPHigh = 4;
int32 CDPDistance = 5;
int32 CDPTraceLow = 6;
int32 CDPTraceHigh = 7;
int32 CDPTraceDistance = 8;
int32 tracesPerSlice = 9;
int32 slicesCount = 10;
int32 tracesCount = 11;
}
message BinaryHeader {
int32 JobID = 1;
int32 LineNumber = 2;
int32 ReelNumber = 3;
int32 Traces = 4;
int32 AuxTraces = 5;
int32 Interval = 6;
int32 IntervalOriginal = 7;
int32 Samples = 8;
int32 SamplesOriginal = 9;
int32 Format = 10;
int32 EnsembleFold = 11;
int32 SortingCode = 12;
int32 VerticalSum = 13;
int32 SweepFrequencyStart = 14;
int32 SweepFrequencyEnd = 15;
int32 SweepLength = 16;
int32 Sweep = 17;
int32 SweepChannel = 18;
int32 SweepTaperStart = 19;
int32 SweepTaperEnd = 20;1
2
/* eslint-disable */
/*
This file was generated from segy.proto at 2023-03-14 14:45:34
Run `yarn generate-protobuf` in the root to update.
*/
export interface SegyHeader {
textHeader?: string
binaryHeader?: BinaryHeader
stats?: Stats
}
export function encodeSegyHeader(message: SegyHeader): Uint8Array {
let bb = popByteBuffer()
_encodeSegyHeader(message, bb)
return toUint8Array(bb)
}
function _encodeSegyHeader(message: SegyHeader, bb: ByteBuffer): void {
// optional string textHeader = 1;
let $textHeader = message.textHeader
if ($textHeader !== undefined) {
writeVarint32(bb, 10)
writeString(bb, $textHeader)
}
// optional BinaryHeader binaryHeader = 2;
let $binaryHeader = message.binaryHeader
if ($binaryHeader !== undefined) {
//...
}3
/* eslint-disable */
/*
This file was generated from segy.proto at 2023-03-14 14:45:34
Run `yarn generate-protobuf` in the root to update.
*/
export interface SegyHeader {
textHeader?: string
binaryHeader?: BinaryHeader
stats?: Stats
}
export function encodeSegyHeader(message: SegyHeader): Uint8Array {
let bb = popByteBuffer()
_encodeSegyHeader(message, bb)
return toUint8Array(bb)
}
function _encodeSegyHeader(message: SegyHeader, bb: ByteBuffer): void {
// optional string textHeader = 1;
let $textHeader = message.textHeader
if ($textHeader !== undefined) {
writeVarint32(bb, 10)
writeString(bb, $textHeader)
}
// optional BinaryHeader binaryHeader = 2;
let $binaryHeader = message.binaryHeader
if ($binaryHeader !== undefined) {
writeVarint32(bb, 18)
let nested = popByteBuffer()
_encodeBinaryHeader($binaryHeader, nested)
writeVarint32(bb, nested.limit)
writeByteBuffer(bb, nested)
pushByteBuffer(nested)
}
// optional Stats stats = 3;
let $stats = message.stats
if ($stats !== undefined) {
writeVarint32(bb, 26)
let nested = popByteBuffer()
_encodeStats($stats, nested)
writeVarint32(bb, nested.limit)
writeByteBuffer(bb, nested)
pushByteBuffer(nested)
}
}
export function decodeSegyHeader(binary: Uint8Array): SegyHeader {
return _decodeSegyHeader(wrapByteBuffer(binary))
}
function _decodeSegyHeader(bb: ByteBuffer): SegyHeader {
let message: SegyHeader = {} as any
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb)
switch (tag >>> 3) {
case 0:
break end_of_message
// optional string textHeader = 1;
case 1: {
message.textHeader = readString(bb, readVarint32(bb))
break
}
// optional BinaryHeader binaryHeader = 2;
case 2: {
let limit = pushTemporaryLength(bb)
message.binaryHeader = _decodeBinaryHeader(bb)
bb.limit = limit
break
}
// optional Stats stats = 3;
case 3: {
let limit = pushTemporaryLength(bb)
message.stats = _decodeStats(bb)
bb.limit = limit
break
}
default:
skipUnknownField(bb, tag & 7)
}
}
return message
}
export interface Stats {
samplesDelta?: number
samplesPerTrace?: number
CDPLow?: number
CDPHigh?: number
CDPDistance?: number
CDPTraceLow?: number
CDPTraceHigh?: number
CDPTraceDistance?: number
tracesPerSlice?: number
slicesCount?: number
tracesCount?: number
}
export function encodeStats(message: Stats): Uint8Array {
let bb = popByteBuffer()
_encodeStats(message, bb)
return toUint8Array(bb)
}
function _encodeStats(message: Stats, bb: ByteBuffer): void {
// optional double samplesDelta = 1;
let $samplesDelta = message.samplesDelta
if ($samplesDelta !== undefined) {
writeVarint32(bb, 9)
writeDouble(bb, $samplesDelta)
}
// optional int32 samplesPerTrace = 2;
let $samplesPerTrace = message.samplesPerTrace
if ($samplesPerTrace !== undefined) {
writeVarint32(bb, 16)
writeVarint64(bb, intToLong($samplesPerTrace))
}
// optional int32 CDPLow = 3;
let $CDPLow = message.CDPLow
if ($CDPLow !== undefined) {
writeVarint32(bb, 24)
writeVarint64(bb, intToLong($CDPLow))
}
// optional int32 CDPHigh = 4;
let $CDPHigh = message.CDPHigh
if ($CDPHigh !== undefined) {
writeVarint32(bb, 32)
writeVarint64(bb, intToLong($CDPHigh))
}
// optional int32 CDPDistance = 5;
let $CDPDistance = message.CDPDistance
if ($CDPDistance !== undefined) {
writeVarint32(bb, 40)
writeVarint64(bb, intToLong($CDPDistance))
}
// optional int32 CDPTraceLow = 6;
let $CDPTraceLow = message.CDPTraceLow
if ($CDPTraceLow !== undefined) {
writeVarint32(bb, 48)
writeVarint64(bb, intToLong($CDPTraceLow))
}
// optional int32 CDPTraceHigh = 7;
let $CDPTraceHigh = message.CDPTraceHigh
if ($CDPTraceHigh !== undefined) {
writeVarint32(bb, 56)
writeVarint64(bb, intToLong($CDPTraceHigh))
}
// optional int32 CDPTraceDistance = 8;
let $CDPTraceDistance = message.CDPTraceDistance
if ($CDPTraceDistance !== undefined) {
writeVarint32(bb, 64)
writeVarint64(bb, intToLong($CDPTraceDistance))
}
// optional int32 tracesPerSlice = 9;
let $tracesPerSlice = message.tracesPerSlice
if ($tracesPerSlice !== undefined) {
writeVarint32(bb, 72)
writeVarint64(bb, intToLong($tracesPerSlice))
}
// optional int32 slicesCount = 10;
let $slicesCount = message.slicesCount
if ($slicesCount !== undefined) {
writeVarint32(bb, 80)
writeVarint64(bb, intToLong($slicesCount))
}
// optional int32 tracesCount = 11;
let $tracesCount = message.tracesCount
if ($tracesCount !== undefined) {
writeVarint32(bb, 88)
writeVarint64(bb, intToLong($tracesCount))
}
}
export function decodeStats(binary: Uint8Array): Stats {
return _decodeStats(wrapByteBuffer(binary))
}
function _decodeStats(bb: ByteBuffer): Stats {
let message: Stats = {} as any
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb)
switch (tag >>> 3) {
case 0:
break end_of_message
// optional double samplesDelta = 1;
case 1: {
message.samplesDelta = readDouble(bb)
break
}
// optional int32 samplesPerTrace = 2;
case 2: {
message.samplesPerTrace = readVarint32(bb)
break
}
// optional int32 CDPLow = 3;
case 3: {
message.CDPLow = readVarint32(bb)
break
}
// optional int32 CDPHigh = 4;
case 4: {
message.CDPHigh = readVarint32(bb)
break
}
// optional int32 CDPDistance = 5;
case 5: {
message.CDPDistance = readVarint32(bb)
break
}
// optional int32 CDPTraceLow = 6;
case 6: {
message.CDPTraceLow = readVarint32(bb)
break
}
// optional int32 CDPTraceHigh = 7;
case 7: {
message.CDPTraceHigh = readVarint32(bb)
break
}
// optional int32 CDPTraceDistance = 8;
case 8: {
message.CDPTraceDistance = readVarint32(bb)
break
}
// optional int32 tracesPerSlice = 9;
case 9: {
message.tracesPerSlice = readVarint32(bb)
break
}
// optional int32 slicesCount = 10;
case 10: {
message.slicesCount = readVarint32(bb)
break
}
// optional int32 tracesCount = 11;
case 11: {
message.tracesCount = readVarint32(bb)
break
}
default:
skipUnknownField(bb, tag & 7)
}
}
return message
}
export interface BinaryHeader {
JobID?: number
LineNumber?: number
ReelNumber?: number
Traces?: number
AuxTraces?: number
Interval?: number
IntervalOriginal?: number
Samples?: number
SamplesOriginal?: number
Format?: number
EnsembleFold?: number
SortingCode?: number
VerticalSum?: number
SweepFrequencyStart?: number
SweepFrequencyEnd?: number
SweepLength?: number
Sweep?: number
SweepChannel?: number
SweepTaperStart?: number
SweepTaperEnd?: number
Taper?: number
CorrelatedTraces?: number
BinaryGainRecovery?: number
AmplitudeRecovery?: number
MeasurementSystem?: number
ImpulseSignalPolarity?: number
VibratoryPolarity?: number
SEGY_BIN_EXT_TRACES?: number
SEGY_BIN_EXT_AUX_TRACES?: number
SEGY_BIN_DT?: number
SEGY_BIN_EXT_SAMPLES?: number
SEGY_BIN_EXT_SAMPLE_INTERVAL?: Long
SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG?: Long
SEGY_BIN_EXT_SAMPLES_ORIGINAL?: number
SEGY_BIN_EXT_ENSEMBLE_FOLD?: number
SEGY_BIN_EXT_BYTE_ORDER_CHECK?: number
SEGY_BIN_NS?: number
SEGY_BIN_SEGY_REVISION_MAJOR?: number
SEGY_BIN_SEGY_REVISION_MINOR?: number
SEGY_BIN_FIXED_LENGTH_TRACES?: number
SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS?: number
SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS?: number
SEGY_BIN_TIME_BASIS_CODE?: number
SEGY_BIN_TRACE_NUMBER?: Long
SEGY_BIN_BYTE_OFFSET_FOR_TRACES?: Long
SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS?: number
}
export function encodeBinaryHeader(message: BinaryHeader): Uint8Array {
let bb = popByteBuffer()
_encodeBinaryHeader(message, bb)
return toUint8Array(bb)
}
function _encodeBinaryHeader(message: BinaryHeader, bb: ByteBuffer): void {
// optional int32 JobID = 1;
let $JobID = message.JobID
if ($JobID !== undefined) {
writeVarint32(bb, 8)
writeVarint64(bb, intToLong($JobID))
}
// optional int32 LineNumber = 2;
let $LineNumber = message.LineNumber
if ($LineNumber !== undefined) {
writeVarint32(bb, 16)
writeVarint64(bb, intToLong($LineNumber))
}
// optional int32 ReelNumber = 3;
let $ReelNumber = message.ReelNumber
if ($ReelNumber !== undefined) {
writeVarint32(bb, 24)
writeVarint64(bb, intToLong($ReelNumber))
}
// optional int32 Traces = 4;
let $Traces = message.Traces
if ($Traces !== undefined) {
writeVarint32(bb, 32)
writeVarint64(bb, intToLong($Traces))
}
// optional int32 AuxTraces = 5;
let $AuxTraces = message.AuxTraces
if ($AuxTraces !== undefined) {
writeVarint32(bb, 40)
writeVarint64(bb, intToLong($AuxTraces))
}
// optional int32 Interval = 6;
let $Interval = message.Interval
if ($Interval !== undefined) {
writeVarint32(bb, 48)
writeVarint64(bb, intToLong($Interval))
}
// optional int32 IntervalOriginal = 7;
let $IntervalOriginal = message.IntervalOriginal
if ($IntervalOriginal !== undefined) {
writeVarint32(bb, 56)
writeVarint64(bb, intToLong($IntervalOriginal))
}
// optional int32 Samples = 8;
let $Samples = message.Samples
if ($Samples !== undefined) {
writeVarint32(bb, 64)
writeVarint64(bb, intToLong($Samples))
}
// optional int32 SamplesOriginal = 9;
let $SamplesOriginal = message.SamplesOriginal
if ($SamplesOriginal !== undefined) {
writeVarint32(bb, 72)
writeVarint64(bb, intToLong($SamplesOriginal))
}
// optional int32 Format = 10;
let $Format = message.Format
if ($Format !== undefined) {
writeVarint32(bb, 80)
writeVarint64(bb, intToLong($Format))
}
// optional int32 EnsembleFold = 11;
let $EnsembleFold = message.EnsembleFold
if ($EnsembleFold !== undefined) {
writeVarint32(bb, 88)
writeVarint64(bb, intToLong($EnsembleFold))
}
// optional int32 SortingCode = 12;
let $SortingCode = message.SortingCode
if ($SortingCode !== undefined) {
writeVarint32(bb, 96)
writeVarint64(bb, intToLong($SortingCode))
}
// optional int32 VerticalSum = 13;
let $VerticalSum = message.VerticalSum
if ($VerticalSum !== undefined) {
writeVarint32(bb, 104)
writeVarint64(bb, intToLong($VerticalSum))
}
// optional int32 SweepFrequencyStart = 14;
let $SweepFrequencyStart = message.SweepFrequencyStart
if ($SweepFrequencyStart !== undefined) {
writeVarint32(bb, 112)
writeVarint64(bb, intToLong($SweepFrequencyStart))
}
// optional int32 SweepFrequencyEnd = 15;
let $SweepFrequencyEnd = message.SweepFrequencyEnd
if ($SweepFrequencyEnd !== undefined) {
writeVarint32(bb, 120)
writeVarint64(bb, intToLong($SweepFrequencyEnd))
}
// optional int32 SweepLength = 16;
let $SweepLength = message.SweepLength
if ($SweepLength !== undefined) {
writeVarint32(bb, 128)
writeVarint64(bb, intToLong($SweepLength))
}
// optional int32 Sweep = 17;
let $Sweep = message.Sweep
if ($Sweep !== undefined) {
writeVarint32(bb, 136)
writeVarint64(bb, intToLong($Sweep))
}
// optional int32 SweepChannel = 18;
let $SweepChannel = message.SweepChannel
if ($SweepChannel !== undefined) {
writeVarint32(bb, 144)
writeVarint64(bb, intToLong($SweepChannel))
}
// optional int32 SweepTaperStart = 19;
let $SweepTaperStart = message.SweepTaperStart
if ($SweepTaperStart !== undefined) {
writeVarint32(bb, 152)
writeVarint64(bb, intToLong($SweepTaperStart))
}
// optional int32 SweepTaperEnd = 20;
let $SweepTaperEnd = message.SweepTaperEnd
if ($SweepTaperEnd !== undefined) {
writeVarint32(bb, 160)
writeVarint64(bb, intToLong($SweepTaperEnd))
}
// optional int32 Taper = 21;
let $Taper = message.Taper
if ($Taper !== undefined) {
writeVarint32(bb, 168)
writeVarint64(bb, intToLong($Taper))
}
// optional int32 CorrelatedTraces = 22;
let $CorrelatedTraces = message.CorrelatedTraces
if ($CorrelatedTraces !== undefined) {
writeVarint32(bb, 176)
writeVarint64(bb, intToLong($CorrelatedTraces))
}
// optional int32 BinaryGainRecovery = 23;
let $BinaryGainRecovery = message.BinaryGainRecovery
if ($BinaryGainRecovery !== undefined) {
writeVarint32(bb, 184)
writeVarint64(bb, intToLong($BinaryGainRecovery))
}
// optional int32 AmplitudeRecovery = 24;
let $AmplitudeRecovery = message.AmplitudeRecovery
if ($AmplitudeRecovery !== undefined) {
writeVarint32(bb, 192)
writeVarint64(bb, intToLong($AmplitudeRecovery))
}
// optional int32 MeasurementSystem = 25;
let $MeasurementSystem = message.MeasurementSystem
if ($MeasurementSystem !== undefined) {
writeVarint32(bb, 200)
writeVarint64(bb, intToLong($MeasurementSystem))
}
// optional int32 ImpulseSignalPolarity = 26;
let $ImpulseSignalPolarity = message.ImpulseSignalPolarity
if ($ImpulseSignalPolarity !== undefined) {
writeVarint32(bb, 208)
writeVarint64(bb, intToLong($ImpulseSignalPolarity))
}
// optional int32 VibratoryPolarity = 27;
let $VibratoryPolarity = message.VibratoryPolarity
if ($VibratoryPolarity !== undefined) {
writeVarint32(bb, 216)
writeVarint64(bb, intToLong($VibratoryPolarity))
}
// optional int32 SEGY_BIN_EXT_TRACES = 28;
let $SEGY_BIN_EXT_TRACES = message.SEGY_BIN_EXT_TRACES
if ($SEGY_BIN_EXT_TRACES !== undefined) {
writeVarint32(bb, 224)
writeVarint64(bb, intToLong($SEGY_BIN_EXT_TRACES))
}
// optional int32 SEGY_BIN_EXT_AUX_TRACES = 29;
let $SEGY_BIN_EXT_AUX_TRACES = message.SEGY_BIN_EXT_AUX_TRACES
if ($SEGY_BIN_EXT_AUX_TRACES !== undefined) {
writeVarint32(bb, 232)
writeVarint64(bb, intToLong($SEGY_BIN_EXT_AUX_TRACES))
}
// optional int32 SEGY_BIN_DT = 30;
let $SEGY_BIN_DT = message.SEGY_BIN_DT
if ($SEGY_BIN_DT !== undefined) {
writeVarint32(bb, 240)
writeVarint64(bb, intToLong($SEGY_BIN_DT))
}
// optional int32 SEGY_BIN_EXT_SAMPLES = 31;
let $SEGY_BIN_EXT_SAMPLES = message.SEGY_BIN_EXT_SAMPLES
if ($SEGY_BIN_EXT_SAMPLES !== undefined) {
writeVarint32(bb, 248)
writeVarint64(bb, intToLong($SEGY_BIN_EXT_SAMPLES))
}
// optional int64 SEGY_BIN_EXT_SAMPLE_INTERVAL = 32;
let $SEGY_BIN_EXT_SAMPLE_INTERVAL = message.SEGY_BIN_EXT_SAMPLE_INTERVAL
if ($SEGY_BIN_EXT_SAMPLE_INTERVAL !== undefined) {
writeVarint32(bb, 256)
writeVarint64(bb, $SEGY_BIN_EXT_SAMPLE_INTERVAL)
}
// optional int64 SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG = 33;
let $SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG = message.SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG
if ($SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG !== undefined) {
writeVarint32(bb, 264)
writeVarint64(bb, $SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG)
}
// optional int32 SEGY_BIN_EXT_SAMPLES_ORIGINAL = 34;
let $SEGY_BIN_EXT_SAMPLES_ORIGINAL = message.SEGY_BIN_EXT_SAMPLES_ORIGINAL
if ($SEGY_BIN_EXT_SAMPLES_ORIGINAL !== undefined) {
writeVarint32(bb, 272)
writeVarint64(bb, intToLong($SEGY_BIN_EXT_SAMPLES_ORIGINAL))
}
// optional int32 SEGY_BIN_EXT_ENSEMBLE_FOLD = 35;
let $SEGY_BIN_EXT_ENSEMBLE_FOLD = message.SEGY_BIN_EXT_ENSEMBLE_FOLD
if ($SEGY_BIN_EXT_ENSEMBLE_FOLD !== undefined) {
writeVarint32(bb, 280)
writeVarint64(bb, intToLong($SEGY_BIN_EXT_ENSEMBLE_FOLD))
}
// optional int32 SEGY_BIN_EXT_BYTE_ORDER_CHECK = 36;
let $SEGY_BIN_EXT_BYTE_ORDER_CHECK = message.SEGY_BIN_EXT_BYTE_ORDER_CHECK
if ($SEGY_BIN_EXT_BYTE_ORDER_CHECK !== undefined) {
writeVarint32(bb, 288)
writeVarint64(bb, intToLong($SEGY_BIN_EXT_BYTE_ORDER_CHECK))
}
// optional int32 SEGY_BIN_NS = 37;
let $SEGY_BIN_NS = message.SEGY_BIN_NS
if ($SEGY_BIN_NS !== undefined) {
writeVarint32(bb, 296)
writeVarint64(bb, intToLong($SEGY_BIN_NS))
}
// optional int32 SEGY_BIN_SEGY_REVISION_MAJOR = 38;
let $SEGY_BIN_SEGY_REVISION_MAJOR = message.SEGY_BIN_SEGY_REVISION_MAJOR
if ($SEGY_BIN_SEGY_REVISION_MAJOR !== undefined) {
writeVarint32(bb, 304)
writeVarint64(bb, intToLong($SEGY_BIN_SEGY_REVISION_MAJOR))
}
// optional int32 SEGY_BIN_SEGY_REVISION_MINOR = 39;
let $SEGY_BIN_SEGY_REVISION_MINOR = message.SEGY_BIN_SEGY_REVISION_MINOR
if ($SEGY_BIN_SEGY_REVISION_MINOR !== undefined) {
writeVarint32(bb, 312)
writeVarint64(bb, intToLong($SEGY_BIN_SEGY_REVISION_MINOR))
}
// optional int32 SEGY_BIN_FIXED_LENGTH_TRACES = 40;
let $SEGY_BIN_FIXED_LENGTH_TRACES = message.SEGY_BIN_FIXED_LENGTH_TRACES
if ($SEGY_BIN_FIXED_LENGTH_TRACES !== undefined) {
writeVarint32(bb, 320)
writeVarint64(bb, intToLong($SEGY_BIN_FIXED_LENGTH_TRACES))
}
// optional int32 SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS = 41;
let $SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS = message.SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS
if ($SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS !== undefined) {
writeVarint32(bb, 328)
writeVarint64(bb, intToLong($SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS))
}
// optional int32 SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS = 42;
let $SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS = message.SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS
if ($SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS !== undefined) {
writeVarint32(bb, 336)
writeVarint64(bb, intToLong($SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS))
}
// optional int32 SEGY_BIN_TIME_BASIS_CODE = 43;
let $SEGY_BIN_TIME_BASIS_CODE = message.SEGY_BIN_TIME_BASIS_CODE
if ($SEGY_BIN_TIME_BASIS_CODE !== undefined) {
writeVarint32(bb, 344)
writeVarint64(bb, intToLong($SEGY_BIN_TIME_BASIS_CODE))
}
// optional uint64 SEGY_BIN_TRACE_NUMBER = 44;
let $SEGY_BIN_TRACE_NUMBER = message.SEGY_BIN_TRACE_NUMBER
if ($SEGY_BIN_TRACE_NUMBER !== undefined) {
writeVarint32(bb, 352)
writeVarint64(bb, $SEGY_BIN_TRACE_NUMBER)
}
// optional uint64 SEGY_BIN_BYTE_OFFSET_FOR_TRACES = 45;
let $SEGY_BIN_BYTE_OFFSET_FOR_TRACES = message.SEGY_BIN_BYTE_OFFSET_FOR_TRACES
if ($SEGY_BIN_BYTE_OFFSET_FOR_TRACES !== undefined) {
writeVarint32(bb, 360)
writeVarint64(bb, $SEGY_BIN_BYTE_OFFSET_FOR_TRACES)
}
// optional int32 SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS = 46;
let $SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS = message.SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS
if ($SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS !== undefined) {
writeVarint32(bb, 368)
writeVarint64(bb, intToLong($SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS))
}
}
export function decodeBinaryHeader(binary: Uint8Array): BinaryHeader {
return _decodeBinaryHeader(wrapByteBuffer(binary))
}
function _decodeBinaryHeader(bb: ByteBuffer): BinaryHeader {
let message: BinaryHeader = {} as any
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb)
switch (tag >>> 3) {
case 0:
break end_of_message
// optional int32 JobID = 1;
case 1: {
message.JobID = readVarint32(bb)
break
}
// optional int32 LineNumber = 2;
case 2: {
message.LineNumber = readVarint32(bb)
break
}
// optional int32 ReelNumber = 3;
case 3: {
message.ReelNumber = readVarint32(bb)
break
}
// optional int32 Traces = 4;
case 4: {
message.Traces = readVarint32(bb)
break
}
// optional int32 AuxTraces = 5;
case 5: {
message.AuxTraces = readVarint32(bb)
break
}
// optional int32 Interval = 6;
case 6: {
message.Interval = readVarint32(bb)
break
}
// optional int32 IntervalOriginal = 7;
case 7: {
message.IntervalOriginal = readVarint32(bb)
break
}
// optional int32 Samples = 8;
case 8: {
message.Samples = readVarint32(bb)
break
}
// optional int32 SamplesOriginal = 9;
case 9: {
message.SamplesOriginal = readVarint32(bb)
break
}
// optional int32 Format = 10;
case 10: {
message.Format = readVarint32(bb)
break
}
// optional int32 EnsembleFold = 11;
case 11: {
message.EnsembleFold = readVarint32(bb)
break
}
// optional int32 SortingCode = 12;
case 12: {
message.SortingCode = readVarint32(bb)
break
}
// optional int32 VerticalSum = 13;
case 13: {
message.VerticalSum = readVarint32(bb)
break
}
// optional int32 SweepFrequencyStart = 14;
case 14: {
message.SweepFrequencyStart = readVarint32(bb)
break
}
// optional int32 SweepFrequencyEnd = 15;
case 15: {
message.SweepFrequencyEnd = readVarint32(bb)
break
}
// optional int32 SweepLength = 16;
case 16: {
message.SweepLength = readVarint32(bb)
break
}
// optional int32 Sweep = 17;
case 17: {
message.Sweep = readVarint32(bb)
break
}
// optional int32 SweepChannel = 18;
case 18: {
message.SweepChannel = readVarint32(bb)
break
}
// optional int32 SweepTaperStart = 19;
case 19: {
message.SweepTaperStart = readVarint32(bb)
break
}
// optional int32 SweepTaperEnd = 20;
case 20: {
message.SweepTaperEnd = readVarint32(bb)
break
}
// optional int32 Taper = 21;
case 21: {
message.Taper = readVarint32(bb)
break
}
// optional int32 CorrelatedTraces = 22;
case 22: {
message.CorrelatedTraces = readVarint32(bb)
break
}
// optional int32 BinaryGainRecovery = 23;
case 23: {
message.BinaryGainRecovery = readVarint32(bb)
break
}
// optional int32 AmplitudeRecovery = 24;
case 24: {
message.AmplitudeRecovery = readVarint32(bb)
break
}
// optional int32 MeasurementSystem = 25;
case 25: {
message.MeasurementSystem = readVarint32(bb)
break
}
// optional int32 ImpulseSignalPolarity = 26;
case 26: {
message.ImpulseSignalPolarity = readVarint32(bb)
break
}
// optional int32 VibratoryPolarity = 27;
case 27: {
message.VibratoryPolarity = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_EXT_TRACES = 28;
case 28: {
message.SEGY_BIN_EXT_TRACES = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_EXT_AUX_TRACES = 29;
case 29: {
message.SEGY_BIN_EXT_AUX_TRACES = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_DT = 30;
case 30: {
message.SEGY_BIN_DT = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_EXT_SAMPLES = 31;
case 31: {
message.SEGY_BIN_EXT_SAMPLES = readVarint32(bb)
break
}
// optional int64 SEGY_BIN_EXT_SAMPLE_INTERVAL = 32;
case 32: {
message.SEGY_BIN_EXT_SAMPLE_INTERVAL = readVarint64(bb, /* unsigned */ false)
break
}
// optional int64 SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG = 33;
case 33: {
message.SEGY_BIN_EXT_SAMPLE_INTERVAL_ORIG = readVarint64(bb, /* unsigned */ false)
break
}
// optional int32 SEGY_BIN_EXT_SAMPLES_ORIGINAL = 34;
case 34: {
message.SEGY_BIN_EXT_SAMPLES_ORIGINAL = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_EXT_ENSEMBLE_FOLD = 35;
case 35: {
message.SEGY_BIN_EXT_ENSEMBLE_FOLD = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_EXT_BYTE_ORDER_CHECK = 36;
case 36: {
message.SEGY_BIN_EXT_BYTE_ORDER_CHECK = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_NS = 37;
case 37: {
message.SEGY_BIN_NS = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_SEGY_REVISION_MAJOR = 38;
case 38: {
message.SEGY_BIN_SEGY_REVISION_MAJOR = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_SEGY_REVISION_MINOR = 39;
case 39: {
message.SEGY_BIN_SEGY_REVISION_MINOR = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_FIXED_LENGTH_TRACES = 40;
case 40: {
message.SEGY_BIN_FIXED_LENGTH_TRACES = readVarint32(bb)
break
}
// optional int32 SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS = 41;
case 41: {
message.SEG_BIN_EXT_NUMBER_OF_EXT_FILE_HEADERS = readVarint32(bb)
break
}
// optional int32 SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS = 42;
case 42: {
message.SEG_BIN_EXT_MAX_NUMBER_OF_ADDITIONAL_TRACE_HEADERS = readVarint32(bb)
break
}
// optional int32 SEGY_BIN_TIME_BASIS_CODE = 43;
case 43: {
message.SEGY_BIN_TIME_BASIS_CODE = readVarint32(bb)
break
}
// optional uint64 SEGY_BIN_TRACE_NUMBER = 44;
case 44: {
message.SEGY_BIN_TRACE_NUMBER = readVarint64(bb, /* unsigned */ true)
break
}
// optional uint64 SEGY_BIN_BYTE_OFFSET_FOR_TRACES = 45;
case 45: {
message.SEGY_BIN_BYTE_OFFSET_FOR_TRACES = readVarint64(bb, /* unsigned */ true)
break
}
// optional int32 SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS = 46;
case 46: {
message.SEGY_BIN_NUMBER_OF_3200_BYTE_TRAILERS = readVarint32(bb)
break
}
default:
skipUnknownField(bb, tag & 7)
}
}
return message
}
export interface SliceHeader {
xline?: number
traces?: Trace[]
}
export function encodeSliceHeader(message: SliceHeader): Uint8Array {
let bb = popByteBuffer()
_encodeSliceHeader(message, bb)
return toUint8Array(bb)
}
function _encodeSliceHeader(message: SliceHeader, bb: ByteBuffer): void {
// optional int32 xline = 1;
let $xline = message.xline
if ($xline !== undefined) {
writeVarint32(bb, 8)
writeVarint64(bb, intToLong($xline))
}
// repeated Trace traces = 2;
let array$traces = message.traces
if (array$traces !== undefined) {
for (let value of array$traces) {
writeVarint32(bb, 18)
let nested = popByteBuffer()
_encodeTrace(value, nested)
writeVarint32(bb, nested.limit)
writeByteBuffer(bb, nested)
pushByteBuffer(nested)
}
}
}
export function decodeSliceHeader(binary: Uint8Array): SliceHeader {
return _decodeSliceHeader(wrapByteBuffer(binary))
}
function _decodeSliceHeader(bb: ByteBuffer): SliceHeader {
let message: SliceHeader = {} as any
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb)
switch (tag >>> 3) {
case 0:
break end_of_message
// optional int32 xline = 1;
case 1: {
message.xline = readVarint32(bb)
break
}
// repeated Trace traces = 2;
case 2: {
let limit = pushTemporaryLength(bb)
let values = message.traces || (message.traces = [])
values.push(_decodeTrace(bb))
bb.limit = limit
break
}
default:
skipUnknownField(bb, tag & 7)
}
}
return message
}
export interface Trace {
TRACE_SEQUENCE_LINE?: number
TRACE_SEQUENCE_FILE?: number
FieldRecord?: number
TraceNumber?: number
EnergySourcePoint?: number
CDP?: number
CDP_TRACE?: number
TraceIdentificationCode?: number
NSummedTraces?: number
NStackedTraces?: number
DataUse?: number
offset?: number
ReceiverGroupElevation?: number
SourceSurfaceElevation?: number
SourceDepth?: number
ReceiverDatumElevation?: number
SourceDatumElevation?: number
SourceWaterDepth?: number
GroupWaterDepth?: number
ElevationScalar?: number
SourceGroupScalar?: number
SourceX?: number
SourceY?: number
GroupX?: number
GroupY?: number
CoordinateUnits?: number
WeatheringVelocity?: number
SubWeatheringVelocity?: number
SourceUpholeTime?: number
GroupUpholeTime?: number
SourceStaticCorrection?: number
GroupStaticCorrection?: number
TotalStaticApplied?: number
LagTimeA?: number
LagTimeB?: number
DelayRecordingTime?: number
MuteTimeStart?: number
MuteTimeEND?: number
TRACE_SAMPLE_COUNT?: number
TRACE_SAMPLE_INTERVAL?: number
GainType?: number
InstrumentGainConstant?: number
InstrumentInitialGain?: number
Correlated?: number
SweepFrequencyStart?: number
SweepFrequencyEnd?: number
SweepLength?: number
SweepType?: number
SweepTraceTaperLengthStart?: number
SweepTraceTaperLengthEnd?: number
TaperType?: number
AliasFilterFrequency?: number
AliasFilterSlope?: number
NotchFilterFrequency?: number
NotchFilterSlope?: number
LowCutFrequency?: number
HighCutFrequency?: number
LowCutSlope?: number
HighCutSlope?: number
YearDataRecorded?: number
DayOfYear?: number
HourOfDay?: number
MinuteOfHour?: number
SecondOfMinute?: number
TimeBaseCode?: number
TraceWeightingFactor?: number
GeophoneGroupNumberRoll1?: number
GeophoneGroupNumberFirstTraceOrigField?: number
GeophoneGroupNumberLastTraceOrigField?: number
GapSize?: number
OverTravel?: number
CDP_X?: number
CDP_Y?: number
INLINE_3D?: number
CROSSLINE_3D?: number
ShotPoint?: number
ShotPointScalar?: number
TraceValueMeasurementUnit?: number
TransductionConstantMantissa?: number
TransductionConstantPower?: number
TransductionUnit?: number
TraceIdentifier?: number
ScalarTraceHeader?: number
SourceType?: number
SourceEnergyDirectionMantissa?: number
SourceEnergyDirectionExponent?: number
SourceMeasurementMantissa?: number
SourceMeasurementExponent?: number
SourceMeasurementUnit?: number
UnassignedInt1?: number
UnassignedInt2?: number
}
export function encodeTrace(message: Trace): Uint8Array {
let bb = popByteBuffer()
_encodeTrace(message, bb)
return toUint8Array(bb)
}
function _encodeTrace(message: Trace, bb: ByteBuffer): void {
// optional int32 TRACE_SEQUENCE_LINE = 1;
let $TRACE_SEQUENCE_LINE = message.TRACE_SEQUENCE_LINE
if ($TRACE_SEQUENCE_LINE !== undefined) {
writeVarint32(bb, 8)
writeVarint64(bb, intToLong($TRACE_SEQUENCE_LINE))
}
// optional int32 TRACE_SEQUENCE_FILE = 2;
let $TRACE_SEQUENCE_FILE = message.TRACE_SEQUENCE_FILE
if ($TRACE_SEQUENCE_FILE !== undefined) {
writeVarint32(bb, 16)
writeVarint64(bb, intToLong($TRACE_SEQUENCE_FILE))
}
// optional int32 FieldRecord = 3;
let $FieldRecord = message.FieldRecord
if ($FieldRecord !== undefined) {
writeVarint32(bb, 24)
writeVarint64(bb, intToLong($FieldRecord))
}
// optional int32 TraceNumber = 4;
let $TraceNumber = message.TraceNumber
if ($TraceNumber !== undefined) {
writeVarint32(bb, 32)
writeVarint64(bb, intToLong($TraceNumber))
}
// optional int32 EnergySourcePoint = 5;
let $EnergySourcePoint = message.EnergySourcePoint
if ($EnergySourcePoint !== undefined) {
writeVarint32(bb, 40)
writeVarint64(bb, intToLong($EnergySourcePoint))
}
// optional int32 CDP = 6;
let $CDP = message.CDP
if ($CDP !== undefined) {
writeVarint32(bb, 48)
writeVarint64(bb, intToLong($CDP))
}
// optional int32 CDP_TRACE = 7;
let $CDP_TRACE = message.CDP_TRACE
if ($CDP_TRACE !== undefined) {
writeVarint32(bb, 56)
writeVarint64(bb, intToLong($CDP_TRACE))
}
// optional int32 TraceIdentificationCode = 8;
let $TraceIdentificationCode = message.TraceIdentificationCode
if ($TraceIdentificationCode !== undefined) {
writeVarint32(bb, 64)
writeVarint64(bb, intToLong($TraceIdentificationCode))
}
// optional int32 NSummedTraces = 9;
let $NSummedTraces = message.NSummedTraces
if ($NSummedTraces !== undefined) {
writeVarint32(bb, 72)
writeVarint64(bb, intToLong($NSummedTraces))
}
// optional int32 NStackedTraces = 10;
let $NStackedTraces = message.NStackedTraces
if ($NStackedTraces !== undefined) {
writeVarint32(bb, 80)
writeVarint64(bb, intToLong($NStackedTraces))
}
// optional int32 DataUse = 11;
let $DataUse = message.DataUse
if ($DataUse !== undefined) {
writeVarint32(bb, 88)
writeVarint64(bb, intToLong($DataUse))
}
// optional int32 offset = 12;
let $offset = message.offset
if ($offset !== undefined) {
writeVarint32(bb, 96)
writeVarint64(bb, intToLong($offset))
}
// optional int32 ReceiverGroupElevation = 13;
let $ReceiverGroupElevation = message.ReceiverGroupElevation
if ($ReceiverGroupElevation !== undefined) {
writeVarint32(bb, 104)
writeVarint64(bb, intToLong($ReceiverGroupElevation))
}
// optional int32 SourceSurfaceElevation = 14;
let $SourceSurfaceElevation = message.SourceSurfaceElevation
if ($SourceSurfaceElevation !== undefined) {
writeVarint32(bb, 112)
writeVarint64(bb, intToLong($SourceSurfaceElevation))
}
// optional int32 SourceDepth = 15;
let $SourceDepth = message.SourceDepth
if ($SourceDepth !== undefined) {
writeVarint32(bb, 120)
writeVarint64(bb, intToLong($SourceDepth))
}
// optional int32 ReceiverDatumElevation = 16;
let $ReceiverDatumElevation = message.ReceiverDatumElevation
if ($ReceiverDatumElevation !== undefined) {
writeVarint32(bb, 128)
writeVarint64(bb, intToLong($ReceiverDatumElevation))
}
// optional int32 SourceDatumElevation = 17;
let $SourceDatumElevation = message.SourceDatumElevation
if ($SourceDatumElevation !== undefined) {
writeVarint32(bb, 136)
writeVarint64(bb, intToLong($SourceDatumElevation))
}
// optional int32 SourceWaterDepth = 18;
let $SourceWaterDepth = message.SourceWaterDepth
if ($SourceWaterDepth !== undefined) {
writeVarint32(bb, 144)
writeVarint64(bb, intToLong($SourceWaterDepth))
}
// optional int32 GroupWaterDepth = 19;
let $GroupWaterDepth = message.GroupWaterDepth
if ($GroupWaterDepth !== undefined) {
writeVarint32(bb, 152)
writeVarint64(bb, intToLong($GroupWaterDepth))
}
// optional int32 ElevationScalar = 20;
let $ElevationScalar = message.ElevationScalar
if ($ElevationScalar !== undefined) {
writeVarint32(bb, 160)
writeVarint64(bb, intToLong($ElevationScalar))
}
// optional int32 SourceGroupScalar = 21;
let $SourceGroupScalar = message.SourceGroupScalar
if ($SourceGroupScalar !== undefined) {
writeVarint32(bb, 168)
writeVarint64(bb, intToLong($SourceGroupScalar))
}
// optional int32 SourceX = 22;
let $SourceX = message.SourceX
if ($SourceX !== undefined) {
writeVarint32(bb, 176)
writeVarint64(bb, intToLong($SourceX))
}
// optional int32 SourceY = 23;
let $SourceY = message.SourceY
if ($SourceY !== undefined) {
writeVarint32(bb, 184)
writeVarint64(bb, intToLong($SourceY))
}
// optional int32 GroupX = 24;
let $GroupX = message.GroupX
if ($GroupX !== undefined) {
writeVarint32(bb, 192)
writeVarint64(bb, intToLong($GroupX))
}
// optional int32 GroupY = 25;
let $GroupY = message.GroupY
if ($GroupY !== undefined) {
writeVarint32(bb, 200)
writeVarint64(bb, intToLong($GroupY))
}
// optional int32 CoordinateUnits = 26;
let $CoordinateUnits = message.CoordinateUnits
if ($CoordinateUnits !== undefined) {
writeVarint32(bb, 208)
writeVarint64(bb, intToLong($CoordinateUnits))
}
// optional int32 WeatheringVelocity = 27;
let $WeatheringVelocity = message.WeatheringVelocity
if ($WeatheringVelocity !== undefined) {
writeVarint32(bb, 216)
writeVarint64(bb, intToLong($WeatheringVelocity))
}
// optional int32 SubWeatheringVelocity = 28;
let $SubWeatheringVelocity = message.SubWeatheringVelocity
if ($SubWeatheringVelocity !== undefined) {
writeVarint32(bb, 224)
writeVarint64(bb, intToLong($SubWeatheringVelocity))
}
// optional int32 SourceUpholeTime = 29;
let $SourceUpholeTime = message.SourceUpholeTime
if ($SourceUpholeTime !== undefined) {
writeVarint32(bb, 232)
writeVarint64(bb, intToLong($SourceUpholeTime))
}
// optional int32 GroupUpholeTime = 30;
let $GroupUpholeTime = message.GroupUpholeTime
if ($GroupUpholeTime !== undefined) {
writeVarint32(bb, 240)
writeVarint64(bb, intToLong($GroupUpholeTime))
}
// optional int32 SourceStaticCorrection = 31;
let $SourceStaticCorrection = message.SourceStaticCorrection
if ($SourceStaticCorrection !== undefined) {
writeVarint32(bb, 248)
writeVarint64(bb, intToLong($SourceStaticCorrection))
}
// optional int32 GroupStaticCorrection = 32;
let $GroupStaticCorrection = message.GroupStaticCorrection
if ($GroupStaticCorrection !== undefined) {
writeVarint32(bb, 256)
writeVarint64(bb, intToLong($GroupStaticCorrection))
}
// optional int32 TotalStaticApplied = 33;
let $TotalStaticApplied = message.TotalStaticApplied
if ($TotalStaticApplied !== undefined) {
writeVarint32(bb, 264)
writeVarint64(bb, intToLong($TotalStaticApplied))
}
// optional int32 LagTimeA = 34;
let $LagTimeA = message.LagTimeA
if ($LagTimeA !== undefined) {
writeVarint32(bb, 272)
writeVarint64(bb, intToLong($LagTimeA))
}
// optional int32 LagTimeB = 35;
let $LagTimeB = message.LagTimeB
if ($LagTimeB !== undefined) {
writeVarint32(bb, 280)
writeVarint64(bb, intToLong($LagTimeB))
}
// optional int32 DelayRecordingTime = 36;
let $DelayRecordingTime = message.DelayRecordingTime
if ($DelayRecordingTime !== undefined) {
writeVarint32(bb, 288)
writeVarint64(bb, intToLong($DelayRecordingTime))
}
// optional int32 MuteTimeStart = 37;
let $MuteTimeStart = message.MuteTimeStart
if ($MuteTimeStart !== undefined) {
writeVarint32(bb, 296)
writeVarint64(bb, intToLong($MuteTimeStart))
}
// optional int32 MuteTimeEND = 38;
let $MuteTimeEND = message.MuteTimeEND
if ($MuteTimeEND !== undefined) {
writeVarint32(bb, 304)
writeVarint64(bb, intToLong($MuteTimeEND))
}
// optional int32 TRACE_SAMPLE_COUNT = 39;
let $TRACE_SAMPLE_COUNT = message.TRACE_SAMPLE_COUNT
if ($TRACE_SAMPLE_COUNT !== undefined) {
writeVarint32(bb, 312)
writeVarint64(bb, intToLong($TRACE_SAMPLE_COUNT))
}
// optional int32 TRACE_SAMPLE_INTERVAL = 40;
let $TRACE_SAMPLE_INTERVAL = message.TRACE_SAMPLE_INTERVAL
if ($TRACE_SAMPLE_INTERVAL !== undefined) {
writeVarint32(bb, 320)
writeVarint64(bb, intToLong($TRACE_SAMPLE_INTERVAL))
}
// optional int32 GainType = 41;
let $GainType = message.GainType
if ($GainType !== undefined) {
writeVarint32(bb, 328)
writeVarint64(bb, intToLong($GainType))
}
// optional int32 InstrumentGainConstant = 42;
let $InstrumentGainConstant = message.InstrumentGainConstant
if ($InstrumentGainConstant !== undefined) {
writeVarint32(bb, 336)
writeVarint64(bb, intToLong($InstrumentGainConstant))
}
// optional int32 InstrumentInitialGain = 43;
let $InstrumentInitialGain = message.InstrumentInitialGain
if ($InstrumentInitialGain !== undefined) {
writeVarint32(bb, 344)
writeVarint64(bb, intToLong($InstrumentInitialGain))
}
// optional int32 Correlated = 44;
let $Correlated = message.Correlated
if ($Correlated !== undefined) {
writeVarint32(bb, 352)
writeVarint64(bb, intToLong($Correlated))
}
// optional int32 SweepFrequencyStart = 45;
let $SweepFrequencyStart = message.SweepFrequencyStart
if ($SweepFrequencyStart !== undefined) {
writeVarint32(bb, 360)
writeVarint64(bb, intToLong($SweepFrequencyStart))
}
// optional int32 SweepFrequencyEnd = 46;
let $SweepFrequencyEnd = message.SweepFrequencyEnd
if ($SweepFrequencyEnd !== undefined) {
writeVarint32(bb, 368)
writeVarint64(bb, intToLong($SweepFrequencyEnd))
}
// optional int32 SweepLength = 47;
let $SweepLength = message.SweepLength
if ($SweepLength !== undefined) {
writeVarint32(bb, 376)
writeVarint64(bb, intToLong($SweepLength))
}
// optional int32 SweepType = 48;
let $SweepType = message.SweepType
if ($SweepType !== undefined) {
writeVarint32(bb, 384)
writeVarint64(bb, intToLong($SweepType))
}
// optional int32 SweepTraceTaperLengthStart = 49;
let $SweepTraceTaperLengthStart = message.SweepTraceTaperLengthStart
if ($SweepTraceTaperLengthStart !== undefined) {
writeVarint32(bb, 392)
writeVarint64(bb, intToLong($SweepTraceTaperLengthStart))
}
// optional int32 SweepTraceTaperLengthEnd = 50;
let $SweepTraceTaperLengthEnd = message.SweepTraceTaperLengthEnd
if ($SweepTraceTaperLengthEnd !== undefined) {
writeVarint32(bb, 400)
writeVarint64(bb, intToLong($SweepTraceTaperLengthEnd))
}
// optional int32 TaperType = 51;
let $TaperType = message.TaperType
if ($TaperType !== undefined) {
writeVarint32(bb, 408)
writeVarint64(bb, intToLong($TaperType))
}
// optional int32 AliasFilterFrequency = 52;
let $AliasFilterFrequency = message.AliasFilterFrequency
if ($AliasFilterFrequency !== undefined) {
writeVarint32(bb, 416)
writeVarint64(bb, intToLong($AliasFilterFrequency))
}
// optional int32 AliasFilterSlope = 53;
let $AliasFilterSlope = message.AliasFilterSlope
if ($AliasFilterSlope !== undefined) {
writeVarint32(bb, 424)
writeVarint64(bb, intToLong($AliasFilterSlope))
}
// optional int32 NotchFilterFrequency = 54;
let $NotchFilterFrequency = message.NotchFilterFrequency
if ($NotchFilterFrequency !== undefined) {
writeVarint32(bb, 432)
writeVarint64(bb, intToLong($NotchFilterFrequency))
}
// optional int32 NotchFilterSlope = 55;
let $NotchFilterSlope = message.NotchFilterSlope
if ($NotchFilterSlope !== undefined) {
writeVarint32(bb, 440)
writeVarint64(bb, intToLong($NotchFilterSlope))
}
// optional int32 LowCutFrequency = 56;
let $LowCutFrequency = message.LowCutFrequency
if ($LowCutFrequency !== undefined) {
writeVarint32(bb, 448)
writeVarint64(bb, intToLong($LowCutFrequency))
}
// optional int32 HighCutFrequency = 57;
let $HighCutFrequency = message.HighCutFrequency
if ($HighCutFrequency !== undefined) {
writeVarint32(bb, 456)
writeVarint64(bb, intToLong($HighCutFrequency))
}
// optional int32 LowCutSlope = 58;
let $LowCutSlope = message.LowCutSlope
if ($LowCutSlope !== undefined) {
writeVarint32(bb, 464)
writeVarint64(bb, intToLong($LowCutSlope))
}
// optional int32 HighCutSlope = 59;
let $HighCutSlope = message.HighCutSlope
if ($HighCutSlope !== undefined) {
writeVarint32(bb, 472)
writeVarint64(bb, intToLong($HighCutSlope))
}
// optional int32 YearDataRecorded = 60;
let $YearDataRecorded = message.YearDataRecorded
if ($YearDataRecorded !== undefined) {
writeVarint32(bb, 480)
writeVarint64(bb, intToLong($YearDataRecorded))
}
// optional int32 DayOfYear = 61;
let $DayOfYear = message.DayOfYear
if ($DayOfYear !== undefined) {
writeVarint32(bb, 488)
writeVarint64(bb, intToLong($DayOfYear))
}
// optional int32 HourOfDay = 62;
let $HourOfDay = message.HourOfDay
if ($HourOfDay !== undefined) {
writeVarint32(bb, 496)
writeVarint64(bb, intToLong($HourOfDay))
}
// optional int32 MinuteOfHour = 63;
let $MinuteOfHour = message.MinuteOfHour
if ($MinuteOfHour !== undefined) {
writeVarint32(bb, 504)
writeVarint64(bb, intToLong($MinuteOfHour))
}
// optional int32 SecondOfMinute = 64;
let $SecondOfMinute = message.SecondOfMinute
if ($SecondOfMinute !== undefined) {
writeVarint32(bb, 512)
writeVarint64(bb, intToLong($SecondOfMinute))
}
// optional int32 TimeBaseCode = 65;
let $TimeBaseCode = message.TimeBaseCode
if ($TimeBaseCode !== undefined) {
writeVarint32(bb, 520)
writeVarint64(bb, intToLong($TimeBaseCode))
}
// optional int32 TraceWeightingFactor = 66;
let $TraceWeightingFactor = message.TraceWeightingFactor
if ($TraceWeightingFactor !== undefined) {
writeVarint32(bb, 528)
writeVarint64(bb, intToLong($TraceWeightingFactor))
}
// optional int32 GeophoneGroupNumberRoll1 = 67;
let $GeophoneGroupNumberRoll1 = message.GeophoneGroupNumberRoll1
if ($GeophoneGroupNumberRoll1 !== undefined) {
writeVarint32(bb, 536)
writeVarint64(bb, intToLong($GeophoneGroupNumberRoll1))
}
// optional int32 GeophoneGroupNumberFirstTraceOrigField = 68;
let $GeophoneGroupNumberFirstTraceOrigField = message.GeophoneGroupNumberFirstTraceOrigField
if ($GeophoneGroupNumberFirstTraceOrigField !== undefined) {
writeVarint32(bb, 544)
writeVarint64(bb, intToLong($GeophoneGroupNumberFirstTraceOrigField))
}
// optional int32 GeophoneGroupNumberLastTraceOrigField = 69;
let $GeophoneGroupNumberLastTraceOrigField = message.GeophoneGroupNumberLastTraceOrigField
if ($GeophoneGroupNumberLastTraceOrigField !== undefined) {
writeVarint32(bb, 552)
writeVarint64(bb, intToLong($GeophoneGroupNumberLastTraceOrigField))
}
// optional int32 GapSize = 70;
let $GapSize = message.GapSize
if ($GapSize !== undefined) {
writeVarint32(bb, 560)
writeVarint64(bb, intToLong($GapSize))
}
// optional int32 OverTravel = 71;
let $OverTravel = message.OverTravel
if ($OverTravel !== undefined) {
writeVarint32(bb, 568)
writeVarint64(bb, intToLong($OverTravel))
}
// optional int32 CDP_X = 72;
let $CDP_X = message.CDP_X
if ($CDP_X !== undefined) {
writeVarint32(bb, 576)
writeVarint64(bb, intToLong($CDP_X))
}
// optional int32 CDP_Y = 73;
let $CDP_Y = message.CDP_Y
if ($CDP_Y !== undefined) {
writeVarint32(bb, 584)
writeVarint64(bb, intToLong($CDP_Y))
}
// optional int32 INLINE_3D = 74;
let $INLINE_3D = message.INLINE_3D
if ($INLINE_3D !== undefined) {
writeVarint32(bb, 592)
writeVarint64(bb, intToLong($INLINE_3D))
}
// optional int32 CROSSLINE_3D = 75;
let $CROSSLINE_3D = message.CROSSLINE_3D
if ($CROSSLINE_3D !== undefined) {
writeVarint32(bb, 600)
writeVarint64(bb, intToLong($CROSSLINE_3D))
}
// optional int32 ShotPoint = 76;
let $ShotPoint = message.ShotPoint
if ($ShotPoint !== undefined) {
writeVarint32(bb, 608)
writeVarint64(bb, intToLong($ShotPoint))
}
// optional int32 ShotPointScalar = 77;
let $ShotPointScalar = message.ShotPointScalar
if ($ShotPointScalar !== undefined) {
writeVarint32(bb, 616)
writeVarint64(bb, intToLong($ShotPointScalar))
}
// optional int32 TraceValueMeasurementUnit = 78;
let $TraceValueMeasurementUnit = message.TraceValueMeasurementUnit
if ($TraceValueMeasurementUnit !== undefined) {
writeVarint32(bb, 624)
writeVarint64(bb, intToLong($TraceValueMeasurementUnit))
}
// optional int32 TransductionConstantMantissa = 79;
let $TransductionConstantMantissa = message.TransductionConstantMantissa
if ($TransductionConstantMantissa !== undefined) {
writeVarint32(bb, 632)
writeVarint64(bb, intToLong($TransductionConstantMantissa))
}
// optional int32 TransductionConstantPower = 80;
let $TransductionConstantPower = message.TransductionConstantPower
if ($TransductionConstantPower !== undefined) {
writeVarint32(bb, 640)
writeVarint64(bb, intToLong($TransductionConstantPower))
}
// optional int32 TransductionUnit = 81;
let $TransductionUnit = message.TransductionUnit
if ($TransductionUnit !== undefined) {
writeVarint32(bb, 648)
writeVarint64(bb, intToLong($TransductionUnit))
}
// optional int32 TraceIdentifier = 82;
let $TraceIdentifier = message.TraceIdentifier
if ($TraceIdentifier !== undefined) {
writeVarint32(bb, 656)
writeVarint64(bb, intToLong($TraceIdentifier))
}
// optional int32 ScalarTraceHeader = 83;
let $ScalarTraceHeader = message.ScalarTraceHeader
if ($ScalarTraceHeader !== undefined) {
writeVarint32(bb, 664)
writeVarint64(bb, intToLong($ScalarTraceHeader))
}
// optional int32 SourceType = 84;
let $SourceType = message.SourceType
if ($SourceType !== undefined) {
writeVarint32(bb, 672)
writeVarint64(bb, intToLong($SourceType))
}
// optional int32 SourceEnergyDirectionMantissa = 85;
let $SourceEnergyDirectionMantissa = message.SourceEnergyDirectionMantissa
if ($SourceEnergyDirectionMantissa !== undefined) {
writeVarint32(bb, 680)
writeVarint64(bb, intToLong($SourceEnergyDirectionMantissa))
}
// optional int32 SourceEnergyDirectionExponent = 86;
let $SourceEnergyDirectionExponent = message.SourceEnergyDirectionExponent
if ($SourceEnergyDirectionExponent !== undefined) {
writeVarint32(bb, 688)
writeVarint64(bb, intToLong($SourceEnergyDirectionExponent))
}
// optional int32 SourceMeasurementMantissa = 87;
let $SourceMeasurementMantissa = message.SourceMeasurementMantissa
if ($SourceMeasurementMantissa !== undefined) {
writeVarint32(bb, 696)
writeVarint64(bb, intToLong($SourceMeasurementMantissa))
}
// optional int32 SourceMeasurementExponent = 88;
let $SourceMeasurementExponent = message.SourceMeasurementExponent
if ($SourceMeasurementExponent !== undefined) {
writeVarint32(bb, 704)
writeVarint64(bb, intToLong($SourceMeasurementExponent))
}
// optional int32 SourceMeasurementUnit = 89;
let $SourceMeasurementUnit = message.SourceMeasurementUnit
if ($SourceMeasurementUnit !== undefined) {
writeVarint32(bb, 712)
writeVarint64(bb, intToLong($SourceMeasurementUnit))
}
// optional int32 UnassignedInt1 = 90;
let $UnassignedInt1 = message.UnassignedInt1
if ($UnassignedInt1 !== undefined) {
writeVarint32(bb, 720)
writeVarint64(bb, intToLong($UnassignedInt1))
}
// optional int32 UnassignedInt2 = 91;
let $UnassignedInt2 = message.UnassignedInt2
if ($UnassignedInt2 !== undefined) {
writeVarint32(bb, 728)
writeVarint64(bb, intToLong($UnassignedInt2))
}
}
export function decodeTrace(binary: Uint8Array): Trace {
return _decodeTrace(wrapByteBuffer(binary))
}
function _decodeTrace(bb: ByteBuffer): Trace {
let message: Trace = {} as any
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb)
switch (tag >>> 3) {
case 0:
break end_of_message
// optional int32 TRACE_SEQUENCE_LINE = 1;
case 1: {
message.TRACE_SEQUENCE_LINE = readVarint32(bb)
break
}
// optional int32 TRACE_SEQUENCE_FILE = 2;
case 2: {
message.TRACE_SEQUENCE_FILE = readVarint32(bb)
break
}
// optional int32 FieldRecord = 3;
case 3: {
message.FieldRecord = readVarint32(bb)
break
}
// optional int32 TraceNumber = 4;
case 4: {
message.TraceNumber = readVarint32(bb)
break
}
// optional int32 EnergySourcePoint = 5;
case 5: {
message.EnergySourcePoint = readVarint32(bb)
break
}
// optional int32 CDP = 6;
case 6: {
message.CDP = readVarint32(bb)
break
}
// optional int32 CDP_TRACE = 7;
case 7: {
message.CDP_TRACE = readVarint32(bb)
break
}
// optional int32 TraceIdentificationCode = 8;
case 8: {
message.TraceIdentificationCode = readVarint32(bb)
break
}
// optional int32 NSummedTraces = 9;
case 9: {
message.NSummedTraces = readVarint32(bb)
break
}
// optional int32 NStackedTraces = 10;
case 10: {
message.NStackedTraces = readVarint32(bb)
break
}
// optional int32 DataUse = 11;
case 11: {
message.DataUse = readVarint32(bb)
break
}
// optional int32 offset = 12;
case 12: {
message.offset = readVarint32(bb)
break
}
// optional int32 ReceiverGroupElevation = 13;
case 13: {
message.ReceiverGroupElevation = readVarint32(bb)
break
}
// optional int32 SourceSurfaceElevation = 14;
case 14: {
message.SourceSurfaceElevation = readVarint32(bb)
break
}
// optional int32 SourceDepth = 15;
case 15: {
message.SourceDepth = readVarint32(bb)
break
}
// optional int32 ReceiverDatumElevation = 16;
case 16: {
message.ReceiverDatumElevation = readVarint32(bb)
break
}
// optional int32 SourceDatumElevation = 17;
case 17: {
message.SourceDatumElevation = readVarint32(bb)
break
}
// optional int32 SourceWaterDepth = 18;
case 18: {
message.SourceWaterDepth = readVarint32(bb)
break
}
// optional int32 GroupWaterDepth = 19;
case 19: {
message.GroupWaterDepth = readVarint32(bb)
break
}
// optional int32 ElevationScalar = 20;
case 20: {
message.ElevationScalar = readVarint32(bb)
break
}
// optional int32 SourceGroupScalar = 21;
case 21: {
message.SourceGroupScalar = readVarint32(bb)
break
}
// optional int32 SourceX = 22;
case 22: {
message.SourceX = readVarint32(bb)
break
}
// optional int32 SourceY = 23;
case 23: {
message.SourceY = readVarint32(bb)
break
}
// optional int32 GroupX = 24;
case 24: {
message.GroupX = readVarint32(bb)
break
}
// optional int32 GroupY = 25;
case 25: {
message.GroupY = readVarint32(bb)
break
}
// optional int32 CoordinateUnits = 26;
case 26: {
message.CoordinateUnits = readVarint32(bb)
break
}
// optional int32 WeatheringVelocity = 27;
case 27: {
message.WeatheringVelocity = readVarint32(bb)
break
}
// optional int32 SubWeatheringVelocity = 28;
case 28: {
message.SubWeatheringVelocity = readVarint32(bb)
break
}
// optional int32 SourceUpholeTime = 29;
case 29: {
message.SourceUpholeTime = readVarint32(bb)
break
}
// optional int32 GroupUpholeTime = 30;
case 30: {
message.GroupUpholeTime = readVarint32(bb)
break
}
// optional int32 SourceStaticCorrection = 31;
case 31: {
message.SourceStaticCorrection = readVarint32(bb)
break
}
// optional int32 GroupStaticCorrection = 32;
case 32: {
message.GroupStaticCorrection = readVarint32(bb)
break
}
// optional int32 TotalStaticApplied = 33;
case 33: {
message.TotalStaticApplied = readVarint32(bb)
break
}
// optional int32 LagTimeA = 34;
case 34: {
message.LagTimeA = readVarint32(bb)
break
}
// optional int32 LagTimeB = 35;
case 35: {
message.LagTimeB = readVarint32(bb)
break
}
// optional int32 DelayRecordingTime = 36;
case 36: {
message.DelayRecordingTime = readVarint32(bb)
break
}
// optional int32 MuteTimeStart = 37;
case 37: {
message.MuteTimeStart = readVarint32(bb)
break
}
// optional int32 MuteTimeEND = 38;
case 38: {
message.MuteTimeEND = readVarint32(bb)
break
}
// optional int32 TRACE_SAMPLE_COUNT = 39;
case 39: {
message.TRACE_SAMPLE_COUNT = readVarint32(bb)
break
}
// optional int32 TRACE_SAMPLE_INTERVAL = 40;
case 40: {
message.TRACE_SAMPLE_INTERVAL = readVarint32(bb)
break
}
// optional int32 GainType = 41;
case 41: {
message.GainType = readVarint32(bb)
break
}
// optional int32 InstrumentGainConstant = 42;
case 42: {
message.InstrumentGainConstant = readVarint32(bb)
break
}
// optional int32 InstrumentInitialGain = 43;
case 43: {
message.InstrumentInitialGain = readVarint32(bb)
break
}
// optional int32 Correlated = 44;
case 44: {
message.Correlated = readVarint32(bb)
break
}
// optional int32 SweepFrequencyStart = 45;
case 45: {
message.SweepFrequencyStart = readVarint32(bb)
break
}
// optional int32 SweepFrequencyEnd = 46;
case 46: {
message.SweepFrequencyEnd = readVarint32(bb)
break
}
// optional int32 SweepLength = 47;
case 47: {
message.SweepLength = readVarint32(bb)
break
}
// optional int32 SweepType = 48;
case 48: {
message.SweepType = readVarint32(bb)
break
}
// optional int32 SweepTraceTaperLengthStart = 49;
case 49: {
message.SweepTraceTaperLengthStart = readVarint32(bb)
break
}
// optional int32 SweepTraceTaperLengthEnd = 50;
case 50: {
message.SweepTraceTaperLengthEnd = readVarint32(bb)
break
}
// optional int32 TaperType = 51;
case 51: {
message.TaperType = readVarint32(bb)
break
}
// optional int32 AliasFilterFrequency = 52;
case 52: {
message.AliasFilterFrequency = readVarint32(bb)
break
}
// optional int32 AliasFilterSlope = 53;
case 53: {
message.AliasFilterSlope = readVarint32(bb)
break
}
// optional int32 NotchFilterFrequency = 54;
case 54: {
message.NotchFilterFrequency = readVarint32(bb)
break
}
// optional int32 NotchFilterSlope = 55;
case 55: {
message.NotchFilterSlope = readVarint32(bb)
break
}
// optional int32 LowCutFrequency = 56;
case 56: {
message.LowCutFrequency = readVarint32(bb)
break
}
// optional int32 HighCutFrequency = 57;
case 57: {
message.HighCutFrequency = readVarint32(bb)
break
}
// optional int32 LowCutSlope = 58;
case 58: {
message.LowCutSlope = readVarint32(bb)
break
}
// optional int32 HighCutSlope = 59;
case 59: {
message.HighCutSlope = readVarint32(bb)
break
}
// optional int32 YearDataRecorded = 60;
case 60: {
message.YearDataRecorded = readVarint32(bb)
break
}
// optional int32 DayOfYear = 61;
case 61: {
message.DayOfYear = readVarint32(bb)
break
}
// optional int32 HourOfDay = 62;
case 62: {
message.HourOfDay = readVarint32(bb)
break
}
// optional int32 MinuteOfHour = 63;
case 63: {
message.MinuteOfHour = readVarint32(bb)
break
}
// optional int32 SecondOfMinute = 64;
case 64: {
message.SecondOfMinute = readVarint32(bb)
break
}
// optional int32 TimeBaseCode = 65;
case 65: {
message.TimeBaseCode = readVarint32(bb)
break
}
// optional int32 TraceWeightingFactor = 66;
case 66: {
message.TraceWeightingFactor = readVarint32(bb)
break
}
// optional int32 GeophoneGroupNumberRoll1 = 67;
case 67: {
message.GeophoneGroupNumberRoll1 = readVarint32(bb)
break
}
// optional int32 GeophoneGroupNumberFirstTraceOrigField = 68;
case 68: {
message.GeophoneGroupNumberFirstTraceOrigField = readVarint32(bb)
break
}
// optional int32 GeophoneGroupNumberLastTraceOrigField = 69;
case 69: {
message.GeophoneGroupNumberLastTraceOrigField = readVarint32(bb)
break
}
// optional int32 GapSize = 70;
case 70: {
message.GapSize = readVarint32(bb)
break
}
// optional int32 OverTravel = 71;
case 71: {
message.OverTravel = readVarint32(bb)
break
}
// optional int32 CDP_X = 72;
case 72: {
message.CDP_X = readVarint32(bb)
break
}
// optional int32 CDP_Y = 73;
case 73: {
message.CDP_Y = readVarint32(bb)
break
}
// optional int32 INLINE_3D = 74;
case 74: {
message.INLINE_3D = readVarint32(bb)
break
}
// optional int32 CROSSLINE_3D = 75;
case 75: {
message.CROSSLINE_3D = readVarint32(bb)
break
}
// optional int32 ShotPoint = 76;
case 76: {
message.ShotPoint = readVarint32(bb)
break
}
// optional int32 ShotPointScalar = 77;
case 77: {
message.ShotPointScalar = readVarint32(bb)
break
}
// optional int32 TraceValueMeasurementUnit = 78;
case 78: {
message.TraceValueMeasurementUnit = readVarint32(bb)
break
}
// optional int32 TransductionConstantMantissa = 79;
case 79: {
message.TransductionConstantMantissa = readVarint32(bb)
break
}
// optional int32 TransductionConstantPower = 80;
case 80: {
message.TransductionConstantPower = readVarint32(bb)
break
}
// optional int32 TransductionUnit = 81;
case 81: {
message.TransductionUnit = readVarint32(bb)
break
}
// optional int32 TraceIdentifier = 82;
case 82: {
message.TraceIdentifier = readVarint32(bb)
break
}
// optional int32 ScalarTraceHeader = 83;
case 83: {
message.ScalarTraceHeader = readVarint32(bb)
break
}
// optional int32 SourceType = 84;
case 84: {
message.SourceType = readVarint32(bb)
break
}
// optional int32 SourceEnergyDirectionMantissa = 85;
case 85: {
message.SourceEnergyDirectionMantissa = readVarint32(bb)
break
}
// optional int32 SourceEnergyDirectionExponent = 86;
case 86: {
message.SourceEnergyDirectionExponent = readVarint32(bb)
break
}
// optional int32 SourceMeasurementMantissa = 87;
case 87: {
message.SourceMeasurementMantissa = readVarint32(bb)
break
}
// optional int32 SourceMeasurementExponent = 88;
case 88: {
message.SourceMeasurementExponent = readVarint32(bb)
break
}
// optional int32 SourceMeasurementUnit = 89;
case 89: {
message.SourceMeasurementUnit = readVarint32(bb)
break
}
// optional int32 UnassignedInt1 = 90;
case 90: {
message.UnassignedInt1 = readVarint32(bb)
break
}
// optional int32 UnassignedInt2 = 91;
case 91: {
message.UnassignedInt2 = readVarint32(bb)
break
}
default:
skipUnknownField(bb, tag & 7)
}
}
return message
}
export interface Long {
low: number
high: number
unsigned: boolean
}
interface ByteBuffer {
bytes: Uint8Array
offset: number
limit: number
}
function pushTemporaryLength(bb: ByteBuffer): number {
let length = readVarint32(bb)
let limit = bb.limit
bb.limit = bb.offset + length
return limit
}
function skipUnknownField(bb: ByteBuffer, type: number): void {
switch (type) {
case 0:
while (readByte(bb) & 0x80) {}
break
case 2:
skip(bb, readVarint32(bb))
break
case 5:
skip(bb, 4)
break
case 1:
skip(bb, 8)
break
default:
throw new Error('Unimplemented type: ' + type)
}
}
function stringToLong(value: string): Long {
return {
low: value.charCodeAt(0) | (value.charCodeAt(1) << 16),
high: value.charCodeAt(2) | (value.charCodeAt(3) << 16),
unsigned: false,
}
}
function longToString(value: Long): string {
let low = value.low
let high = value.high
return String.fromCharCode(low & 0xffff, low >>> 16, high & 0xffff, high >>> 16)
}
// The code below was modified from https://github.com/protobufjs/bytebuffer.js
// which is under the Apache License 2.0.
let f32 = new Float32Array(1)
let f32_u8 = new Uint8Array(f32.buffer)
let f64 = new Float64Array(1)
let f64_u8 = new Uint8Array(f64.buffer)
function intToLong(value: number): Long {
value |= 0
return {
low: value,
high: value >> 31,
unsigned: value >= 0,
}
}
let bbStack: ByteBuffer[] = []
function popByteBuffer(): ByteBuffer {
const bb = bbStack.pop()
if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 }
bb.offset = bb.limit = 0
return bb
}
function pushByteBuffer(bb: ByteBuffer): void {
bbStack.push(bb)
}
function wrapByteBuffer(bytes: Uint8Array): ByteBuffer {
return { bytes, offset: 0, limit: bytes.length }
}
function toUint8Array(bb: ByteBuffer): Uint8Array {
let bytes = bb.bytes
let limit = bb.limit
return bytes.length === limit ? bytes : bytes.subarray(0, limit)
}
function skip(bb: ByteBuffer, offset: number): void {
if (bb.offset + offset > bb.limit) {
throw new Error('Skip past limit')
}
bb.offset += offset
}
function isAtEnd(bb: ByteBuffer): boolean {
return bb.offset >= bb.limit
}
function grow(bb: ByteBuffer, count: number): number {
let bytes = bb.bytes
let offset = bb.offset
let limit = bb.limit
let finalOffset = offset + count
if (finalOffset > bytes.length) {
let newBytes = new Uint8Array(finalOffset * 2)
newBytes.set(bytes)
bb.bytes = newBytes
}
bb.offset = finalOffset
if (finalOffset > limit) {
bb.limit = finalOffset
}
return offset
}
function advance(bb: ByteBuffer, count: number): number {
let offset = bb.offset
if (offset + count > bb.limit) {
throw new Error('Read past limit')
}
bb.offset += count
return offset
}
function readBytes(bb: ByteBuffer, count: number): Uint8Array {
let offset = advance(bb, count)
return bb.bytes.subarray(offset, offset + count)
}
function writeBytes(bb: ByteBuffer, buffer: Uint8Array): void {
let offset = grow(bb, buffer.length)
bb.bytes.set(buffer, offset)
}
function readString(bb: ByteBuffer, count: number): string {
// Sadly a hand-coded UTF8 decoder is much faster than subarray+TextDecoder in V8
let offset = advance(bb, count)
let fromCharCode = String.fromCharCode
let bytes = bb.bytes
let invalid = '\uFFFD'
let text = ''
for (let i = 0; i < count; i++) {
let c1 = bytes[i + offset],
c2: number,
c3: number,
c4: number,
c: number
// 1 byte
if ((c1 & 0x80) === 0) {
text += fromCharCode(c1)
}
// 2 bytes
else if ((c1 & 0xe0) === 0xc0) {
if (i + 1 >= count) text += invalid
else {
c2 = bytes[i + offset + 1]
if ((c2 & 0xc0) !== 0x80) text += invalid
else {
c = ((c1 & 0x1f) << 6) | (c2 & 0x3f)
if (c < 0x80) text += invalid
else {
text += fromCharCode(c)
i++
}
}
}
}
// 3 bytes
else if ((c1 & 0xf0) == 0xe0) {
if (i + 2 >= count) text += invalid
else {
c2 = bytes[i + offset + 1]
c3 = bytes[i + offset + 2]
if (((c2 | (c3 << 8)) & 0xc0c0) !== 0x8080) text += invalid
else {
c = ((c1 & 0x0f) << 12) | ((c2 & 0x3f) << 6) | (c3 & 0x3f)
if (c < 0x0800 || (c >= 0xd800 && c <= 0xdfff)) text += invalid
else {
text += fromCharCode(c)
i += 2
}
}
}
}
// 4 bytes
else if ((c1 & 0xf8) == 0xf0) {
if (i + 3 >= count) text += invalid
else {
c2 = bytes[i + offset + 1]
c3 = bytes[i + offset + 2]
c4 = bytes[i + offset + 3]
if (((c2 | (c3 << 8) | (c4 << 16)) & 0xc0c0c0) !== 0x808080) text += invalid
else {
c = ((c1 & 0x07) << 0x12) | ((c2 & 0x3f) << 0x0c) | ((c3 & 0x3f) << 0x06) | (c4 & 0x3f)
if (c < 0x10000 || c > 0x10ffff) text += invalid
else {
c -= 0x10000
text += fromCharCode((c >> 10) + 0xd800, (c & 0x3ff) + 0xdc00)
i += 3
}
}
}
} else text += invalid
}
return text
}
function writeString(bb: ByteBuffer, text: string): void {
// Sadly a hand-coded UTF8 encoder is much faster than TextEncoder+set in V8
let n = text.length
let byteCount = 0
// Write the byte count first
for (let i = 0; i < n; i++) {
let c = text.charCodeAt(i)
if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) {
c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00
}
byteCount += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4
}
writeVarint32(bb, byteCount)
let offset = grow(bb, byteCount)
let bytes = bb.bytes
// Then write the bytes
for (let i = 0; i < n; i++) {
let c = text.charCodeAt(i)
if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) {
c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00
}
if (c < 0x80) {
bytes[offset++] = c
} else {
if (c < 0x800) {
bytes[offset++] = ((c >> 6) & 0x1f) | 0xc0
} else {
if (c < 0x10000) {
bytes[offset++] = ((c >> 12) & 0x0f) | 0xe0
} else {
bytes[offset++] = ((c >> 18) & 0x07) | 0xf0
bytes[offset++] = ((c >> 12) & 0x3f) | 0x80
}
bytes[offset++] = ((c >> 6) & 0x3f) | 0x80
}
bytes[offset++] = (c & 0x3f) | 0x80
}
}
}
function writeByteBuffer(bb: ByteBuffer, buffer: ByteBuffer): void {
let offset = grow(bb, buffer.limit)
let from = bb.bytes
let to = buffer.bytes
// This for loop is much faster than subarray+set on V8
for (let i = 0, n = buffer.limit; i < n; i++) {
from[i + offset] = to[i]
}
}
function readByte(bb: ByteBuffer): number {
return bb.bytes[advance(bb, 1)]
}
function writeByte(bb: ByteBuffer, value: number): void {
let offset = grow(bb, 1)
bb.bytes[offset] = value
}
function readFloat(bb: ByteBuffer): number {
let offset = advance(bb, 4)
let bytes = bb.bytes
// Manual copying is much faster than subarray+set in V8
f32_u8[0] = bytes[offset++]
f32_u8[1] = bytes[offset++]
f32_u8[2] = bytes[offset++]
f32_u8[3] = bytes[offset++]
return f32[0]
}
function writeFloat(bb: ByteBuffer, value: number): void {
let offset = grow(bb, 4)
let bytes = bb.bytes
f32[0] = value
// Manual copying is much faster than subarray+set in V8
bytes[offset++] = f32_u8[0]
bytes[offset++] = f32_u8[1]
bytes[offset++] = f32_u8[2]
bytes[offset++] = f32_u8[3]
}
function readDouble(bb: ByteBuffer): number {
let offset = advance(bb, 8)
let bytes = bb.bytes
// Manual copying is much faster than subarray+set in V8
f64_u8[0] = bytes[offset++]
f64_u8[1] = bytes[offset++]
f64_u8[2] = bytes[offset++]
f64_u8[3] = bytes[offset++]
f64_u8[4] = bytes[offset++]
f64_u8[5] = bytes[offset++]
f64_u8[6] = bytes[offset++]
f64_u8[7] = bytes[offset++]
return f64[0]
}
function writeDouble(bb: ByteBuffer, value: number): void {
let offset = grow(bb, 8)
let bytes = bb.bytes
f64[0] = value
// Manual copying is much faster than subarray+set in V8
bytes[offset++] = f64_u8[0]
bytes[offset++] = f64_u8[1]
bytes[offset++] = f64_u8[2]
bytes[offset++] = f64_u8[3]
bytes[offset++] = f64_u8[4]
bytes[offset++] = f64_u8[5]
bytes[offset++] = f64_u8[6]
bytes[offset++] = f64_u8[7]
}
function readInt32(bb: ByteBuffer): number {
let offset = advance(bb, 4)
let bytes = bb.bytes
return bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24)
}
function writeInt32(bb: ByteBuffer, value: number): void {
let offset = grow(bb, 4)
let bytes = bb.bytes
bytes[offset] = value
bytes[offset + 1] = value >> 8
bytes[offset + 2] = value >> 16
bytes[offset + 3] = value >> 24
}
function readInt64(bb: ByteBuffer, unsigned: boolean): Long {
return {
low: readInt32(bb),
high: readInt32(bb),
unsigned,
}
}
function writeInt64(bb: ByteBuffer, value: Long): void {
writeInt32(bb, value.low)
writeInt32(bb, value.high)
}
function readVarint32(bb: ByteBuffer): number {
let c = 0
let value = 0
let b: number
do {
b = readByte(bb)
if (c < 32) value |= (b & 0x7f) << c
c += 7
} while (b & 0x80)
return value
}
function writeVarint32(bb: ByteBuffer, value: number): void {
value >>>= 0
while (value >= 0x80) {
writeByte(bb, (value & 0x7f) | 0x80)
value >>>= 7
}
writeByte(bb, value)
}
function readVarint64(bb: ByteBuffer, unsigned: boolean): Long {
let part0 = 0
let part1 = 0
let part2 = 0
let b: number
b = readByte(bb)
part0 = b & 0x7f
if (b & 0x80) {
b = readByte(bb)
part0 |= (b & 0x7f) << 7
if (b & 0x80) {
b = readByte(bb)
part0 |= (b & 0x7f) << 14
if (b & 0x80) {
b = readByte(bb)
part0 |= (b & 0x7f) << 21
if (b & 0x80) {
b = readByte(bb)
part1 = b & 0x7f
if (b & 0x80) {
b = readByte(bb)
part1 |= (b & 0x7f) << 7
if (b & 0x80) {
b = readByte(bb)
part1 |= (b & 0x7f) << 14
if (b & 0x80) {
b = readByte(bb)
part1 |= (b & 0x7f) << 21
if (b & 0x80) {
b = readByte(bb)
part2 = b & 0x7f
if (b & 0x80) {
b = readByte(bb)
part2 |= (b & 0x7f) << 7
}
}
}
}
}
}
}
}
}
return {
low: part0 | (part1 << 28),
high: (part1 >>> 4) | (part2 << 24),
unsigned,
}
}
function writeVarint64(bb: ByteBuffer, value: Long): void {
let part0 = value.low >>> 0
let part1 = ((value.low >>> 28) | (value.high << 4)) >>> 0
let part2 = value.high >>> 24
// ref: src/google/protobuf/io/coded_stream.cc
let size =
part2 === 0
? part1 === 0
? part0 < 1 << 14
? part0 < 1 << 7
? 1
: 2
: part0 < 1 << 21
? 3
: 4
: part1 < 1 << 14
? part1 < 1 << 7
? 5
: 6
: part1 < 1 << 21
? 7
: 8
: part2 < 1 << 7
? 9
: 10
let offset = grow(bb, size)
let bytes = bb.bytes
switch (size) {
case 10:
bytes[offset + 9] = (part2 >>> 7) & 0x01
case 9:
bytes[offset + 8] = size !== 9 ? part2 | 0x80 : part2 & 0x7f
case 8:
bytes[offset + 7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7f
case 7:
bytes[offset + 6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7f
case 6:
bytes[offset + 5] = size !== 6 ? (part1 >>> 7) | 0x80 : (part1 >>> 7) & 0x7f
case 5:
bytes[offset + 4] = size !== 5 ? part1 | 0x80 : part1 & 0x7f
case 4:
bytes[offset + 3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7f
case 3:
bytes[offset + 2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7f
case 2:
bytes[offset + 1] = size !== 2 ? (part0 >>> 7) | 0x80 : (part0 >>> 7) & 0x7f
case 1:
bytes[offset] = size !== 1 ? part0 | 0x80 : part0 & 0x7f
}
}
function readVarint32ZigZag(bb: ByteBuffer): number {
let value = readVarint32(bb)
// ref: src/google/protobuf/wire_format_lite.h
return (value >>> 1) ^ -(value & 1)
}
function writeVarint32ZigZag(bb: ByteBuffer, value: number): void {
// ref: src/google/protobuf/wire_format_lite.h
writeVarint32(bb, (value << 1) ^ (value >> 31))
}
function readVarint64ZigZag(bb: ByteBuffer): Long {
let value = readVarint64(bb, /* unsigned */ false)
let low = value.low
let high = value.high
let flip = -(low & 1)
// ref: src/google/protobuf/wire_format_lite.h
return {
low: ((low >>> 1) | (high << 31)) ^ flip,
high: (high >>> 1) ^ flip,
unsigned: false,
}
}
function writeVarint64ZigZag(bb: ByteBuffer, value: Long): void {
let low = value.low
let high = value.high
let flip = high >> 31
// ref: src/google/protobuf/wire_format_lite.h
writeVarint64(bb, {
low: (low << 1) ^ flip,
high: ((high << 1) | (low >>> 31)) ^ flip,
unsigned: false,
})
}export interface SegyHeader {
textHeader?: string
binaryHeader?: BinaryHeader
stats?: Stats
}
export function encodeSegyHeader(message: SegyHeader): Uint8Array {
let bb = popByteBuffer()
_encodeSegyHeader(message, bb)
return toUint8Array(bb)
}
- Interfaces
- Encode
- Decode
- A whole bunch of parsing
import { encodeSegyHeader } from 'segy.ts'
const parsed = parseSegyToBin(rawSegyFile)
const encodedSH = encodeSegyHeader(parsed)
const segyHeaderUpload = s3
.upload({
Key: encodedSHPath,
Bucket,
Body: encodedSH,
})
.promise()
import { decodeSegyHeader } from 'segy.ts'
async function fetchSegyHeader(segyHeaderURL: string) {
return fetch(segyHeaderURL, {
headers: { 'Content-Type': 'application/octet-stream' },
})
.then((res) => res.arrayBuffer())
.then((data) => decodeSegyHeader(new Uint8Array(data)))
}
1
2
3
Encode
Store
Retrieve
Did it work out?
Handwave:
This is Just the transport layer!
-
3d in browser optimization (Babylon JS)
-
Canvas Optimization
-
React Optimization
-
Parsing Optimization
-
AWS Lambda/ s3/EventBridge Optimization
-
Downsampling
44.1 Million Data Points
gRPC
You can't really mention Protobufs
without also mentioning gRPC
- Rewrite of Google's internal tool Stubby
- First written with microservices in mind
- Supported in basically every language
- Uses Http/2 (2015)
- ... multiplexing over 1 TCP
- And Http/3 (soon? cloudflare can do it, somehow)
gRPC
differnt from..
- graphQL
- REST
- SOAP
- tRPC
gRPC
remote procedure call! Send a message and invoke a function
1
RPC
The Protobufs. The part we just covered
2
Message
The (namespaced) container that glues the RPC functions to the Messages
3
Service
syntax = "proto3";
//nothing new here
message HelloThereRequest {
string name = 1;
}
//or here
message HelloThereReply {
string message = 1;
}
//the new thing.
service HelloThereService {
rpc SayHello (HelloRequest) returns (HelloReply) {}
rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}
}
gRPC
Browser gRPC
Buf
Connect
service ElizaService {
rpc Say(SayRequest) returns (SayResponse) {}
}const answer = await eliza.say({sentence: "I feel happy."});
console.log(answer);
// {sentence: 'When you feel happy, what do you do?'}- React
- Svelte
- Next
- Angular
More Resources:
Thank You!
Questions?
twitter @5imian
github the-simian
soundcloud the simian
email info@simiancraft.com
site simiancraft.com
jesseharlin.net