package f0;

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;

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

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

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

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

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

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

    public C0902b(byte[] bArr) {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
        this(byteArrayInputStream, 0);
        this.f12611u = bArr.length;
    }

    public final void a(int i) throws IOException {
        int i5 = 0;
        while (i5 < i) {
            DataInputStream dataInputStream = this.f12607q;
            int i8 = i - i5;
            int iSkip = (int) dataInputStream.skip(i8);
            if (iSkip <= 0) {
                if (this.f12610t == null) {
                    this.f12610t = new byte[8192];
                }
                iSkip = dataInputStream.read(this.f12610t, 0, Math.min(8192, i8));
                if (iSkip == -1) {
                    throw new EOFException(I1.a.k(i, "Reached EOF while skipping ", " bytes."));
                }
            }
            i5 += iSkip;
        }
        this.f12608r += i5;
    }

    @Override // java.io.InputStream
    public final int available() {
        return this.f12607q.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.f12608r++;
        return this.f12607q.read();
    }

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

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

    @Override // java.io.DataInput
    public final char readChar() {
        this.f12608r += 2;
        return this.f12607q.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.f12608r += i5;
        this.f12607q.readFully(bArr, i, i5);
    }

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

    @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 j8;
        long j9;
        this.f12608r += 8;
        DataInputStream dataInputStream = this.f12607q;
        int i = dataInputStream.read();
        int i5 = dataInputStream.read();
        int i8 = dataInputStream.read();
        int i9 = dataInputStream.read();
        int i10 = dataInputStream.read();
        int i11 = dataInputStream.read();
        int i12 = dataInputStream.read();
        int i13 = dataInputStream.read();
        if ((i | i5 | i8 | i9 | i10 | i11 | i12 | i13) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f12609s;
        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
            j8 = (((long) i13) << 56) + (((long) i12) << 48) + (((long) i11) << 40) + (((long) i10) << 32) + (((long) i9) << 24) + (((long) i8) << 16) + (((long) i5) << 8);
            j9 = i;
        } else {
            if (byteOrder != ByteOrder.BIG_ENDIAN) {
                throw new IOException("Invalid byte order: " + this.f12609s);
            }
            j8 = (((long) i) << 56) + (((long) i5) << 48) + (((long) i8) << 40) + (((long) i9) << 32) + (((long) i10) << 24) + (((long) i11) << 16) + (((long) i12) << 8);
            j9 = i13;
        }
        return j8 + j9;
    }

    @Override // java.io.DataInput
    public final short readShort() throws IOException {
        this.f12608r += 2;
        DataInputStream dataInputStream = this.f12607q;
        int i = dataInputStream.read();
        int i5 = dataInputStream.read();
        if ((i | i5) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f12609s;
        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.f12609s);
    }

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

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

    @Override // java.io.DataInput
    public final int readUnsignedShort() throws IOException {
        this.f12608r += 2;
        DataInputStream dataInputStream = this.f12607q;
        int i = dataInputStream.read();
        int i5 = dataInputStream.read();
        if ((i | i5) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f12609s;
        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.f12609s);
    }

    @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");
    }

    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
    public C0902b(InputStream inputStream) {
        this(inputStream, 0);
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
    }

    @Override // java.io.InputStream
    public final int read(byte[] bArr, int i, int i5) throws IOException {
        int i8 = this.f12607q.read(bArr, i, i5);
        this.f12608r += i8;
        return i8;
    }

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

    public C0902b(InputStream inputStream, int i) {
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        this.f12607q = dataInputStream;
        dataInputStream.mark(0);
        this.f12608r = 0;
        this.f12609s = byteOrder;
        this.f12611u = inputStream instanceof C0902b ? ((C0902b) inputStream).f12611u : -1;
    }
}