id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c8300 |
for n, c := range s.count[:s.symbolLen] {
r := (highBit32(c+1) + 1) & 31
pos := rank[r].current
rank[r].current++
prev := nodes[(pos-1)&huffNodesMask]
for pos > rank[r].base && c > prev.count {
nodes[pos&huffNodesMask] = prev
pos--
prev = nodes[(pos-1)&huffNodesMask]
}
nodes[pos&huffNodesMask] ... | |
c8301 | DefaultCompression, nil)
return z
} | |
c8302 | return NewWriterLevelDict(w, level, nil)
} | |
c8303 | compression level: %d", level)
}
return &Writer{
w: w,
level: level,
dict: dict,
}, nil
} | |
c8304 | nil {
z.compressor.Reset(w)
}
if z.digest != nil {
z.digest.Reset()
}
z.err = nil
z.scratch = [4]byte{}
z.wroteHeader = false
} | |
c8305 | err
}
if z.dict != nil {
// The next four bytes are the Adler-32 checksum of the dictionary.
checksum := adler32.Checksum(z.dict)
z.scratch[0] = uint8(checksum >> 24)
z.scratch[1] = uint8(checksum >> 16)
z.scratch[2] = uint8(checksum >> 8)
z.scratch[3] = uint8(checksum >> 0)
if _, err = z.w.Write(z.scr... | |
c8306 | return 0, nil
}
n, err = z.compressor.Write(p)
if err != nil {
z.err = err
return
}
z.digest.Write(p)
return
} | |
c8307 | &countWriter{w: bufio.NewWriter(w)}}
} | |
c8308 | 0 {
panic("zip: SetOffset called after data was written")
}
w.cw.count = n
} | |
c8309 | {
return w.cw.w.(*bufio.Writer).Flush()
} | |
c8310 | make(map[uint16]Compressor)
}
w.compressors[method] = comp
} | |
c8311 | nbBits += uint32(v.nBits) * hist[i]
}
return int(nbBits >> 3)
} | |
c8312 |
nbBits += math.Log2(fTotal/n) * n
}
}
return int(nbBits) >> 3
} | |
c8313 | }
lu := t[symb]
return decSymbol{
addBits: lu.addBits,
baseline: lu.baseLine,
}, nil
} | |
c8314 | 0
s.maxBits = 0
s.dt[0] = symbol
} | |
c8315 | entry %d, symbol %d >= max (%d)", i, v.addBits, len(t))
}
lu := t[v.addBits]
if lu.addBits > s.maxBits {
s.maxBits = lu.addBits
}
s.dt[i&maxTableMask] = decSymbol{
newState: v.newState,
nbBits: v.nbBits,
addBits: lu.addBits,
baseline: lu.baseLine,
}
}
return nil
} | |
c8316 | dt []decSymbol) {
s.dt = dt
br.fill()
s.state = dt[br.getBits(tableLog)]
} | |
c8317 | s.state = s.dt[s.state.newState+lowBits]
} | |
c8318 | {
return int(s.state.baseline), s.state.addBits
} | |
c8319 | error) {
return NewReaderDict(r, nil)
} | |
c8320 | dict)
if err != nil {
return nil, err
}
return z, nil
} | |
c8321 |
z.err = z.decompressor.Close()
return z.err
} | |
c8322 | && !f.preDefined {
fseDecoderPool.Put(f)
}
h.decoders = sequenceDecs{}
if h.huffTree != nil {
huffDecoderPool.Put(h.huffTree)
}
h.huffTree = nil
//printf("history created: %+v (l: %d, c: %d)", *h, len(h.b), cap(h.b))
} | |
c8323 | have less than window size in b at this point.
discard := len(b) + len(h.b) - h.windowSize
copy(h.b, h.b[discard:])
h.b = h.b[:h.windowSize]
copy(h.b[h.windowSize-len(b):], b)
} | |
c8324 | = append(h.b, b...)
} | |
c8325 | full sized table.
const tlSize = 1 << tableLogMax
const tlMask = tlSize - 1
dt := s.dt.single[:tlSize]
// Use temp table to avoid bound checks/append penalty.
var tmp = s.huffWeight[:256]
var off uint8
for br.off >= 8 {
br.fillFast()
tmp[off+0] = hasDec(dt[br.peekBitsFast(s.actualTableLog)&tlMask])
tmp[... | |
c8326 | // Ensure that all combinations are covered.
for i := uint16(0); i < (1 << ub); i++ {
vval := top | i
dec := dt[vval]
if dec.nBits != enc.nBits {
fmt.Fprintf(w, "symbol 0x%x bit size mismatch (enc: %d, dec:%d).\n", vval, enc.nBits, dec.nBits)
errs++
}
if dec.byte != uint8(sym) {
fmt.Fprint... | |
c8327 | err = s.buildDtable()
if err != nil {
return nil, err
}
err = s.decompress()
if err != nil {
return nil, err
}
return s.Out, nil
} | |
c8328 | s.ct.tableSymbol[:256]
if cap(s.ct.stateTable) < 256 {
s.ct.stateTable = make([]uint16, 256)
}
s.ct.stateTable = s.ct.stateTable[:256]
} | |
c8329 | off = 0
if len(s.Out) >= s.DecompressLimit {
return fmt.Errorf("output size (%d) > DecompressLimit (%d)", len(s.Out), s.DecompressLimit)
}
}
}
}
s.Out = append(s.Out, tmp[:off]...)
// Final bits, a bit more expensive check
for {
if s1.finished() {
s.Out = append(s.Out, s1.final(), s2.fin... | |
c8330 | in
d.state = uint16(in.getBits(tableLog))
} | |
c8331 | = n.newState + lowBits
return n.symbol
} | |
c8332 | block:", block)
}
d.asyncRunningMu.Lock()
defer d.asyncRunningMu.Unlock()
if !d.asyncRunning {
return nil
}
if block.Last {
// We indicate the frame is done by sending io.EOF
d.decoding <- block
return io.EOF
}
d.decoding <- block
return nil
} | |
c8333 | }
println("sending error", err.Error())
block.sendErr(err)
d.decoding <- block
return true
} | |
c8334 | want == nil {
println("CRC missing?")
return io.ErrUnexpectedEOF
}
if !bytes.Equal(gotB[:4], want) {
println("CRC Check Failed:", gotB[:4], "!=", want)
return ErrCRCMismatch
}
println("CRC ok")
return nil
} | |
c8335 | != nil {
break
}
if debug {
println("next block:", dec)
}
err = dec.decodeBuf(&d.history)
if err != nil || dec.Last {
break
}
if uint64(len(d.history.b)) > d.o.maxDecodedSize {
err = ErrDecoderSizeExceeded
break
}
}
dst = d.history.b
if err == nil {
if d.HasCheckSum {
var n int
... | |
c8336 | numCodegens) +
w.codegenEncoding.bitLength(w.codegenFreq[:]) +
int(w.codegenFreq[16])*2 +
int(w.codegenFreq[17])*3 +
int(w.codegenFreq[18])*7
size = header +
litEnc.bitLength(w.literalFreq) +
offEnc.bitLength(w.offsetFreq) +
extraBits
return size, numCodegens
} | |
c8337 | +
fixedOffsetEncoding.bitLength(w.offsetFreq) +
extraBits
} | |
c8338 | if len(in) <= maxStoreBlockSize {
return (len(in) + 5) * 8, true
}
return 0, false
} | |
c8339 | i++
if codeWord == badCode {
break
}
w.writeCode(w.codegenEncoding.codes[uint32(codeWord)])
switch codeWord {
case 16:
w.writeBits(int32(w.codegen[i]), 2)
i++
break
case 17:
w.writeBits(int32(w.codegen[i]), 3)
i++
break
case 18:
w.writeBits(int32(w.codegen[i]), 7)
i++
break... | |
c8340 | to encode
// the literalEncoding and the offsetEncoding.
w.generateCodegen(numLiterals, numOffsets, w.literalEncoding, w.offsetEncoding)
w.codegenEncoding.generate(w.codegenFreq[:], 7)
dynamicSize, numCodegens := w.dynamicSize(w.literalEncoding, w.offsetEncoding, extraBits)
if dynamicSize < size {
size = dynam... | |
c8341 |
for numOffsets > 0 && w.offsetFreq[numOffsets-1] == 0 {
numOffsets--
}
if numOffsets == 0 {
// We haven't found a single match. If we want to go with the dynamic encoding,
// we should count at least one offset to be sure that the offset huffman tree could be encoded.
w.offsetFreq[0] = 1
numOffsets = 1
}... | |
c8342 | offset := t.offset()
offsetCode := offsetCode(offset)
w.writeCode(oeCodes[offsetCode])
extraOffsetBits := uint(offsetExtraBits[offsetCode])
if extraOffsetBits > 0 {
extraOffset := int32(offset - offsetBase[offsetCode])
w.writeBits(extraOffset, extraOffsetBits)
}
}
} | |
c8343 | ~30% speedup
c := encoding[t]
w.bits |= uint64(c.code) << w.nbits
w.nbits += uint(c.len)
if w.nbits < 48 {
continue
}
// Store 6 bytes
bits := w.bits
w.bits >>= 48
w.nbits -= 48
bytes := w.bytes[n : n+6]
bytes[0] = byte(bits)
bytes[1] = byte(bits >> 8)
bytes[2] = byte(bits >> 16)
bytes[3... | |
c8344 | r := new(ReadCloser)
if err := r.init(f, fi.Size()); err != nil {
f.Close()
return nil, err
}
r.f = f
return r, nil
} | |
c8345 | != nil {
return nil, err
}
return zr, nil
} | |
c8346 | z.decompressors == nil {
z.decompressors = make(map[uint16]Decompressor)
}
z.decompressors[method] = dcomp
} | |
c8347 |
return
}
return f.headerOffset + bodyOffset, nil
} | |
c8348 |
if dcomp == nil {
err = ErrAlgorithm
return
}
rc = dcomp(r)
var desr io.Reader
if f.hasDataDescriptor() {
desr = io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset+size, dataDescriptorLen)
}
rc = &checksumReader{
rc: rc,
hash: crc32.NewIEEE(),
f: f,
desr: desr,
}
return
} | |
c8349 | = b[22:] // skip over most of the header
filenameLen := int(b.uint16())
extraLen := int(b.uint16())
return int64(fileHeaderLen + filenameLen + extraLen), nil
} | |
c8350 | d.diskNbr = b.uint32() // number of this disk
d.dirDiskNbr = b.uint32() // number of the disk with the start of the central directory
d.dirRecordsThisDisk = b.uint64() // total number of entries in the central directory on this disk
d.directoryRecords = b.uint64() // total number of entries in ... | |
c8351 |
}
fh.SetModTime(fi.ModTime())
fh.SetMode(fi.Mode())
if fh.UncompressedSize64 > uint32max {
fh.UncompressedSize = uint32max
} else {
fh.UncompressedSize = uint32(fh.UncompressedSize64)
}
return fh, nil
} | |
c8352 | {
return msDosTimeToTime(h.ModifiedDate, h.ModifiedTime)
} | |
c8353 | {
h.ModifiedDate, h.ModifiedTime = timeToMsDosTime(t)
} | |
c8354 | mode = msdosModeToFileMode(h.ExternalAttrs)
}
if len(h.Name) > 0 && h.Name[len(h.Name)-1] == '/' {
mode |= os.ModeDir
}
return mode
} | |
c8355 | 16
// set MSDOS attributes too, as the original zip does.
if mode&os.ModeDir != 0 {
h.ExternalAttrs |= msdosDir
}
if mode&0200 == 0 {
h.ExternalAttrs |= msdosReadOnly
}
} | |
c8356 | >= uint32max || fh.UncompressedSize64 >= uint32max
} | |
c8357 | h.len = length
h.code = code
} | |
c8358 |
size = 8
break
case ch < 256:
// size 9, 110010000 .. 111111111
bits = ch + 400 - 144
size = 9
break
case ch < 280:
// size 7, 0000000 .. 0010111
bits = ch - 256
size = 7
break
default:
// size 8, 11000000 .. 11000111
bits = ch + 192 - 280
size = 8
}
codes[ch] = hcode{c... | |
c8359 | chunk := list[len(list)-int(bits):]
h.lns.sort(chunk)
for _, node := range chunk {
h.codes[node.literal] = hcode{code: reverseBits(code, uint8(n)), len: uint16(n)}
code++
}
list = list[0 : len(list)-int(bits)]
}
} | |
c8360 | return offsetCodes[off>>7] + 14
} else {
return offsetCodes[off>>14] + 28
}
} | |
c8361 |
dd.wrPos = copy(dd.hist, dict)
if dd.wrPos == len(dd.hist) {
dd.wrPos = 0
dd.full = true
}
dd.rdPos = dd.wrPos
} | |
c8362 |
if dd.full {
return len(dd.hist)
}
return dd.wrPos
} | |
c8363 | {
dd.wrPos, dd.rdPos = 0, 0
dd.full = true
}
return toRead
} | |
c8364 | e.cur += maxMatchOffset
} | |
c8365 | error { o.lowMem = b; return nil }
} | |
c8366 | return fmt.Errorf("Concurrency must be at least 1")
}
o.concurrent = n
return nil
}
} | |
c8367 | {
s.maxCount = maxCount
s.symbolLen = uint16(maxSymbol) + 1
s.clearCount = maxCount != 0
} | |
c8368 | > maxTableLog (%d)", s.TableLog, maxTableLog)
}
if cap(s.Out) == 0 {
s.Out = make([]byte, 0, len(in))
}
if s.clearCount && s.maxCount == 0 {
for i := range s.count {
s.count[i] = 0
}
s.clearCount = false
}
s.br.init(in)
if s.DecompressLimit == 0 {
// Max size 2GB.
s.DecompressLimit = 2 << 30
}
... | |
c8369 | {
Δ := float64(v) - avg
variance += Δ * Δ
}
stddev := math.Sqrt(float64(variance)) / float64(len(b))
exp := math.Sqrt(1 / float64(len(b)))
// Subtract expected stddev
stddev -= exp
if stddev < 0 {
stddev = 0
}
stddev *= 1 + exp
// Use x^0.4 to give better spread
entropy := math.Pow(stddev, 0.4)
//... | |
c8370 | []byte) {
b.b = in
b.off = 0
} | |
c8371 | := b.b[b.off]
return v
} | |
c8372 | err != nil {
f.err = noEOF(err)
return
}
n := int(f.buf[0]) | int(f.buf[1])<<8
nn := int(f.buf[2]) | int(f.buf[3])<<8
if uint16(nn) != uint16(^n) {
f.err = CorruptInputError(f.roffset)
return
}
if n == 0 {
f.toRead = f.dict.readFlush()
f.finishBlock()
return
}
f.copyLen = n
f.copyData()
} | |
c8373 |
return
}
if f.dict.availWrite() == 0 || f.copyLen > 0 {
f.toRead = f.dict.readFlush()
f.step = (*decompressor).copyData
return
}
f.finishBlock()
} | |
c8374 | return io.ErrUnexpectedEOF
}
return e
} | |
c8375 |
f.roffset++
b |= uint32(c) << (nb & 31)
nb += 8
}
chunk := h.chunks[b&(huffmanNumChunks-1)]
n = uint(chunk & huffmanCountMask)
if n > huffmanChunkBits {
chunk = h.links[chunk>>huffmanValueShift][(b>>huffmanChunkBits)&h.linkMask]
n = uint(chunk & huffmanCountMask)
}
if n <= nb {
if n == 0 ... | |
c8376 | new([numCodes]int)
f.step = (*decompressor).nextBlock
f.dict.init(maxMatchOffset, nil)
return &f
} | |
c8377 | panic(fmt.Sprintf("invalid decoding table, base overflows int32"))
}
dst[i] = baseOffset{
baseLine: base,
addBits: bit,
}
base += 1 << bit
}
} | |
c8378 |
return nil, err
}
if false {
err = s.validateNorm()
if err != nil {
return nil, err
}
}
err = s.buildCTable()
if err != nil {
return nil, err
}
err = s.compress(in)
if err != nil {
return nil, err
}
s.Out = s.bw.out
// Check if we compressed.
if len(s.Out) >= len(in) {
return nil, ErrInc... | |
c8379 | first.deltaNbBits)
lu := (im >> nbBitsOut) + first.deltaFindState
c.state = c.stateTable[lu]
return
} | |
c8380 |
c.bw.addBits16NC(c.state, tableLog)
c.bw.flush()
} | |
c8381 | fs:%d", s.deltaNbBits, s.deltaFindState)
} | |
c8382 | ctSize)
}
s.ct.stateTable = s.ct.stateTable[:ctSize]
if cap(s.ct.symbolTT) < int(s.symbolLen) {
s.ct.symbolTT = make([]symbolTransform, 256)
}
s.ct.symbolTT = s.ct.symbolTT[:256]
} | |
c8383 | restToBeat := vStep * uint64(rtbTable[proba])
v := uint64(cnt)*step - (uint64(proba) << scale)
if v > restToBeat {
proba++
}
}
if proba > largestP {
largestP = proba
largest = i
}
s.norm[i] = proba
stillToDistribute -= proba
}
}
if -stillToDistribute >= (s.norm[largest] ... | |
c8384 | return fmt.Errorf("warning: Total == %d != %d", total, 1<<s.actualTableLog)
}
for i, v := range s.count[s.symbolLen:] {
if v != 0 {
return fmt.Errorf("warning: Found symbol out of range, %d after cut", i)
}
}
return nil
} | |
c8385 | if len(p) == 0 {
break
}
if len(d.current.b) == 0 {
// We have an error and no more data
if d.current.err != nil {
break
}
d.nextBlock()
}
}
if len(d.current.b) > 0 {
// Only return error at end of block
return n, nil
}
if d.current.err != nil {
d.drainOutput()
}
if debug {
prin... | |
c8386 | {
d.stream = make(chan decodeStream, 1)
go d.startStreamDecoder(d.stream)
}
d.drainOutput()
// Remove current block.
d.current.decodeOutput = decodeOutput{}
d.current.err = nil
d.current.cancel = make(chan struct{})
d.current.flushed = false
d.current.d = nil
d.stream <- decodeStream{
r: r,
ou... | |
c8387 | {
case v := <-d.current.output:
if v.d != nil {
println("got decoder", v.d)
d.decoders <- v.d
}
if v.err == errEndOfStream {
println("current flushed")
d.current.flushed = true
return
}
}
}
} | |
c8388 | break
}
}
d.nextBlock()
}
err := d.current.err
if err != nil {
d.drainOutput()
}
if err == io.EOF {
err = nil
}
return n, err
} | |
c8389 | := frame.reset(&br)
if err == io.EOF {
return dst, nil
}
if err != nil {
return dst, err
}
if frame.FrameContentSize > d.o.maxDecodedSize-uint64(len(dst)) {
return dst, ErrDecoderSizeExceeded
}
if frame.FrameContentSize > 0 && frame.FrameContentSize < 1<<30 {
// Never preallocate moe than 1 G... | |
c8390 | nil {
// Keep error state.
return
}
d.current.decodeOutput = <-d.current.output
if debug {
println("got", len(d.current.b), "bytes, error:", d.current.err)
}
} | |
c8391 | range d.decoders {
dec.Close()
}
d.decoders = nil
}
if d.current.d != nil {
d.current.d.Close()
d.current.d = nil
}
d.current.err = ErrDecoderClosed
} | |
c8392 | ditionalRender, (C.GLuint)(id), (C.GLenum)(mode))
} | |
c8393 | (C.GLuint)(program), (C.GLuint)(color), (*C.GLchar)(unsafe.Pointer(name)))
} | |
c8394 | C.glowClampColor(gpClampColor, (C.GLenum)(target), (C.GLenum)(clamp))
} | |
c8395 | (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLenum)(format), (C.GLenum)(xtype), table)
} | |
c8396 | (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLenum)(format), (C.GLenum)(xtype), image)
} | |
c8397 | (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), image)
} | |
c8398 | (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width))
} | |
c8399 | (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width))
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.