diff options
27 files changed, 809 insertions, 41 deletions
diff --git a/cmds/stagefright/sf2.cpp b/cmds/stagefright/sf2.cpp index e47cdc0..64df5d1 100644 --- a/cmds/stagefright/sf2.cpp +++ b/cmds/stagefright/sf2.cpp @@ -176,8 +176,9 @@ protected: } onDrainThisBuffer(msg); - } else if (what == ACodec::kWhatEOS) { - printf("$\n"); + } else if (what == ACodec::kWhatEOS + || what == ACodec::kWhatError) { + printf((what == ACodec::kWhatEOS) ? "$\n" : "E\n"); int64_t delayUs = ALooper::GetNowUs() - mStartTimeUs; @@ -412,7 +413,8 @@ private: sp<AMessage> reply; CHECK(msg->findMessage("reply", &reply)); - if (mSeekState == SEEK_FLUSHING) { + if (mSource == NULL || mSeekState == SEEK_FLUSHING) { + reply->setInt32("err", ERROR_END_OF_STREAM); reply->post(); return; } diff --git a/include/media/AudioTrack.h b/include/media/AudioTrack.h index ad27a1e..7d5d772 100644 --- a/include/media/AudioTrack.h +++ b/include/media/AudioTrack.h @@ -476,8 +476,7 @@ protected: int frameCount, audio_policy_output_flags_t flags, const sp<IMemory>& sharedBuffer, - audio_io_handle_t output, - bool enforceFrameCount); + audio_io_handle_t output); void flush_l(); status_t setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount); audio_io_handle_t getOutput_l(); diff --git a/include/media/stagefright/MetaData.h b/include/media/stagefright/MetaData.h index 00b8679..c3ccb56 100644 --- a/include/media/stagefright/MetaData.h +++ b/include/media/stagefright/MetaData.h @@ -24,6 +24,7 @@ #include <utils/RefBase.h> #include <utils/KeyedVector.h> +#include <utils/String8.h> namespace android { @@ -180,6 +181,8 @@ public: bool findData(uint32_t key, uint32_t *type, const void **data, size_t *size) const; + void dumpToLog() const; + protected: virtual ~MetaData(); @@ -194,6 +197,7 @@ private: void clear(); void setData(uint32_t type, const void *data, size_t size); void getData(uint32_t *type, const void **data, size_t *size) const; + String8 asString() const; private: uint32_t mType; diff --git a/include/media/stagefright/OMXCodec.h b/include/media/stagefright/OMXCodec.h index 392ea87..7c612ba 100644 --- a/include/media/stagefright/OMXCodec.h +++ b/include/media/stagefright/OMXCodec.h @@ -30,6 +30,7 @@ struct MediaCodecList; class MemoryDealer; struct OMXCodecObserver; struct CodecProfileLevel; +class SkipCutBuffer; struct OMXCodec : public MediaSource, public MediaBufferObserver { @@ -201,6 +202,7 @@ private: ReadOptions::SeekMode mSeekMode; int64_t mTargetTimeUs; bool mOutputPortSettingsChangedPending; + SkipCutBuffer *mSkipCutBuffer; MediaBuffer *mLeftOverBuffer; @@ -378,6 +380,7 @@ status_t QueryCodecs( const char *mimeType, bool queryDecoders, Vector<CodecCapabilities> *results); + } // namespace android #endif // OMX_CODEC_H_ diff --git a/include/media/stagefright/SkipCutBuffer.h b/include/media/stagefright/SkipCutBuffer.h new file mode 100644 index 0000000..5c7cd47 --- /dev/null +++ b/include/media/stagefright/SkipCutBuffer.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SKIP_CUT_BUFFER_H_ + +#define SKIP_CUT_BUFFER_H_ + +#include <media/stagefright/MediaBuffer.h> + +namespace android { + +/** + * utility class to cut the start and end off a stream of data in MediaBuffers + * + */ +class SkipCutBuffer { + public: + // 'skip' is the number of bytes to skip from the beginning + // 'cut' is the number of bytes to cut from the end + // 'output_size' is the size in bytes of the MediaBuffers that will be used + SkipCutBuffer(int32_t skip, int32_t cut, int32_t output_size); + virtual ~SkipCutBuffer(); + + // Submit one MediaBuffer for skipping and cutting. This may consume all or + // some of the data in the buffer, or it may add data to it. + // After this, the caller should continue processing the buffer as usual. + void submit(MediaBuffer *buffer); + void clear(); + size_t size(); // how many bytes are currently stored in the buffer + + private: + void write(const char *src, size_t num); + size_t read(char *dst, size_t num); + int32_t mFrontPadding; + int32_t mBackPadding; + int32_t mWriteHead; + int32_t mReadHead; + int32_t mCapacity; + char* mCutBuffer; + DISALLOW_EVIL_CONSTRUCTORS(SkipCutBuffer); +}; + +} // namespace android + +#endif // OMX_CODEC_H_ diff --git a/media/libmedia/AudioTrack.cpp b/media/libmedia/AudioTrack.cpp index 55cd3ad..50fbf36 100644 --- a/media/libmedia/AudioTrack.cpp +++ b/media/libmedia/AudioTrack.cpp @@ -261,8 +261,7 @@ status_t AudioTrack::set( frameCount, flags, sharedBuffer, - output, - true); + output); if (status != NO_ERROR) { return status; @@ -741,8 +740,7 @@ status_t AudioTrack::createTrack_l( int frameCount, audio_policy_output_flags_t flags, const sp<IMemory>& sharedBuffer, - audio_io_handle_t output, - bool enforceFrameCount) + audio_io_handle_t output) { status_t status; const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger(); @@ -789,7 +787,8 @@ status_t AudioTrack::createTrack_l( mNotificationFramesAct = frameCount/2; } if (frameCount < minFrameCount) { - ALOGW_IF(enforceFrameCount, "Minimum buffer size corrected from %d to %d", + // not ALOGW because it happens all the time when playing key clicks over A2DP + ALOGV("Minimum buffer size corrected from %d to %d", frameCount, minFrameCount); frameCount = minFrameCount; } @@ -1249,8 +1248,7 @@ status_t AudioTrack::restoreTrack_l(audio_track_cblk_t*& cblk, bool fromStart) mFrameCount, mFlags, mSharedBuffer, - getOutput_l(), - false); + getOutput_l()); if (result == NO_ERROR) { uint32_t user = cblk->user; diff --git a/media/libmediaplayerservice/MediaPlayerService.cpp b/media/libmediaplayerservice/MediaPlayerService.cpp index 148018d..840e475 100644 --- a/media/libmediaplayerservice/MediaPlayerService.cpp +++ b/media/libmediaplayerservice/MediaPlayerService.cpp @@ -541,6 +541,12 @@ void MediaPlayerService::Client::disconnect() } static player_type getDefaultPlayerType() { + char value[PROPERTY_VALUE_MAX]; + if (property_get("media.stagefright.use-nuplayer", value, NULL) + && (!strcmp("1", value) || !strcasecmp("true", value))) { + return NU_PLAYER; + } + return STAGEFRIGHT_PLAYER; } diff --git a/media/libmediaplayerservice/MetadataRetrieverClient.cpp b/media/libmediaplayerservice/MetadataRetrieverClient.cpp index 7dbb57f..776d288 100644 --- a/media/libmediaplayerservice/MetadataRetrieverClient.cpp +++ b/media/libmediaplayerservice/MetadataRetrieverClient.cpp @@ -87,6 +87,7 @@ static sp<MediaMetadataRetrieverBase> createRetriever(player_type playerType) sp<MediaMetadataRetrieverBase> p; switch (playerType) { case STAGEFRIGHT_PLAYER: + case NU_PLAYER: { p = new StagefrightMetadataRetriever; break; diff --git a/media/libmediaplayerservice/nuplayer/Android.mk b/media/libmediaplayerservice/nuplayer/Android.mk index 9b485d7..73336ef 100644 --- a/media/libmediaplayerservice/nuplayer/Android.mk +++ b/media/libmediaplayerservice/nuplayer/Android.mk @@ -2,6 +2,7 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES:= \ + GenericSource.cpp \ HTTPLiveSource.cpp \ NuPlayer.cpp \ NuPlayerDecoder.cpp \ diff --git a/media/libmediaplayerservice/nuplayer/GenericSource.cpp b/media/libmediaplayerservice/nuplayer/GenericSource.cpp new file mode 100644 index 0000000..99569c9 --- /dev/null +++ b/media/libmediaplayerservice/nuplayer/GenericSource.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "GenericSource.h" + +#include "AnotherPacketSource.h" + +#include <media/stagefright/foundation/ABuffer.h> +#include <media/stagefright/foundation/ADebug.h> +#include <media/stagefright/foundation/AMessage.h> +#include <media/stagefright/DataSource.h> +#include <media/stagefright/FileSource.h> +#include <media/stagefright/MediaBuffer.h> +#include <media/stagefright/MediaDefs.h> +#include <media/stagefright/MediaExtractor.h> +#include <media/stagefright/MediaSource.h> +#include <media/stagefright/MetaData.h> + +namespace android { + +NuPlayer::GenericSource::GenericSource( + const char *url, + const KeyedVector<String8, String8> *headers, + bool uidValid, + uid_t uid) + : mDurationUs(0ll), + mAudioIsVorbis(false) { + DataSource::RegisterDefaultSniffers(); + + sp<DataSource> dataSource = + DataSource::CreateFromURI(url, headers); + CHECK(dataSource != NULL); + + initFromDataSource(dataSource); +} + +NuPlayer::GenericSource::GenericSource( + int fd, int64_t offset, int64_t length) + : mDurationUs(0ll), + mAudioIsVorbis(false) { + DataSource::RegisterDefaultSniffers(); + + sp<DataSource> dataSource = new FileSource(dup(fd), offset, length); + + initFromDataSource(dataSource); +} + +void NuPlayer::GenericSource::initFromDataSource( + const sp<DataSource> &dataSource) { + sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource); + + CHECK(extractor != NULL); + + for (size_t i = 0; i < extractor->countTracks(); ++i) { + sp<MetaData> meta = extractor->getTrackMetaData(i); + + const char *mime; + CHECK(meta->findCString(kKeyMIMEType, &mime)); + + sp<MediaSource> track; + + if (!strncasecmp(mime, "audio/", 6)) { + if (mAudioTrack.mSource == NULL) { + mAudioTrack.mSource = track = extractor->getTrack(i); + + if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_VORBIS)) { + mAudioIsVorbis = true; + } else { + mAudioIsVorbis = false; + } + } + } else if (!strncasecmp(mime, "video/", 6)) { + if (mVideoTrack.mSource == NULL) { + mVideoTrack.mSource = track = extractor->getTrack(i); + } + } + + if (track != NULL) { + int64_t durationUs; + if (meta->findInt64(kKeyDuration, &durationUs)) { + if (durationUs > mDurationUs) { + mDurationUs = durationUs; + } + } + } + } +} + +NuPlayer::GenericSource::~GenericSource() { +} + +void NuPlayer::GenericSource::start() { + ALOGI("start"); + + if (mAudioTrack.mSource != NULL) { + CHECK_EQ(mAudioTrack.mSource->start(), (status_t)OK); + + mAudioTrack.mPackets = + new AnotherPacketSource(mAudioTrack.mSource->getFormat()); + + readBuffer(true /* audio */); + } + + if (mVideoTrack.mSource != NULL) { + CHECK_EQ(mVideoTrack.mSource->start(), (status_t)OK); + + mVideoTrack.mPackets = + new AnotherPacketSource(mVideoTrack.mSource->getFormat()); + + readBuffer(false /* audio */); + } +} + +status_t NuPlayer::GenericSource::feedMoreTSData() { + return OK; +} + +sp<MetaData> NuPlayer::GenericSource::getFormat(bool audio) { + sp<MediaSource> source = audio ? mAudioTrack.mSource : mVideoTrack.mSource; + + if (source == NULL) { + return NULL; + } + + return source->getFormat(); +} + +status_t NuPlayer::GenericSource::dequeueAccessUnit( + bool audio, sp<ABuffer> *accessUnit) { + Track *track = audio ? &mAudioTrack : &mVideoTrack; + + if (track->mSource == NULL) { + return -EWOULDBLOCK; + } + + status_t finalResult; + if (!track->mPackets->hasBufferAvailable(&finalResult)) { + return finalResult == OK ? -EWOULDBLOCK : finalResult; + } + + status_t result = track->mPackets->dequeueAccessUnit(accessUnit); + + readBuffer(audio, -1ll); + + return result; +} + +status_t NuPlayer::GenericSource::getDuration(int64_t *durationUs) { + *durationUs = mDurationUs; + return OK; +} + +status_t NuPlayer::GenericSource::seekTo(int64_t seekTimeUs) { + if (mVideoTrack.mSource != NULL) { + int64_t actualTimeUs; + readBuffer(false /* audio */, seekTimeUs, &actualTimeUs); + + seekTimeUs = actualTimeUs; + } + + if (mAudioTrack.mSource != NULL) { + readBuffer(true /* audio */, seekTimeUs); + } + + return OK; +} + +void NuPlayer::GenericSource::readBuffer( + bool audio, int64_t seekTimeUs, int64_t *actualTimeUs) { + Track *track = audio ? &mAudioTrack : &mVideoTrack; + CHECK(track->mSource != NULL); + + if (actualTimeUs) { + *actualTimeUs = seekTimeUs; + } + + MediaSource::ReadOptions options; + + bool seeking = false; + + if (seekTimeUs >= 0) { + options.setSeekTo(seekTimeUs); + seeking = true; + } + + for (;;) { + MediaBuffer *mbuf; + status_t err = track->mSource->read(&mbuf, &options); + + options.clearSeekTo(); + + if (err == OK) { + size_t outLength = mbuf->range_length(); + + if (audio && mAudioIsVorbis) { + outLength += sizeof(int32_t); + } + + sp<ABuffer> buffer = new ABuffer(outLength); + + memcpy(buffer->data(), + (const uint8_t *)mbuf->data() + mbuf->range_offset(), + mbuf->range_length()); + + if (audio && mAudioIsVorbis) { + int32_t numPageSamples; + if (!mbuf->meta_data()->findInt32( + kKeyValidSamples, &numPageSamples)) { + numPageSamples = -1; + } + + memcpy(buffer->data() + mbuf->range_length(), + &numPageSamples, + sizeof(numPageSamples)); + } + + int64_t timeUs; + CHECK(mbuf->meta_data()->findInt64(kKeyTime, &timeUs)); + + buffer->meta()->setInt64("timeUs", timeUs); + + if (actualTimeUs) { + *actualTimeUs = timeUs; + } + + mbuf->release(); + mbuf = NULL; + + if (seeking) { + track->mPackets->queueDiscontinuity( + ATSParser::DISCONTINUITY_SEEK, NULL); + } + + track->mPackets->queueAccessUnit(buffer); + break; + } else if (err == INFO_FORMAT_CHANGED) { +#if 0 + track->mPackets->queueDiscontinuity( + ATSParser::DISCONTINUITY_FORMATCHANGE, NULL); +#endif + } else { + track->mPackets->signalEOS(err); + break; + } + } +} + +bool NuPlayer::GenericSource::isSeekable() { + return true; +} + +} // namespace android diff --git a/media/libmediaplayerservice/nuplayer/GenericSource.h b/media/libmediaplayerservice/nuplayer/GenericSource.h new file mode 100644 index 0000000..aaa5876 --- /dev/null +++ b/media/libmediaplayerservice/nuplayer/GenericSource.h @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef GENERIC_SOURCE_H_ + +#define GENERIC_SOURCE_H_ + +#include "NuPlayer.h" +#include "NuPlayerSource.h" + +#include "ATSParser.h" + +namespace android { + +struct AnotherPacketSource; +struct ARTSPController; +struct DataSource; +struct MediaSource; + +struct NuPlayer::GenericSource : public NuPlayer::Source { + GenericSource( + const char *url, + const KeyedVector<String8, String8> *headers, + bool uidValid = false, + uid_t uid = 0); + + GenericSource(int fd, int64_t offset, int64_t length); + + virtual void start(); + + virtual status_t feedMoreTSData(); + + virtual sp<MetaData> getFormat(bool audio); + virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit); + + virtual status_t getDuration(int64_t *durationUs); + virtual status_t seekTo(int64_t seekTimeUs); + virtual bool isSeekable(); + +protected: + virtual ~GenericSource(); + +private: + struct Track { + sp<MediaSource> mSource; + sp<AnotherPacketSource> mPackets; + }; + + Track mAudioTrack; + Track mVideoTrack; + + int64_t mDurationUs; + bool mAudioIsVorbis; + + void initFromDataSource(const sp<DataSource> &dataSource); + + void readBuffer( + bool audio, + int64_t seekTimeUs = -1ll, int64_t *actualTimeUs = NULL); + + DISALLOW_EVIL_CONSTRUCTORS(GenericSource); +}; + +} // namespace android + +#endif // GENERIC_SOURCE_H_ diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp index 526120a..544d501 100644 --- a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp +++ b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp @@ -27,6 +27,7 @@ #include "NuPlayerSource.h" #include "RTSPSource.h" #include "StreamingSource.h" +#include "GenericSource.h" #include "ATSParser.h" @@ -84,18 +85,44 @@ void NuPlayer::setDataSource(const sp<IStreamSource> &source) { msg->post(); } +static bool IsHTTPLiveURL(const char *url) { + if (!strncasecmp("http://", url, 7) + || !strncasecmp("https://", url, 8)) { + size_t len = strlen(url); + if (len >= 5 && !strcasecmp(".m3u8", &url[len - 5])) { + return true; + } + + if (strstr(url,"m3u8")) { + return true; + } + } + + return false; +} + void NuPlayer::setDataSource( const char *url, const KeyedVector<String8, String8> *headers) { sp<AMessage> msg = new AMessage(kWhatSetDataSource, id()); - if (!strncasecmp(url, "rtsp://", 7)) { - msg->setObject( - "source", new RTSPSource(url, headers, mUIDValid, mUID)); + sp<Source> source; + if (IsHTTPLiveURL(url)) { + source = new HTTPLiveSource(url, headers, mUIDValid, mUID); + } else if (!strncasecmp(url, "rtsp://", 7)) { + source = new RTSPSource(url, headers, mUIDValid, mUID); } else { - msg->setObject( - "source", new HTTPLiveSource(url, headers, mUIDValid, mUID)); + source = new GenericSource(url, headers, mUIDValid, mUID); } + msg->setObject("source", source); + msg->post(); +} + +void NuPlayer::setDataSource(int fd, int64_t offset, int64_t length) { + sp<AMessage> msg = new AMessage(kWhatSetDataSource, id()); + + sp<Source> source = new GenericSource(fd, offset, length); + msg->setObject("source", source); msg->post(); } diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.h b/media/libmediaplayerservice/nuplayer/NuPlayer.h index 6be14be..25766e0 100644 --- a/media/libmediaplayerservice/nuplayer/NuPlayer.h +++ b/media/libmediaplayerservice/nuplayer/NuPlayer.h @@ -40,6 +40,8 @@ struct NuPlayer : public AHandler { void setDataSource( const char *url, const KeyedVector<String8, String8> *headers); + void setDataSource(int fd, int64_t offset, int64_t length); + void setVideoSurfaceTexture(const sp<ISurfaceTexture> &surfaceTexture); void setAudioSink(const sp<MediaPlayerBase::AudioSink> &sink); void start(); @@ -60,12 +62,13 @@ protected: private: struct Decoder; + struct GenericSource; struct HTTPLiveSource; struct NuPlayerStreamListener; struct Renderer; + struct RTSPSource; struct Source; struct StreamingSource; - struct RTSPSource; enum { kWhatSetDataSource = '=DaS', diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp index 460fc98..1600141 100644 --- a/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp +++ b/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp @@ -228,6 +228,20 @@ sp<AMessage> NuPlayer::Decoder::makeFormat(const sp<MetaData> &meta) { buffer->meta()->setInt32("csd", true); mCSD.push(buffer); + } else if (meta->findData(kKeyVorbisInfo, &type, &data, &size)) { + sp<ABuffer> buffer = new ABuffer(size); + memcpy(buffer->data(), data, size); + + buffer->meta()->setInt32("csd", true); + mCSD.push(buffer); + + CHECK(meta->findData(kKeyVorbisBooks, &type, &data, &size)); + + buffer = new ABuffer(size); + memcpy(buffer->data(), data, size); + + buffer->meta()->setInt32("csd", true); + mCSD.push(buffer); } return msg; diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp index 5aa99bf..253bc2f 100644 --- a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp +++ b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp @@ -76,7 +76,13 @@ status_t NuPlayerDriver::setDataSource( } status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) { - return INVALID_OPERATION; + CHECK_EQ((int)mState, (int)UNINITIALIZED); + + mPlayer->setDataSource(fd, offset, length); + + mState = STOPPED; + + return OK; } status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) { @@ -97,13 +103,16 @@ status_t NuPlayerDriver::setVideoSurfaceTexture( } status_t NuPlayerDriver::prepare() { + sendEvent(MEDIA_SET_VIDEO_SIZE, 320, 240); return OK; } status_t NuPlayerDriver::prepareAsync() { + status_t err = prepare(); + notifyListener(MEDIA_PREPARED); - return OK; + return err; } status_t NuPlayerDriver::start() { diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp index 5738ecb..ecbc428 100644 --- a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp +++ b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp @@ -376,7 +376,8 @@ void NuPlayer::Renderer::onDrainVideoQueue() { bool tooLate = (mVideoLateByUs > 40000); if (tooLate) { - ALOGV("video late by %lld us (%.2f secs)", mVideoLateByUs, mVideoLateByUs / 1E6); + ALOGV("video late by %lld us (%.2f secs)", + mVideoLateByUs, mVideoLateByUs / 1E6); } else { ALOGV("rendering video at media time %.2f secs", mediaTimeUs / 1E6); } diff --git a/media/libstagefright/Android.mk b/media/libstagefright/Android.mk index 77714f3..7d7bd7d 100644 --- a/media/libstagefright/Android.mk +++ b/media/libstagefright/Android.mk @@ -42,6 +42,7 @@ LOCAL_SRC_FILES:= \ OggExtractor.cpp \ SampleIterator.cpp \ SampleTable.cpp \ + SkipCutBuffer.cpp \ StagefrightMediaScanner.cpp \ StagefrightMetadataRetriever.cpp \ SurfaceMediaSource.cpp \ diff --git a/media/libstagefright/MPEG4Extractor.cpp b/media/libstagefright/MPEG4Extractor.cpp index 6c95d4e..9385b8a 100644 --- a/media/libstagefright/MPEG4Extractor.cpp +++ b/media/libstagefright/MPEG4Extractor.cpp @@ -373,7 +373,8 @@ status_t MPEG4Extractor::readMetaData() { if (mInitCheck == OK) { if (mHasVideo) { - mFileMetaData->setCString(kKeyMIMEType, "video/mp4"); + mFileMetaData->setCString( + kKeyMIMEType, MEDIA_MIMETYPE_CONTAINER_MPEG4); } else { mFileMetaData->setCString(kKeyMIMEType, "audio/mp4"); } @@ -599,6 +600,7 @@ static void convertTimeToDate(int64_t time_1904, String8 *s) { } status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) { + ALOGV("entering parseChunk %lld/%d", *offset, depth); uint32_t hdr[2]; if (mDataSource->readAt(*offset, hdr, 8) < 8) { return ERROR_IO; @@ -625,6 +627,7 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) { char chunk[5]; MakeFourCCString(chunk_type, chunk); + ALOGV("chunk: %s @ %lld", chunk, *offset); #if 0 static const char kWhitespace[] = " "; @@ -1302,6 +1305,8 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) { break; } + case FOURCC('m', 'e', 'a', 'n'): + case FOURCC('n', 'a', 'm', 'e'): case FOURCC('d', 'a', 't', 'a'): { if (mPath.size() == 6 && underMetaDataPath(mPath)) { @@ -1437,6 +1442,15 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) { break; } + case FOURCC('-', '-', '-', '-'): + { + mLastCommentMean.clear(); + mLastCommentName.clear(); + mLastCommentData.clear(); + *offset += chunk_size; + break; + } + default: { *offset += chunk_size; @@ -1553,6 +1567,9 @@ status_t MPEG4Extractor::parseMetaData(off64_t offset, size_t size) { uint32_t flags = U32_AT(buffer); uint32_t metadataKey = 0; + char chunk[5]; + MakeFourCCString(mPath[4], chunk); + ALOGV("meta: %s @ %lld", chunk, offset); switch (mPath[4]) { case FOURCC(0xa9, 'a', 'l', 'b'): { @@ -1632,6 +1649,35 @@ status_t MPEG4Extractor::parseMetaData(off64_t offset, size_t size) { } break; } + case FOURCC('-', '-', '-', '-'): + { + buffer[size] = '\0'; + switch (mPath[5]) { + case FOURCC('m', 'e', 'a', 'n'): + mLastCommentMean.setTo((const char *)buffer + 4); + break; + case FOURCC('n', 'a', 'm', 'e'): + mLastCommentName.setTo((const char *)buffer + 4); + break; + case FOURCC('d', 'a', 't', 'a'): + mLastCommentData.setTo((const char *)buffer + 8); + break; + } + if (mLastCommentMean == "com.apple.iTunes" + && mLastCommentName == "iTunSMPB" + && mLastCommentData.length() != 0) { + int32_t delay, padding; + if (sscanf(mLastCommentData, + " %*x %x %x %*x", &delay, &padding) == 2) { + mLastTrack->meta->setInt32(kKeyEncoderDelay, delay); + mLastTrack->meta->setInt32(kKeyEncoderPadding, padding); + } + mLastCommentMean.clear(); + mLastCommentName.clear(); + mLastCommentData.clear(); + } + break; + } default: break; diff --git a/media/libstagefright/MediaDefs.cpp b/media/libstagefright/MediaDefs.cpp index 2549de6..2740d6b 100644 --- a/media/libstagefright/MediaDefs.cpp +++ b/media/libstagefright/MediaDefs.cpp @@ -41,7 +41,7 @@ const char *MEDIA_MIMETYPE_AUDIO_RAW = "audio/raw"; const char *MEDIA_MIMETYPE_AUDIO_FLAC = "audio/flac"; const char *MEDIA_MIMETYPE_AUDIO_AAC_ADTS = "audio/aac-adts"; -const char *MEDIA_MIMETYPE_CONTAINER_MPEG4 = "video/mpeg4"; +const char *MEDIA_MIMETYPE_CONTAINER_MPEG4 = "video/mp4"; const char *MEDIA_MIMETYPE_CONTAINER_WAV = "audio/wav"; const char *MEDIA_MIMETYPE_CONTAINER_OGG = "application/ogg"; const char *MEDIA_MIMETYPE_CONTAINER_MATROSKA = "video/x-matroska"; diff --git a/media/libstagefright/MetaData.cpp b/media/libstagefright/MetaData.cpp index 66dec90..755594a 100644 --- a/media/libstagefright/MetaData.cpp +++ b/media/libstagefright/MetaData.cpp @@ -14,6 +14,10 @@ * limitations under the License. */ +//#define LOG_NDEBUG 0 +#define LOG_TAG "MetaData" +#include <utils/Log.h> + #include <stdlib.h> #include <string.h> @@ -282,5 +286,60 @@ void MetaData::typed_data::freeStorage() { mSize = 0; } +String8 MetaData::typed_data::asString() const { + String8 out; + const void *data = storage(); + switch(mType) { + case TYPE_NONE: + out = String8::format("no type, size %d)", mSize); + break; + case TYPE_C_STRING: + out = String8::format("(char*) %s", (const char *)data); + break; + case TYPE_INT32: + out = String8::format("(int32_t) %d", *(int32_t *)data); + break; + case TYPE_INT64: + out = String8::format("(int64_t) %lld", *(int64_t *)data); + break; + case TYPE_FLOAT: + out = String8::format("(float) %f", *(float *)data); + break; + case TYPE_POINTER: + out = String8::format("(void*) %p", *(void **)data); + break; + case TYPE_RECT: + { + const Rect *r = (const Rect *)data; + out = String8::format("Rect(%d, %d, %d, %d)", + r->mLeft, r->mTop, r->mRight, r->mBottom); + break; + } + + default: + out = String8::format("(unknown type %d, size %d)", mType, mSize); + break; + } + return out; +} + +static void MakeFourCCString(uint32_t x, char *s) { + s[0] = x >> 24; + s[1] = (x >> 16) & 0xff; + s[2] = (x >> 8) & 0xff; + s[3] = x & 0xff; + s[4] = '\0'; +} + +void MetaData::dumpToLog() const { + for (int i = mItems.size(); --i >= 0;) { + int32_t key = mItems.keyAt(i); + char cc[5]; + MakeFourCCString(key, cc); + const typed_data &item = mItems.valueAt(i); + ALOGI("%s: %s", cc, item.asString().string()); + } +} + } // namespace android diff --git a/media/libstagefright/OMXCodec.cpp b/media/libstagefright/OMXCodec.cpp index d5e6bec..8b6e9d5 100755 --- a/media/libstagefright/OMXCodec.cpp +++ b/media/libstagefright/OMXCodec.cpp @@ -38,6 +38,7 @@ #include <media/stagefright/MetaData.h> #include <media/stagefright/OMXCodec.h> #include <media/stagefright/Utils.h> +#include <media/stagefright/SkipCutBuffer.h> #include <utils/Vector.h> #include <OMX_Audio.h> @@ -1303,6 +1304,7 @@ OMXCodec::OMXCodec( mSeekMode(ReadOptions::SEEK_CLOSEST_SYNC), mTargetTimeUs(-1), mOutputPortSettingsChangedPending(false), + mSkipCutBuffer(NULL), mLeftOverBuffer(NULL), mPaused(false), mNativeWindow( @@ -1413,6 +1415,9 @@ OMXCodec::~OMXCodec() { free(mMIME); mMIME = NULL; + + delete mSkipCutBuffer; + mSkipCutBuffer = NULL; } status_t OMXCodec::init() { @@ -1573,6 +1578,34 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) { portIndex == kPortIndexInput ? "input" : "output"); } + if (portIndex == kPortIndexOutput) { + + sp<MetaData> meta = mSource->getFormat(); + int32_t delay = 0; + if (!meta->findInt32(kKeyEncoderDelay, &delay)) { + delay = 0; + } + int32_t padding = 0; + if (!meta->findInt32(kKeyEncoderPadding, &padding)) { + padding = 0; + } + int32_t numchannels = 0; + if (delay + padding) { + if (meta->findInt32(kKeyChannelCount, &numchannels)) { + size_t frameSize = numchannels * sizeof(int16_t); + if (mSkipCutBuffer) { + size_t prevbuffersize = mSkipCutBuffer->size(); + if (prevbuffersize != 0) { + ALOGW("Replacing SkipCutBuffer holding %d bytes", prevbuffersize); + } + delete mSkipCutBuffer; + } + mSkipCutBuffer = new SkipCutBuffer(delay * frameSize, padding * frameSize, + def.nBufferSize); + } + } + } + // dumpPortStatus(portIndex); if (portIndex == kPortIndexInput && (mFlags & kUseSecureInputBuffers)) { @@ -2490,6 +2523,10 @@ void OMXCodec::onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data) { CHECK_EQ(countBuffersWeOwn(mPortBuffers[portIndex]), mPortBuffers[portIndex].size()); + if (mSkipCutBuffer && mPortStatus[kPortIndexOutput] == ENABLED) { + mSkipCutBuffer->clear(); + } + if (mState == RECONFIGURING) { CHECK_EQ(portIndex, (OMX_U32)kPortIndexOutput); @@ -3800,6 +3837,9 @@ status_t OMXCodec::read( info->mStatus = OWNED_BY_CLIENT; info->mMediaBuffer->add_ref(); + if (mSkipCutBuffer) { + mSkipCutBuffer->submit(info->mMediaBuffer); + } *buffer = info->mMediaBuffer; return OK; diff --git a/media/libstagefright/SkipCutBuffer.cpp b/media/libstagefright/SkipCutBuffer.cpp new file mode 100755 index 0000000..6d331b0 --- /dev/null +++ b/media/libstagefright/SkipCutBuffer.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//#define LOG_NDEBUG 0 +#define LOG_TAG "SkipCutBuffer" +#include <utils/Log.h> + +#include <media/stagefright/foundation/ADebug.h> +#include <media/stagefright/MediaBuffer.h> +#include <media/stagefright/SkipCutBuffer.h> + +namespace android { + +SkipCutBuffer::SkipCutBuffer(int32_t skip, int32_t cut, int32_t output_size) { + mFrontPadding = skip; + mBackPadding = cut; + mWriteHead = 0; + mReadHead = 0; + mCapacity = cut + output_size; + mCutBuffer = new char[mCapacity]; + ALOGV("skipcutbuffer %d %d %d", skip, cut, mCapacity); +} + +SkipCutBuffer::~SkipCutBuffer() { + delete[] mCutBuffer; +} + +void SkipCutBuffer::submit(MediaBuffer *buffer) { + int32_t offset = buffer->range_offset(); + int32_t buflen = buffer->range_length(); + + // drop the initial data from the buffer if needed + if (mFrontPadding > 0) { + // still data left to drop + int32_t to_drop = (buflen < mFrontPadding) ? buflen : mFrontPadding; + offset += to_drop; + buflen -= to_drop; + buffer->set_range(offset, buflen); + mFrontPadding -= to_drop; + } + + + // append data to cutbuffer + char *src = ((char*) buffer->data()) + offset; + write(src, buflen); + + + // the mediabuffer is now empty. Fill it from cutbuffer, always leaving + // at least mBackPadding bytes in the cutbuffer + char *dst = (char*) buffer->data(); + size_t copied = read(dst, buffer->size()); + buffer->set_range(0, copied); +} + +void SkipCutBuffer::clear() { + mWriteHead = mReadHead = 0; +} + +void SkipCutBuffer::write(const char *src, size_t num) { + int32_t sizeused = (mWriteHead - mReadHead); + if (sizeused < 0) sizeused += mCapacity; + + // everything must fit + CHECK_GE((mCapacity - size_t(sizeused)), num); + + size_t copyfirst = (mCapacity - mWriteHead); + if (copyfirst > num) copyfirst = num; + if (copyfirst) { + memcpy(mCutBuffer + mWriteHead, src, copyfirst); + num -= copyfirst; + src += copyfirst; + mWriteHead += copyfirst; + CHECK_LE(mWriteHead, mCapacity); + if (mWriteHead == mCapacity) mWriteHead = 0; + if (num) { + memcpy(mCutBuffer, src, num); + mWriteHead += num; + } + } +} + +size_t SkipCutBuffer::read(char *dst, size_t num) { + int32_t available = (mWriteHead - mReadHead); + if (available < 0) available += mCapacity; + + available -= mBackPadding; + if (available <=0) { + return 0; + } + if (available < num) { + num = available; + } + + size_t copyfirst = (mCapacity - mReadHead); + if (copyfirst > num) copyfirst = num; + if (copyfirst) { + memcpy(dst, mCutBuffer + mReadHead, copyfirst); + num -= copyfirst; + dst += copyfirst; + mReadHead += copyfirst; + CHECK_LE(mReadHead, mCapacity); + if (mReadHead == mCapacity) mReadHead = 0; + if (num) { + memcpy(dst, mCutBuffer, num); + mReadHead += num; + } + } + return available; +} + +size_t SkipCutBuffer::size() { + int32_t available = (mWriteHead - mReadHead); + if (available < 0) available += mCapacity; + return available; +} + +} // namespace android diff --git a/media/libstagefright/codecs/mp3dec/SoftMP3.cpp b/media/libstagefright/codecs/mp3dec/SoftMP3.cpp index ad55295..92009ee 100644 --- a/media/libstagefright/codecs/mp3dec/SoftMP3.cpp +++ b/media/libstagefright/codecs/mp3dec/SoftMP3.cpp @@ -115,6 +115,7 @@ void SoftMP3::initDecoder() { mDecoderBuf = malloc(memRequirements); pvmp3_InitDecoder(mConfig, mDecoderBuf); + mIsFirst = true; } OMX_ERRORTYPE SoftMP3::internalGetParameter( @@ -190,7 +191,10 @@ void SoftMP3::onQueueFilled(OMX_U32 portIndex) { inInfo->mOwnedByUs = false; notifyEmptyBufferDone(inHeader); - outHeader->nFilledLen = 0; + // pad the end of the stream with 529 samples, since that many samples + // were trimmed off the beginning when decoding started + outHeader->nFilledLen = kPVMP3DecoderDelay * mNumChannels * sizeof(int16_t); + memset(outHeader->pBuffer, 0, outHeader->nFilledLen); outHeader->nFlags = OMX_BUFFERFLAG_EOS; outQueue.erase(outQueue.begin()); @@ -251,8 +255,17 @@ void SoftMP3::onQueueFilled(OMX_U32 portIndex) { return; } - outHeader->nOffset = 0; - outHeader->nFilledLen = mConfig->outputFrameSize * sizeof(int16_t); + if (mIsFirst) { + mIsFirst = false; + // The decoder delay is 529 samples, so trim that many samples off + // the start of the first output buffer. This essentially makes this + // decoder have zero delay, which the rest of the pipeline assumes. + outHeader->nOffset = kPVMP3DecoderDelay * mNumChannels * sizeof(int16_t); + outHeader->nFilledLen = mConfig->outputFrameSize * sizeof(int16_t) - outHeader->nOffset; + } else { + outHeader->nOffset = 0; + outHeader->nFilledLen = mConfig->outputFrameSize * sizeof(int16_t); + } outHeader->nTimeStamp = mAnchorTimeUs @@ -288,6 +301,7 @@ void SoftMP3::onPortFlushCompleted(OMX_U32 portIndex) { // Make sure that the next buffer output does not still // depend on fragments from the last one decoded. pvmp3_InitDecoder(mConfig, mDecoderBuf); + mIsFirst = true; } } diff --git a/media/libstagefright/codecs/mp3dec/SoftMP3.h b/media/libstagefright/codecs/mp3dec/SoftMP3.h index 70d0682..3a05466 100644 --- a/media/libstagefright/codecs/mp3dec/SoftMP3.h +++ b/media/libstagefright/codecs/mp3dec/SoftMP3.h @@ -46,7 +46,8 @@ protected: private: enum { kNumBuffers = 4, - kOutputBufferSize = 4608 * 2 + kOutputBufferSize = 4608 * 2, + kPVMP3DecoderDelay = 529 // frames }; tPVMP3DecoderExternal *mConfig; @@ -57,8 +58,7 @@ private: int32_t mNumChannels; int32_t mSamplingRate; - bool mConfigured; - + bool mIsFirst; bool mSignalledError; enum { diff --git a/media/libstagefright/include/MPEG4Extractor.h b/media/libstagefright/include/MPEG4Extractor.h index eae62c6..5c549e0 100644 --- a/media/libstagefright/include/MPEG4Extractor.h +++ b/media/libstagefright/include/MPEG4Extractor.h @@ -20,6 +20,7 @@ #include <media/stagefright/MediaExtractor.h> #include <utils/Vector.h> +#include <utils/String8.h> namespace android { @@ -64,6 +65,9 @@ private: sp<MetaData> mFileMetaData; Vector<uint32_t> mPath; + String8 mLastCommentMean; + String8 mLastCommentName; + String8 mLastCommentData; status_t readMetaData(); status_t parseChunk(off64_t *offset, int depth); diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp index 3ab4e34..e92e69c 100644 --- a/services/audioflinger/AudioFlinger.cpp +++ b/services/audioflinger/AudioFlinger.cpp @@ -3481,23 +3481,27 @@ AudioFlinger::PlaybackThread::Track::Track( const sp<IMemory>& sharedBuffer, int sessionId) : TrackBase(thread, client, sampleRate, format, channelMask, frameCount, sharedBuffer, sessionId), - mMute(false), mSharedBuffer(sharedBuffer), mName(-1), mMainBuffer(NULL), mAuxBuffer(NULL), + mMute(false), + // mFillingUpStatus ? + // mRetryCount initialized later when needed + mSharedBuffer(sharedBuffer), + mStreamType(streamType), + mName(-1), // see note below + mMainBuffer(thread->mixBuffer()), + mAuxBuffer(NULL), mAuxEffectId(0), mHasVolumeController(false) { if (mCblk != NULL) { - if (thread != NULL) { - mName = thread->getTrackName_l(); - mMainBuffer = thread->mixBuffer(); - } - ALOGV("Track constructor name %d, calling pid %d", mName, IPCThreadState::self()->getCallingPid()); - if (mName < 0) { - ALOGE("no more track names available"); - } - mStreamType = streamType; // NOTE: audio_track_cblk_t::frameSize for 8 bit PCM data is based on a sample size of // 16 bit because data is converted to 16 bit before being stored in buffer by AudioTrack mCblk->frameSize = audio_is_linear_pcm(format) ? mChannelCount * sizeof(int16_t) : sizeof(uint8_t); + // to avoid leaking a track name, do not allocate one unless there is an mCblk + mName = thread->getTrackName_l(); + if (mName < 0) { + ALOGE("no more track names available"); + } } + ALOGV("Track constructor name %d, calling pid %d", mName, IPCThreadState::self()->getCallingPid()); } AudioFlinger::PlaybackThread::Track::~Track() diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h index 7a57613..d1950a3 100644 --- a/services/audioflinger/AudioFlinger.h +++ b/services/audioflinger/AudioFlinger.h @@ -681,9 +681,9 @@ private: enum {FS_FILLING, FS_FILLED, FS_ACTIVE}; mutable uint8_t mFillingUpStatus; int8_t mRetryCount; - sp<IMemory> mSharedBuffer; + const sp<IMemory> mSharedBuffer; bool mResetDone; - audio_stream_type_t mStreamType; + const audio_stream_type_t mStreamType; int mName; int16_t *mMainBuffer; int32_t *mAuxBuffer; |