从google发布的各个android版本源码看，android4.0开始就做了支持buffer播放的接口及demo了，编译完android SDK后在out中会生成一个可执行文件stream，这个就是一个非常好的demo测试程序，支持H264的ts播放，程序源代码位置以android4.3为例说明下，目录：android4.3\frameworks\av\cmds\stagefright，对应文件为stream.cpp，通用播放器用buffer来做突破口就在此哦，从这里开始，感兴趣的可以这么做，先做一个自己的DEMO，先播放本地文件，然后再把流媒体协议加进来集成就OK，此文件代码如下：
/*
* Copyright (C) 2010 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 "stream"
#include "utils/Log.h"
#include <binder/ProcessState.h>
#include <cutils/properties.h> // for property_get
#include <media/IStreamSource.h>
#include <media/mediaplayer.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/DataSource.h>
#include <media/stagefright/MPEG2TSWriter.h>
#include <media/stagefright/MediaExtractor.h>
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/MetaData.h>
#include <binder/IServiceManager.h>
#include <media/IMediaPlayerService.h>
#include <gui/ISurfaceComposer.h>
#include <gui/SurfaceComposerClient.h>
#include <gui/Surface.h>
#include <fcntl.h>
#include <ui/DisplayInfo.h>
using namespace android;
struct MyStreamSource : public BnStreamSource {
// Object assumes ownership of fd.
MyStreamSource(int fd);
virtual void setListener(const sp<IStreamListener> &listener);
virtual void setBuffers(const Vector<sp<IMemory> > &buffers);
virtual void onBufferAvailable(size_t index);
protected:
virtual ~MyStreamSource();
private:
int mFd;
off64_t mFileSize;
uint64_t mNumPacketsSent;
sp<IStreamListener> mListener;
Vector<sp<IMemory> > mBuffers;
DISALLOW_EVIL_CONSTRUCTORS(MyStreamSource);
};
MyStreamSource::MyStreamSource(int fd)
: mFd(fd),
mFileSize(0),
mNumPacketsSent(0) {
CHECK_GE(fd, 0);
mFileSize = lseek64(fd, 0, SEEK_END);
lseek64(fd, 0, SEEK_SET);
}
MyStreamSource::~MyStreamSource() {
close(mFd);
mFd = -1;
}
void MyStreamSource::setListener(const sp<IStreamListener> &listener) {
mListener = listener;
}
void MyStreamSource::setBuffers(const Vector<sp<IMemory> > &buffers) {
mBuffers = buffers;
}
void MyStreamSource::onBufferAvailable(size_t index) {
CHECK_LT(index, mBuffers.size());
#if 0
if (mNumPacketsSent >= 20000) {
ALOGI("signalling discontinuity now");
off64_t offset = 0;
CHECK((offset % 188) == 0);
lseek(mFd, offset, SEEK_SET);
sp<AMessage> extra = new AMessage;
extra->setInt32(IStreamListener::kKeyFormatChange, 0);
mListener->issueCommand(
IStreamListener::DISCONTINUITY, false /* synchronous */, extra);
mNumPacketsSent = 0;
}
#endif
sp<IMemory> mem = mBuffers.itemAt(index);
ssize_t n = read(mFd, mem->pointer(), mem->size());
if (n <= 0) {
mListener->issueCommand(IStreamListener::EOS, false /* synchronous */);
} else {
mListener->queueBuffer(index, n);
mNumPacketsSent += n / 188;
}
}
////////////////////////////////////////////////////////////////////////////////
struct MyConvertingStreamSource : public BnStreamSource {
MyConvertingStreamSource(const char *filename);
virtual void setListener(const sp<IStreamListener> &listener);
virtual void setBuffers(const Vector<sp<IMemory> > &buffers);
virtual void onBufferAvailable(size_t index);
protected:
virtual ~MyConvertingStreamSource();
private:
Mutex mLock;
Condition mCondition;
sp<IStreamListener> mListener;
Vector<sp<IMemory> > mBuffers;
sp<MPEG2TSWriter> mWriter;
ssize_t mCurrentBufferIndex;
size_t mCurrentBufferOffset;
List<size_t> mBufferQueue;
static ssize_t WriteDataWrapper(void *me, const void *data, size_t size);
ssize_t writeData(const void *data, size_t size);
DISALLOW_EVIL_CONSTRUCTORS(MyConvertingStreamSource);
};
////////////////////////////////////////////////////////////////////////////////
MyConvertingStreamSource::MyConvertingStreamSource(const char *filename)
: mCurrentBufferIndex(-1),
mCurrentBufferOffset(0) {
sp<DataSource> dataSource = DataSource::CreateFromURI(filename);
CHECK(dataSource != NULL);
sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource);
CHECK(extractor != NULL);
mWriter = new MPEG2TSWriter(
this, &MyConvertingStreamSource::WriteDataWrapper);
for (size_t i = 0; i < extractor->countTracks(); ++i) {
const sp<MetaData> &meta = extractor->getTrackMetaData(i);
const char *mime;
CHECK(meta->findCString(kKeyMIMEType, &mime));
if (strncasecmp("video/", mime, 6) && strncasecmp("audio/", mime, 6)) {
continue;
}
CHECK_EQ(mWriter->addSource(extractor->getTrack(i)), (status_t)OK);
}
CHECK_EQ(mWriter->start(), (status_t)OK);
}
MyConvertingStreamSource::~MyConvertingStreamSource() {
}
void MyConvertingStreamSource::setListener(
const sp<IStreamListener> &listener) {
mListener = listener;
}
void MyConvertingStreamSource::setBuffers(
const Vector<sp<IMemory> > &buffers) {
mBuffers = buffers;
}
ssize_t MyConvertingStreamSource::WriteDataWrapper(
void *me, const void *data, size_t size) {
return static_cast<MyConvertingStreamSource *>(me)->writeData(data, size);
}
ssize_t MyConvertingStreamSource::writeData(const void *data, size_t size) {
size_t totalWritten = 0;
while (size > 0) {
Mutex::Autolock autoLock(mLock);
if (mCurrentBufferIndex < 0) {
while (mBufferQueue.empty()) {
mCondition.wait(mLock);
}
mCurrentBufferIndex = *mBufferQueue.begin();
mCurrentBufferOffset = 0;
mBufferQueue.erase(mBufferQueue.begin());
}
sp<IMemory> mem = mBuffers.itemAt(mCurrentBufferIndex);
size_t copy = size;
if (copy + mCurrentBufferOffset > mem->size()) {
copy = mem->size() - mCurrentBufferOffset;
}
memcpy((uint8_t *)mem->pointer() + mCurrentBufferOffset, data, copy);
mCurrentBufferOffset += copy;
if (mCurrentBufferOffset == mem->size()) {
mListener->queueBuffer(mCurrentBufferIndex, mCurrentBufferOffset);
mCurrentBufferIndex = -1;
}
data = (const uint8_t *)data + copy;
size -= copy;
totalWritten += copy;
}
return (ssize_t)totalWritten;
}
void MyConvertingStreamSource::onBufferAvailable(size_t index) {
Mutex::Autolock autoLock(mLock);
mBufferQueue.push_back(index);
mCondition.signal();
if (mWriter->reachedEOS()) {
if (mCurrentBufferIndex >= 0) {
mListener->queueBuffer(mCurrentBufferIndex, mCurrentBufferOffset);
mCurrentBufferIndex = -1;
}
mListener->issueCommand(IStreamListener::EOS, false /* synchronous */);
}
}
////////////////////////////////////////////////////////////////////////////////
struct MyClient : public BnMediaPlayerClient {
MyClient()
: mEOS(false) {
}
virtual void notify(int msg, int ext1, int ext2, const Parcel *obj) {
Mutex::Autolock autoLock(mLock);
if (msg == MEDIA_ERROR || msg == MEDIA_PLAYBACK_COMPLETE) {
mEOS = true;
mCondition.signal();
}
}
void waitForEOS() {
Mutex::Autolock autoLock(mLock);
while (!mEOS) {
mCondition.wait(mLock);
}
}
protected:
virtual ~MyClient() {
}
private:
Mutex mLock;
Condition mCondition;
bool mEOS;
DISALLOW_EVIL_CONSTRUCTORS(MyClient);
};
int main(int argc, char **argv) {
android::ProcessState::self()->startThreadPool();
DataSource::RegisterDefaultSniffers();
if (argc != 2) {
fprintf(stderr, "Usage: %s filename\n", argv[0]);
return 1;
}
sp<SurfaceComposerClient> composerClient = new SurfaceComposerClient;
CHECK_EQ(composerClient->initCheck(), (status_t)OK);
sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
ISurfaceComposer::eDisplayIdMain));
DisplayInfo info;
SurfaceComposerClient::getDisplayInfo(display, &info);
ssize_t displayWidth = info.w;
ssize_t displayHeight = info.h;
ALOGV("display is %d x %d\n", displayWidth, displayHeight);
sp<SurfaceControl> control =
composerClient->createSurface(
String8("A Surface"),
displayWidth,
displayHeight,
PIXEL_FORMAT_RGB_565,
0);
CHECK(control != NULL);
CHECK(control->isValid());
SurfaceComposerClient::openGlobalTransaction();
CHECK_EQ(control->setLayer(INT_MAX), (status_t)OK);
CHECK_EQ(control->show(), (status_t)OK);
SurfaceComposerClient::closeGlobalTransaction();
sp<Surface> surface = control->getSurface();
CHECK(surface != NULL);
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("media.player"));
sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);
CHECK(service.get() != NULL);
sp<MyClient> client = new MyClient;
sp<IStreamSource> source;
char prop[PROPERTY_VALUE_MAX];
bool usemp4 = property_get("media.stagefright.use-mp4source", prop, NULL) &&
(!strcmp(prop, "1") || !strcasecmp(prop, "true"));
size_t len = strlen(argv[1]);
if ((!usemp4 && len >= 3 && !strcasecmp(".ts", &argv[1][len - 3])) ||
(usemp4 && len >= 4 &&
(!strcasecmp(".mp4", &argv[1][len - 4])
|| !strcasecmp(".3gp", &argv[1][len- 4])
|| !strcasecmp(".3g2", &argv[1][len- 4])))) {
int fd = open(argv[1], O_RDONLY);
if (fd < 0) {
fprintf(stderr, "Failed to open file ‘%s‘.", argv[1]);
return 1;
}
source = new MyStreamSource(fd);
} else {
printf("Converting file to transport stream for streaming...\n");
source = new MyConvertingStreamSource(argv[1]);
}
sp<IMediaPlayer> player =
service->create(client, 0);
if (player != NULL && player->setDataSource(source) == NO_ERROR) {
player->setVideoSurfaceTexture(surface->getIGraphicBufferProducer());
player->start();
client->waitForEOS();
player->stop();
} else {
fprintf(stderr, "failed to instantiate player.\n");
}
composerClient->dispose();
return 0;
}