package io.netty.buffer;

import g.a.a.a.a;
import io.netty.util.internal.PlatformDependent;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.FileChannel;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
public class UnpooledUnsafeDirectByteBuf extends AbstractReferenceCountedByteBuf {
    private final ByteBufAllocator alloc;
    public ByteBuffer buffer;
    private int capacity;
    private boolean doNotFree;
    public long memoryAddress;
    private ByteBuffer tmpNioBuf;

    public UnpooledUnsafeDirectByteBuf(ByteBufAllocator byteBufAllocator, int i2, int i3) {
        super(i3);
        Objects.requireNonNull(byteBufAllocator, "alloc");
        if (i2 < 0) {
            throw new IllegalArgumentException(a.l("initialCapacity: ", i2));
        }
        if (i3 < 0) {
            throw new IllegalArgumentException(a.l("maxCapacity: ", i3));
        }
        if (i2 > i3) {
            throw new IllegalArgumentException(String.format("initialCapacity(%d) > maxCapacity(%d)", Integer.valueOf(i2), Integer.valueOf(i3)));
        }
        this.alloc = byteBufAllocator;
        setByteBuffer(allocateDirect(i2), false);
    }

    public UnpooledUnsafeDirectByteBuf(ByteBufAllocator byteBufAllocator, ByteBuffer byteBuffer, int i2) {
        this(byteBufAllocator, byteBuffer.slice(), i2, false);
    }

    public UnpooledUnsafeDirectByteBuf(ByteBufAllocator byteBufAllocator, ByteBuffer byteBuffer, int i2, boolean z2) {
        super(i2);
        Objects.requireNonNull(byteBufAllocator, "alloc");
        Objects.requireNonNull(byteBuffer, "initialBuffer");
        if (!byteBuffer.isDirect()) {
            throw new IllegalArgumentException("initialBuffer is not a direct buffer.");
        }
        if (byteBuffer.isReadOnly()) {
            throw new IllegalArgumentException("initialBuffer is a read-only buffer.");
        }
        int iRemaining = byteBuffer.remaining();
        if (iRemaining > i2) {
            throw new IllegalArgumentException(String.format("initialCapacity(%d) > maxCapacity(%d)", Integer.valueOf(iRemaining), Integer.valueOf(i2)));
        }
        this.alloc = byteBufAllocator;
        this.doNotFree = !z2;
        setByteBuffer(byteBuffer.order(ByteOrder.BIG_ENDIAN), false);
        writerIndex(iRemaining);
    }

    private int getBytes(int i2, FileChannel fileChannel, long j2, int i3, boolean z2) {
        ensureAccessible();
        if (i3 == 0) {
            return 0;
        }
        ByteBuffer byteBufferInternalNioBuffer = z2 ? internalNioBuffer() : this.buffer.duplicate();
        byteBufferInternalNioBuffer.clear().position(i2).limit(i2 + i3);
        return fileChannel.write(byteBufferInternalNioBuffer, j2);
    }

    private int getBytes(int i2, GatheringByteChannel gatheringByteChannel, int i3, boolean z2) {
        ensureAccessible();
        if (i3 == 0) {
            return 0;
        }
        ByteBuffer byteBufferInternalNioBuffer = z2 ? internalNioBuffer() : this.buffer.duplicate();
        byteBufferInternalNioBuffer.clear().position(i2).limit(i2 + i3);
        return gatheringByteChannel.write(byteBufferInternalNioBuffer);
    }

