package e0;

import android.util.Log;
import java.io.ByteArrayInputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteOrder;
import p0.AbstractC0928a;

/* JADX INFO: renamed from: e0.b, reason: case insensitive filesystem */
/* JADX INFO: loaded from: classes.dex */
public class C0555b extends InputStream implements DataInput {

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    public final DataInputStream f6170k;

    /* JADX INFO: renamed from: l, reason: collision with root package name */
    public int f6171l;

    /* JADX INFO: renamed from: m, reason: collision with root package name */
    public ByteOrder f6172m;

    /* JADX INFO: renamed from: n, reason: collision with root package name */
    public byte[] f6173n;

    /* JADX INFO: renamed from: o, reason: collision with root package name */
    public final int f6174o;

    public C0555b(byte[] bArr) {
        this(new ByteArrayInputStream(bArr), ByteOrder.BIG_ENDIAN);
        this.f6174o = bArr.length;
    }

    public final void a(int i) throws IOException {
        int i5 = 0;
        while (i5 < i) {
            DataInputStream dataInputStream = this.f6170k;
            int i6 = i - i5;
            int iSkip = (int) dataInputStream.skip(i6);
            if (iSkip <= 0) {
                if (this.f6173n == null) {
                    this.f6173n = new byte[8192];
                }
                iSkip = dataInputStream.read(this.f6173n, 0, Math.min(8192, i6));
                if (iSkip == -1) {
                    throw new EOFException(AbstractC0928a.j(i, "Reached EOF while skipping ", " bytes."));
                }
            }
            i5 += iSkip;
        }
        this.f6171l += i5;
    }

    @Override // java.io.InputStream
    public final int available() {
        return this.f6170k.available();
    }

    @Override // java.io.InputStream
    public final void mark(int i) {
        throw new UnsupportedOperationException("Mark is currently unsupported");
    }

    @Override // java.io.InputStream
    public final int read() {
        this.f6171l++;
        return this.f6170k.read();
    }

    @Override // java.io.DataInput
    public final boolean readBoolean() {
        this.f6171l++;
        return this.f6170k.readBoolean();
    }

    @Override // java.io.DataInput
    public final byte readByte() throws IOException {
        this.f6171l++;
        int i = this.f6170k.read();
        if (i >= 0) {
            return (byte) i;
        }
        throw new EOFException();
    }

    @Override // java.io.DataInput
    public final char readChar() {
        this.f6171l += 2;
        return this.f6170k.readChar();
    }

    @Override // java.io.DataInput
    public final double readDouble() {
        return Double.longBitsToDouble(readLong());
    }

    @Override // java.io.DataInput
    public final float readFloat() {
        return Float.intBitsToFloat(readInt());
    }

    @Override // java.io.DataInput
    public final void readFully(byte[] bArr, int i, int i5) throws IOException {
        this.f6171l += i5;
        this.f6170k.readFully(bArr, i, i5);
    }

    @Override // java.io.DataInput
    public final int readInt() throws IOException {
        this.f6171l += 4;
        DataInputStream dataInputStream = this.f6170k;
        int i = dataInputStream.read();
        int i5 = dataInputStream.read();
        int i6 = dataInputStream.read();
        int i7 = dataInputStream.read();
        if ((i | i5 | i6 | i7) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f6172m;
        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
            return (i7 << 24) + (i6 << 16) + (i5 << 8) + i;
        }
        if (byteOrder == ByteOrder.BIG_ENDIAN) {
            return (i << 24) + (i5 << 16) + (i6 << 8) + i7;
        }
        throw new IOException("Invalid byte order: " + this.f6172m);
    }

    @Override // java.io.DataInput
    public final String readLine() {
        Log.d("ExifInterface", "Currently unsupported");
        return null;
    }

    @Override // java.io.DataInput
    public final long readLong() throws IOException {
        long j5;
        long j6;
        this.f6171l += 8;
        DataInputStream dataInputStream = this.f6170k;
        int i = dataInputStream.read();
        int i5 = dataInputStream.read();
        int i6 = dataInputStream.read();
        int i7 = dataInputStream.read();
        int i8 = dataInputStream.read();
        int i9 = dataInputStream.read();
        int i10 = dataInputStream.read();
        int i11 = dataInputStream.read();
        if ((i | i5 | i6 | i7 | i8 | i9 | i10 | i11) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f6172m;
        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
            j5 = (((long) i11) << 56) + (((long) i10) << 48) + (((long) i9) << 40) + (((long) i8) << 32) + (((long) i7) << 24) + (((long) i6) << 16) + (((long) i5) << 8);
            j6 = i;
        } else {
            if (byteOrder != ByteOrder.BIG_ENDIAN) {
                throw new IOException("Invalid byte order: " + this.f6172m);
            }
            j5 = (((long) i) << 56) + (((long) i5) << 48) + (((long) i6) << 40) + (((long) i7) << 32) + (((long) i8) << 24) + (((long) i9) << 16) + (((long) i10) << 8);
            j6 = i11;
        }
        return j5 + j6;
    }

    @Override // java.io.DataInput
    public final short readShort() throws IOException {
        this.f6171l += 2;
        DataInputStream dataInputStream = this.f6170k;
        int i = dataInputStream.read();
        int i5 = dataInputStream.read();
        if ((i | i5) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f6172m;
        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
            return (short) ((i5 << 8) + i);
        }
        if (byteOrder == ByteOrder.BIG_ENDIAN) {
            return (short) ((i << 8) + i5);
        }
        throw new IOException("Invalid byte order: " + this.f6172m);
    }

    @Override // java.io.DataInput
    public final String readUTF() {
        this.f6171l += 2;
        return this.f6170k.readUTF();
    }

    @Override // java.io.DataInput
    public final int readUnsignedByte() {
        this.f6171l++;
        return this.f6170k.readUnsignedByte();
    }

    @Override // java.io.DataInput
    public final int readUnsignedShort() throws IOException {
        this.f6171l += 2;
        DataInputStream dataInputStream = this.f6170k;
        int i = dataInputStream.read();
        int i5 = dataInputStream.read();
        if ((i | i5) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f6172m;
        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
            return (i5 << 8) + i;
        }
        if (byteOrder == ByteOrder.BIG_ENDIAN) {
            return (i << 8) + i5;
        }
        throw new IOException("Invalid byte order: " + this.f6172m);
    }

    @Override // java.io.InputStream
    public final void reset() {
        throw new UnsupportedOperationException("Reset is currently unsupported");
    }

    @Override // java.io.DataInput
    public final int skipBytes(int i) {
        throw new UnsupportedOperationException("skipBytes is currently unsupported");
    }

    public C0555b(InputStream inputStream) {
        this(inputStream, ByteOrder.BIG_ENDIAN);
    }

    @Override // java.io.InputStream
    public final int read(byte[] bArr, int i, int i5) {
        int i6 = this.f6170k.read(bArr, i, i5);
        this.f6171l += i6;
        return i6;
    }

    @Override // java.io.DataInput
    public final void readFully(byte[] bArr) throws IOException {
        this.f6171l += bArr.length;
        this.f6170k.readFully(bArr);
    }

    public C0555b(InputStream inputStream, ByteOrder byteOrder) {
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        this.f6170k = dataInputStream;
        dataInputStream.mark(0);
        this.f6171l = 0;
        this.f6172m = byteOrder;
        this.f6174o = inputStream instanceof C0555b ? ((C0555b) inputStream).f6174o : -1;
    }
}