package io.netty.buffer;

import io.netty.util.IllegalReferenceCountException;
import io.netty.util.internal.PlatformDependent;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import org.snmp4j.mp.MPv3;

/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
    private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater;
    private volatile int refCnt;

    static {
        AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater = PlatformDependent.newAtomicIntegerFieldUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
        if (atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater == null) {
            atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
        }
        refCntUpdater = atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater;
    }

    protected AbstractReferenceCountedByteBuf(int i2) {
        super(i2);
        this.refCnt = 1;
    }

    protected abstract void deallocate();

    @Override // io.netty.util.ReferenceCounted
    public int refCnt() {
        return this.refCnt;
    }

    @Override // io.netty.util.ReferenceCounted
    public boolean release() {
        int i2;
        do {
            i2 = this.refCnt;
            if (i2 == 0) {
                throw new IllegalReferenceCountException(0, -1);
            }
        } while (!refCntUpdater.compareAndSet(this, i2, i2 - 1));
        if (i2 != 1) {
            return false;
        }
        deallocate();
        return true;
    }

    protected final void setRefCnt(int i2) {
        this.refCnt = i2;
    }

    @Override // io.netty.buffer.ByteBuf, io.netty.util.ReferenceCounted
    public ByteBuf touch() {
        return this;
    }

    @Override // io.netty.buffer.ByteBuf, io.netty.util.ReferenceCounted
    public ByteBuf touch(Object obj) {
        return this;
    }

    @Override // io.netty.buffer.ByteBuf, io.netty.util.ReferenceCounted
    public ByteBuf retain() {
        int i2;
        do {
            i2 = this.refCnt;
            if (i2 == 0) {
                throw new IllegalReferenceCountException(0, 1);
            }
            if (i2 == Integer.MAX_VALUE) {
                throw new IllegalReferenceCountException(MPv3.MAX_MESSAGE_ID, 1);
            }
        } while (!refCntUpdater.compareAndSet(this, i2, i2 + 1));
        return this;
    }

    @Override // io.netty.util.ReferenceCounted
    public boolean release(int i2) {
        int i3;
        if (i2 > 0) {
            do {
                i3 = this.refCnt;
                if (i3 < i2) {
                    throw new IllegalReferenceCountException(i3, -i2);
                }
            } while (!refCntUpdater.compareAndSet(this, i3, i3 - i2));
            if (i3 != i2) {
                return false;
            }
            deallocate();
            return true;
        }
        throw new IllegalArgumentException("decrement: " + i2 + " (expected: > 0)");
    }

    @Override // io.netty.buffer.ByteBuf, io.netty.util.ReferenceCounted
    public ByteBuf retain(int i2) {
        int i3;
        if (i2 > 0) {
            do {
                i3 = this.refCnt;
                if (i3 == 0) {
                    throw new IllegalReferenceCountException(0, i2);
                }
                if (i3 > MPv3.MAX_MESSAGE_ID - i2) {
                    throw new IllegalReferenceCountException(i3, i2);
                }
            } while (!refCntUpdater.compareAndSet(this, i3, i3 + i2));
            return this;
        }
        throw new IllegalArgumentException("increment: " + i2 + " (expected: > 0)");
    }
}