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//#define LOG_NDEBUG 0
18#define LOG_TAG "VBRISeeker"
19
20#include <inttypes.h>
21
22#include <utils/Log.h>
23
24#include "VBRISeeker.h"
25
26#include <media/stagefright/foundation/avc_utils.h>
27
28#include <media/stagefright/foundation/ADebug.h>
29#include <media/stagefright/foundation/ByteUtils.h>
30#include <media/DataSourceBase.h>
31
32namespace android {
33
34static uint32_t U24_AT(const uint8_t *ptr) {
35    return ptr[0] << 16 | ptr[1] << 8 | ptr[2];
36}
37
38// static
39VBRISeeker *VBRISeeker::CreateFromSource(
40        DataSourceBase *source, off64_t post_id3_pos) {
41    off64_t pos = post_id3_pos;
42
43    uint8_t header[4];
44    ssize_t n = source->readAt(pos, header, sizeof(header));
45    if (n < (ssize_t)sizeof(header)) {
46        return NULL;
47    }
48
49    uint32_t tmp = U32_AT(&header[0]);
50    size_t frameSize;
51    int sampleRate;
52    if (!GetMPEGAudioFrameSize(tmp, &frameSize, &sampleRate)) {
53        return NULL;
54    }
55
56    // VBRI header follows 32 bytes after the header _ends_.
57    pos += sizeof(header) + 32;
58
59    uint8_t vbriHeader[26];
60    n = source->readAt(pos, vbriHeader, sizeof(vbriHeader));
61    if (n < (ssize_t)sizeof(vbriHeader)) {
62        return NULL;
63    }
64
65    if (memcmp(vbriHeader, "VBRI", 4)) {
66        return NULL;
67    }
68
69    size_t numFrames = U32_AT(&vbriHeader[14]);
70
71    int64_t durationUs =
72        numFrames * 1000000ll * (sampleRate >= 32000 ? 1152 : 576) / sampleRate;
73
74    ALOGV("duration = %.2f secs", durationUs / 1E6);
75
76    size_t numEntries = U16_AT(&vbriHeader[18]);
77    size_t entrySize = U16_AT(&vbriHeader[22]);
78    size_t scale = U16_AT(&vbriHeader[20]);
79
80    ALOGV("%zu entries, scale=%zu, size_per_entry=%zu",
81         numEntries,
82         scale,
83         entrySize);
84
85    if (entrySize > 4) {
86        ALOGE("invalid VBRI entry size: %zu", entrySize);
87        return NULL;
88    }
89
90    VBRISeeker *seeker = new (std::nothrow) VBRISeeker;
91    if (seeker == NULL) {
92        ALOGW("Couldn't allocate VBRISeeker");
93        return NULL;
94    }
95
96    size_t totalEntrySize = numEntries * entrySize;
97    uint8_t *buffer = new (std::nothrow) uint8_t[totalEntrySize];
98    if (!buffer) {
99        ALOGW("Couldn't allocate %zu bytes", totalEntrySize);
100        delete seeker;
101        return NULL;
102    }
103
104    n = source->readAt(pos + sizeof(vbriHeader), buffer, totalEntrySize);
105    if (n < (ssize_t)totalEntrySize) {
106        delete[] buffer;
107        buffer = NULL;
108        delete seeker;
109        return NULL;
110    }
111
112    seeker->mBasePos = post_id3_pos + frameSize;
113    // only update mDurationUs if the calculated duration is valid (non zero)
114    // otherwise, leave duration at -1 so that getDuration() and getOffsetForTime()
115    // return false when called, to indicate that this vbri tag does not have the
116    // requested information
117    if (durationUs) {
118        seeker->mDurationUs = durationUs;
119    }
120
121    off64_t offset = post_id3_pos;
122    for (size_t i = 0; i < numEntries; ++i) {
123        uint32_t numBytes;
124        switch (entrySize) {
125            case 1: numBytes = buffer[i]; break;
126            case 2: numBytes = U16_AT(buffer + 2 * i); break;
127            case 3: numBytes = U24_AT(buffer + 3 * i); break;
128            default:
129            {
130                CHECK_EQ(entrySize, 4u);
131                numBytes = U32_AT(buffer + 4 * i); break;
132            }
133        }
134
135        numBytes *= scale;
136
137        seeker->mSegments.push(numBytes);
138
139        ALOGV("entry #%zu: %u offset %#016llx", i, numBytes, (long long)offset);
140        offset += numBytes;
141    }
142
143    delete[] buffer;
144    buffer = NULL;
145
146    ALOGI("Found VBRI header.");
147
148    return seeker;
149}
150
151VBRISeeker::VBRISeeker()
152    : mDurationUs(-1) {
153}
154
155bool VBRISeeker::getDuration(int64_t *durationUs) {
156    if (mDurationUs < 0) {
157        return false;
158    }
159
160    *durationUs = mDurationUs;
161
162    return true;
163}
164
165bool VBRISeeker::getOffsetForTime(int64_t *timeUs, off64_t *pos) {
166    if (mDurationUs < 0 || mSegments.size() == 0) {
167        return false;
168    }
169
170    int64_t segmentDurationUs = mDurationUs / mSegments.size();
171
172    int64_t nowUs = 0;
173    *pos = mBasePos;
174    size_t segmentIndex = 0;
175    while (segmentIndex < mSegments.size() && nowUs < *timeUs) {
176        nowUs += segmentDurationUs;
177        *pos += mSegments.itemAt(segmentIndex++);
178    }
179
180    ALOGV("getOffsetForTime %lld us => 0x%016llx", (long long)*timeUs, (long long)*pos);
181
182    *timeUs = nowUs;
183
184    return true;
185}
186
187}  // namespace android
188
189