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