【第一篇章-android平台buffer播放探索】buffer play demo

时间：2014-10-11 14:45:55 阅读：266 评论：0 收藏：0 [点我收藏+]

标签：android style http io os ar for 文件 sp

从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;
}

标签：android style http io os ar for 文件 sp

原文地址：http://blog.csdn.net/acm2008/article/details/39991471

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行