Example usage for java.nio IntBuffer put

List of usage examples for java.nio IntBuffer put

  1. HOME
  2. Java
  3. java
  4. java.nio.*
  5. IntBuffer
  6. put

Introduction

In this page you can find the example usage for java.nio IntBuffer put.

Prototype

public IntBuffer put(IntBuffer src)

Source Link

Document

Writes all the remaining ints of the src int buffer to this buffer's current position, and increases both buffers' position by the number of ints copied.

Usage

From source file:org.jcodec.codecs.mjpeg.JpegDecoder.java

private static void decodeBlock(MCU block, QuantTable qLum, QuantTable qChrom) {

    zigzagDecodeAll(block.lum.data);//ww w  .  ja  v  a  2s .c o m
    zigzagDecodeAll(block.cb.data);
    zigzagDecodeAll(block.cr.data);

    dequantAll(block.lum.data, qLum);
    dequantAll(block.cb.data, qChrom);
    dequantAll(block.cr.data, qChrom);

    dct.decodeAll(block.lum.data);
    dct.decodeAll(block.cb.data);
    dct.decodeAll(block.cr.data);

    IntBuffer rgb = block.getRgb24();
    IntBuffer Cb = IntBuffer.wrap(block.cb.data[0]);
    IntBuffer Cr = IntBuffer.wrap(block.cr.data[0]);
    if (block.is420()) {
        IntBuffer y00 = IntBuffer.wrap(block.lum.data[0]);
        IntBuffer y01 = IntBuffer.wrap(block.lum.data[1]);
        IntBuffer y10 = IntBuffer.wrap(block.lum.data[2]);
        IntBuffer y11 = IntBuffer.wrap(block.lum.data[3]);

        for (int j = 0; j < 8; j++) {
            Cb.position((j & ~1) << 2);
            Cr.position((j & ~1) << 2);
            lineToRgb(y00, Cb, Cr, rgb);
            lineToRgb(y01, Cb, Cr, rgb);
        }
        for (int j = 8; j < 16; j++) {
            Cb.position((j & ~1) << 2);
            Cr.position((j & ~1) << 2);
            lineToRgb(y10, Cb, Cr, rgb);
            lineToRgb(y11, Cb, Cr, rgb);
        }
    } else if (block.is422()) {
        IntBuffer y00 = IntBuffer.wrap(block.lum.data[0]);
        IntBuffer y01 = IntBuffer.wrap(block.lum.data[1]);
        for (int j = 0; j < 8; j++) {
            Cb.position(j << 3);
            Cr.position(j << 3);
            lineToRgb(y00, Cb, Cr, rgb);
            lineToRgb(y01, Cb, Cr, rgb);
        }
    } else if (block.is444()) {
        IntBuffer Y = IntBuffer.wrap(block.lum.data[0]);
        while (rgb.hasRemaining()) {
            rgb.put(ImageConvert.ycbcr_to_rgb24(Y.get(), Cb.get(), Cr.get()));
        }
    } else {
        throw new IllegalStateException("unsupported MCU");
    }

}

From source file:io.druid.segment.IndexMerger.java

