1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef A_BIT_READER_H_
18
19#define A_BIT_READER_H_
20
21#include <media/stagefright/foundation/ABase.h>
22
23#include <sys/types.h>
24#include <stdint.h>
25
26namespace android {
27
28class ABitReader {
29public:
30    ABitReader(const uint8_t *data, size_t size);
31    virtual ~ABitReader();
32
33    // Tries to get |n| bits. If not successful, returns |fallback|. Otherwise, returns result.
34    // Reading 0 bits will always succeed and return 0.
35    uint32_t getBitsWithFallback(size_t n, uint32_t fallback);
36
37    // Tries to get |n| bits. If not successful, returns false. Otherwise, stores result in |out|
38    // and returns true. Use !overRead() to determine if this call was successful. Reading 0 bits
39    // will always succeed and write 0 in |out|.
40    bool getBitsGraceful(size_t n, uint32_t *out);
41
42    // Gets |n| bits and returns result. ABORTS if unsuccessful. Reading 0 bits will always
43    // succeed.
44    uint32_t getBits(size_t n);
45
46    // Tries to skip |n| bits. Returns true iff successful. Skipping 0 bits will always succeed.
47    bool skipBits(size_t n);
48
49    // "Puts" |n| bits with the value |x| back virtually into the bit stream. The put-back bits
50    // are not actually written into the data, but are tracked in a separate buffer that can
51    // store at most 32 bits. This is a no-op if the stream has already been over-read.
52    void putBits(uint32_t x, size_t n);
53
54    size_t numBitsLeft() const;
55
56    const uint8_t *data() const;
57
58    // Returns true iff the stream was over-read (e.g. any getBits operation has been unsuccessful
59    // due to overread (and not trying to read >32 bits).)
60    bool overRead() const { return mOverRead; }
61
62protected:
63    const uint8_t *mData;
64    size_t mSize;
65
66    uint32_t mReservoir;  // left-aligned bits
67    size_t mNumBitsLeft;
68    bool mOverRead;
69
70    virtual bool fillReservoir();
71
72    DISALLOW_EVIL_CONSTRUCTORS(ABitReader);
73};
74
75class NALBitReader : public ABitReader {
76public:
77    NALBitReader(const uint8_t *data, size_t size);
78
79    bool atLeastNumBitsLeft(size_t n) const;
80
81private:
82    int32_t mNumZeros;
83
84    virtual bool fillReservoir();
85
86    DISALLOW_EVIL_CONSTRUCTORS(NALBitReader);
87};
88
89}  // namespace android
90
91#endif  // A_BIT_READER_H_
92