    private ByteBuffer internalNioBuffer() {
        ByteBuffer byteBuffer = this.tmpNioBuf;
        if (byteBuffer != null) {
            return byteBuffer;
        }
        ByteBuffer byteBufferDuplicate = this.buffer.duplicate();
        this.tmpNioBuf = byteBufferDuplicate;
        return byteBufferDuplicate;
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public byte _getByte(int i2) {
        return UnsafeByteBufUtil.getByte(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public int _getInt(int i2) {
        return UnsafeByteBufUtil.getInt(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public int _getIntLE(int i2) {
        return UnsafeByteBufUtil.getIntLE(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public long _getLong(int i2) {
        return UnsafeByteBufUtil.getLong(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public long _getLongLE(int i2) {
        return UnsafeByteBufUtil.getLongLE(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public short _getShort(int i2) {
        return UnsafeByteBufUtil.getShort(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public short _getShortLE(int i2) {
        return UnsafeByteBufUtil.getShortLE(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public int _getUnsignedMedium(int i2) {
        return UnsafeByteBufUtil.getUnsignedMedium(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public int _getUnsignedMediumLE(int i2) {
        return UnsafeByteBufUtil.getUnsignedMediumLE(addr(i2));
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setByte(int i2, int i3) {
        UnsafeByteBufUtil.setByte(addr(i2), i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setInt(int i2, int i3) {
        UnsafeByteBufUtil.setInt(addr(i2), i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setIntLE(int i2, int i3) {
        UnsafeByteBufUtil.setIntLE(addr(i2), i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setLong(int i2, long j2) {
        UnsafeByteBufUtil.setLong(addr(i2), j2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setLongLE(int i2, long j2) {
        UnsafeByteBufUtil.setLongLE(addr(i2), j2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setMedium(int i2, int i3) {
        UnsafeByteBufUtil.setMedium(addr(i2), i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setMediumLE(int i2, int i3) {
        UnsafeByteBufUtil.setMediumLE(addr(i2), i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setShort(int i2, int i3) {
        UnsafeByteBufUtil.setShort(addr(i2), i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public void _setShortLE(int i2, int i3) {
        UnsafeByteBufUtil.setShortLE(addr(i2), i3);
    }

    public long addr(int i2) {
        return this.memoryAddress + ((long) i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBufAllocator alloc() {
        return this.alloc;
    }

    public ByteBuffer allocateDirect(int i2) {
        return ByteBuffer.allocateDirect(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public byte[] array() {
        throw new UnsupportedOperationException("direct buffer");
    }

    @Override // io.netty.buffer.ByteBuf
    public int arrayOffset() {
        throw new UnsupportedOperationException("direct buffer");
    }

    @Override // io.netty.buffer.ByteBuf
    public int capacity() {
        return this.capacity;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf capacity(int i2) {
        checkNewCapacity(i2);
        int i3 = readerIndex();
        int iWriterIndex = writerIndex();
        int i4 = this.capacity;
        if (i2 > i4) {
            ByteBuffer byteBuffer = this.buffer;
            ByteBuffer byteBufferAllocateDirect = allocateDirect(i2);
            byteBuffer.position(0).limit(byteBuffer.capacity());
            byteBufferAllocateDirect.position(0).limit(byteBuffer.capacity());
            byteBufferAllocateDirect.put(byteBuffer);
            byteBufferAllocateDirect.clear();
            setByteBuffer(byteBufferAllocateDirect, true);
        } else if (i2 < i4) {
            ByteBuffer byteBuffer2 = this.buffer;
            ByteBuffer byteBufferAllocateDirect2 = allocateDirect(i2);
            if (i3 < i2) {
                if (iWriterIndex > i2) {
                    writerIndex(i2);
                } else {
                    i2 = iWriterIndex;
                }
                byteBuffer2.position(i3).limit(i2);
                byteBufferAllocateDirect2.position(i3).limit(i2);
                byteBufferAllocateDirect2.put(byteBuffer2);
                byteBufferAllocateDirect2.clear();
            } else {
                setIndex(i2, i2);
            }
            setByteBuffer(byteBufferAllocateDirect2, true);
        }
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf copy(int i2, int i3) {
        return UnsafeByteBufUtil.copy(this, addr(i2), i2, i3);
    }

    @Override // io.netty.buffer.AbstractReferenceCountedByteBuf
    public void deallocate() {
        ByteBuffer byteBuffer = this.buffer;
        if (byteBuffer == null) {
            return;
        }
        this.buffer = null;
        if (this.doNotFree) {
            return;
        }
        freeDirect(byteBuffer);
    }

    public void freeDirect(ByteBuffer byteBuffer) {
        PlatformDependent.freeDirectBuffer(byteBuffer);
    }

    @Override // io.netty.buffer.ByteBuf
    public int getBytes(int i2, FileChannel fileChannel, long j2, int i3) {
        return getBytes(i2, fileChannel, j2, i3, false);
    }

    @Override // io.netty.buffer.ByteBuf
    public int getBytes(int i2, GatheringByteChannel gatheringByteChannel, int i3) {
        return getBytes(i2, gatheringByteChannel, i3, false);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, ByteBuf byteBuf, int i3, int i4) {
        UnsafeByteBufUtil.getBytes(this, addr(i2), i2, byteBuf, i3, i4);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, OutputStream outputStream, int i3) {
        UnsafeByteBufUtil.getBytes(this, addr(i2), i2, outputStream, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, ByteBuffer byteBuffer) {
        UnsafeByteBufUtil.getBytes(this, addr(i2), i2, byteBuffer);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, byte[] bArr, int i3, int i4) {
        UnsafeByteBufUtil.getBytes(this, addr(i2), i2, bArr, i3, i4);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean hasArray() {
        return false;
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean hasMemoryAddress() {
        return true;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuffer internalNioBuffer(int i2, int i3) {
        checkIndex(i2, i3);
        return (ByteBuffer) internalNioBuffer().clear().position(i2).limit(i2 + i3);
    }

    @Override // io.netty.buffer.ByteBuf
    public boolean isDirect() {
        return true;
    }

    @Override // io.netty.buffer.ByteBuf
    public long memoryAddress() {
        ensureAccessible();
        return this.memoryAddress;
    }

    @Override // io.netty.buffer.AbstractByteBuf
    public SwappedByteBuf newSwappedByteBuf() {
        return PlatformDependent.isUnaligned() ? new UnsafeDirectSwappedByteBuf(this) : super.newSwappedByteBuf();
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuffer nioBuffer(int i2, int i3) {
        checkIndex(i2, i3);
        return ((ByteBuffer) this.buffer.duplicate().position(i2).limit(i2 + i3)).slice();
    }

    @Override // io.netty.buffer.ByteBuf
    public int nioBufferCount() {
        return 1;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuffer[] nioBuffers(int i2, int i3) {
        return new ByteBuffer[]{nioBuffer(i2, i3)};
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteOrder order() {
        return ByteOrder.BIG_ENDIAN;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public int readBytes(FileChannel fileChannel, long j2, int i2) {
        checkReadableBytes(i2);
        int bytes = getBytes(this.readerIndex, fileChannel, j2, i2, true);
        this.readerIndex += bytes;
        return bytes;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public int readBytes(GatheringByteChannel gatheringByteChannel, int i2) {
        checkReadableBytes(i2);
        int bytes = getBytes(this.readerIndex, gatheringByteChannel, i2, true);
        this.readerIndex += bytes;
        return bytes;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf readBytes(ByteBuffer byteBuffer) {
        int iRemaining = byteBuffer.remaining();
        checkReadableBytes(iRemaining);
        getBytes(this.readerIndex, byteBuffer);
        this.readerIndex += iRemaining;
        return this;
    }

    public final void setByteBuffer(ByteBuffer byteBuffer, boolean z2) {
        ByteBuffer byteBuffer2;
        if (z2 && (byteBuffer2 = this.buffer) != null) {
            if (this.doNotFree) {
                this.doNotFree = false;
            } else {
                freeDirect(byteBuffer2);
            }
        }
        this.buffer = byteBuffer;
        this.memoryAddress = PlatformDependent.directBufferAddress(byteBuffer);
        this.tmpNioBuf = null;
        this.capacity = byteBuffer.remaining();
    }

    @Override // io.netty.buffer.ByteBuf
    public int setBytes(int i2, InputStream inputStream, int i3) {
        return UnsafeByteBufUtil.setBytes(this, addr(i2), i2, inputStream, i3);
    }

    @Override // io.netty.buffer.ByteBuf
    public int setBytes(int i2, FileChannel fileChannel, long j2, int i3) {
        ensureAccessible();
        ByteBuffer byteBufferInternalNioBuffer = internalNioBuffer();
        byteBufferInternalNioBuffer.clear().position(i2).limit(i2 + i3);
        try {
            return fileChannel.read(byteBufferInternalNioBuffer, j2);
        } catch (ClosedChannelException unused) {
            return -1;
        }
    }

    @Override // io.netty.buffer.ByteBuf
    public int setBytes(int i2, ScatteringByteChannel scatteringByteChannel, int i3) {
        ensureAccessible();
        ByteBuffer byteBufferInternalNioBuffer = internalNioBuffer();
        byteBufferInternalNioBuffer.clear().position(i2).limit(i2 + i3);
        try {
            return scatteringByteChannel.read(byteBufferInternalNioBuffer);
        } catch (ClosedChannelException unused) {
            return -1;
        }
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBytes(int i2, ByteBuf byteBuf, int i3, int i4) {
        UnsafeByteBufUtil.setBytes(this, addr(i2), i2, byteBuf, i3, i4);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBytes(int i2, ByteBuffer byteBuffer) {
        UnsafeByteBufUtil.setBytes(this, addr(i2), i2, byteBuffer);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBytes(int i2, byte[] bArr, int i3, int i4) {
        UnsafeByteBufUtil.setBytes(this, addr(i2), i2, bArr, i3, i4);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setZero(int i2, int i3) {
        checkIndex(i2, i3);
        UnsafeByteBufUtil.setZero(addr(i2), i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf unwrap() {
        return null;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf writeZero(int i2) {
        ensureWritable(i2);
        int i3 = this.writerIndex;
        UnsafeByteBufUtil.setZero(addr(i3), i2);
        this.writerIndex = i3 + i2;
        return this;
    }
}