private static File makeIndexFiles(final List<IndexableAdapter> indexes, final File outDir,
        final ProgressIndicator progress, final List<String> mergedDimensions, final List<String> mergedMetrics,
        final Map<String, Object> segmentMetadata,
        final Function<ArrayList<Iterable<Rowboat>>, Iterable<Rowboat>> rowMergerFn, final IndexSpec indexSpec)
        throws IOException {
    final Map<String, ValueType> valueTypes = Maps.newTreeMap(Ordering.<String>natural().nullsFirst());
    final Map<String, String> metricTypeNames = Maps.newTreeMap(Ordering.<String>natural().nullsFirst());
    final Map<String, ColumnCapabilitiesImpl> columnCapabilities = Maps.newHashMap();

    for (IndexableAdapter adapter : indexes) {
        for (String dimension : adapter.getDimensionNames()) {
            ColumnCapabilitiesImpl mergedCapabilities = columnCapabilities.get(dimension);
            ColumnCapabilities capabilities = adapter.getCapabilities(dimension);
            if (mergedCapabilities == null) {
                mergedCapabilities = new ColumnCapabilitiesImpl();
                mergedCapabilities.setType(ValueType.STRING);
            }//  w w w.j a  v a2s .  co  m
            columnCapabilities.put(dimension, mergedCapabilities.merge(capabilities));
        }
        for (String metric : adapter.getMetricNames()) {
            ColumnCapabilitiesImpl mergedCapabilities = columnCapabilities.get(metric);
            ColumnCapabilities capabilities = adapter.getCapabilities(metric);
            if (mergedCapabilities == null) {
                mergedCapabilities = new ColumnCapabilitiesImpl();
            }
            columnCapabilities.put(metric, mergedCapabilities.merge(capabilities));

            valueTypes.put(metric, capabilities.getType());
            metricTypeNames.put(metric, adapter.getMetricType(metric));
        }
    }

    final Interval dataInterval;
    File v8OutDir = new File(outDir, "v8-tmp");
    v8OutDir.mkdirs();

    /*************  Main index.drd file **************/
    progress.progress();
    long startTime = System.currentTimeMillis();
    File indexFile = new File(v8OutDir, "index.drd");

    try (FileOutputStream fileOutputStream = new FileOutputStream(indexFile);
            FileChannel channel = fileOutputStream.getChannel()) {
        channel.write(ByteBuffer.wrap(new byte[] { IndexIO.V8_VERSION }));

        GenericIndexed.fromIterable(mergedDimensions, GenericIndexed.STRING_STRATEGY).writeToChannel(channel);
        GenericIndexed.fromIterable(mergedMetrics, GenericIndexed.STRING_STRATEGY).writeToChannel(channel);

        DateTime minTime = new DateTime(JodaUtils.MAX_INSTANT);
        DateTime maxTime = new DateTime(JodaUtils.MIN_INSTANT);

        for (IndexableAdapter index : indexes) {
            minTime = JodaUtils.minDateTime(minTime, index.getDataInterval().getStart());
            maxTime = JodaUtils.maxDateTime(maxTime, index.getDataInterval().getEnd());
        }

        dataInterval = new Interval(minTime, maxTime);
        serializerUtils.writeString(channel, String.format("%s/%s", minTime, maxTime));
        serializerUtils.writeString(channel, mapper.writeValueAsString(indexSpec.getBitmapSerdeFactory()));
    }
    IndexIO.checkFileSize(indexFile);
    log.info("outDir[%s] completed index.drd in %,d millis.", v8OutDir, System.currentTimeMillis() - startTime);

    /************* Setup Dim Conversions **************/
    progress.progress();
    startTime = System.currentTimeMillis();

    IOPeon ioPeon = new TmpFileIOPeon();
    ArrayList<FileOutputSupplier> dimOuts = Lists.newArrayListWithCapacity(mergedDimensions.size());
    Map<String, Integer> dimensionCardinalities = Maps.newHashMap();
    ArrayList<Map<String, IntBuffer>> dimConversions = Lists.newArrayListWithCapacity(indexes.size());

    for (IndexableAdapter index : indexes) {
        dimConversions.add(Maps.<String, IntBuffer>newHashMap());
    }

    for (String dimension : mergedDimensions) {
        final GenericIndexedWriter<String> writer = new GenericIndexedWriter<String>(ioPeon, dimension,
                GenericIndexed.STRING_STRATEGY);
        writer.open();

        List<Indexed<String>> dimValueLookups = Lists.newArrayListWithCapacity(indexes.size());
        DimValueConverter[] converters = new DimValueConverter[indexes.size()];
        for (int i = 0; i < indexes.size(); i++) {
            Indexed<String> dimValues = indexes.get(i).getDimValueLookup(dimension);
            if (!isNullColumn(dimValues)) {
                dimValueLookups.add(dimValues);
                converters[i] = new DimValueConverter(dimValues);
            }
        }

        Iterable<String> dimensionValues = CombiningIterable.createSplatted(
                Iterables.transform(dimValueLookups, new Function<Indexed<String>, Iterable<String>>() {
                    @Override
                    public Iterable<String> apply(@Nullable Indexed<String> indexed) {
                        return Iterables.transform(indexed, new Function<String, String>() {
                            @Override
                            public String apply(@Nullable String input) {
                                return (input == null) ? "" : input;
                            }
                        });
                    }
                }), Ordering.<String>natural().nullsFirst());

        int count = 0;
        for (String value : dimensionValues) {
            value = value == null ? "" : value;
            writer.write(value);

            for (int i = 0; i < indexes.size(); i++) {
                DimValueConverter converter = converters[i];
                if (converter != null) {
                    converter.convert(value, count);
                }
            }

            ++count;
        }
        dimensionCardinalities.put(dimension, count);

        FileOutputSupplier dimOut = new FileOutputSupplier(IndexIO.makeDimFile(v8OutDir, dimension), true);
        dimOuts.add(dimOut);

        writer.close();
        serializerUtils.writeString(dimOut, dimension);
        ByteStreams.copy(writer.combineStreams(), dimOut);
        for (int i = 0; i < indexes.size(); ++i) {
            DimValueConverter converter = converters[i];
            if (converter != null) {
                dimConversions.get(i).put(dimension, converters[i].getConversionBuffer());
            }
        }

        ioPeon.cleanup();
    }
    log.info("outDir[%s] completed dim conversions in %,d millis.", v8OutDir,
            System.currentTimeMillis() - startTime);

    /************* Walk through data sets and merge them *************/
    progress.progress();
    startTime = System.currentTimeMillis();

    ArrayList<Iterable<Rowboat>> boats = Lists.newArrayListWithCapacity(indexes.size());

    for (int i = 0; i < indexes.size(); ++i) {
        final IndexableAdapter adapter = indexes.get(i);

        final int[] dimLookup = new int[mergedDimensions.size()];
        int count = 0;
        for (String dim : adapter.getDimensionNames()) {
            dimLookup[count] = mergedDimensions.indexOf(dim);
            count++;
        }

        final int[] metricLookup = new int[mergedMetrics.size()];
        count = 0;
        for (String metric : adapter.getMetricNames()) {
            metricLookup[count] = mergedMetrics.indexOf(metric);
            count++;
        }

        boats.add(new MMappedIndexRowIterable(
                Iterables.transform(indexes.get(i).getRows(), new Function<Rowboat, Rowboat>() {
                    @Override
                    public Rowboat apply(@Nullable Rowboat input) {
                        int[][] newDims = new int[mergedDimensions.size()][];
                        int j = 0;
                        for (int[] dim : input.getDims()) {
                            newDims[dimLookup[j]] = dim;
                            j++;
                        }

                        Object[] newMetrics = new Object[mergedMetrics.size()];
                        j = 0;
                        for (Object met : input.getMetrics()) {
                            newMetrics[metricLookup[j]] = met;
                            j++;
                        }

                        return new Rowboat(input.getTimestamp(), newDims, newMetrics, input.getRowNum());
                    }
                }), mergedDimensions, dimConversions.get(i), i));
    }

    Iterable<Rowboat> theRows = rowMergerFn.apply(boats);

    CompressedLongsSupplierSerializer timeWriter = CompressedLongsSupplierSerializer.create(ioPeon,
            "little_end_time", IndexIO.BYTE_ORDER, CompressedObjectStrategy.DEFAULT_COMPRESSION_STRATEGY);

    timeWriter.open();

    ArrayList<VSizeIndexedWriter> forwardDimWriters = Lists.newArrayListWithCapacity(mergedDimensions.size());
    for (String dimension : mergedDimensions) {
        VSizeIndexedWriter writer = new VSizeIndexedWriter(ioPeon, dimension,
                dimensionCardinalities.get(dimension));
        writer.open();
        forwardDimWriters.add(writer);
    }

    ArrayList<MetricColumnSerializer> metWriters = Lists.newArrayListWithCapacity(mergedMetrics.size());
    for (String metric : mergedMetrics) {
        ValueType type = valueTypes.get(metric);
        switch (type) {
        case LONG:
            metWriters.add(new LongMetricColumnSerializer(metric, v8OutDir, ioPeon));
            break;
        case FLOAT:
            metWriters.add(new FloatMetricColumnSerializer(metric, v8OutDir, ioPeon));
            break;
        case COMPLEX:
            final String typeName = metricTypeNames.get(metric);
            ComplexMetricSerde serde = ComplexMetrics.getSerdeForType(typeName);

            if (serde == null) {
                throw new ISE("Unknown type[%s]", typeName);
            }

            metWriters.add(new ComplexMetricColumnSerializer(metric, v8OutDir, ioPeon, serde));
            break;
        default:
            throw new ISE("Unknown type[%s]", type);
        }
    }

    for (MetricColumnSerializer metWriter : metWriters) {
        metWriter.open();
    }

    int rowCount = 0;
    long time = System.currentTimeMillis();
    List<IntBuffer> rowNumConversions = Lists.newArrayListWithCapacity(indexes.size());
    for (IndexableAdapter index : indexes) {
        int[] arr = new int[index.getNumRows()];
        Arrays.fill(arr, INVALID_ROW);
        rowNumConversions.add(IntBuffer.wrap(arr));
    }

    for (Rowboat theRow : theRows) {
        progress.progress();
        timeWriter.add(theRow.getTimestamp());

        final Object[] metrics = theRow.getMetrics();
        for (int i = 0; i < metrics.length; ++i) {
            metWriters.get(i).serialize(metrics[i]);
        }

        int[][] dims = theRow.getDims();
        for (int i = 0; i < dims.length; ++i) {
            List<Integer> listToWrite = (i >= dims.length || dims[i] == null) ? null : Ints.asList(dims[i]);
            forwardDimWriters.get(i).write(listToWrite);
        }

        for (Map.Entry<Integer, TreeSet<Integer>> comprisedRow : theRow.getComprisedRows().entrySet()) {
            final IntBuffer conversionBuffer = rowNumConversions.get(comprisedRow.getKey());

            for (Integer rowNum : comprisedRow.getValue()) {
                while (conversionBuffer.position() < rowNum) {
                    conversionBuffer.put(INVALID_ROW);
                }
                conversionBuffer.put(rowCount);
            }
        }

        if ((++rowCount % 500000) == 0) {
            log.info("outDir[%s] walked 500,000/%,d rows in %,d millis.", v8OutDir, rowCount,
                    System.currentTimeMillis() - time);
            time = System.currentTimeMillis();
        }
    }

    for (IntBuffer rowNumConversion : rowNumConversions) {
        rowNumConversion.rewind();
    }

    final File timeFile = IndexIO.makeTimeFile(v8OutDir, IndexIO.BYTE_ORDER);
    timeFile.delete();
    OutputSupplier<FileOutputStream> out = Files.newOutputStreamSupplier(timeFile, true);
    timeWriter.closeAndConsolidate(out);
    IndexIO.checkFileSize(timeFile);

    for (int i = 0; i < mergedDimensions.size(); ++i) {
        forwardDimWriters.get(i).close();
        ByteStreams.copy(forwardDimWriters.get(i).combineStreams(), dimOuts.get(i));
    }

    for (MetricColumnSerializer metWriter : metWriters) {
        metWriter.close();
    }

    ioPeon.cleanup();
    log.info("outDir[%s] completed walk through of %,d rows in %,d millis.", v8OutDir, rowCount,
            System.currentTimeMillis() - startTime);

    /************ Create Inverted Indexes *************/
    startTime = System.currentTimeMillis();

    final File invertedFile = new File(v8OutDir, "inverted.drd");
    Files.touch(invertedFile);
    out = Files.newOutputStreamSupplier(invertedFile, true);

    final File geoFile = new File(v8OutDir, "spatial.drd");
    Files.touch(geoFile);
    OutputSupplier<FileOutputStream> spatialOut = Files.newOutputStreamSupplier(geoFile, true);

    for (int i = 0; i < mergedDimensions.size(); ++i) {
        long dimStartTime = System.currentTimeMillis();
        String dimension = mergedDimensions.get(i);

        File dimOutFile = dimOuts.get(i).getFile();
        final MappedByteBuffer dimValsMapped = Files.map(dimOutFile);

        if (!dimension.equals(serializerUtils.readString(dimValsMapped))) {
            throw new ISE("dimensions[%s] didn't equate!?  This is a major WTF moment.", dimension);
        }
        Indexed<String> dimVals = GenericIndexed.read(dimValsMapped, GenericIndexed.STRING_STRATEGY);
        log.info("Starting dimension[%s] with cardinality[%,d]", dimension, dimVals.size());

        final BitmapSerdeFactory bitmapSerdeFactory = indexSpec.getBitmapSerdeFactory();
        GenericIndexedWriter<ImmutableBitmap> writer = new GenericIndexedWriter<>(ioPeon, dimension,
                bitmapSerdeFactory.getObjectStrategy());
        writer.open();

        boolean isSpatialDim = columnCapabilities.get(dimension).hasSpatialIndexes();
        ByteBufferWriter<ImmutableRTree> spatialWriter = null;
        RTree tree = null;
        IOPeon spatialIoPeon = new TmpFileIOPeon();
        if (isSpatialDim) {
            BitmapFactory bitmapFactory = bitmapSerdeFactory.getBitmapFactory();
            spatialWriter = new ByteBufferWriter<ImmutableRTree>(spatialIoPeon, dimension,
                    new IndexedRTree.ImmutableRTreeObjectStrategy(bitmapFactory));
            spatialWriter.open();
            tree = new RTree(2, new LinearGutmanSplitStrategy(0, 50, bitmapFactory), bitmapFactory);
        }

        for (String dimVal : IndexedIterable.create(dimVals)) {
            progress.progress();
            List<Iterable<Integer>> convertedInverteds = Lists.newArrayListWithCapacity(indexes.size());
            for (int j = 0; j < indexes.size(); ++j) {
                convertedInverteds.add(new ConvertingIndexedInts(
                        indexes.get(j).getBitmapIndex(dimension, dimVal), rowNumConversions.get(j)));
            }

            MutableBitmap bitset = bitmapSerdeFactory.getBitmapFactory().makeEmptyMutableBitmap();
            for (Integer row : CombiningIterable.createSplatted(convertedInverteds,
                    Ordering.<Integer>natural().nullsFirst())) {
                if (row != INVALID_ROW) {
                    bitset.add(row);
                }
            }

            writer.write(bitmapSerdeFactory.getBitmapFactory().makeImmutableBitmap(bitset));

            if (isSpatialDim && dimVal != null) {
                List<String> stringCoords = Lists.newArrayList(SPLITTER.split(dimVal));
                float[] coords = new float[stringCoords.size()];
                for (int j = 0; j < coords.length; j++) {
                    coords[j] = Float.valueOf(stringCoords.get(j));
                }
                tree.insert(coords, bitset);
            }
        }
        writer.close();

        serializerUtils.writeString(out, dimension);
        ByteStreams.copy(writer.combineStreams(), out);
        ioPeon.cleanup();

        log.info("Completed dimension[%s] in %,d millis.", dimension,
                System.currentTimeMillis() - dimStartTime);

        if (isSpatialDim) {
            spatialWriter.write(ImmutableRTree.newImmutableFromMutable(tree));
            spatialWriter.close();

            serializerUtils.writeString(spatialOut, dimension);
            ByteStreams.copy(spatialWriter.combineStreams(), spatialOut);
            spatialIoPeon.cleanup();
        }

    }

    log.info("outDir[%s] completed inverted.drd in %,d millis.", v8OutDir,
            System.currentTimeMillis() - startTime);

    final ArrayList<String> expectedFiles = Lists.newArrayList(Iterables.concat(
            Arrays.asList("index.drd", "inverted.drd", "spatial.drd",
                    String.format("time_%s.drd", IndexIO.BYTE_ORDER)),
            Iterables.transform(mergedDimensions, GuavaUtils.formatFunction("dim_%s.drd")),
            Iterables.transform(mergedMetrics,
                    GuavaUtils.formatFunction(String.format("met_%%s_%s.drd", IndexIO.BYTE_ORDER)))));

    if (segmentMetadata != null && !segmentMetadata.isEmpty()) {
        writeMetadataToFile(new File(v8OutDir, "metadata.drd"), segmentMetadata);
        log.info("wrote metadata.drd in outDir[%s].", v8OutDir);

        expectedFiles.add("metadata.drd");
    }

    Map<String, File> files = Maps.newLinkedHashMap();
    for (String fileName : expectedFiles) {
        files.put(fileName, new File(v8OutDir, fileName));
    }

    File smooshDir = new File(v8OutDir, "smoosher");
    smooshDir.mkdir();

    for (Map.Entry<String, File> entry : Smoosh.smoosh(v8OutDir, smooshDir, files).entrySet()) {
        entry.getValue().delete();
    }

    for (File file : smooshDir.listFiles()) {
        Files.move(file, new File(v8OutDir, file.getName()));
    }

    if (!smooshDir.delete()) {
        log.info("Unable to delete temporary dir[%s], contains[%s]", smooshDir,
                Arrays.asList(smooshDir.listFiles()));
        throw new IOException(String.format("Unable to delete temporary dir[%s]", smooshDir));
    }

    createIndexDrdFile(IndexIO.V8_VERSION, v8OutDir,
            GenericIndexed.fromIterable(mergedDimensions, GenericIndexed.STRING_STRATEGY),
            GenericIndexed.fromIterable(mergedMetrics, GenericIndexed.STRING_STRATEGY), dataInterval,
            indexSpec.getBitmapSerdeFactory());

    IndexIO.DefaultIndexIOHandler.convertV8toV9(v8OutDir, outDir, indexSpec);
    FileUtils.deleteDirectory(v8OutDir);

    return outDir;
}

