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; 1251db91aff064ca986dc4eb14e1722de1b7f18add9Patrik void (*mCopy)(short *dst, const int *const *src, unsigned nSamples, unsigned nChannels); 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( 21184333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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( 21884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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( 22584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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( 23284333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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( 23984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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( 24584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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( 25284333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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( 25984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber 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 38384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyMono8( 38484333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 38584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const int *const *src, 38684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 38784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 388856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 389856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] << 8; 390856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 391856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 392856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 39384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyStereo8( 39484333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 39584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const int *const *src, 39684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 39784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 398856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 399856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] << 8; 400856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i] << 8; 401856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 402856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 403856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 4041db91aff064ca986dc4eb14e1722de1b7f18add9Patrikstatic void copyMultiCh8(short *dst, const int *const *src, unsigned nSamples, unsigned nChannels) 4051db91aff064ca986dc4eb14e1722de1b7f18add9Patrik{ 4061db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned i = 0; i < nSamples; ++i) { 4071db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned c = 0; c < nChannels; ++c) { 4081db91aff064ca986dc4eb14e1722de1b7f18add9Patrik *dst++ = src[c][i] << 8; 4091db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4101db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4111db91aff064ca986dc4eb14e1722de1b7f18add9Patrik} 4121db91aff064ca986dc4eb14e1722de1b7f18add9Patrik 41384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyMono16( 41484333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 41584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const int *const *src, 41684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 41784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 418856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 419856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i]; 420856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 421856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 422856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 42384333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyStereo16( 42484333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 42584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const int *const *src, 42684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 42784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 428856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 429856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i]; 430856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i]; 431856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 432856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 433856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 4341db91aff064ca986dc4eb14e1722de1b7f18add9Patrikstatic void copyMultiCh16(short *dst, const int *const *src, unsigned nSamples, unsigned nChannels) 4351db91aff064ca986dc4eb14e1722de1b7f18add9Patrik{ 4361db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned i = 0; i < nSamples; ++i) { 4371db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned c = 0; c < nChannels; ++c) { 4381db91aff064ca986dc4eb14e1722de1b7f18add9Patrik *dst++ = src[c][i]; 4391db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4401db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4411db91aff064ca986dc4eb14e1722de1b7f18add9Patrik} 4421db91aff064ca986dc4eb14e1722de1b7f18add9Patrik 443856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// 24-bit versions should do dithering or noise-shaping, here or in AudioFlinger 444856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 44584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyMono24( 44684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 44784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const int *const *src, 44884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 44984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 450856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 451856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] >> 8; 452856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 453856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 454856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 45584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyStereo24( 45684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short *dst, 45784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const int *const *src, 45884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned nSamples, 45984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 460856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < nSamples; ++i) { 461856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[0][i] >> 8; 462856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *dst++ = src[1][i] >> 8; 463856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 464856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 465856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 4661db91aff064ca986dc4eb14e1722de1b7f18add9Patrikstatic void copyMultiCh24(short *dst, const int *const *src, unsigned nSamples, unsigned nChannels) 4671db91aff064ca986dc4eb14e1722de1b7f18add9Patrik{ 4681db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned i = 0; i < nSamples; ++i) { 4691db91aff064ca986dc4eb14e1722de1b7f18add9Patrik for (unsigned c = 0; c < nChannels; ++c) { 4701db91aff064ca986dc4eb14e1722de1b7f18add9Patrik *dst++ = src[c][i] >> 8; 4711db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4721db91aff064ca986dc4eb14e1722de1b7f18add9Patrik } 4731db91aff064ca986dc4eb14e1722de1b7f18add9Patrik} 4741db91aff064ca986dc4eb14e1722de1b7f18add9Patrik 47584333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatic void copyTrespass( 47684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber short * /* dst */, 47784333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber const int *const * /* src */, 47884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nSamples */, 47984333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber unsigned /* nChannels */) { 480856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten TRESPASS(); 481856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 482856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 483856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACParser 484856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 485856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACParser::FLACParser( 486856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 487856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &fileMetadata, 488856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata) 489856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 490856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata(fileMetadata), 491856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata(trackMetadata), 492856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false), 493856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mMaxBufferSize(0), 494856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup(NULL), 495856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCopy(copyTrespass), 496856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder(NULL), 497856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCurrentPos(0LL), 498856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mEOF(false), 499856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStreamInfoValid(false), 500856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested(false), 501856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted(false), 502856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteBuffer(NULL), 503856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mErrorStatus((FLAC__StreamDecoderErrorStatus) -1) 504856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 5053856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::FLACParser"); 506856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten memset(&mStreamInfo, 0, sizeof(mStreamInfo)); 507856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten memset(&mWriteHeader, 0, sizeof(mWriteHeader)); 508856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 509856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 510856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 511856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACParser::~FLACParser() 512856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 5133856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::~FLACParser"); 514856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mDecoder != NULL) { 515856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_delete(mDecoder); 516856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder = NULL; 517856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 518856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 519856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 520856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACParser::init() 521856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 522856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // setup libFLAC parser 523856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder = FLAC__stream_decoder_new(); 524856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mDecoder == NULL) { 525856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // The new should succeed, since probably all it does is a malloc 526856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // that always succeeds in Android. But to avoid dependence on the 527856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // libFLAC internals, we check and log here. 52829357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("new failed"); 529856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 530856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 531856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_md5_checking(mDecoder, false); 532856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_ignore_all(mDecoder); 533856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 534856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_STREAMINFO); 535856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 536856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_PICTURE); 537856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__stream_decoder_set_metadata_respond( 538856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); 539856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__StreamDecoderInitStatus initStatus; 540856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten initStatus = FLAC__stream_decoder_init_stream( 541856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mDecoder, 542856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten read_callback, seek_callback, tell_callback, 543856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten length_callback, eof_callback, write_callback, 544856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten metadata_callback, error_callback, (void *) this); 545856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) { 546856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // A failure here probably indicates a programming error and so is 547856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // unlikely to happen. But we check and log here similarly to above. 54829357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("init_stream failed %d", initStatus); 549856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 550856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 551856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // parse all metadata 552856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_process_until_end_of_metadata(mDecoder)) { 55329357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("end_of_metadata failed"); 554856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 555856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 556856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mStreamInfoValid) { 557856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check channel count 5581db91aff064ca986dc4eb14e1722de1b7f18add9Patrik if (getChannels() == 0 || getChannels() > 8) { 55929357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported channel count %u", getChannels()); 560856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 561856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 562856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check bit depth 563856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (getBitsPerSample()) { 564856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 8: 565856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 16: 566856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 24: 567856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 568856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 56929357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported bits per sample %u", getBitsPerSample()); 570856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 571856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 572856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // check sample rate 573856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten switch (getSampleRate()) { 574856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 8000: 575856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 11025: 576856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 12000: 577856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 16000: 578856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 22050: 579856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 24000: 580856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 32000: 581856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 44100: 582856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten case 48000: 5831db91aff064ca986dc4eb14e1722de1b7f18add9Patrik case 88200: 5841db91aff064ca986dc4eb14e1722de1b7f18add9Patrik case 96000: 585856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 586856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten default: 58729357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("unsupported sample rate %u", getSampleRate()); 588856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 589856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 590856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // configure the appropriate copy function, defaulting to trespass 591856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten static const struct { 592856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned mChannels; 593856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned mBitsPerSample; 5941db91aff064ca986dc4eb14e1722de1b7f18add9Patrik void (*mCopy)(short *dst, const int *const *src, unsigned nSamples, unsigned nChannels); 595856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } table[] = { 596856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 8, copyMono8 }, 597856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 8, copyStereo8 }, 5981db91aff064ca986dc4eb14e1722de1b7f18add9Patrik { 8, 8, copyMultiCh8 }, 599856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 16, copyMono16 }, 600856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 16, copyStereo16 }, 6011db91aff064ca986dc4eb14e1722de1b7f18add9Patrik { 8, 16, copyMultiCh16 }, 602856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 1, 24, copyMono24 }, 603856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 2, 24, copyStereo24 }, 6041db91aff064ca986dc4eb14e1722de1b7f18add9Patrik { 8, 24, copyMultiCh24 }, 605856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten }; 606856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten for (unsigned i = 0; i < sizeof(table)/sizeof(table[0]); ++i) { 6071db91aff064ca986dc4eb14e1722de1b7f18add9Patrik if (table[i].mChannels >= getChannels() && 608856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten table[i].mBitsPerSample == getBitsPerSample()) { 609856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mCopy = table[i].mCopy; 610856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten break; 611856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 612856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 613856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // populate track metadata 614856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mTrackMetadata != 0) { 615856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW); 616856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt32(kKeyChannelCount, getChannels()); 617856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt32(kKeySampleRate, getSampleRate()); 61878bd91b15ee8ea5aa2ab5a8cad7e892cb2d01c1bLajos Molnar mTrackMetadata->setInt32(kKeyPcmEncoding, kAudioEncodingPcm16bit); 619856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample rate is non-zero, so division by zero not possible 620856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt64(kKeyDuration, 621856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten (getTotalSamples() * 1000000LL) / getSampleRate()); 622856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 623856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 62429357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("missing STREAMINFO"); 625856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 626856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 627856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mFileMetadata != 0) { 628856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC); 629856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 630856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 631856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 632856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 633856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::allocateBuffers() 634856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 635856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup == NULL); 636856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = new MediaBufferGroup; 637856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mMaxBufferSize = getMaxBlockSize() * getChannels() * sizeof(short); 638856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup->add_buffer(new MediaBuffer(mMaxBufferSize)); 639856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 640856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 641856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::releaseBuffers() 642856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 643856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 644856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten delete mGroup; 645856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = NULL; 646856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 647856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 648856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenMediaBuffer *FLACParser::readBuffer(bool doSeek, FLAC__uint64 sample) 649856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 650856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested = true; 651856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted = false; 652856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (doSeek) { 653856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // We implement the seek callback, so this works without explicit flush 654856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_seek_absolute(mDecoder, sample)) { 655ee4e1b1a63758941460ae79a064249d3a5189443Lajos Molnar ALOGE("FLACParser::readBuffer seek to sample %lld failed", (long long)sample); 656856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 657856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 658ee4e1b1a63758941460ae79a064249d3a5189443Lajos Molnar ALOGV("FLACParser::readBuffer seek to sample %lld succeeded", (long long)sample); 659856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 660856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_process_single(mDecoder)) { 66129357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer process_single failed"); 662856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 663856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 664856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 665856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!mWriteCompleted) { 6663856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::readBuffer write did not complete"); 667856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 668856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 669856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // verify that block header keeps the promises made by STREAMINFO 670856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned blocksize = mWriteHeader.blocksize; 671856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (blocksize == 0 || blocksize > getMaxBlockSize()) { 67229357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer write invalid blocksize %u", blocksize); 673856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 674856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 675856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mWriteHeader.sample_rate != getSampleRate() || 676856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.channels != getChannels() || 677856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.bits_per_sample != getBitsPerSample()) { 6788af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen ALOGE("FLACParser::readBuffer write changed parameters mid-stream: %d/%d/%d -> %d/%d/%d", 6798af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen getSampleRate(), getChannels(), getBitsPerSample(), 6808af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen mWriteHeader.sample_rate, mWriteHeader.channels, mWriteHeader.bits_per_sample); 6818af1b90d4161e287bdcb03c91832c425363ded16Marco Nelissen return NULL; 682856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 683856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // acquire a media buffer 684856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 685856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 686856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t err = mGroup->acquire_buffer(&buffer); 687856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (err != OK) { 688856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 689856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 690856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t bufferSize = blocksize * getChannels() * sizeof(short); 691856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(bufferSize <= mMaxBufferSize); 692856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten short *data = (short *) buffer->data(); 693856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->set_range(0, bufferSize); 694856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // copy PCM from FLAC write buffer to our media buffer, with interleaving 6951db91aff064ca986dc4eb14e1722de1b7f18add9Patrik (*mCopy)(data, mWriteBuffer, blocksize, getChannels()); 696856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // fill in buffer metadata 697856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mWriteHeader.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); 698856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sampleNumber = mWriteHeader.number.sample_number; 699856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t timeUs = (1000000LL * sampleNumber) / getSampleRate(); 700856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt64(kKeyTime, timeUs); 701856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); 702856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer; 703856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 704856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 705856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACsource 706856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 707856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::FLACSource( 708856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 709856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata) 710856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 711856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata(trackMetadata), 712856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser(0), 713856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false), 714856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted(false) 715856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7163856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::FLACSource"); 717856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 718856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 719856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 720856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::~FLACSource() 721856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7223856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACSource::FLACSource"); 723856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mStarted) { 724856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten stop(); 725856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 726856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 727856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 72884333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatus_t FLACSource::start(MetaData * /* params */) 729856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7303856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::start"); 731856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 732856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(!mStarted); 733856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->allocateBuffers(); 734856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = true; 735856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 736856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 737856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 738856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 739856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::stop() 740856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7413856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::stop"); 742856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 743856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mStarted); 744856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->releaseBuffers(); 745856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = false; 746856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 747856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 748856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 749856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 750856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACSource::getFormat() 751856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 752856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 753856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 754856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 755856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::read( 756856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer **outBuffer, const ReadOptions *options) 757856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 758856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 759856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // process an optional seek request 760856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t seekTimeUs; 761856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ReadOptions::SeekMode mode; 762856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if ((NULL != options) && options->getSeekTo(&seekTimeUs, &mode)) { 763856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sample; 764856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (seekTimeUs <= 0LL) { 765856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = 0LL; 766856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 767856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample and total samples are both zero-based, and seek to EOF ok 768856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = (seekTimeUs * mParser->getSampleRate()) / 1000000LL; 769856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (sample >= mParser->getTotalSamples()) { 770856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = mParser->getTotalSamples(); 771856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 772856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 773856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(sample); 774856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // otherwise read sequentially 775856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 776856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(); 777856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 778856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *outBuffer = buffer; 779856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer != NULL ? (status_t) OK : (status_t) ERROR_END_OF_STREAM; 780856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 781856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 782856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::init() 783856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7843856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::init"); 785856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // re-use the same track metadata passed into constructor from FLACExtractor 786856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource); 787856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 788856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 789856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 790856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACExtractor 791856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 792856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::FLACExtractor( 793856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource) 794856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 795856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false) 796856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7973856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACExtractor::FLACExtractor"); 798856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 799856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 800856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 801856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::~FLACExtractor() 802856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 8033856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACExtractor::FLACExtractor"); 804856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 805856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 806856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensize_t FLACExtractor::countTracks() 807856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 808856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mInitCheck == OK ? 1 : 0; 809856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 810856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 811b2487f03f12dcafdb801fc0007c8df8412397f44Marco Nelissensp<IMediaSource> FLACExtractor::getTrack(size_t index) 812856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 813856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 814856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 815856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 816856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return new FLACSource(mDataSource, mTrackMetadata); 817856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 818856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 819856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getTrackMetaData( 82084333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber size_t index, uint32_t /* flags */) { 821856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 822856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 823856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 824856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 825856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 826856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 827856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACExtractor::init() 828856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 829856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata = new MetaData; 830856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata = new MetaData; 831856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLACParser will fill in the metadata for us 832856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource, mFileMetadata, mTrackMetadata); 833856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 834856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 835856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 836856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getMetaData() 837856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 838856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mFileMetadata; 839856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 840856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 841856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// Sniffer 842856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 843856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenbool SniffFLAC( 844856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &source, String8 *mimeType, float *confidence, 845856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<AMessage> *) 846856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 847856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // first 4 is the signature word 848856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // second 4 is the sizeof STREAMINFO 849856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // 042 is the mandatory STREAMINFO 850856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // no need to read rest of the header, as a premature EOF will be caught later 851856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten uint8_t header[4+4]; 852856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (source->readAt(0, header, sizeof(header)) != sizeof(header) 853856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten || memcmp("fLaC\0\0\0\042", header, 4+4)) 854856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 855856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return false; 856856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 857856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 858856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *mimeType = MEDIA_MIMETYPE_AUDIO_FLAC; 859856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *confidence = 0.5; 860856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 861856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return true; 862856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 863856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 864856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} // namespace android 865