xref: /frameworks/av/media/libstagefright/foundation/include/foundation/ABitReader.h

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef A_BIT_READER_H_

#define A_BIT_READER_H_

#include <media/stagefright/foundation/ABase.h>

#include <sys/types.h>
#include <stdint.h>

namespace android {

class ABitReader {
public:
    ABitReader(const uint8_t *data, size_t size);
    virtual ~ABitReader();

    // Tries to get |n| bits. If not successful, returns |fallback|. Otherwise, returns result.
    // Reading 0 bits will always succeed and return 0.
    uint32_t getBitsWithFallback(size_t n, uint32_t fallback);

    // Tries to get |n| bits. If not successful, returns false. Otherwise, stores result in |out|
    // and returns true. Use !overRead() to determine if this call was successful. Reading 0 bits
    // will always succeed and write 0 in |out|.
    bool getBitsGraceful(size_t n, uint32_t *out);

    // Gets |n| bits and returns result. ABORTS if unsuccessful. Reading 0 bits will always
    // succeed.
    uint32_t getBits(size_t n);

    // Tries to skip |n| bits. Returns true iff successful. Skipping 0 bits will always succeed.
    bool skipBits(size_t n);

    // "Puts" |n| bits with the value |x| back virtually into the bit stream. The put-back bits
    // are not actually written into the data, but are tracked in a separate buffer that can
    // store at most 32 bits. This is a no-op if the stream has already been over-read.
    void putBits(uint32_t x, size_t n);

    size_t numBitsLeft() const;

    const uint8_t *data() const;

    // Returns true iff the stream was over-read (e.g. any getBits operation has been unsuccessful
    // due to overread (and not trying to read >32 bits).)
    bool overRead() const { return mOverRead; }

protected:
    const uint8_t *mData;
    size_t mSize;

    uint32_t mReservoir;  // left-aligned bits
    size_t mNumBitsLeft;
    bool mOverRead;

    virtual bool fillReservoir();

    DISALLOW_EVIL_CONSTRUCTORS(ABitReader);
};

class NALBitReader : public ABitReader {
public:
    NALBitReader(const uint8_t *data, size_t size);

    bool atLeastNumBitsLeft(size_t n) const;

private:
    int32_t mNumZeros;

    virtual bool fillReservoir();

    DISALLOW_EVIL_CONSTRUCTORS(NALBitReader);
};

}  // namespace android

#endif  // A_BIT_READER_H_