From source file:com.alvermont.terraj.fracplanet.geom.TriangleBufferArray.java

/**
 * Resize this buffer to accomodate a larger number of elements
 *///from  w w w . j a v  a2  s . c  o m
protected void resizeBuffer() {
    // we can't resize it so we have to allocate a new one and copy the data across
    final int slots = this.buffer.capacity() / INTS_PER_ENTRY;
    final int newCapacity = this.buffer.capacity()
            + (((slots * CAPACITY_PCT_INCREASE) / PERCENT_100) * INTS_PER_ENTRY);

    final IntBuffer newBuffer = ByteBuffer.allocateDirect(newCapacity * SIZEOF_INT)
            .order(ByteOrder.nativeOrder()).asIntBuffer();

    newBuffer.limit(this.buffer.limit());

    if (log.isDebugEnabled()) {
        log.debug("Resizing triangle buffer capacity to: " + newCapacity + " " + newBuffer.capacity());
    }

    this.buffer.rewind();
    newBuffer.put(this.buffer);

    this.buffer = newBuffer;
}

From source file:io.druid.segment.IndexMergerV9.java

private void mergeIndexesAndWriteColumns(final List<IndexableAdapter> adapters,
        final ProgressIndicator progress, final Iterable<Rowboat> theRows,
        final LongColumnSerializer timeWriter, final ArrayList<GenericColumnSerializer> metWriters,
        final List<IntBuffer> rowNumConversions, final List<DimensionMerger> mergers) throws IOException {
    final String section = "walk through and merge rows";
    progress.startSection(section);/* ww w . ja va  2  s . c o  m*/
    long startTime = System.currentTimeMillis();

    int rowCount = 0;
    for (IndexableAdapter adapter : adapters) {
        int[] arr = new int[adapter.getNumRows()];
        Arrays.fill(arr, INVALID_ROW);
        rowNumConversions.add(IntBuffer.wrap(arr));
    }

    long time = System.currentTimeMillis();
    for (Rowboat theRow : theRows) {
        progress.progress();
        timeWriter.serialize(theRow.getTimestamp());

        final Object[] metrics = theRow.getMetrics();
        for (int i = 0; i < metrics.length; ++i) {
            metWriters.get(i).serialize(metrics[i]);
        }

        Object[] dims = theRow.getDims();
        for (int i = 0; i < dims.length; ++i) {
            DimensionMerger merger = mergers.get(i);
            if (merger.canSkip()) {
                continue;
            }
            merger.processMergedRow(dims[i]);
        }

        for (Map.Entry<Integer, TreeSet<Integer>> comprisedRow : theRow.getComprisedRows().entrySet()) {
            final IntBuffer conversionBuffer = rowNumConversions.get(comprisedRow.getKey());

            for (Integer rowNum : comprisedRow.getValue()) {
                while (conversionBuffer.position() < rowNum) {
                    conversionBuffer.put(INVALID_ROW);
                }
                conversionBuffer.put(rowCount);
            }
        }
        if ((++rowCount % 500000) == 0) {
            log.info("walked 500,000/%d rows in %,d millis.", rowCount, System.currentTimeMillis() - time);
            time = System.currentTimeMillis();
        }
    }
    for (IntBuffer rowNumConversion : rowNumConversions) {
        rowNumConversion.rewind();
    }
    log.info("completed walk through of %,d rows in %,d millis.", rowCount,
            System.currentTimeMillis() - startTime);
    progress.stopSection(section);
}

