package io.netty.buffer;

import g.a.a.a.a;
import io.netty.util.ResourceLeakDetector;
import io.netty.util.ResourceLeakTracker;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.StringUtil;

/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractByteBufAllocator implements ByteBufAllocator {
    public static final int CALCULATE_THRESHOLD = 4194304;
    public static final int DEFAULT_INITIAL_CAPACITY = 256;
    public static final int DEFAULT_MAX_CAPACITY = Integer.MAX_VALUE;
    public static final int DEFAULT_MAX_COMPONENTS = 16;
    private final boolean directByDefault;
    private final ByteBuf emptyBuf;

    /* JADX INFO: renamed from: io.netty.buffer.AbstractByteBufAllocator$1, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass1 {
        public static final /* synthetic */ int[] $SwitchMap$io$netty$util$ResourceLeakDetector$Level;

        static {
            ResourceLeakDetector.Level.values();
            int[] iArr = new int[4];
            $SwitchMap$io$netty$util$ResourceLeakDetector$Level = iArr;
            try {
                iArr[ResourceLeakDetector.Level.SIMPLE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$io$netty$util$ResourceLeakDetector$Level[ResourceLeakDetector.Level.ADVANCED.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$io$netty$util$ResourceLeakDetector$Level[ResourceLeakDetector.Level.PARANOID.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
        }
    }

    static {
        ResourceLeakDetector.addExclusions(AbstractByteBufAllocator.class, "toLeakAwareBuffer");
    }

    public AbstractByteBufAllocator() {
        this(false);
    }

    public AbstractByteBufAllocator(boolean z2) {
        this.directByDefault = z2 && PlatformDependent.hasUnsafe();
        this.emptyBuf = new EmptyByteBuf(this);
    }

    public static ByteBuf toLeakAwareBuffer(ByteBuf byteBuf) {
        ByteBuf simpleLeakAwareByteBuf;
        ResourceLeakTracker<ByteBuf> resourceLeakTrackerTrack;
        int iOrdinal = ResourceLeakDetector.getLevel().ordinal();
        if (iOrdinal == 1) {
            ResourceLeakTracker<ByteBuf> resourceLeakTrackerTrack2 = AbstractByteBuf.leakDetector.track(byteBuf);
            if (resourceLeakTrackerTrack2 == null) {
                return byteBuf;
            }
            simpleLeakAwareByteBuf = new SimpleLeakAwareByteBuf(byteBuf, resourceLeakTrackerTrack2);
        } else {
            if ((iOrdinal != 2 && iOrdinal != 3) || (resourceLeakTrackerTrack = AbstractByteBuf.leakDetector.track(byteBuf)) == null) {
                return byteBuf;
            }
            simpleLeakAwareByteBuf = new AdvancedLeakAwareByteBuf(byteBuf, resourceLeakTrackerTrack);
        }
        return simpleLeakAwareByteBuf;
    }

    public static CompositeByteBuf toLeakAwareBuffer(CompositeByteBuf compositeByteBuf) {
        CompositeByteBuf simpleLeakAwareCompositeByteBuf;
        ResourceLeakTracker<ByteBuf> resourceLeakTrackerTrack;
        int iOrdinal = ResourceLeakDetector.getLevel().ordinal();
        if (iOrdinal == 1) {
            ResourceLeakTracker<ByteBuf> resourceLeakTrackerTrack2 = AbstractByteBuf.leakDetector.track(compositeByteBuf);
            if (resourceLeakTrackerTrack2 == null) {
                return compositeByteBuf;
            }
            simpleLeakAwareCompositeByteBuf = new SimpleLeakAwareCompositeByteBuf(compositeByteBuf, resourceLeakTrackerTrack2);
        } else {
            if ((iOrdinal != 2 && iOrdinal != 3) || (resourceLeakTrackerTrack = AbstractByteBuf.leakDetector.track(compositeByteBuf)) == null) {
                return compositeByteBuf;
            }
            simpleLeakAwareCompositeByteBuf = new AdvancedLeakAwareCompositeByteBuf(compositeByteBuf, resourceLeakTrackerTrack);
        }
        return simpleLeakAwareCompositeByteBuf;
    }

    private static void validate(int i2, int i3) {
        if (i2 < 0) {
            throw new IllegalArgumentException(a.n("initialCapacity: ", i2, " (expected: 0+)"));
        }
        if (i2 > i3) {
            throw new IllegalArgumentException(String.format("initialCapacity: %d (expected: not greater than maxCapacity(%d)", Integer.valueOf(i2), Integer.valueOf(i3)));
        }
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf buffer() {
        return this.directByDefault ? directBuffer() : heapBuffer();
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf buffer(int i2) {
        return this.directByDefault ? directBuffer(i2) : heapBuffer(i2);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf buffer(int i2, int i3) {
        return this.directByDefault ? directBuffer(i2, i3) : heapBuffer(i2, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public int calculateNewCapacity(int i2, int i3) {
        if (i2 < 0) {
            throw new IllegalArgumentException(a.n("minNewCapacity: ", i2, " (expected: 0+)"));
        }
        if (i2 > i3) {
            throw new IllegalArgumentException(String.format("minNewCapacity: %d (expected: not greater than maxCapacity(%d)", Integer.valueOf(i2), Integer.valueOf(i3)));
        }
        if (i2 == 4194304) {
            return CALCULATE_THRESHOLD;
        }
        if (i2 > 4194304) {
            int i4 = (i2 / CALCULATE_THRESHOLD) * CALCULATE_THRESHOLD;
            return i4 > i3 - CALCULATE_THRESHOLD ? i3 : i4 + CALCULATE_THRESHOLD;
        }
        int i5 = 64;
        while (i5 < i2) {
            i5 <<= 1;
        }
        return Math.min(i5, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeBuffer() {
        return this.directByDefault ? compositeDirectBuffer() : compositeHeapBuffer();
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeBuffer(int i2) {
        return this.directByDefault ? compositeDirectBuffer(i2) : compositeHeapBuffer(i2);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeDirectBuffer() {
        return compositeDirectBuffer(16);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeDirectBuffer(int i2) {
        return toLeakAwareBuffer(new CompositeByteBuf(this, true, i2));
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeHeapBuffer() {
        return compositeHeapBuffer(16);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeHeapBuffer(int i2) {
        return toLeakAwareBuffer(new CompositeByteBuf(this, false, i2));
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf directBuffer() {
        return directBuffer(256, Integer.MAX_VALUE);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf directBuffer(int i2) {
        return directBuffer(i2, Integer.MAX_VALUE);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf directBuffer(int i2, int i3) {
        if (i2 == 0 && i3 == 0) {
            return this.emptyBuf;
        }
        validate(i2, i3);
        return newDirectBuffer(i2, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf heapBuffer() {
        return heapBuffer(256, Integer.MAX_VALUE);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf heapBuffer(int i2) {
        return heapBuffer(i2, Integer.MAX_VALUE);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf heapBuffer(int i2, int i3) {
        if (i2 == 0 && i3 == 0) {
            return this.emptyBuf;
        }
        validate(i2, i3);
        return newHeapBuffer(i2, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf ioBuffer() {
        return PlatformDependent.hasUnsafe() ? directBuffer(256) : heapBuffer(256);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf ioBuffer(int i2) {
        return PlatformDependent.hasUnsafe() ? directBuffer(i2) : heapBuffer(i2);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf ioBuffer(int i2, int i3) {
        return PlatformDependent.hasUnsafe() ? directBuffer(i2, i3) : heapBuffer(i2, i3);
    }

    public abstract ByteBuf newDirectBuffer(int i2, int i3);

    public abstract ByteBuf newHeapBuffer(int i2, int i3);

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(StringUtil.simpleClassName(this));
        sb.append("(directByDefault: ");
        return a.C(sb, this.directByDefault, ')');
    }
}