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()); 618856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample rate is non-zero, so division by zero not possible 619856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata->setInt64(kKeyDuration, 620856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten (getTotalSamples() * 1000000LL) / getSampleRate()); 621856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 622856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 62329357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("missing STREAMINFO"); 624856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NO_INIT; 625856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 626856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mFileMetadata != 0) { 627856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC); 628856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 629856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 630856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 631856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 632856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::allocateBuffers() 633856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 634856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup == NULL); 635856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = new MediaBufferGroup; 636856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mMaxBufferSize = getMaxBlockSize() * getChannels() * sizeof(short); 637856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup->add_buffer(new MediaBuffer(mMaxBufferSize)); 638856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 639856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 640856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenvoid FLACParser::releaseBuffers() 641856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 642856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 643856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten delete mGroup; 644856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mGroup = NULL; 645856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 646856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 647856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenMediaBuffer *FLACParser::readBuffer(bool doSeek, FLAC__uint64 sample) 648856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 649856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteRequested = true; 650856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteCompleted = false; 651856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (doSeek) { 652856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // We implement the seek callback, so this works without explicit flush 653856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_seek_absolute(mDecoder, sample)) { 65429357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer seek to sample %llu failed", sample); 655856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 656856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 6573856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::readBuffer seek to sample %llu succeeded", sample); 658856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 659856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!FLAC__stream_decoder_process_single(mDecoder)) { 66029357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer process_single failed"); 661856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 662856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 663856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 664856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (!mWriteCompleted) { 6653856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACParser::readBuffer write did not complete"); 666856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 667856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 668856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // verify that block header keeps the promises made by STREAMINFO 669856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten unsigned blocksize = mWriteHeader.blocksize; 670856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (blocksize == 0 || blocksize > getMaxBlockSize()) { 67129357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer write invalid blocksize %u", blocksize); 672856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 673856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 674856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mWriteHeader.sample_rate != getSampleRate() || 675856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.channels != getChannels() || 676856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mWriteHeader.bits_per_sample != getBitsPerSample()) { 67729357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block ALOGE("FLACParser::readBuffer write changed parameters mid-stream"); 678856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 679856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // acquire a media buffer 680856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mGroup != NULL); 681856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 682856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten status_t err = mGroup->acquire_buffer(&buffer); 683856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (err != OK) { 684856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 685856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 686856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten size_t bufferSize = blocksize * getChannels() * sizeof(short); 687856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(bufferSize <= mMaxBufferSize); 688856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten short *data = (short *) buffer->data(); 689856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->set_range(0, bufferSize); 690856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // copy PCM from FLAC write buffer to our media buffer, with interleaving 6911db91aff064ca986dc4eb14e1722de1b7f18add9Patrik (*mCopy)(data, mWriteBuffer, blocksize, getChannels()); 692856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // fill in buffer metadata 693856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mWriteHeader.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); 694856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sampleNumber = mWriteHeader.number.sample_number; 695856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t timeUs = (1000000LL * sampleNumber) / getSampleRate(); 696856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt64(kKeyTime, timeUs); 697856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); 698856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer; 699856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 700856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 701856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACsource 702856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 703856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::FLACSource( 704856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource, 705856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<MetaData> &trackMetadata) 706856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 707856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata(trackMetadata), 708856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser(0), 709856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false), 710856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted(false) 711856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7123856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::FLACSource"); 713856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 714856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 715856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 716856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACSource::~FLACSource() 717856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7183856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACSource::FLACSource"); 719856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mStarted) { 720856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten stop(); 721856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 722856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 723856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 72484333e0475bc911adc16417f4ca327c975cf6c36Andreas Huberstatus_t FLACSource::start(MetaData * /* params */) 725856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7263856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::start"); 727856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 728856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(!mStarted); 729856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->allocateBuffers(); 730856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = true; 731856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 732856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 733856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 734856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 735856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::stop() 736856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7373856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::stop"); 738856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 739856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten CHECK(mStarted); 740856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser->releaseBuffers(); 741856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mStarted = false; 742856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 743856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return OK; 744856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 745856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 746856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACSource::getFormat() 747856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 748856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 749856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 750856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 751856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::read( 752856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer **outBuffer, const ReadOptions *options) 753856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 754856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten MediaBuffer *buffer; 755856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // process an optional seek request 756856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten int64_t seekTimeUs; 757856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten ReadOptions::SeekMode mode; 758856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if ((NULL != options) && options->getSeekTo(&seekTimeUs, &mode)) { 759856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten FLAC__uint64 sample; 760856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (seekTimeUs <= 0LL) { 761856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = 0LL; 762856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 763856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // sample and total samples are both zero-based, and seek to EOF ok 764856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = (seekTimeUs * mParser->getSampleRate()) / 1000000LL; 765856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (sample >= mParser->getTotalSamples()) { 766856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sample = mParser->getTotalSamples(); 767856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 768856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 769856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(sample); 770856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // otherwise read sequentially 771856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } else { 772856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten buffer = mParser->readBuffer(); 773856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 774856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *outBuffer = buffer; 775856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return buffer != NULL ? (status_t) OK : (status_t) ERROR_END_OF_STREAM; 776856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 777856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 778856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACSource::init() 779856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7803856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACSource::init"); 781856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // re-use the same track metadata passed into constructor from FLACExtractor 782856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource); 783856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 784856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 785856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 786856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// FLACExtractor 787856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 788856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::FLACExtractor( 789856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &dataSource) 790856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten : mDataSource(dataSource), 791856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck(false) 792856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7933856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("FLACExtractor::FLACExtractor"); 794856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mInitCheck = init(); 795856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 796856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 797856990b491d84b7ed4fefe337485c8997ba9dd02Glenn KastenFLACExtractor::~FLACExtractor() 798856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 7993856b090cd04ba5dd4a59a12430ed724d5995909Steve Block ALOGV("~FLACExtractor::FLACExtractor"); 800856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 801856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 802856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensize_t FLACExtractor::countTracks() 803856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 804856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mInitCheck == OK ? 1 : 0; 805856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 806856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 807856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MediaSource> FLACExtractor::getTrack(size_t index) 808856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 809856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 810856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 811856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 812856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return new FLACSource(mDataSource, mTrackMetadata); 813856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 814856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 815856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getTrackMetaData( 81684333e0475bc911adc16417f4ca327c975cf6c36Andreas Huber size_t index, uint32_t /* flags */) { 817856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (mInitCheck != OK || index > 0) { 818856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return NULL; 819856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 820856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mTrackMetadata; 821856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 822856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 823856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenstatus_t FLACExtractor::init() 824856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 825856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mFileMetadata = new MetaData; 826856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mTrackMetadata = new MetaData; 827856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // FLACParser will fill in the metadata for us 828856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten mParser = new FLACParser(mDataSource, mFileMetadata, mTrackMetadata); 829856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mParser->initCheck(); 830856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 831856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 832856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastensp<MetaData> FLACExtractor::getMetaData() 833856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 834856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return mFileMetadata; 835856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 836856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 837856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten// Sniffer 838856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 839856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kastenbool SniffFLAC( 840856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten const sp<DataSource> &source, String8 *mimeType, float *confidence, 841856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten sp<AMessage> *) 842856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten{ 843856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // first 4 is the signature word 844856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // second 4 is the sizeof STREAMINFO 845856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // 042 is the mandatory STREAMINFO 846856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten // no need to read rest of the header, as a premature EOF will be caught later 847856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten uint8_t header[4+4]; 848856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten if (source->readAt(0, header, sizeof(header)) != sizeof(header) 849856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten || memcmp("fLaC\0\0\0\042", header, 4+4)) 850856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten { 851856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return false; 852856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten } 853856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 854856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *mimeType = MEDIA_MIMETYPE_AUDIO_FLAC; 855856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten *confidence = 0.5; 856856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 857856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten return true; 858856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} 859856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten 860856990b491d84b7ed4fefe337485c8997ba9dd02Glenn Kasten} // namespace android 861