frameworks/base/media/libstagefright/WAVExtractor.cpp

   1 /*
   2  * Copyright (C) 2009 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 "WAVExtractor"
  19 #include <utils/Log.h>
  20
  21 #include "include/WAVExtractor.h"
  22
  23 #include <media/stagefright/DataSource.h>
  24 #include <media/stagefright/MediaBufferGroup.h>
  25 #include <media/stagefright/MediaDebug.h>
  26 #include <media/stagefright/MediaDefs.h>
  27 #include <media/stagefright/MediaErrors.h>
  28 #include <media/stagefright/MediaSource.h>
  29 #include <media/stagefright/MetaData.h>
  30 #include <utils/String8.h>
  31
  32 namespace android {
  33
  34 enum {
  35     WAVE_FORMAT_PCM = 1,
  36     WAVE_FORMAT_ALAW = 6,
  37     WAVE_FORMAT_MULAW = 7,
  38 };
  39
  40 static uint32_t U32_LE_AT(const uint8_t *ptr) {
  41     return ptr[3] << 24 | ptr[2] << 16 | ptr[1] << 8 | ptr[0];
  42 }
  43
  44 static uint16_t U16_LE_AT(const uint8_t *ptr) {
  45     return ptr[1] << 8 | ptr[0];
  46 }
  47
  48 struct WAVSource : public MediaSource {
  49     WAVSource(
  50             const sp<DataSource> &dataSource,
  51             const sp<MetaData> &meta,
  52             uint16_t waveFormat,
  53             int32_t bitsPerSample,
  54             off_t offset, size_t size);
  55
  56     virtual status_t start(MetaData *params = NULL);
  57     virtual status_t stop();
  58     virtual sp<MetaData> getFormat();
  59
  60     virtual status_t read(
  61             MediaBuffer **buffer, const ReadOptions *options = NULL);
  62
  63 protected:
  64     virtual ~WAVSource();
  65
  66 private:
  67     static const size_t kMaxFrameSize;
  68
  69     sp<DataSource> mDataSource;
  70     sp<MetaData> mMeta;
  71     uint16_t mWaveFormat;
  72     int32_t mSampleRate;
  73     int32_t mNumChannels;
  74     int32_t mBitsPerSample;
  75     off_t mOffset;
  76     size_t mSize;
  77     bool mStarted;
  78     MediaBufferGroup *mGroup;
  79     off_t mCurrentPos;
  80
  81     WAVSource(const WAVSource &);
  82     WAVSource &operator=(const WAVSource &);
  83 };
  84
  85 WAVExtractor::WAVExtractor(const sp<DataSource> &source)
  86     : mDataSource(source),
  87       mValidFormat(false) {
  88     mInitCheck = init();
  89 }
  90
  91 WAVExtractor::~WAVExtractor() {
  92 }
  93
  94 sp<MetaData> WAVExtractor::getMetaData() {
  95     sp<MetaData> meta = new MetaData;
  96
  97     if (mInitCheck != OK) {
  98         return meta;
  99     }
 100
 101     meta->setCString(kKeyMIMEType, "audio/x-wav");
 102
 103     return meta;
 104 }
 105
 106 size_t WAVExtractor::countTracks() {
 107     return mInitCheck == OK ? 1 : 0;
 108 }
 109
 110 sp<MediaSource> WAVExtractor::getTrack(size_t index) {
 111     if (mInitCheck != OK || index > 0) {
 112         return NULL;
 113     }
 114
 115     return new WAVSource(
 116             mDataSource, mTrackMeta,
 117             mWaveFormat, mBitsPerSample, mDataOffset, mDataSize);
 118 }
 119
 120 sp<MetaData> WAVExtractor::getTrackMetaData(
 121         size_t index, uint32_t flags) {
 122     if (mInitCheck != OK || index > 0) {
 123         return NULL;
 124     }
 125
 126     return mTrackMeta;
 127 }
 128
 129 status_t WAVExtractor::init() {
 130     uint8_t header[12];
 131     if (mDataSource->readAt(
 132                 0, header, sizeof(header)) < (ssize_t)sizeof(header)) {
 133         return NO_INIT;
 134     }
 135
 136     if (memcmp(header, "RIFF", 4) || memcmp(&header[8], "WAVE", 4)) {
 137         return NO_INIT;
 138     }
 139
 140     size_t totalSize = U32_LE_AT(&header[4]);
 141
 142     off_t offset = 12;
 143     size_t remainingSize = totalSize;
 144     while (remainingSize >= 8) {
 145         uint8_t chunkHeader[8];
 146         if (mDataSource->readAt(offset, chunkHeader, 8) < 8) {
 147             return NO_INIT;
 148         }
 149
 150         remainingSize -= 8;
 151         offset += 8;
 152
 153         uint32_t chunkSize = U32_LE_AT(&chunkHeader[4]);
 154
 155         if (chunkSize > remainingSize) {
 156             return NO_INIT;
 157         }
 158
 159         if (!memcmp(chunkHeader, "fmt ", 4)) {
 160             if (chunkSize < 16) {
 161                 return NO_INIT;
 162             }
 163
 164             uint8_t formatSpec[16];
 165             if (mDataSource->readAt(offset, formatSpec, 16) < 16) {
 166                 return NO_INIT;
 167             }
 168
 169             mWaveFormat = U16_LE_AT(formatSpec);
 170             if (mWaveFormat != WAVE_FORMAT_PCM
 171                     && mWaveFormat != WAVE_FORMAT_ALAW
 172                     && mWaveFormat != WAVE_FORMAT_MULAW) {
 173                 return ERROR_UNSUPPORTED;
 174             }
 175
 176             mNumChannels = U16_LE_AT(&formatSpec[2]);
 177             if (mNumChannels != 1 && mNumChannels != 2) {
 178                 return ERROR_UNSUPPORTED;
 179             }
 180
 181             mSampleRate = U32_LE_AT(&formatSpec[4]);
 182
 183             if (mSampleRate == 0) {
 184                 return ERROR_MALFORMED;
 185             }
 186
 187             mBitsPerSample = U16_LE_AT(&formatSpec[14]);
 188
 189             if (mWaveFormat == WAVE_FORMAT_PCM) {
 190                 if (mBitsPerSample != 8 && mBitsPerSample != 16
 191                     && mBitsPerSample != 24) {
 192                     return ERROR_UNSUPPORTED;
 193                 }
 194             } else {
 195                 CHECK(mWaveFormat == WAVE_FORMAT_MULAW
 196                         || mWaveFormat == WAVE_FORMAT_ALAW);
 197                 if (mBitsPerSample != 8) {
 198                     return ERROR_UNSUPPORTED;
 199                 }
 200             }
 201
 202             mValidFormat = true;
 203         } else if (!memcmp(chunkHeader, "data", 4)) {
 204             if (mValidFormat) {
 205                 mDataOffset = offset;
 206                 mDataSize = chunkSize;
 207
 208                 mTrackMeta = new MetaData;
 209
 210                 switch (mWaveFormat) {
 211                     case WAVE_FORMAT_PCM:
 212                         mTrackMeta->setCString(
 213                                 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW);
 214                         break;
 215                     case WAVE_FORMAT_ALAW:
 216                         mTrackMeta->setCString(
 217                                 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_G711_ALAW);
 218                         break;
 219                     default:
 220                         CHECK_EQ(mWaveFormat, WAVE_FORMAT_MULAW);
 221                         mTrackMeta->setCString(
 222                                 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_G711_MLAW);
 223                         break;
 224                 }
 225
 226                 mTrackMeta->setInt32(kKeyChannelCount, mNumChannels);
 227                 mTrackMeta->setInt32(kKeySampleRate, mSampleRate);
 228
 229                 size_t bytesPerSample = mBitsPerSample >> 3;
 230
 231                 int64_t durationUs =
 232                     1000000LL * (mDataSize / (mNumChannels * bytesPerSample))
 233                         / mSampleRate;
 234
 235                 mTrackMeta->setInt64(kKeyDuration, durationUs);
 236
 237                 return OK;
 238             }
 239         }
 240
 241         offset += chunkSize;
 242     }
 243
 244     return NO_INIT;
 245 }
 246
 247 const size_t WAVSource::kMaxFrameSize = 32768;
 248
 249 WAVSource::WAVSource(
 250         const sp<DataSource> &dataSource,
 251         const sp<MetaData> &meta,
 252         uint16_t waveFormat,
 253         int32_t bitsPerSample,
 254         off_t offset, size_t size)
 255     : mDataSource(dataSource),
 256       mMeta(meta),
 257       mWaveFormat(waveFormat),
 258       mSampleRate(0),
 259       mNumChannels(0),
 260       mBitsPerSample(bitsPerSample),
 261       mOffset(offset),
 262       mSize(size),
 263       mStarted(false),
 264       mGroup(NULL) {
 265     CHECK(mMeta->findInt32(kKeySampleRate, &mSampleRate));
 266     CHECK(mMeta->findInt32(kKeyChannelCount, &mNumChannels));
 267 }
 268
 269 WAVSource::~WAVSource() {
 270     if (mStarted) {
 271         stop();
 272     }
 273 }
 274
 275 status_t WAVSource::start(MetaData *params) {
 276     LOGV("WAVSource::start");
 277
 278     CHECK(!mStarted);
 279
 280     mGroup = new MediaBufferGroup;
 281     mGroup->add_buffer(new MediaBuffer(kMaxFrameSize));
 282
 283     if (mBitsPerSample == 8) {
 284         // As a temporary buffer for 8->16 bit conversion.
 285         mGroup->add_buffer(new MediaBuffer(kMaxFrameSize));
 286     }
 287
 288     mCurrentPos = mOffset;
 289
 290     mStarted = true;
 291
 292     return OK;
 293 }
 294
 295 status_t WAVSource::stop() {
 296     LOGV("WAVSource::stop");
 297
 298     CHECK(mStarted);
 299
 300     delete mGroup;
 301     mGroup = NULL;
 302
 303     mStarted = false;
 304
 305     return OK;
 306 }
 307
 308 sp<MetaData> WAVSource::getFormat() {
 309     LOGV("WAVSource::getFormat");
 310
 311     return mMeta;
 312 }
 313
 314 status_t WAVSource::read(
 315         MediaBuffer **out, const ReadOptions *options) {
 316     *out = NULL;
 317
 318     int64_t seekTimeUs;
 319     ReadOptions::SeekMode mode;
 320     if (options != NULL && options->getSeekTo(&seekTimeUs, &mode)) {
 321         int64_t pos = (seekTimeUs * mSampleRate) / 1000000 * mNumChannels * 2;
 322         if (pos > mSize) {
 323             pos = mSize;
 324         }
 325         mCurrentPos = pos + mOffset;
 326     }
 327
 328     MediaBuffer *buffer;
 329     status_t err = mGroup->acquire_buffer(&buffer);
 330     if (err != OK) {
 331         return err;
 332     }
 333
 334     size_t maxBytesToRead =
 335         mBitsPerSample == 8 ? kMaxFrameSize / 2 : kMaxFrameSize;
 336
 337     size_t maxBytesAvailable =
 338         (mCurrentPos - mOffset >= (off_t)mSize)
 339             ? 0 : mSize - (mCurrentPos - mOffset);
 340
 341     if (maxBytesToRead > maxBytesAvailable) {
 342         maxBytesToRead = maxBytesAvailable;
 343     }
 344
 345     ssize_t n = mDataSource->readAt(
 346             mCurrentPos, buffer->data(),
 347             maxBytesToRead);
 348
 349     if (n <= 0) {
 350         buffer->release();
 351         buffer = NULL;
 352
 353         return ERROR_END_OF_STREAM;
 354     }
 355
 356     mCurrentPos += n;
 357
 358     buffer->set_range(0, n);
 359
 360     if (mWaveFormat == WAVE_FORMAT_PCM) {
 361         if (mBitsPerSample == 8) {
 362             // Convert 8-bit unsigned samples to 16-bit signed.
 363
 364             MediaBuffer *tmp;
 365             CHECK_EQ(mGroup->acquire_buffer(&tmp), OK);
 366
 367             // The new buffer holds the sample number of samples, but each
 368             // one is 2 bytes wide.
 369             tmp->set_range(0, 2 * n);
 370
 371             int16_t *dst = (int16_t *)tmp->data();
 372             const uint8_t *src = (const uint8_t *)buffer->data();
 373             while (n-- > 0) {
 374                 *dst++ = ((int16_t)(*src) - 128) * 256;
 375                 ++src;
 376             }
 377
 378             buffer->release();
 379             buffer = tmp;
 380         } else if (mBitsPerSample == 24) {
 381             // Convert 24-bit signed samples to 16-bit signed.
 382
 383             const uint8_t *src =
 384                 (const uint8_t *)buffer->data() + buffer->range_offset();
 385             int16_t *dst = (int16_t *)src;
 386
 387             size_t numSamples = buffer->range_length() / 3;
 388             for (size_t i = 0; i < numSamples; ++i) {
 389                 int32_t x = (int32_t)(src[0] | src[1] << 8 | src[2] << 16);
 390                 x = (x << 8) >> 8;  // sign extension
 391
 392                 x = x >> 8;
 393                 *dst++ = (int16_t)x;
 394                 src += 3;
 395             }
 396
 397             buffer->set_range(buffer->range_offset(), 2 * numSamples);
 398         }
 399     }
 400
 401     size_t bytesPerSample = mBitsPerSample >> 3;
 402
 403     buffer->meta_data()->setInt64(
 404             kKeyTime,
 405             1000000LL * (mCurrentPos - mOffset)
 406                 / (mNumChannels * bytesPerSample) / mSampleRate);
 407
 408     buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1);
 409
 410     *out = buffer;
 411
 412     return OK;
 413 }
 414
 415 ////////////////////////////////////////////////////////////////////////////////
 416
 417 bool SniffWAV(
 418         const sp<DataSource> &source, String8 *mimeType, float *confidence,
 419         sp<AMessage> *) {
 420     char header[12];
 421     if (source->readAt(0, header, sizeof(header)) < (ssize_t)sizeof(header)) {
 422         return false;
 423     }
 424
 425     if (memcmp(header, "RIFF", 4) || memcmp(&header[8], "WAVE", 4)) {
 426         return false;
 427     }
 428
 429     *mimeType = MEDIA_MIMETYPE_CONTAINER_WAV;
 430     *confidence = 0.3f;
 431
 432     return true;
 433 }
 434
 435 }  // namespace android
 436