From source file:com.asakusafw.runtime.io.csv.CsvParser.java

private void addSeparator() {
    IntBuffer buf = cellBeginPositions;
    if (buf.remaining() == 0) {
        IntBuffer newBuf = IntBuffer.allocate(buf.capacity() * 2);
        newBuf.clear();//w w w.j a  va  2  s .  com
        buf.flip();
        newBuf.put(buf);
        buf = newBuf;
        cellBeginPositions = newBuf;
    }
    buf.put(lineBuffer.position());
}

From source file:org.bimserver.GeometryGenerator.java

private byte[] intArrayToByteArray(int[] indices) {
    if (indices == null) {
        return null;
    }/*ww  w . j  a v  a 2  s  .com*/
    ByteBuffer buffer = ByteBuffer.wrap(new byte[indices.length * 4]);
    buffer.order(ByteOrder.LITTLE_ENDIAN);
    IntBuffer asIntBuffer = buffer.asIntBuffer();
    for (int i : indices) {
        asIntBuffer.put(i);
    }
    return buffer.array();
}

From source file:org.jtrfp.trcl.obj.WorldObject.java

public final void initializeObjectDefinitions() {
    if (model == null)
        throw new NullPointerException("Model is null. Did you forget to set it?");
    final ArrayList<Integer> opaqueIndicesList = new ArrayList<Integer>();
    final ArrayList<Integer> transparentIndicesList = new ArrayList<Integer>();
    tr.getThreadManager().submitToThreadPool(new Callable<Void>() {
        @Override/*from  ww w .  j av  a2s .  com*/
        public Void call() throws Exception {
            tr.getThreadManager().submitToGPUMemAccess(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    processPrimitiveList(model.getTriangleList(), triangleObjectDefinitions, opaqueIndicesList);
                    processPrimitiveList(model.getTransparentTriangleList(),
                            transparentTriangleObjectDefinitions, transparentIndicesList);
                    return null;
                }
            }).get();//TODO: Make non-blocking
            ByteOrder order = getTr().gpu.get().getByteOrder();
            opaqueObjectDefinitionAddressesInVec4 = ByteBuffer.allocateDirect(opaqueIndicesList.size() * 4)
                    .order(order);// 4 bytes per int
            opaqueObjectDefinitionAddressesInVEC4 = new VEC4Address[opaqueIndicesList.size()];
            for (int i = 0; i < opaqueIndicesList.size(); i++)
                opaqueObjectDefinitionAddressesInVEC4[i] = new VEC4Address(opaqueIndicesList.get(i));
            transparentObjectDefinitionAddressesInVec4 = ByteBuffer
                    .allocateDirect(transparentIndicesList.size() * 4).order(order);
            transparentObjectDefinitionAddressesInVEC4 = new VEC4Address[transparentIndicesList.size()];
            for (int i = 0; i < transparentIndicesList.size(); i++)
                transparentObjectDefinitionAddressesInVEC4[i] = new VEC4Address(transparentIndicesList.get(i));

            IntBuffer trans = transparentObjectDefinitionAddressesInVec4.asIntBuffer(),
                    opaque = opaqueObjectDefinitionAddressesInVec4.asIntBuffer();

            for (Integer elm : transparentIndicesList)
                trans.put(elm);
            for (Integer elm : opaqueIndicesList)
                opaque.put(elm);
            return null;
        }
    });
}

