media/libstagefright/VBRISeeker.cpp

   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 "include/VBRISeeker.h"
  25
  26 #include "include/avc_utils.h"
  27 #include "include/MP3Extractor.h"
  28
  29 #include <media/stagefright/foundation/ADebug.h>
  30 #include <media/stagefright/DataSource.h>
  31 #include <media/stagefright/Utils.h>
  32
  33 namespace android {
  34
  35 static uint32_t U24_AT(const uint8_t *ptr) {
  36     return ptr[0] << 16 | ptr[1] << 8 | ptr[2];
  37 }
  38
  39 // static
  40 sp<VBRISeeker> VBRISeeker::CreateFromSource(
  41         const sp<DataSource> &source, off64_t post_id3_pos) {
  42     off64_t pos = post_id3_pos;
  43
  44     uint8_t header[4];
  45     ssize_t n = source->readAt(pos, header, sizeof(header));
  46     if (n < (ssize_t)sizeof(header)) {
  47         return NULL;
  48     }
  49
  50     uint32_t tmp = U32_AT(&header[0]);
  51     size_t frameSize;
  52     int sampleRate;
  53     if (!GetMPEGAudioFrameSize(tmp, &frameSize, &sampleRate)) {
  54         return NULL;
  55     }
  56
  57     // VBRI header follows 32 bytes after the header _ends_.
  58     pos += sizeof(header) + 32;
  59
  60     uint8_t vbriHeader[26];
  61     n = source->readAt(pos, vbriHeader, sizeof(vbriHeader));
  62     if (n < (ssize_t)sizeof(vbriHeader)) {
  63         return NULL;
  64     }
  65
  66     if (memcmp(vbriHeader, "VBRI", 4)) {
  67         return NULL;
  68     }
  69
  70     size_t numFrames = U32_AT(&vbriHeader[14]);
  71
  72     int64_t durationUs =
  73         numFrames * 1000000ll * (sampleRate >= 32000 ? 1152 : 576) / sampleRate;
  74
  75     ALOGV("duration = %.2f secs", durationUs / 1E6);
  76
  77     size_t numEntries = U16_AT(&vbriHeader[18]);
  78     size_t entrySize = U16_AT(&vbriHeader[22]);
  79     size_t scale = U16_AT(&vbriHeader[20]);
  80
  81     ALOGV("%zu entries, scale=%zu, size_per_entry=%zu",
  82          numEntries,
  83          scale,
  84          entrySize);
  85
  86     if (entrySize > 4) {
  87         ALOGE("invalid VBRI entry size: %zu", entrySize);
  88         return NULL;
  89     }
  90
  91     sp<VBRISeeker> seeker = new (std::nothrow) VBRISeeker;
  92     if (seeker == NULL) {
  93         ALOGW("Couldn't allocate VBRISeeker");
  94         return NULL;
  95     }
  96
  97     size_t totalEntrySize = numEntries * entrySize;
  98     uint8_t *buffer = new (std::nothrow) uint8_t[totalEntrySize];
  99     if (!buffer) {
 100         ALOGW("Couldn't allocate %zu bytes", totalEntrySize);
 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
 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 0x%016llx", i, numBytes, offset);
 140         offset += numBytes;
 141     }
 142
 143     delete[] buffer;
 144     buffer = NULL;
 145
 146     ALOGI("Found VBRI header.");
 147
 148     return seeker;
 149 }
 150
 151 VBRISeeker::VBRISeeker()
 152     : mDurationUs(-1) {
 153 }
 154
 155 bool VBRISeeker::getDuration(int64_t *durationUs) {
 156     if (mDurationUs < 0) {
 157         return false;
 158     }
 159
 160     *durationUs = mDurationUs;
 161
 162     return true;
 163 }
 164
 165 bool VBRISeeker::getOffsetForTime(int64_t *timeUs, off64_t *pos) {
 166     if (mDurationUs < 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 %" PRId64 " us => 0x%016llx", *timeUs, *pos);
 181
 182     *timeUs = nowUs;
 183
 184     return true;
 185 }
 186
 187 }  // namespace android
 188