1/* 2 * Copyright (C) 2011 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 "FLACExtractor" 19#include <utils/Log.h> 20 21#include "include/FLACExtractor.h" 22// Vorbis comments 23#include "include/OggExtractor.h" 24// libFLAC parser 25#include "FLAC/stream_decoder.h" 26 27#include <media/stagefright/foundation/ADebug.h> 28#include <media/stagefright/DataSource.h> 29#include <media/stagefright/MediaBufferGroup.h> 30#include <media/stagefright/MediaDefs.h> 31#include <media/stagefright/MetaData.h> 32#include <media/stagefright/MediaSource.h> 33#include <media/stagefright/MediaBuffer.h> 34 35namespace android { 36 37class FLACParser; 38 39class FLACSource : public MediaSource { 40 41public: 42 FLACSource( 43 const sp<DataSource> &dataSource, 44 const sp<MetaData> &trackMetadata); 45 46 virtual status_t start(MetaData *params); 47 virtual status_t stop(); 48 virtual sp<MetaData> getFormat(); 49 50 virtual status_t read( 51 MediaBuffer **buffer, const ReadOptions *options = NULL); 52 53protected: 54 virtual ~FLACSource(); 55 56private: 57 sp<DataSource> mDataSource; 58 sp<MetaData> mTrackMetadata; 59 sp<FLACParser> mParser; 60 bool mInitCheck; 61 bool mStarted; 62 63 status_t init(); 64 65 // no copy constructor or assignment 66 FLACSource(const FLACSource &); 67 FLACSource &operator=(const FLACSource &); 68 69}; 70 71// FLACParser wraps a C libFLAC parser aka stream decoder 72 73class FLACParser : public RefBase { 74 75public: 76 enum { 77 kMaxChannels = 8, 78 }; 79 80 explicit FLACParser( 81 const sp<DataSource> &dataSource, 82 // If metadata pointers aren't provided, we don't fill them 83 const sp<MetaData> &fileMetadata = 0, 84 const sp<MetaData> &trackMetadata = 0); 85 86 status_t initCheck() const { 87 return mInitCheck; 88 } 89 90 // stream properties 91 unsigned getMaxBlockSize() const { 92 return mStreamInfo.max_blocksize; 93 } 94 unsigned getSampleRate() const { 95 return mStreamInfo.sample_rate; 96 } 97 unsigned getChannels() const { 98 return mStreamInfo.channels; 99 } 100 unsigned getBitsPerSample() const { 101 return mStreamInfo.bits_per_sample; 102 } 103 FLAC__uint64 getTotalSamples() const { 104 return mStreamInfo.total_samples; 105 } 106 107 // media buffers 108 void allocateBuffers(); 109 void releaseBuffers(); 110 MediaBuffer *readBuffer() { 111 return readBuffer(false, 0LL); 112 } 113 MediaBuffer *readBuffer(FLAC__uint64 sample) { 114 return readBuffer(true, sample); 115 } 116 117protected: 118 virtual ~FLACParser(); 119 120private: 121 sp<DataSource> mDataSource; 122 sp<MetaData> mFileMetadata; 123 sp<MetaData> mTrackMetadata; 124 bool mInitCheck; 125 126 // media buffers 127 size_t mMaxBufferSize; 128 MediaBufferGroup *mGroup; 129 void (*mCopy)(short *dst, const int * src[kMaxChannels], unsigned nSamples, unsigned nChannels); 130 131 // handle to underlying libFLAC parser 132 FLAC__StreamDecoder *mDecoder; 133 134 // current position within the data source 135 off64_t mCurrentPos; 136 bool mEOF; 137 138 // cached when the STREAMINFO metadata is parsed by libFLAC 139 FLAC__StreamMetadata_StreamInfo mStreamInfo; 140 bool mStreamInfoValid; 141 142 // cached when a decoded PCM block is "written" by libFLAC parser 143 bool mWriteRequested; 144 bool mWriteCompleted; 145 FLAC__FrameHeader mWriteHeader; 146 FLAC__int32 const * mWriteBuffer[kMaxChannels]; 147 148 // most recent error reported by libFLAC parser 149 FLAC__StreamDecoderErrorStatus mErrorStatus; 150 151 status_t init(); 152 MediaBuffer *readBuffer(bool doSeek, FLAC__uint64 sample); 153 154 // no copy constructor or assignment 155 FLACParser(const FLACParser &); 156 FLACParser &operator=(const FLACParser &); 157 158 // FLAC parser callbacks as C++ instance methods 159 FLAC__StreamDecoderReadStatus readCallback( 160 FLAC__byte buffer[], size_t *bytes); 161 FLAC__StreamDecoderSeekStatus seekCallback( 162 FLAC__uint64 absolute_byte_offset); 163 FLAC__StreamDecoderTellStatus tellCallback( 164 FLAC__uint64 *absolute_byte_offset); 165 FLAC__StreamDecoderLengthStatus lengthCallback( 166 FLAC__uint64 *stream_length); 167 FLAC__bool eofCallback(); 168 FLAC__StreamDecoderWriteStatus writeCallback( 169 const FLAC__Frame *frame, const FLAC__int32 * const buffer[]); 170 void metadataCallback(const FLAC__StreamMetadata *metadata); 171 void errorCallback(FLAC__StreamDecoderErrorStatus status); 172 173 // FLAC parser callbacks as C-callable functions 174 static FLAC__StreamDecoderReadStatus read_callback( 175 const FLAC__StreamDecoder *decoder, 176 FLAC__byte buffer[], size_t *bytes, 177 void *client_data); 178 static FLAC__StreamDecoderSeekStatus seek_callback( 179 const FLAC__StreamDecoder *decoder, 180 FLAC__uint64 absolute_byte_offset, 181 void *client_data); 182 static FLAC__StreamDecoderTellStatus tell_callback( 183 const FLAC__StreamDecoder *decoder, 184 FLAC__uint64 *absolute_byte_offset, 185 void *client_data); 186 static FLAC__StreamDecoderLengthStatus length_callback( 187 const FLAC__StreamDecoder *decoder, 188 FLAC__uint64 *stream_length, 189 void *client_data); 190 static FLAC__bool eof_callback( 191 const FLAC__StreamDecoder *decoder, 192 void *client_data); 193 static FLAC__StreamDecoderWriteStatus write_callback( 194 const FLAC__StreamDecoder *decoder, 195 const FLAC__Frame *frame, const FLAC__int32 * const buffer[], 196 void *client_data); 197 static void metadata_callback( 198 const FLAC__StreamDecoder *decoder, 199 const FLAC__StreamMetadata *metadata, 200 void *client_data); 201 static void error_callback( 202 const FLAC__StreamDecoder *decoder, 203 FLAC__StreamDecoderErrorStatus status, 204 void *client_data); 205 206}; 207 208// The FLAC parser calls our C++ static callbacks using C calling conventions, 209// inside FLAC__stream_decoder_process_until_end_of_metadata 210// and FLAC__stream_decoder_process_single. 211// We immediately then call our corresponding C++ instance methods 212// with the same parameter list, but discard redundant information. 213 214FLAC__StreamDecoderReadStatus FLACParser::read_callback( 215 const FLAC__StreamDecoder * /* decoder */, FLAC__byte buffer[], 216 size_t *bytes, void *client_data) 217{ 218 return ((FLACParser *) client_data)->readCallback(buffer, bytes); 219} 220 221FLAC__StreamDecoderSeekStatus FLACParser::seek_callback( 222 const FLAC__StreamDecoder * /* decoder */, 223 FLAC__uint64 absolute_byte_offset, void *client_data) 224{ 225 return ((FLACParser *) client_data)->seekCallback(absolute_byte_offset); 226} 227 228FLAC__StreamDecoderTellStatus FLACParser::tell_callback( 229 const FLAC__StreamDecoder * /* decoder */, 230 FLAC__uint64 *absolute_byte_offset, void *client_data) 231{ 232 return ((FLACParser *) client_data)->tellCallback(absolute_byte_offset); 233} 234 235FLAC__StreamDecoderLengthStatus FLACParser::length_callback( 236 const FLAC__StreamDecoder * /* decoder */, 237 FLAC__uint64 *stream_length, void *client_data) 238{ 239 return ((FLACParser *) client_data)->lengthCallback(stream_length); 240} 241 242FLAC__bool FLACParser::eof_callback( 243 const FLAC__StreamDecoder * /* decoder */, void *client_data) 244{ 245 return ((FLACParser *) client_data)->eofCallback(); 246} 247 248FLAC__StreamDecoderWriteStatus FLACParser::write_callback( 249 const FLAC__StreamDecoder * /* decoder */, const FLAC__Frame *frame, 250 const FLAC__int32 * const buffer[], void *client_data) 251{ 252 return ((FLACParser *) client_data)->writeCallback(frame, buffer); 253} 254 255void FLACParser::metadata_callback( 256 const FLAC__StreamDecoder * /* decoder */, 257 const FLAC__StreamMetadata *metadata, void *client_data) 258{ 259 ((FLACParser *) client_data)->metadataCallback(metadata); 260} 261 262void FLACParser::error_callback( 263 const FLAC__StreamDecoder * /* decoder */, 264 FLAC__StreamDecoderErrorStatus status, void *client_data) 265{ 266 ((FLACParser *) client_data)->errorCallback(status); 267} 268 269// These are the corresponding callbacks with C++ calling conventions 270 271FLAC__StreamDecoderReadStatus FLACParser::readCallback( 272 FLAC__byte buffer[], size_t *bytes) 273{ 274 size_t requested = *bytes; 275 ssize_t actual = mDataSource->readAt(mCurrentPos, buffer, requested); 276 if (0 > actual) { 277 *bytes = 0; 278 return FLAC__STREAM_DECODER_READ_STATUS_ABORT; 279 } else if (0 == actual) { 280 *bytes = 0; 281 mEOF = true; 282 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; 283 } else { 284 assert(actual <= requested); 285 *bytes = actual; 286 mCurrentPos += actual; 287 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; 288 } 289} 290 291FLAC__StreamDecoderSeekStatus FLACParser::seekCallback( 292 FLAC__uint64 absolute_byte_offset) 293{ 294 mCurrentPos = absolute_byte_offset; 295 mEOF = false; 296 return FLAC__STREAM_DECODER_SEEK_STATUS_OK; 297} 298 299FLAC__StreamDecoderTellStatus FLACParser::tellCallback( 300 FLAC__uint64 *absolute_byte_offset) 301{ 302 *absolute_byte_offset = mCurrentPos; 303 return FLAC__STREAM_DECODER_TELL_STATUS_OK; 304} 305 306FLAC__StreamDecoderLengthStatus FLACParser::lengthCallback( 307 FLAC__uint64 *stream_length) 308{ 309 off64_t size; 310 if (OK == mDataSource->getSize(&size)) { 311 *stream_length = size; 312 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; 313 } else { 314 return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED; 315 } 316} 317 318FLAC__bool FLACParser::eofCallback() 319{ 320 return mEOF; 321} 322 323FLAC__StreamDecoderWriteStatus FLACParser::writeCallback( 324 const FLAC__Frame *frame, const FLAC__int32 * const buffer[]) 325{ 326 if (mWriteRequested) { 327 mWriteRequested = false; 328 // FLAC parser doesn't free or realloc buffer until next frame or finish 329 mWriteHeader = frame->header; 330 memmove(mWriteBuffer, buffer, sizeof(const FLAC__int32 * const) * getChannels()); 331 mWriteCompleted = true; 332 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 333 } else { 334 ALOGE("FLACParser::writeCallback unexpected"); 335 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 336 } 337} 338 339void FLACParser::metadataCallback(const FLAC__StreamMetadata *metadata) 340{ 341 switch (metadata->type) { 342 case FLAC__METADATA_TYPE_STREAMINFO: 343 if (!mStreamInfoValid) { 344 mStreamInfo = metadata->data.stream_info; 345 mStreamInfoValid = true; 346 } else { 347 ALOGE("FLACParser::metadataCallback unexpected STREAMINFO"); 348 } 349 break; 350 case FLAC__METADATA_TYPE_VORBIS_COMMENT: 351 { 352 const FLAC__StreamMetadata_VorbisComment *vc; 353 vc = &metadata->data.vorbis_comment; 354 for (FLAC__uint32 i = 0; i < vc->num_comments; ++i) { 355 FLAC__StreamMetadata_VorbisComment_Entry *vce; 356 vce = &vc->comments[i]; 357 if (mFileMetadata != 0 && vce->entry != NULL) { 358 parseVorbisComment(mFileMetadata, (const char *) vce->entry, 359 vce->length); 360 } 361 } 362 } 363 break; 364 case FLAC__METADATA_TYPE_PICTURE: 365 if (mFileMetadata != 0) { 366 const FLAC__StreamMetadata_Picture *p = &metadata->data.picture; 367 mFileMetadata->setData(kKeyAlbumArt, 368 MetaData::TYPE_NONE, p->data, p->data_length); 369 mFileMetadata->setCString(kKeyAlbumArtMIME, p->mime_type); 370 } 371 break; 372 default: 373 ALOGW("FLACParser::metadataCallback unexpected type %u", metadata->type); 374 break; 375 } 376} 377 378void FLACParser::errorCallback(FLAC__StreamDecoderErrorStatus status) 379{ 380 ALOGE("FLACParser::errorCallback status=%d", status); 381 mErrorStatus = status; 382} 383 384// Copy samples from FLAC native 32-bit non-interleaved to 16-bit interleaved. 385// These are candidates for optimization if needed. 386 387static void copyMono8( 388 short *dst, 389 const int * src[FLACParser::kMaxChannels], 390 unsigned nSamples, 391 unsigned /* nChannels */) { 392 for (unsigned i = 0; i < nSamples; ++i) { 393 *dst++ = src[0][i] << 8; 394 } 395} 396 397static void copyStereo8( 398 short *dst, 399 const int * src[FLACParser::kMaxChannels], 400 unsigned nSamples, 401 unsigned /* nChannels */) { 402 for (unsigned i = 0; i < nSamples; ++i) { 403 *dst++ = src[0][i] << 8; 404 *dst++ = src[1][i] << 8; 405 } 406} 407 408static void copyMultiCh8(short *dst, const int * src[FLACParser::kMaxChannels], unsigned nSamples, unsigned nChannels) 409{ 410 for (unsigned i = 0; i < nSamples; ++i) { 411 for (unsigned c = 0; c < nChannels; ++c) { 412 *dst++ = src[c][i] << 8; 413 } 414 } 415} 416 417static void copyMono16( 418 short *dst, 419 const int * src[FLACParser::kMaxChannels], 420 unsigned nSamples, 421 unsigned /* nChannels */) { 422 for (unsigned i = 0; i < nSamples; ++i) { 423 *dst++ = src[0][i]; 424 } 425} 426 427static void copyStereo16( 428 short *dst, 429 const int * src[FLACParser::kMaxChannels], 430 unsigned nSamples, 431 unsigned /* nChannels */) { 432 for (unsigned i = 0; i < nSamples; ++i) { 433 *dst++ = src[0][i]; 434 *dst++ = src[1][i]; 435 } 436} 437 438static void copyMultiCh16(short *dst, const int * src[FLACParser::kMaxChannels], unsigned nSamples, unsigned nChannels) 439{ 440 for (unsigned i = 0; i < nSamples; ++i) { 441 for (unsigned c = 0; c < nChannels; ++c) { 442 *dst++ = src[c][i]; 443 } 444 } 445} 446 447// 24-bit versions should do dithering or noise-shaping, here or in AudioFlinger 448 449static void copyMono24( 450 short *dst, 451 const int * src[FLACParser::kMaxChannels], 452 unsigned nSamples, 453 unsigned /* nChannels */) { 454 for (unsigned i = 0; i < nSamples; ++i) { 455 *dst++ = src[0][i] >> 8; 456 } 457} 458 459static void copyStereo24( 460 short *dst, 461 const int * src[FLACParser::kMaxChannels], 462 unsigned nSamples, 463 unsigned /* nChannels */) { 464 for (unsigned i = 0; i < nSamples; ++i) { 465 *dst++ = src[0][i] >> 8; 466 *dst++ = src[1][i] >> 8; 467 } 468} 469 470static void copyMultiCh24(short *dst, const int * src[FLACParser::kMaxChannels], unsigned nSamples, unsigned nChannels) 471{ 472 for (unsigned i = 0; i < nSamples; ++i) { 473 for (unsigned c = 0; c < nChannels; ++c) { 474 *dst++ = src[c][i] >> 8; 475 } 476 } 477} 478 479static void copyTrespass( 480 short * /* dst */, 481 const int *[FLACParser::kMaxChannels] /* src */, 482 unsigned /* nSamples */, 483 unsigned /* nChannels */) { 484 TRESPASS(); 485} 486 487// FLACParser 488 489FLACParser::FLACParser( 490 const sp<DataSource> &dataSource, 491 const sp<MetaData> &fileMetadata, 492 const sp<MetaData> &trackMetadata) 493 : mDataSource(dataSource), 494 mFileMetadata(fileMetadata), 495 mTrackMetadata(trackMetadata), 496 mInitCheck(false), 497 mMaxBufferSize(0), 498 mGroup(NULL), 499 mCopy(copyTrespass), 500 mDecoder(NULL), 501 mCurrentPos(0LL), 502 mEOF(false), 503 mStreamInfoValid(false), 504 mWriteRequested(false), 505 mWriteCompleted(false), 506 mErrorStatus((FLAC__StreamDecoderErrorStatus) -1) 507{ 508 ALOGV("FLACParser::FLACParser"); 509 memset(&mStreamInfo, 0, sizeof(mStreamInfo)); 510 memset(&mWriteHeader, 0, sizeof(mWriteHeader)); 511 mInitCheck = init(); 512} 513 514FLACParser::~FLACParser() 515{ 516 ALOGV("FLACParser::~FLACParser"); 517 if (mDecoder != NULL) { 518 FLAC__stream_decoder_delete(mDecoder); 519 mDecoder = NULL; 520 } 521} 522 523status_t FLACParser::init() 524{ 525 // setup libFLAC parser 526 mDecoder = FLAC__stream_decoder_new(); 527 if (mDecoder == NULL) { 528 // The new should succeed, since probably all it does is a malloc 529 // that always succeeds in Android. But to avoid dependence on the 530 // libFLAC internals, we check and log here. 531 ALOGE("new failed"); 532 return NO_INIT; 533 } 534 FLAC__stream_decoder_set_md5_checking(mDecoder, false); 535 FLAC__stream_decoder_set_metadata_ignore_all(mDecoder); 536 FLAC__stream_decoder_set_metadata_respond( 537 mDecoder, FLAC__METADATA_TYPE_STREAMINFO); 538 FLAC__stream_decoder_set_metadata_respond( 539 mDecoder, FLAC__METADATA_TYPE_PICTURE); 540 FLAC__stream_decoder_set_metadata_respond( 541 mDecoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); 542 FLAC__StreamDecoderInitStatus initStatus; 543 initStatus = FLAC__stream_decoder_init_stream( 544 mDecoder, 545 read_callback, seek_callback, tell_callback, 546 length_callback, eof_callback, write_callback, 547 metadata_callback, error_callback, (void *) this); 548 if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) { 549 // A failure here probably indicates a programming error and so is 550 // unlikely to happen. But we check and log here similarly to above. 551 ALOGE("init_stream failed %d", initStatus); 552 return NO_INIT; 553 } 554 // parse all metadata 555 if (!FLAC__stream_decoder_process_until_end_of_metadata(mDecoder)) { 556 ALOGE("end_of_metadata failed"); 557 return NO_INIT; 558 } 559 if (mStreamInfoValid) { 560 // check channel count 561 if (getChannels() == 0 || getChannels() > kMaxChannels) { 562 ALOGE("unsupported channel count %u", getChannels()); 563 return NO_INIT; 564 } 565 // check bit depth 566 switch (getBitsPerSample()) { 567 case 8: 568 case 16: 569 case 24: 570 break; 571 default: 572 ALOGE("unsupported bits per sample %u", getBitsPerSample()); 573 return NO_INIT; 574 } 575 // check sample rate 576 switch (getSampleRate()) { 577 case 8000: 578 case 11025: 579 case 12000: 580 case 16000: 581 case 22050: 582 case 24000: 583 case 32000: 584 case 44100: 585 case 48000: 586 case 88200: 587 case 96000: 588 break; 589 default: 590 ALOGE("unsupported sample rate %u", getSampleRate()); 591 return NO_INIT; 592 } 593 // configure the appropriate copy function, defaulting to trespass 594 static const struct { 595 unsigned mChannels; 596 unsigned mBitsPerSample; 597 void (*mCopy)(short *dst, const int * src[kMaxChannels], unsigned nSamples, unsigned nChannels); 598 } table[] = { 599 { 1, 8, copyMono8 }, 600 { 2, 8, copyStereo8 }, 601 { 8, 8, copyMultiCh8 }, 602 { 1, 16, copyMono16 }, 603 { 2, 16, copyStereo16 }, 604 { 8, 16, copyMultiCh16 }, 605 { 1, 24, copyMono24 }, 606 { 2, 24, copyStereo24 }, 607 { 8, 24, copyMultiCh24 }, 608 }; 609 for (unsigned i = 0; i < sizeof(table)/sizeof(table[0]); ++i) { 610 if (table[i].mChannels >= getChannels() && 611 table[i].mBitsPerSample == getBitsPerSample()) { 612 mCopy = table[i].mCopy; 613 break; 614 } 615 } 616 // populate track metadata 617 if (mTrackMetadata != 0) { 618 mTrackMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW); 619 mTrackMetadata->setInt32(kKeyChannelCount, getChannels()); 620 mTrackMetadata->setInt32(kKeySampleRate, getSampleRate()); 621 mTrackMetadata->setInt32(kKeyPcmEncoding, kAudioEncodingPcm16bit); 622 // sample rate is non-zero, so division by zero not possible 623 mTrackMetadata->setInt64(kKeyDuration, 624 (getTotalSamples() * 1000000LL) / getSampleRate()); 625 } 626 } else { 627 ALOGE("missing STREAMINFO"); 628 return NO_INIT; 629 } 630 if (mFileMetadata != 0) { 631 mFileMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC); 632 } 633 return OK; 634} 635 636void FLACParser::allocateBuffers() 637{ 638 CHECK(mGroup == NULL); 639 mGroup = new MediaBufferGroup; 640 mMaxBufferSize = getMaxBlockSize() * getChannels() * sizeof(short); 641 mGroup->add_buffer(new MediaBuffer(mMaxBufferSize)); 642} 643 644void FLACParser::releaseBuffers() 645{ 646 CHECK(mGroup != NULL); 647 delete mGroup; 648 mGroup = NULL; 649} 650 651MediaBuffer *FLACParser::readBuffer(bool doSeek, FLAC__uint64 sample) 652{ 653 mWriteRequested = true; 654 mWriteCompleted = false; 655 if (doSeek) { 656 // We implement the seek callback, so this works without explicit flush 657 if (!FLAC__stream_decoder_seek_absolute(mDecoder, sample)) { 658 ALOGE("FLACParser::readBuffer seek to sample %lld failed", (long long)sample); 659 return NULL; 660 } 661 ALOGV("FLACParser::readBuffer seek to sample %lld succeeded", (long long)sample); 662 } else { 663 if (!FLAC__stream_decoder_process_single(mDecoder)) { 664 ALOGE("FLACParser::readBuffer process_single failed"); 665 return NULL; 666 } 667 } 668 if (!mWriteCompleted) { 669 ALOGV("FLACParser::readBuffer write did not complete"); 670 return NULL; 671 } 672 // verify that block header keeps the promises made by STREAMINFO 673 unsigned blocksize = mWriteHeader.blocksize; 674 if (blocksize == 0 || blocksize > getMaxBlockSize()) { 675 ALOGE("FLACParser::readBuffer write invalid blocksize %u", blocksize); 676 return NULL; 677 } 678 if (mWriteHeader.sample_rate != getSampleRate() || 679 mWriteHeader.channels != getChannels() || 680 mWriteHeader.bits_per_sample != getBitsPerSample()) { 681 ALOGE("FLACParser::readBuffer write changed parameters mid-stream: %d/%d/%d -> %d/%d/%d", 682 getSampleRate(), getChannels(), getBitsPerSample(), 683 mWriteHeader.sample_rate, mWriteHeader.channels, mWriteHeader.bits_per_sample); 684 return NULL; 685 } 686 // acquire a media buffer 687 CHECK(mGroup != NULL); 688 MediaBuffer *buffer; 689 status_t err = mGroup->acquire_buffer(&buffer); 690 if (err != OK) { 691 return NULL; 692 } 693 size_t bufferSize = blocksize * getChannels() * sizeof(short); 694 CHECK(bufferSize <= mMaxBufferSize); 695 short *data = (short *) buffer->data(); 696 buffer->set_range(0, bufferSize); 697 // copy PCM from FLAC write buffer to our media buffer, with interleaving 698 (*mCopy)(data, mWriteBuffer, blocksize, getChannels()); 699 // fill in buffer metadata 700 CHECK(mWriteHeader.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); 701 FLAC__uint64 sampleNumber = mWriteHeader.number.sample_number; 702 int64_t timeUs = (1000000LL * sampleNumber) / getSampleRate(); 703 buffer->meta_data()->setInt64(kKeyTime, timeUs); 704 buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); 705 return buffer; 706} 707 708// FLACsource 709 710FLACSource::FLACSource( 711 const sp<DataSource> &dataSource, 712 const sp<MetaData> &trackMetadata) 713 : mDataSource(dataSource), 714 mTrackMetadata(trackMetadata), 715 mParser(0), 716 mInitCheck(false), 717 mStarted(false) 718{ 719 ALOGV("FLACSource::FLACSource"); 720 mInitCheck = init(); 721} 722 723FLACSource::~FLACSource() 724{ 725 ALOGV("~FLACSource::FLACSource"); 726 if (mStarted) { 727 stop(); 728 } 729} 730 731status_t FLACSource::start(MetaData * /* params */) 732{ 733 ALOGV("FLACSource::start"); 734 735 CHECK(!mStarted); 736 mParser->allocateBuffers(); 737 mStarted = true; 738 739 return OK; 740} 741 742status_t FLACSource::stop() 743{ 744 ALOGV("FLACSource::stop"); 745 746 CHECK(mStarted); 747 mParser->releaseBuffers(); 748 mStarted = false; 749 750 return OK; 751} 752 753sp<MetaData> FLACSource::getFormat() 754{ 755 return mTrackMetadata; 756} 757 758status_t FLACSource::read( 759 MediaBuffer **outBuffer, const ReadOptions *options) 760{ 761 MediaBuffer *buffer; 762 // process an optional seek request 763 int64_t seekTimeUs; 764 ReadOptions::SeekMode mode; 765 if ((NULL != options) && options->getSeekTo(&seekTimeUs, &mode)) { 766 FLAC__uint64 sample; 767 if (seekTimeUs <= 0LL) { 768 sample = 0LL; 769 } else { 770 // sample and total samples are both zero-based, and seek to EOF ok 771 sample = (seekTimeUs * mParser->getSampleRate()) / 1000000LL; 772 if (sample >= mParser->getTotalSamples()) { 773 sample = mParser->getTotalSamples(); 774 } 775 } 776 buffer = mParser->readBuffer(sample); 777 // otherwise read sequentially 778 } else { 779 buffer = mParser->readBuffer(); 780 } 781 *outBuffer = buffer; 782 return buffer != NULL ? (status_t) OK : (status_t) ERROR_END_OF_STREAM; 783} 784 785status_t FLACSource::init() 786{ 787 ALOGV("FLACSource::init"); 788 // re-use the same track metadata passed into constructor from FLACExtractor 789 mParser = new FLACParser(mDataSource); 790 return mParser->initCheck(); 791} 792 793// FLACExtractor 794 795FLACExtractor::FLACExtractor( 796 const sp<DataSource> &dataSource) 797 : mDataSource(dataSource), 798 mInitCheck(false) 799{ 800 ALOGV("FLACExtractor::FLACExtractor"); 801 mInitCheck = init(); 802} 803 804FLACExtractor::~FLACExtractor() 805{ 806 ALOGV("~FLACExtractor::FLACExtractor"); 807} 808 809size_t FLACExtractor::countTracks() 810{ 811 return mInitCheck == OK ? 1 : 0; 812} 813 814sp<IMediaSource> FLACExtractor::getTrack(size_t index) 815{ 816 if (mInitCheck != OK || index > 0) { 817 return NULL; 818 } 819 return new FLACSource(mDataSource, mTrackMetadata); 820} 821 822sp<MetaData> FLACExtractor::getTrackMetaData( 823 size_t index, uint32_t /* flags */) { 824 if (mInitCheck != OK || index > 0) { 825 return NULL; 826 } 827 return mTrackMetadata; 828} 829 830status_t FLACExtractor::init() 831{ 832 mFileMetadata = new MetaData; 833 mTrackMetadata = new MetaData; 834 // FLACParser will fill in the metadata for us 835 mParser = new FLACParser(mDataSource, mFileMetadata, mTrackMetadata); 836 return mParser->initCheck(); 837} 838 839sp<MetaData> FLACExtractor::getMetaData() 840{ 841 return mFileMetadata; 842} 843 844// Sniffer 845 846bool SniffFLAC( 847 const sp<DataSource> &source, String8 *mimeType, float *confidence, 848 sp<AMessage> *) 849{ 850 // first 4 is the signature word 851 // second 4 is the sizeof STREAMINFO 852 // 042 is the mandatory STREAMINFO 853 // no need to read rest of the header, as a premature EOF will be caught later 854 uint8_t header[4+4]; 855 if (source->readAt(0, header, sizeof(header)) != sizeof(header) 856 || memcmp("fLaC\0\0\0\042", header, 4+4)) 857 { 858 return false; 859 } 860 861 *mimeType = MEDIA_MIMETYPE_AUDIO_FLAC; 862 *confidence = 0.5; 863 864 return true; 865} 866 867} // namespace android 868