From source file:org.tsho.dmc2.core.chart.AbsorbingAreaRenderer.java

public void copyDisplay() {
    IntBuffer buffer = IntBuffer.allocate(grid.length);
    buffer.put(grid);
    buffer.flip();
    buffer.get(gridBackup);
}

From source file:org.tsho.dmc2.core.chart.AbsorbingAreaRenderer.java

public void plotCopiedDisplay() {
    IntBuffer buffer = IntBuffer.allocate(grid.length);
    buffer.put(gridBackup);
    buffer.flip();
    buffer.get(grid);
}

From source file:org.apache.druid.segment.IndexMergerV9.java

/**
 * Returns rowNumConversions, if fillRowNumConversions argument is true
 *//*  w  w w  .j  a  v  a  2 s.c  o  m*/
@Nullable
private List<IntBuffer> mergeIndexesAndWriteColumns(final List<IndexableAdapter> adapters,
        final ProgressIndicator progress, final TimeAndDimsIterator timeAndDimsIterator,
        final GenericColumnSerializer timeWriter, final ArrayList<GenericColumnSerializer> metricWriters,
        final List<DimensionMergerV9> mergers, final boolean fillRowNumConversions) throws IOException {
    final String section = "walk through and merge rows";
    progress.startSection(section);
    long startTime = System.currentTimeMillis();

    List<IntBuffer> rowNumConversions = null;
    int rowCount = 0;
    if (fillRowNumConversions) {
        rowNumConversions = new ArrayList<>(adapters.size());
        for (IndexableAdapter adapter : adapters) {
            int[] arr = new int[adapter.getNumRows()];
            Arrays.fill(arr, INVALID_ROW);
            rowNumConversions.add(IntBuffer.wrap(arr));
        }
    }

    long time = System.currentTimeMillis();
    while (timeAndDimsIterator.moveToNext()) {
        progress.progress();
        TimeAndDimsPointer timeAndDims = timeAndDimsIterator.getPointer();
        timeWriter.serialize(timeAndDims.timestampSelector);

        for (int metricIndex = 0; metricIndex < timeAndDims.getNumMetrics(); metricIndex++) {
            metricWriters.get(metricIndex).serialize(timeAndDims.getMetricSelector(metricIndex));
        }

        for (int dimIndex = 0; dimIndex < timeAndDims.getNumDimensions(); dimIndex++) {
            DimensionMerger merger = mergers.get(dimIndex);
            if (merger.canSkip()) {
                continue;
            }
            merger.processMergedRow(timeAndDims.getDimensionSelector(dimIndex));
        }

        if (timeAndDimsIterator instanceof RowCombiningTimeAndDimsIterator) {
            RowCombiningTimeAndDimsIterator comprisedRows = (RowCombiningTimeAndDimsIterator) timeAndDimsIterator;

            for (int originalIteratorIndex = comprisedRows.nextCurrentlyCombinedOriginalIteratorIndex(
                    0); originalIteratorIndex >= 0; originalIteratorIndex = comprisedRows
                            .nextCurrentlyCombinedOriginalIteratorIndex(originalIteratorIndex + 1)) {

                IntBuffer conversionBuffer = rowNumConversions.get(originalIteratorIndex);
                int minRowNum = comprisedRows
                        .getMinCurrentlyCombinedRowNumByOriginalIteratorIndex(originalIteratorIndex);
                int maxRowNum = comprisedRows
                        .getMaxCurrentlyCombinedRowNumByOriginalIteratorIndex(originalIteratorIndex);

                for (int rowNum = minRowNum; rowNum <= maxRowNum; rowNum++) {
                    while (conversionBuffer.position() < rowNum) {
                        conversionBuffer.put(INVALID_ROW);
                    }
                    conversionBuffer.put(rowCount);
                }

            }

        } else if (timeAndDimsIterator instanceof MergingRowIterator) {
            RowPointer rowPointer = (RowPointer) timeAndDims;
            IntBuffer conversionBuffer = rowNumConversions.get(rowPointer.getIndexNum());
            int rowNum = rowPointer.getRowNum();
            while (conversionBuffer.position() < rowNum) {
                conversionBuffer.put(INVALID_ROW);
            }
            conversionBuffer.put(rowCount);
        } else {
            if (fillRowNumConversions) {
                throw new IllegalStateException(
                        "Filling row num conversions is supported only with RowCombining and Merging iterators");
            }
        }

        if ((++rowCount % 500000) == 0) {
            log.info("walked 500,000/%d rows in %,d millis.", rowCount, System.currentTimeMillis() - time);
            time = System.currentTimeMillis();
        }
    }
    if (rowNumConversions != null) {
        for (IntBuffer rowNumConversion : rowNumConversions) {
            rowNumConversion.rewind();
        }
    }
    log.info("completed walk through of %,d rows in %,d millis.", rowCount,
            System.currentTimeMillis() - startTime);
    progress.stopSection(section);
    return rowNumConversions;
}