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: 76acc192347665943ca674acf117e4f74a88436922Robert Shih enum { 77acc192347665943ca674acf117e4f74a88436922Robert Shih kMaxChannels = 8, 78acc192347665943ca674acf117e4f74a88436922Robert Shih }; 79acc192347665943ca674acf117e4f74a88436922Robert Shih 80090ef604f81447eab4aa0a5b45d6307482573560Chih-Hung Hsieh explicit FLACParser( 81856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 82856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // If metadata pointers aren't provided, we don't fill them 83856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &fileMetadata = 0, 84856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata = 0); 85856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 86856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t initCheck() const { 87856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mInitCheck; 88856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 89856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 90856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // stream properties 91856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getMaxBlockSize() const { 92856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.max_blocksize; 93856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 94856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getSampleRate() const { 95856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.sample_rate; 96856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 97856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getChannels() const { 98856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.channels; 99856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 100856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned getBitsPerSample() const { 101856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.bits_per_sample; 102856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 103856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 getTotalSamples() const { 104856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mStreamInfo.total_samples; 105856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 106856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 107856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // media buffers 108856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void allocateBuffers(); 109856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void releaseBuffers(); 110856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *readBuffer() { 111856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return readBuffer(false, 0LL); 112856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 113856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *readBuffer(FLAC__uint64 sample) { 114856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return readBuffer(true, sample); 115856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 116856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 117856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenprotected: 118856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten virtual ~FLACParser(); 119856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 120856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenprivate: 121856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<DataSource> mDataSource; 122856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<MetaData> mFileMetadata; 123856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<MetaData> mTrackMetadata; 124856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mInitCheck; 125856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 126856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // media buffers 127856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t mMaxBufferSize; 128856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBufferGroup *mGroup; 129acc192347665943ca674acf117e4f74a88436922Robert Shih void (*mCopy)(short *dst, const int * src[kMaxChannels], unsigned nSamples, unsigned nChannels); 130856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 131856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // handle to underlying libFLAC parser 132856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoder *mDecoder; 133856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 134856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // current position within the data source 135856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten off64_t mCurrentPos; 136856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mEOF; 137856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 138856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // cached when the STREAMINFO metadata is parsed by libFLAC 139856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamMetadata_StreamInfo mStreamInfo; 140856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mStreamInfoValid; 141856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 142856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // cached when a decoded PCM block is "written" by libFLAC parser 143856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mWriteRequested; 144856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten bool mWriteCompleted; 145856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__FrameHeader mWriteHeader; 146acc192347665943ca674acf117e4f74a88436922Robert Shih FLAC__int32 const * mWriteBuffer[kMaxChannels]; 147856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 148856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // most recent error reported by libFLAC parser 149856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderErrorStatus mErrorStatus; 150856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 151856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t init(); 152856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *readBuffer(bool doSeek, FLAC__uint64 sample); 153856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 154856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // no copy constructor or assignment 155856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACParser(const FLACParser &); 156856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLACParser &operator=(const FLACParser &); 157856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 158856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLAC parser callbacks as C++ instance methods 159856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderReadStatus readCallback( 160856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__byte buffer[], size_t *bytes); 161856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderSeekStatus seekCallback( 162856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset); 163856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderTellStatus tellCallback( 164856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset); 165856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderLengthStatus lengthCallback( 166856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length); 167856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__bool eofCallback(); 168856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderWriteStatus writeCallback( 169856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__Frame *frame, const FLAC__int32 * const buffer[]); 170856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void metadataCallback(const FLAC__StreamMetadata *metadata); 171856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void errorCallback(FLAC__StreamDecoderErrorStatus status); 172856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 173856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLAC parser callbacks as C-callable functions 174856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderReadStatus read_callback( 175856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 176856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__byte buffer[], size_t *bytes, 177856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 178856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderSeekStatus seek_callback( 179856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 180856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset, 181856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 182856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderTellStatus tell_callback( 183856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 184856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset, 185856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 186856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderLengthStatus length_callback( 187856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 188856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length, 189856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 190856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__bool eof_callback( 191856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 192856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 193856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static FLAC__StreamDecoderWriteStatus write_callback( 194856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 195856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__Frame *frame, const FLAC__int32 * const buffer[], 196856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 197856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static void metadata_callback( 198856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 199856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata *metadata, 200856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 201856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static void error_callback( 202856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamDecoder *decoder, 203856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderErrorStatus status, 204856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten void *client_data); 205856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 206856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten}; 207856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 208856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// The FLAC parser calls our C++ static callbacks using C calling conventions, 209856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// inside FLAC__stream_decoder_process_until_end_of_metadata 210856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// and FLAC__stream_decoder_process_single. 211856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// We immediately then call our corresponding C++ instance methods 212856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// with the same parameter list, but discard redundant information. 213856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 214856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderReadStatus FLACParser::read_callback( 21584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, FLAC__byte buffer[], 216856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t *bytes, void *client_data) 217856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 218856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->readCallback(buffer, bytes); 219856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 220856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 221856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderSeekStatus FLACParser::seek_callback( 22284333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, 223856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset, void *client_data) 224856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 225856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->seekCallback(absolute_byte_offset); 226856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 227856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 228856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderTellStatus FLACParser::tell_callback( 22984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, 230856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset, void *client_data) 231856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 232856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->tellCallback(absolute_byte_offset); 233856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 234856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 235856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderLengthStatus FLACParser::length_callback( 23684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, 237856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length, void *client_data) 238856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 239856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->lengthCallback(stream_length); 240856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 241856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 242856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__bool FLACParser::eof_callback( 24384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, void *client_data) 244856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 245856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->eofCallback(); 246856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 247856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 248856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderWriteStatus FLACParser::write_callback( 24984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, const FLAC__Frame *frame, 250856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__int32 * const buffer[], void *client_data) 251856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 252856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return ((FLACParser *) client_data)->writeCallback(frame, buffer); 253856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 254856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 255856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::metadata_callback( 25684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, 257856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata *metadata, void *client_data) 258856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 259856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ((FLACParser *) client_data)->metadataCallback(metadata); 260856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 261856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 262856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::error_callback( 26384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const FLAC__StreamDecoder * /* decoder */, 264856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderErrorStatus status, void *client_data) 265856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 266856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ((FLACParser *) client_data)->errorCallback(status); 267856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 268856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 269856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// These are the corresponding callbacks with C++ calling conventions 270856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 271856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderReadStatus FLACParser::readCallback( 272856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__byte buffer[], size_t *bytes) 273856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 274856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t requested = *bytes; 275856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ssize_t actual = mDataSource->readAt(mCurrentPos, buffer, requested); 276856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (0 > actual) { 277856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *bytes = 0; 278856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_READ_STATUS_ABORT; 279856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else if (0 == actual) { 280856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *bytes = 0; 281856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mEOF = true; 282856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; 283856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 284856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten assert(actual <= requested); 285856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *bytes = actual; 286856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCurrentPos += actual; 287856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; 288856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 289856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 290856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 291856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderSeekStatus FLACParser::seekCallback( 292856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 absolute_byte_offset) 293856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 294856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCurrentPos = absolute_byte_offset; 295856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mEOF = false; 296856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_SEEK_STATUS_OK; 297856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 298856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 299856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderTellStatus FLACParser::tellCallback( 300856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *absolute_byte_offset) 301856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 302856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *absolute_byte_offset = mCurrentPos; 303856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_TELL_STATUS_OK; 304856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 305856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 306856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderLengthStatus FLACParser::lengthCallback( 307856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 *stream_length) 308856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 309856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten off64_t size; 310856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (OK == mDataSource->getSize(&size)) { 311856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *stream_length = size; 312856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; 313856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 314856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED; 315856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 316856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 317856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 318856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__bool FLACParser::eofCallback() 319856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 320856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mEOF; 321856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 322856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 323856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLAC__StreamDecoderWriteStatus FLACParser::writeCallback( 324856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__Frame *frame, const FLAC__int32 * const buffer[]) 325856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 326856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mWriteRequested) { 327856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested = false; 328856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLAC parser doesn't free or realloc buffer until next frame or finish 329856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader = frame->header; 330acc192347665943ca674acf117e4f74a88436922Robert Shih memmove(mWriteBuffer, buffer, sizeof(const FLAC__int32 * const) * getChannels()); 331856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted = true; 332856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 333856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 33429357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::writeCallback unexpected"); 335856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 336856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 337856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 338856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 339856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::metadataCallback(const FLAC__StreamMetadata *metadata) 340856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 341856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (metadata->type) { 342856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case FLAC__METADATA_TYPE_STREAMINFO: 343856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!mStreamInfoValid) { 344856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStreamInfo = metadata->data.stream_info; 345856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStreamInfoValid = true; 346856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 34729357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::metadataCallback unexpected STREAMINFO"); 348856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 349856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 350856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case FLAC__METADATA_TYPE_VORBIS_COMMENT: 351856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 352856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata_VorbisComment *vc; 353856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten vc = &metadata->data.vorbis_comment; 354856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (FLAC__uint32 i = 0; i < vc->num_comments; ++i) { 355856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamMetadata_VorbisComment_Entry *vce; 356856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten vce = &vc->comments[i]; 357af2e65ca9a0415e68acfae9497ce445e96fb738aGlenn Kasten if (mFileMetadata != 0 && vce->entry != NULL) { 358856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten parseVorbisComment(mFileMetadata, (const char *) vce->entry, 359856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten vce->length); 360856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 361856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 362856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 363856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 364856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case FLAC__METADATA_TYPE_PICTURE: 365856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mFileMetadata != 0) { 366856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const FLAC__StreamMetadata_Picture *p = &metadata->data.picture; 367856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setData(kKeyAlbumArt, 368856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MetaData::TYPE_NONE, p->data, p->data_length); 369856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setCString(kKeyAlbumArtMIME, p->mime_type); 370856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 371856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 372856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 3735ff1dd576bb93c45b44088a51544a18fc43ebf58Steve Block ALOGW("FLACParser::metadataCallback unexpected type %u", metadata->type); 374856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 375856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 376856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 377856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 378856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::errorCallback(FLAC__StreamDecoderErrorStatus status) 379856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 38029357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::errorCallback status=%d", status); 381856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mErrorStatus = status; 382856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 383856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 384856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// Copy samples from FLAC native 32-bit non-interleaved to 16-bit interleaved. 385856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// These are candidates for optimization if needed. 386856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 38784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyMono8( 38884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 389acc192347665943ca674acf117e4f74a88436922Robert Shih const int * src[FLACParser::kMaxChannels], 39084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 39184333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 392856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 393856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] << 8; 394856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 395856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 396856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 39784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyStereo8( 39884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 399acc192347665943ca674acf117e4f74a88436922Robert Shih const int * src[FLACParser::kMaxChannels], 40084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 40184333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 402856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 403856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] << 8; 404856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i] << 8; 405856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 406856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 407856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 408acc192347665943ca674acf117e4f74a88436922Robert Shihstatic void copyMultiCh8(short *dst, const int * src[FLACParser::kMaxChannels], unsigned nSamples, unsigned nChannels) 4091db91aff064ca986dc4eb14e1722de1b7f18add9Patrik{ 4101db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned i = 0; i < nSamples; ++i) { 4111db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned c = 0; c < nChannels; ++c) { 4121db91aff064ca986dc4eb14e1722de1b7f18add9Patrik *dst++ = src[c][i] << 8; 4131db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4141db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4151db91aff064ca986dc4eb14e1722de1b7f18add9Patrik} 4161db91aff064ca986dc4eb14e1722de1b7f18add9Patrik 41784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyMono16( 41884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 419acc192347665943ca674acf117e4f74a88436922Robert Shih const int * src[FLACParser::kMaxChannels], 42084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 42184333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 422856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 423856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i]; 424856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 425856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 426856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 42784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyStereo16( 42884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 429acc192347665943ca674acf117e4f74a88436922Robert Shih const int * src[FLACParser::kMaxChannels], 43084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 43184333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 432856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 433856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i]; 434856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i]; 435856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 436856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 437856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 438acc192347665943ca674acf117e4f74a88436922Robert Shihstatic void copyMultiCh16(short *dst, const int * src[FLACParser::kMaxChannels], unsigned nSamples, unsigned nChannels) 4391db91aff064ca986dc4eb14e1722de1b7f18add9Patrik{ 4401db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned i = 0; i < nSamples; ++i) { 4411db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned c = 0; c < nChannels; ++c) { 4421db91aff064ca986dc4eb14e1722de1b7f18add9Patrik *dst++ = src[c][i]; 4431db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4441db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4451db91aff064ca986dc4eb14e1722de1b7f18add9Patrik} 4461db91aff064ca986dc4eb14e1722de1b7f18add9Patrik 447856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// 24-bit versions should do dithering or noise-shaping, here or in AudioFlinger 448856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 44984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyMono24( 45084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 451acc192347665943ca674acf117e4f74a88436922Robert Shih const int * src[FLACParser::kMaxChannels], 45284333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 45384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 454856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 455856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] >> 8; 456856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 457856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 458856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 45984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyStereo24( 46084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 461acc192347665943ca674acf117e4f74a88436922Robert Shih const int * src[FLACParser::kMaxChannels], 46284333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 46384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 464856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 465856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] >> 8; 466856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i] >> 8; 467856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 468856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 469856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 470acc192347665943ca674acf117e4f74a88436922Robert Shihstatic void copyMultiCh24(short *dst, const int * src[FLACParser::kMaxChannels], unsigned nSamples, unsigned nChannels) 4711db91aff064ca986dc4eb14e1722de1b7f18add9Patrik{ 4721db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned i = 0; i < nSamples; ++i) { 4731db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned c = 0; c < nChannels; ++c) { 4741db91aff064ca986dc4eb14e1722de1b7f18add9Patrik *dst++ = src[c][i] >> 8; 4751db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4761db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4771db91aff064ca986dc4eb14e1722de1b7f18add9Patrik} 4781db91aff064ca986dc4eb14e1722de1b7f18add9Patrik 47984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyTrespass( 48084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short * /* dst */, 481acc192347665943ca674acf117e4f74a88436922Robert Shih const int *[FLACParser::kMaxChannels] /* src */, 48284333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nSamples */, 48384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 484856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten TRESPASS(); 485856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 486856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 487856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACParser 488856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 489856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACParser::FLACParser( 490856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 491856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &fileMetadata, 492856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata) 493856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 494856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata(fileMetadata), 495856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata(trackMetadata), 496856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false), 497856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mMaxBufferSize(0), 498856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup(NULL), 499856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCopy(copyTrespass), 500856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder(NULL), 501856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCurrentPos(0LL), 502856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mEOF(false), 503856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStreamInfoValid(false), 504856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested(false), 505856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted(false), 506856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mErrorStatus((FLAC__StreamDecoderErrorStatus) -1) 507856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 5083856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::FLACParser"); 509856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten memset(&mStreamInfo, 0, sizeof(mStreamInfo)); 510856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten memset(&mWriteHeader, 0, sizeof(mWriteHeader)); 511856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 512856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 513856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 514856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACParser::~FLACParser() 515856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 5163856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::~FLACParser"); 517856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mDecoder != NULL) { 518856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_delete(mDecoder); 519856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder = NULL; 520856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 521856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 522856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 523856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACParser::init() 524856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 525856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // setup libFLAC parser 526856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder = FLAC__stream_decoder_new(); 527856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mDecoder == NULL) { 528856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // The new should succeed, since probably all it does is a malloc 529856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // that always succeeds in Android. But to avoid dependence on the 530856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // libFLAC internals, we check and log here. 53129357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("new failed"); 532856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 533856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 534856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_md5_checking(mDecoder, false); 535856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_ignore_all(mDecoder); 536856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 537856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_STREAMINFO); 538856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 539856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_PICTURE); 540856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 541856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); 542856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderInitStatus initStatus; 543856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten initStatus = FLAC__stream_decoder_init_stream( 544856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, 545856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten read_callback, seek_callback, tell_callback, 546856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten length_callback, eof_callback, write_callback, 547856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten metadata_callback, error_callback, (void *) this); 548856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) { 549856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // A failure here probably indicates a programming error and so is 550856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // unlikely to happen. But we check and log here similarly to above. 55129357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("init_stream failed %d", initStatus); 552856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 553856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 554856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // parse all metadata 555856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_process_until_end_of_metadata(mDecoder)) { 55629357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("end_of_metadata failed"); 557856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 558856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 559856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mStreamInfoValid) { 560856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check channel count 561acc192347665943ca674acf117e4f74a88436922Robert Shih if (getChannels() == 0 || getChannels() > kMaxChannels) { 56229357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported channel count %u", getChannels()); 563856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 564856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 565856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check bit depth 566856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (getBitsPerSample()) { 567856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 8: 568856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 16: 569856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 24: 570856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 571856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 57229357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported bits per sample %u", getBitsPerSample()); 573856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 574856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 575856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check sample rate 576856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (getSampleRate()) { 577856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 8000: 578856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 11025: 579856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 12000: 580856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 16000: 581856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 22050: 582856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 24000: 583856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 32000: 584856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 44100: 585856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 48000: 5861db91aff064ca986dc4eb14e1722de1b7f18add9Patrik case 88200: 5871db91aff064ca986dc4eb14e1722de1b7f18add9Patrik case 96000: 588856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 589856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 59029357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported sample rate %u", getSampleRate()); 591856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 592856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 593856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // configure the appropriate copy function, defaulting to trespass 594856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static const struct { 595856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned mChannels; 596856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned mBitsPerSample; 597acc192347665943ca674acf117e4f74a88436922Robert Shih void (*mCopy)(short *dst, const int * src[kMaxChannels], unsigned nSamples, unsigned nChannels); 598856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } table[] = { 599856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 8, copyMono8 }, 600856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 8, copyStereo8 }, 6011db91aff064ca986dc4eb14e1722de1b7f18add9Patrik { 8, 8, copyMultiCh8 }, 602856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 16, copyMono16 }, 603856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 16, copyStereo16 }, 6041db91aff064ca986dc4eb14e1722de1b7f18add9Patrik { 8, 16, copyMultiCh16 }, 605856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 24, copyMono24 }, 606856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 24, copyStereo24 }, 6071db91aff064ca986dc4eb14e1722de1b7f18add9Patrik { 8, 24, copyMultiCh24 }, 608856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten }; 609856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < sizeof(table)/sizeof(table[0]); ++i) { 6101db91aff064ca986dc4eb14e1722de1b7f18add9Patrik if (table[i].mChannels >= getChannels() && 611856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten table[i].mBitsPerSample == getBitsPerSample()) { 612856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCopy = table[i].mCopy; 613856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 614856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 615856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 616856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // populate track metadata 617856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mTrackMetadata != 0) { 618856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW); 619856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt32(kKeyChannelCount, getChannels()); 620856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt32(kKeySampleRate, getSampleRate()); 62178bd91b15ee8ea5aa2ab5a8cad7e892cb2d01c1bLajos Molnar mTrackMetadata->setInt32(kKeyPcmEncoding, kAudioEncodingPcm16bit); 622856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample rate is non-zero, so division by zero not possible 623856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt64(kKeyDuration, 624856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten (getTotalSamples() * 1000000LL) / getSampleRate()); 625856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 626856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 62729357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("missing STREAMINFO"); 628856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 629856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 630856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mFileMetadata != 0) { 631856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC); 632856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 633856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 634856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 635856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 636856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::allocateBuffers() 637856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 638856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup == NULL); 639856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = new MediaBufferGroup; 640856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mMaxBufferSize = getMaxBlockSize() * getChannels() * sizeof(short); 641856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup->add_buffer(new MediaBuffer(mMaxBufferSize)); 642856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 643856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 644856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::releaseBuffers() 645856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 646856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 647856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten delete mGroup; 648856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = NULL; 649856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 650856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 651856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenMediaBuffer *FLACParser::readBuffer(bool doSeek, FLAC__uint64 sample) 652856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 653856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested = true; 654856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted = false; 655856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (doSeek) { 656856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // We implement the seek callback, so this works without explicit flush 657856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_seek_absolute(mDecoder, sample)) { 658ee4e1b1a63758941460ae79a064249d3a5189443Lajos Molnar ALOGE("FLACParser::readBuffer seek to sample %lld failed", (long long)sample); 659856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 660856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 661ee4e1b1a63758941460ae79a064249d3a5189443Lajos Molnar ALOGV("FLACParser::readBuffer seek to sample %lld succeeded", (long long)sample); 662856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 663856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_process_single(mDecoder)) { 66429357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer process_single failed"); 665856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 666856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 667856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 668856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!mWriteCompleted) { 6693856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::readBuffer write did not complete"); 670856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 671856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 672856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // verify that block header keeps the promises made by STREAMINFO 673856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned blocksize = mWriteHeader.blocksize; 674856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (blocksize == 0 || blocksize > getMaxBlockSize()) { 67529357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer write invalid blocksize %u", blocksize); 676856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 677856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 678856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mWriteHeader.sample_rate != getSampleRate() || 679856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.channels != getChannels() || 680856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.bits_per_sample != getBitsPerSample()) { 6818af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen ALOGE("FLACParser::readBuffer write changed parameters mid-stream: %d/%d/%d -> %d/%d/%d", 6828af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen getSampleRate(), getChannels(), getBitsPerSample(), 6838af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen mWriteHeader.sample_rate, mWriteHeader.channels, mWriteHeader.bits_per_sample); 6848af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen return NULL; 685856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 686856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // acquire a media buffer 687856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 688856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 689856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t err = mGroup->acquire_buffer(&buffer); 690856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (err != OK) { 691856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 692856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 693856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t bufferSize = blocksize * getChannels() * sizeof(short); 694856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(bufferSize <= mMaxBufferSize); 695856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten short *data = (short *) buffer->data(); 696856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->set_range(0, bufferSize); 697856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // copy PCM from FLAC write buffer to our media buffer, with interleaving 6981db91aff064ca986dc4eb14e1722de1b7f18add9Patrik (*mCopy)(data, mWriteBuffer, blocksize, getChannels()); 699856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // fill in buffer metadata 700856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mWriteHeader.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); 701856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sampleNumber = mWriteHeader.number.sample_number; 702856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t timeUs = (1000000LL * sampleNumber) / getSampleRate(); 703856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt64(kKeyTime, timeUs); 704856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); 705856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer; 706856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 707856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 708856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACsource 709856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 710856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::FLACSource( 711856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 712856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata) 713856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 714856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata(trackMetadata), 715856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser(0), 716856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false), 717856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted(false) 718856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7193856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::FLACSource"); 720856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 721856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 722856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 723856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::~FLACSource() 724856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7253856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACSource::FLACSource"); 726856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mStarted) { 727856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten stop(); 728856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 729856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 730856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 73184333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatus_t FLACSource::start(MetaData * /* params */) 732856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7333856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::start"); 734856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 735856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(!mStarted); 736856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->allocateBuffers(); 737856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = true; 738856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 739856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 740856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 741856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 742856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::stop() 743856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7443856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::stop"); 745856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 746856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mStarted); 747856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->releaseBuffers(); 748856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = false; 749856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 750856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 751856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 752856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 753856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACSource::getFormat() 754856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 755856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 756856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 757856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 758856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::read( 759856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer **outBuffer, const ReadOptions *options) 760856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 761856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 762856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // process an optional seek request 763856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t seekTimeUs; 764856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ReadOptions::SeekMode mode; 765856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if ((NULL != options) && options->getSeekTo(&seekTimeUs, &mode)) { 766856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sample; 767856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (seekTimeUs <= 0LL) { 768856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = 0LL; 769856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 770856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample and total samples are both zero-based, and seek to EOF ok 771856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = (seekTimeUs * mParser->getSampleRate()) / 1000000LL; 772856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (sample >= mParser->getTotalSamples()) { 773856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = mParser->getTotalSamples(); 774856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 775856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 776856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(sample); 777856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // otherwise read sequentially 778856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 779856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(); 780856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 781856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *outBuffer = buffer; 782856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer != NULL ? (status_t) OK : (status_t) ERROR_END_OF_STREAM; 783856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 784856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 785856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::init() 786856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7873856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::init"); 788856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // re-use the same track metadata passed into constructor from FLACExtractor 789856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource); 790856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 791856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 792856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 793856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACExtractor 794856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 795856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::FLACExtractor( 796856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource) 797856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 798856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false) 799856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 8003856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACExtractor::FLACExtractor"); 801856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 802856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 803856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 804856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::~FLACExtractor() 805856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 8063856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACExtractor::FLACExtractor"); 807856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 808856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 809856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensize_t FLACExtractor::countTracks() 810856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 811856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mInitCheck == OK ? 1 : 0; 812856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 813856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 814b2487f03f12dcafdb801fc0007c8df8412397f44Marco Nelissensp<IMediaSource> FLACExtractor::getTrack(size_t index) 815856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 816856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 817856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 818856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 819856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return new FLACSource(mDataSource, mTrackMetadata); 820856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 821856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 822856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getTrackMetaData( 82384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber size_t index, uint32_t /* flags */) { 824856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 825856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 826856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 827856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 828856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 829856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 830856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACExtractor::init() 831856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 832856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata = new MetaData; 833856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata = new MetaData; 834856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLACParser will fill in the metadata for us 835856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource, mFileMetadata, mTrackMetadata); 836856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 837856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 838856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 839856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getMetaData() 840856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 841856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mFileMetadata; 842856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 843856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 844856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// Sniffer 845856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 846856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenbool SniffFLAC( 847856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &source, String8 *mimeType, float *confidence, 848856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<AMessage> *) 849856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 850856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // first 4 is the signature word 851856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // second 4 is the sizeof STREAMINFO 852856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // 042 is the mandatory STREAMINFO 853856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // no need to read rest of the header, as a premature EOF will be caught later 854856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten uint8_t header[4+4]; 855856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (source->readAt(0, header, sizeof(header)) != sizeof(header) 856856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten || memcmp("fLaC\0\0\0\042", header, 4+4)) 857856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 858856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return false; 859856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 860856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 861856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *mimeType = MEDIA_MIMETYPE_AUDIO_FLAC; 862856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *confidence = 0.5; 863856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 864856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return true; 865856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 866856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 867856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} // namespace android 868