1856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten/* 2856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * Copyright (C) 2011 The Android Open Source Project 3856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * 4856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * Licensed under the Apache License, Version 2.0 (the "License"); 5856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * you may not use this file except in compliance with the License. 6856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * You may obtain a copy of the License at 7856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * 8856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * http://www.apache.org/licenses/LICENSE-2.0 9856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * 10856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * Unless required by applicable law or agreed to in writing, software 11856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * distributed under the License is distributed on an "AS IS" BASIS, 12856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * See the License for the specific language governing permissions and 14856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten * limitations under the License. 15856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten */ 16856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 17856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten//#define LOG_NDEBUG 0 18856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#define LOG_TAG "FLACExtractor" 19856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <utils/Log.h> 20856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 21856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include "include/FLACExtractor.h" 22856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// Vorbis comments 23856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include "include/OggExtractor.h" 24856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// libFLAC parser 25856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include "FLAC/stream_decoder.h" 26856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 27856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <media/stagefright/foundation/ADebug.h> 28856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <media/stagefright/DataSource.h> 29856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <media/stagefright/MediaBufferGroup.h> 30856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <media/stagefright/MediaDefs.h> 31856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <media/stagefright/MetaData.h> 32856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <media/stagefright/MediaSource.h> 33856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten#include <media/stagefright/MediaBuffer.h> 34856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 35856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastennamespace android { 36856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 37856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenclass FLACParser; 38856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 39856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenclass FLACSource : public MediaSource { 40856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 41856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenpublic: 42856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACSource( 43856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 44856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata); 45856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 46856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten virtual status_t start(MetaData *params); 47856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten virtual status_t stop(); 48856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten virtual sp<MetaData> getFormat(); 49856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 50856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten virtual status_t read( 51856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer **buffer, const ReadOptions *options = NULL); 52856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 53856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenprotected: 54856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten virtual ~FLACSource(); 55856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 56856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenprivate: 57856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<DataSource> mDataSource; 58856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<MetaData> mTrackMetadata; 59856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<FLACParser> mParser; 60856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mInitCheck; 61856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mStarted; 62856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 63856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t init(); 64856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 65856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // no copy constructor or assignment 66856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACSource(const FLACSource &); 67856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACSource &operator=(const FLACSource &); 68856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 69856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten}; 70856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 71856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACParser wraps a C libFLAC parser aka stream decoder 72856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 73856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenclass FLACParser : public RefBase { 74856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 75856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenpublic: 76856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACParser( 77856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 78856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // If metadata pointers aren't provided, we don't fill them 79856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &fileMetadata = 0, 80856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata = 0); 81856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 82856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t initCheck() const { 83856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mInitCheck; 84856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 85856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 86856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // stream properties 87856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getMaxBlockSize() const { 88856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.max_blocksize; 89856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 90856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getSampleRate() const { 91856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.sample_rate; 92856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 93856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getChannels() const { 94856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.channels; 95856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 96856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getBitsPerSample() const { 97856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.bits_per_sample; 98856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 99856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 getTotalSamples() const { 100856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.total_samples; 101856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 102856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 103856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // media buffers 104856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void allocateBuffers(); 105856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void releaseBuffers(); 106856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *readBuffer() { 107856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return readBuffer(false, 0LL); 108856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 109856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *readBuffer(FLAC__uint64 sample) { 110856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return readBuffer(true, sample); 111856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 112856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 113856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenprotected: 114856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten virtual ~FLACParser(); 115856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 116856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenprivate: 117856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<DataSource> mDataSource; 118856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<MetaData> mFileMetadata; 119856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<MetaData> mTrackMetadata; 120856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mInitCheck; 121856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 122856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // media buffers 123856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t mMaxBufferSize; 124856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBufferGroup *mGroup; 125856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void (*mCopy)(short *dst, const int *const *src, unsigned nSamples); 126856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 127856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // handle to underlying libFLAC parser 128856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoder *mDecoder; 129856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 130856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // current position within the data source 131856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten off64_t mCurrentPos; 132856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mEOF; 133856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 134856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // cached when the STREAMINFO metadata is parsed by libFLAC 135856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamMetadata_StreamInfo mStreamInfo; 136856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mStreamInfoValid; 137856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 138856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // cached when a decoded PCM block is "written" by libFLAC parser 139856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mWriteRequested; 140856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mWriteCompleted; 141856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__FrameHeader mWriteHeader; 142856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__int32 * const *mWriteBuffer; 143856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 144856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // most recent error reported by libFLAC parser 145856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderErrorStatus mErrorStatus; 146856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 147856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t init(); 148856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *readBuffer(bool doSeek, FLAC__uint64 sample); 149856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 150856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // no copy constructor or assignment 151856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACParser(const FLACParser &); 152856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACParser &operator=(const FLACParser &); 153856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 154856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLAC parser callbacks as C++ instance methods 155856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderReadStatus readCallback( 156856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__byte buffer[], size_t *bytes); 157856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderSeekStatus seekCallback( 158856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset); 159856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderTellStatus tellCallback( 160856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset); 161856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderLengthStatus lengthCallback( 162856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length); 163856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__bool eofCallback(); 164856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderWriteStatus writeCallback( 165856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__Frame *frame, const FLAC__int32 * const buffer[]); 166856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void metadataCallback(const FLAC__StreamMetadata *metadata); 167856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void errorCallback(FLAC__StreamDecoderErrorStatus status); 168856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 169856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLAC parser callbacks as C-callable functions 170856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderReadStatus read_callback( 171856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 172856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__byte buffer[], size_t *bytes, 173856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 174856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderSeekStatus seek_callback( 175856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 176856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset, 177856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 178856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderTellStatus tell_callback( 179856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 180856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset, 181856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 182856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderLengthStatus length_callback( 183856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 184856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length, 185856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 186856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__bool eof_callback( 187856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 188856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 189856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderWriteStatus write_callback( 190856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 191856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__Frame *frame, const FLAC__int32 * const buffer[], 192856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 193856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static void metadata_callback( 194856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 195856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata *metadata, 196856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 197856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static void error_callback( 198856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 199856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderErrorStatus status, 200856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 201856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 202856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten}; 203856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 204856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// The FLAC parser calls our C++ static callbacks using C calling conventions, 205856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// inside FLAC__stream_decoder_process_until_end_of_metadata 206856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// and FLAC__stream_decoder_process_single. 207856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// We immediately then call our corresponding C++ instance methods 208856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// with the same parameter list, but discard redundant information. 209856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 210856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderReadStatus FLACParser::read_callback( 211856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], 212856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t *bytes, void *client_data) 213856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 214856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->readCallback(buffer, bytes); 215856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 216856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 217856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderSeekStatus FLACParser::seek_callback( 218856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 219856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset, void *client_data) 220856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 221856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->seekCallback(absolute_byte_offset); 222856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 223856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 224856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderTellStatus FLACParser::tell_callback( 225856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 226856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset, void *client_data) 227856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 228856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->tellCallback(absolute_byte_offset); 229856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 230856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 231856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderLengthStatus FLACParser::length_callback( 232856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 233856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length, void *client_data) 234856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 235856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->lengthCallback(stream_length); 236856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 237856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 238856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__bool FLACParser::eof_callback( 239856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, void *client_data) 240856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 241856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->eofCallback(); 242856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 243856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 244856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderWriteStatus FLACParser::write_callback( 245856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, 246856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__int32 * const buffer[], void *client_data) 247856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 248856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->writeCallback(frame, buffer); 249856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 250856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 251856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::metadata_callback( 252856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 253856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata *metadata, void *client_data) 254856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 255856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ((FLACParser *) client_data)->metadataCallback(metadata); 256856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 257856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 258856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::error_callback( 259856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 260856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderErrorStatus status, void *client_data) 261856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 262856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ((FLACParser *) client_data)->errorCallback(status); 263856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 264856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 265856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// These are the corresponding callbacks with C++ calling conventions 266856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 267856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderReadStatus FLACParser::readCallback( 268856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__byte buffer[], size_t *bytes) 269856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 270856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t requested = *bytes; 271856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ssize_t actual = mDataSource->readAt(mCurrentPos, buffer, requested); 272856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (0 > actual) { 273856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *bytes = 0; 274856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_READ_STATUS_ABORT; 275856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else if (0 == actual) { 276856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *bytes = 0; 277856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mEOF = true; 278856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; 279856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 280856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten assert(actual <= requested); 281856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *bytes = actual; 282856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCurrentPos += actual; 283856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; 284856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 285856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 286856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 287856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderSeekStatus FLACParser::seekCallback( 288856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset) 289856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 290856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCurrentPos = absolute_byte_offset; 291856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mEOF = false; 292856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_SEEK_STATUS_OK; 293856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 294856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 295856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderTellStatus FLACParser::tellCallback( 296856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset) 297856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 298856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *absolute_byte_offset = mCurrentPos; 299856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_TELL_STATUS_OK; 300856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 301856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 302856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderLengthStatus FLACParser::lengthCallback( 303856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length) 304856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 305856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten off64_t size; 306856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (OK == mDataSource->getSize(&size)) { 307856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *stream_length = size; 308856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; 309856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 310856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED; 311856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 312856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 313856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 314856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__bool FLACParser::eofCallback() 315856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 316856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mEOF; 317856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 318856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 319856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderWriteStatus FLACParser::writeCallback( 320856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__Frame *frame, const FLAC__int32 * const buffer[]) 321856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 322856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mWriteRequested) { 323856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested = false; 324856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLAC parser doesn't free or realloc buffer until next frame or finish 325856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader = frame->header; 326856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteBuffer = buffer; 327856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted = true; 328856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 329856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 33029357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::writeCallback unexpected"); 331856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 332856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 333856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 334856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 335856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::metadataCallback(const FLAC__StreamMetadata *metadata) 336856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 337856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (metadata->type) { 338856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case FLAC__METADATA_TYPE_STREAMINFO: 339856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!mStreamInfoValid) { 340856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStreamInfo = metadata->data.stream_info; 341856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStreamInfoValid = true; 342856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 34329357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::metadataCallback unexpected STREAMINFO"); 344856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 345856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 346856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case FLAC__METADATA_TYPE_VORBIS_COMMENT: 347856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 348856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata_VorbisComment *vc; 349856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten vc = &metadata->data.vorbis_comment; 350856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (FLAC__uint32 i = 0; i < vc->num_comments; ++i) { 351856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamMetadata_VorbisComment_Entry *vce; 352856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten vce = &vc->comments[i]; 353af2e65ca9a0415e68acfae9497ce445e96fb738aGlenn Kasten if (mFileMetadata != 0 && vce->entry != NULL) { 354856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten parseVorbisComment(mFileMetadata, (const char *) vce->entry, 355856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten vce->length); 356856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 357856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 358856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 359856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 360856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case FLAC__METADATA_TYPE_PICTURE: 361856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mFileMetadata != 0) { 362856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata_Picture *p = &metadata->data.picture; 363856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setData(kKeyAlbumArt, 364856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MetaData::TYPE_NONE, p->data, p->data_length); 365856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setCString(kKeyAlbumArtMIME, p->mime_type); 366856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 367856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 368856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 3695ff1dd576bb93c45b44088a51544a18fc43ebf58Steve Block ALOGW("FLACParser::metadataCallback unexpected type %u", metadata->type); 370856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 371856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 372856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 373856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 374856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::errorCallback(FLAC__StreamDecoderErrorStatus status) 375856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 37629357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::errorCallback status=%d", status); 377856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mErrorStatus = status; 378856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 379856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 380856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// Copy samples from FLAC native 32-bit non-interleaved to 16-bit interleaved. 381856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// These are candidates for optimization if needed. 382856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 383856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatic void copyMono8(short *dst, const int *const *src, unsigned nSamples) 384856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 385856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 386856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] << 8; 387856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 388856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 389856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 390856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatic void copyStereo8(short *dst, const int *const *src, unsigned nSamples) 391856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 392856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 393856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] << 8; 394856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i] << 8; 395856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 396856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 397856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 398856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatic void copyMono16(short *dst, const int *const *src, unsigned nSamples) 399856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 400856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 401856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i]; 402856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 403856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 404856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 405856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatic void copyStereo16(short *dst, const int *const *src, unsigned nSamples) 406856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 407856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 408856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i]; 409856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i]; 410856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 411856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 412856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 413856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// 24-bit versions should do dithering or noise-shaping, here or in AudioFlinger 414856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 415856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatic void copyMono24(short *dst, const int *const *src, unsigned nSamples) 416856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 417856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 418856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] >> 8; 419856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 420856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 421856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 422856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatic void copyStereo24(short *dst, const int *const *src, unsigned nSamples) 423856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 424856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 425856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] >> 8; 426856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i] >> 8; 427856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 428856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 429856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 430856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatic void copyTrespass(short *dst, const int *const *src, unsigned nSamples) 431856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 432856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten TRESPASS(); 433856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 434856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 435856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACParser 436856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 437856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACParser::FLACParser( 438856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 439856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &fileMetadata, 440856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata) 441856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 442856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata(fileMetadata), 443856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata(trackMetadata), 444856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false), 445856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mMaxBufferSize(0), 446856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup(NULL), 447856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCopy(copyTrespass), 448856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder(NULL), 449856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCurrentPos(0LL), 450856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mEOF(false), 451856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStreamInfoValid(false), 452856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested(false), 453856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted(false), 454856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteBuffer(NULL), 455856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mErrorStatus((FLAC__StreamDecoderErrorStatus) -1) 456856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 4573856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::FLACParser"); 458856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten memset(&mStreamInfo, 0, sizeof(mStreamInfo)); 459856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten memset(&mWriteHeader, 0, sizeof(mWriteHeader)); 460856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 461856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 462856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 463856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACParser::~FLACParser() 464856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 4653856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::~FLACParser"); 466856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mDecoder != NULL) { 467856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_delete(mDecoder); 468856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder = NULL; 469856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 470856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 471856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 472856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACParser::init() 473856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 474856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // setup libFLAC parser 475856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder = FLAC__stream_decoder_new(); 476856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mDecoder == NULL) { 477856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // The new should succeed, since probably all it does is a malloc 478856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // that always succeeds in Android. But to avoid dependence on the 479856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // libFLAC internals, we check and log here. 48029357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("new failed"); 481856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 482856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 483856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_md5_checking(mDecoder, false); 484856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_ignore_all(mDecoder); 485856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 486856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_STREAMINFO); 487856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 488856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_PICTURE); 489856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 490856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); 491856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderInitStatus initStatus; 492856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten initStatus = FLAC__stream_decoder_init_stream( 493856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, 494856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten read_callback, seek_callback, tell_callback, 495856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten length_callback, eof_callback, write_callback, 496856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten metadata_callback, error_callback, (void *) this); 497856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) { 498856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // A failure here probably indicates a programming error and so is 499856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // unlikely to happen. But we check and log here similarly to above. 50029357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("init_stream failed %d", initStatus); 501856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 502856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 503856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // parse all metadata 504856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_process_until_end_of_metadata(mDecoder)) { 50529357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("end_of_metadata failed"); 506856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 507856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 508856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mStreamInfoValid) { 509856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check channel count 510856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (getChannels()) { 511856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 1: 512856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 2: 513856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 514856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 51529357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported channel count %u", getChannels()); 516856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 517856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 518856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check bit depth 519856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (getBitsPerSample()) { 520856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 8: 521856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 16: 522856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 24: 523856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 524856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 52529357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported bits per sample %u", getBitsPerSample()); 526856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 527856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 528856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check sample rate 529856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (getSampleRate()) { 530856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 8000: 531856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 11025: 532856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 12000: 533856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 16000: 534856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 22050: 535856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 24000: 536856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 32000: 537856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 44100: 538856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 48000: 539856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 540856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 541856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // 96000 would require a proper downsampler in AudioFlinger 54229357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported sample rate %u", getSampleRate()); 543856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 544856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 545856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // configure the appropriate copy function, defaulting to trespass 546856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static const struct { 547856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned mChannels; 548856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned mBitsPerSample; 549856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void (*mCopy)(short *dst, const int *const *src, unsigned nSamples); 550856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } table[] = { 551856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 8, copyMono8 }, 552856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 8, copyStereo8 }, 553856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 16, copyMono16 }, 554856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 16, copyStereo16 }, 555856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 24, copyMono24 }, 556856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 24, copyStereo24 }, 557856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten }; 558856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < sizeof(table)/sizeof(table[0]); ++i) { 559856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (table[i].mChannels == getChannels() && 560856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten table[i].mBitsPerSample == getBitsPerSample()) { 561856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCopy = table[i].mCopy; 562856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 563856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 564856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 565856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // populate track metadata 566856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mTrackMetadata != 0) { 567856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW); 568856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt32(kKeyChannelCount, getChannels()); 569856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt32(kKeySampleRate, getSampleRate()); 570856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample rate is non-zero, so division by zero not possible 571856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt64(kKeyDuration, 572856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten (getTotalSamples() * 1000000LL) / getSampleRate()); 573856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 574856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 57529357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("missing STREAMINFO"); 576856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 577856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 578856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mFileMetadata != 0) { 579856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC); 580856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 581856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 582856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 583856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 584856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::allocateBuffers() 585856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 586856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup == NULL); 587856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = new MediaBufferGroup; 588856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mMaxBufferSize = getMaxBlockSize() * getChannels() * sizeof(short); 589856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup->add_buffer(new MediaBuffer(mMaxBufferSize)); 590856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 591856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 592856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::releaseBuffers() 593856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 594856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 595856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten delete mGroup; 596856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = NULL; 597856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 598856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 599856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenMediaBuffer *FLACParser::readBuffer(bool doSeek, FLAC__uint64 sample) 600856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 601856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested = true; 602856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted = false; 603856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (doSeek) { 604856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // We implement the seek callback, so this works without explicit flush 605856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_seek_absolute(mDecoder, sample)) { 60629357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer seek to sample %llu failed", sample); 607856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 608856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 6093856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::readBuffer seek to sample %llu succeeded", sample); 610856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 611856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_process_single(mDecoder)) { 61229357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer process_single failed"); 613856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 614856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 615856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 616856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!mWriteCompleted) { 6173856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::readBuffer write did not complete"); 618856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 619856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 620856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // verify that block header keeps the promises made by STREAMINFO 621856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned blocksize = mWriteHeader.blocksize; 622856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (blocksize == 0 || blocksize > getMaxBlockSize()) { 62329357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer write invalid blocksize %u", blocksize); 624856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 625856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 626856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mWriteHeader.sample_rate != getSampleRate() || 627856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.channels != getChannels() || 628856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.bits_per_sample != getBitsPerSample()) { 62929357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer write changed parameters mid-stream"); 630856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 631856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // acquire a media buffer 632856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 633856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 634856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t err = mGroup->acquire_buffer(&buffer); 635856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (err != OK) { 636856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 637856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 638856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t bufferSize = blocksize * getChannels() * sizeof(short); 639856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(bufferSize <= mMaxBufferSize); 640856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten short *data = (short *) buffer->data(); 641856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->set_range(0, bufferSize); 642856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // copy PCM from FLAC write buffer to our media buffer, with interleaving 643856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten (*mCopy)(data, mWriteBuffer, blocksize); 644856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // fill in buffer metadata 645856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mWriteHeader.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); 646856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sampleNumber = mWriteHeader.number.sample_number; 647856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t timeUs = (1000000LL * sampleNumber) / getSampleRate(); 648856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt64(kKeyTime, timeUs); 649856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); 650856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer; 651856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 652856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 653856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACsource 654856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 655856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::FLACSource( 656856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 657856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata) 658856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 659856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata(trackMetadata), 660856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser(0), 661856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false), 662856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted(false) 663856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 6643856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::FLACSource"); 665856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 666856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 667856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 668856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::~FLACSource() 669856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 6703856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACSource::FLACSource"); 671856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mStarted) { 672856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten stop(); 673856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 674856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 675856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 676856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::start(MetaData *params) 677856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 6783856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::start"); 679856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 680856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(!mStarted); 681856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->allocateBuffers(); 682856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = true; 683856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 684856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 685856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 686856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 687856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::stop() 688856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 6893856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::stop"); 690856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 691856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mStarted); 692856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->releaseBuffers(); 693856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = false; 694856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 695856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 696856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 697856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 698856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACSource::getFormat() 699856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 700856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 701856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 702856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 703856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::read( 704856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer **outBuffer, const ReadOptions *options) 705856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 706856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 707856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // process an optional seek request 708856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t seekTimeUs; 709856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ReadOptions::SeekMode mode; 710856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if ((NULL != options) && options->getSeekTo(&seekTimeUs, &mode)) { 711856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sample; 712856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (seekTimeUs <= 0LL) { 713856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = 0LL; 714856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 715856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample and total samples are both zero-based, and seek to EOF ok 716856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = (seekTimeUs * mParser->getSampleRate()) / 1000000LL; 717856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (sample >= mParser->getTotalSamples()) { 718856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = mParser->getTotalSamples(); 719856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 720856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 721856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(sample); 722856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // otherwise read sequentially 723856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 724856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(); 725856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 726856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *outBuffer = buffer; 727856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer != NULL ? (status_t) OK : (status_t) ERROR_END_OF_STREAM; 728856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 729856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 730856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::init() 731856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7323856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::init"); 733856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // re-use the same track metadata passed into constructor from FLACExtractor 734856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource); 735856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 736856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 737856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 738856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACExtractor 739856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 740856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::FLACExtractor( 741856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource) 742856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 743856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false) 744856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7453856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACExtractor::FLACExtractor"); 746856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 747856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 748856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 749856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::~FLACExtractor() 750856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7513856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACExtractor::FLACExtractor"); 752856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 753856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 754856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensize_t FLACExtractor::countTracks() 755856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 756856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mInitCheck == OK ? 1 : 0; 757856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 758856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 759856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MediaSource> FLACExtractor::getTrack(size_t index) 760856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 761856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 762856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 763856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 764856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return new FLACSource(mDataSource, mTrackMetadata); 765856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 766856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 767856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getTrackMetaData( 768856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t index, uint32_t flags) 769856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 770856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 771856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 772856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 773856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 774856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 775856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 776856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACExtractor::init() 777856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 778856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata = new MetaData; 779856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata = new MetaData; 780856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLACParser will fill in the metadata for us 781856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource, mFileMetadata, mTrackMetadata); 782856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 783856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 784856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 785856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getMetaData() 786856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 787856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mFileMetadata; 788856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 789856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 790856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// Sniffer 791856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 792856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenbool SniffFLAC( 793856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &source, String8 *mimeType, float *confidence, 794856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<AMessage> *) 795856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 796856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // first 4 is the signature word 797856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // second 4 is the sizeof STREAMINFO 798856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // 042 is the mandatory STREAMINFO 799856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // no need to read rest of the header, as a premature EOF will be caught later 800856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten uint8_t header[4+4]; 801856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (source->readAt(0, header, sizeof(header)) != sizeof(header) 802856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten || memcmp("fLaC\0\0\0\042", header, 4+4)) 803856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 804856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return false; 805856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 806856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 807856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *mimeType = MEDIA_MIMETYPE_AUDIO_FLAC; 808856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *confidence = 0.5; 809856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 810856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return true; 811856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 812856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 813856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} // namespace android 814