Android媒体播放器-从网络流播放
我正在尝试制作一个android媒体播放器，它可以播放来自网络流的媒体。我知道它可以播放RTSP或HTTP流媒体，但我的情况不同 我没有任何媒体流服务器，如果我打算使用一个，那么我将不得不修改它 我试图做的是将从android摄像头捕获的视频流到服务器，对视频进行少量修改（如更改颜色或应用一些效果等），然后将其流回到手机。因此，我的屏幕通常分为两部分，一部分用于上行，另一部分显示下行视频 现在我正在做的是在SD卡上捕获视频，同时阅读视频并将其流式传输到web。在web部件上，我捕获视频（将其保存在文件中[我还可以在服务器上播放视频]）并将其发送回手机。在电话中，我可以接收到它，但我不知道如何将此流转换为正确的格式，以便在Android媒体播放器-从网络流播放,android,video-streaming,video-capture,Android,Video Streaming,Video Capture,我正在尝试制作一个android媒体播放器，它可以播放来自网络流的媒体。我知道它可以播放RTSP或HTTP流媒体，但我的情况不同 我没有任何媒体流服务器，如果我打算使用一个，那么我将不得不修改它 我试图做的是将从android摄像头捕获的视频流到服务器，对视频进行少量修改（如更改颜色或应用一些效果等），然后将其流回到手机。因此，我的屏幕通常分为两部分，一部分用于上行，另一部分显示下行视频 现在我正在做的是在SD卡上捕获视频，同时阅读视频并将其流式传输到web。在web部件上，我捕获视频（将其保存
视频播放器中播放它
我还发现MediaPlayer
提供了一些从FileDescriptor
播放视频的方法，因此我可以从套接字创建一个FileDescriptor
，并将其传递给MediaPlayer
？这种方法有效吗？是否可以在没有RTSP或HTTP的情况下实现 package com.pocketTravely.media；
package com.pocketjourney.media;
import java.io.BufferedInputStream;
/**
* MediaPlayer does not yet support streaming from external URLs so this class provides a pseudo-streaming function
* by downloading the content incrementally & playing as soon as we get enough audio in our temporary storage.
*/
public class StreamingMediaPlayer {
private static final int INTIAL_KB_BUFFER = 96*10/8;//assume 96kbps*10secs/8bits per byte
private TextView textStreamed;
private ImageButton playButton;
private ProgressBar progressBar;
// Track for display by progressBar
private long mediaLengthInKb, mediaLengthInSeconds;
private int totalKbRead = 0;
// Create Handler to call View updates on the main UI thread.
private final Handler handler = new Handler();
private MediaPlayer mediaPlayer;
private File downloadingMediaFile;
private boolean isInterrupted;
private Context context;
private int counter = 0;
public StreamingMediaPlayer(Context context,TextView textStreamed, ImageButton playButton, Button streamButton,ProgressBar progressBar)
{
this.context = context;
this.textStreamed = textStreamed;
this.playButton = playButton;
this.progressBar = progressBar;
}
/**
* Progressivly download the media to a temporary location and update the MediaPlayer as new content becomes available.
*/
public void startStreaming(final String mediaUrl, long mediaLengthInKb, long mediaLengthInSeconds) throws IOException {
this.mediaLengthInKb = mediaLengthInKb;
this.mediaLengthInSeconds = mediaLengthInSeconds;
Runnable r = new Runnable() {
public void run() {
try {
downloadAudioIncrement(mediaUrl);
} catch (IOException e) {
Log.e(getClass().getName(), "Unable to initialize the MediaPlayer for fileUrl=" + mediaUrl, e);
return;
}
}
};
new Thread(r).start();
}
/**
* Download the url stream to a temporary location and then call the setDataSource
* for that local file
*/
public void downloadAudioIncrement(String mediaUrl) throws IOException {
URLConnection cn = new URL(mediaUrl).openConnection();
cn.connect();
InputStream stream = cn.getInputStream();
if (stream == null) {
Log.e(getClass().getName(), "Unable to create InputStream for mediaUrl:" + mediaUrl);
}
downloadingMediaFile = new File(context.getCacheDir(),"downloadingMedia.dat");
// Just in case a prior deletion failed because our code crashed or something, we also delete any previously
// downloaded file to ensure we start fresh. If you use this code, always delete
// no longer used downloads else you'll quickly fill up your hard disk memory. Of course, you can also
// store any previously downloaded file in a separate data cache for instant replay if you wanted as well.
if (downloadingMediaFile.exists()) {
downloadingMediaFile.delete();
}
FileOutputStream out = new FileOutputStream(downloadingMediaFile);
byte buf[] = new byte[16384];
int totalBytesRead = 0, incrementalBytesRead = 0;
do {
int numread = stream.read(buf);
if (numread <= 0)
break;
out.write(buf, 0, numread);
totalBytesRead += numread;
incrementalBytesRead += numread;
totalKbRead = totalBytesRead/1000;
testMediaBuffer();
fireDataLoadUpdate();
} while (validateNotInterrupted());
stream.close();
if (validateNotInterrupted()) {
fireDataFullyLoaded();
}
}
private boolean validateNotInterrupted() {
if (isInterrupted) {
if (mediaPlayer != null) {
mediaPlayer.pause();
//mediaPlayer.release();
}
return false;
} else {
return true;
}
}
/**
* Test whether we need to transfer buffered data to the MediaPlayer.
* Interacting with MediaPlayer on non-main UI thread can causes crashes to so perform this using a Handler.
*/
private void testMediaBuffer() {
Runnable updater = new Runnable() {
public void run() {
if (mediaPlayer == null) {
// Only create the MediaPlayer once we have the minimum buffered data
if ( totalKbRead >= INTIAL_KB_BUFFER) {
try {
startMediaPlayer();
} catch (Exception e) {
Log.e(getClass().getName(), "Error copying buffered conent.", e);
}
}
} else if ( mediaPlayer.getDuration() - mediaPlayer.getCurrentPosition() <= 1000 ){
// NOTE: The media player has stopped at the end so transfer any existing buffered data
// We test for < 1second of data because the media player can stop when there is still
// a few milliseconds of data left to play
transferBufferToMediaPlayer();
}
}
};
handler.post(updater);
}
private void startMediaPlayer() {
try {
File bufferedFile = new File(context.getCacheDir(),"playingMedia" + (counter++) + ".dat");
// We double buffer the data to avoid potential read/write errors that could happen if the
// download thread attempted to write at the same time the MediaPlayer was trying to read.
// For example, we can't guarantee that the MediaPlayer won't open a file for playing and leave it locked while
// the media is playing. This would permanently deadlock the file download. To avoid such a deadloack,
// we move the currently loaded data to a temporary buffer file that we start playing while the remaining
// data downloads.
moveFile(downloadingMediaFile,bufferedFile);
Log.e(getClass().getName(),"Buffered File path: " + bufferedFile.getAbsolutePath());
Log.e(getClass().getName(),"Buffered File length: " + bufferedFile.length()+"");
mediaPlayer = createMediaPlayer(bufferedFile);
// We have pre-loaded enough content and started the MediaPlayer so update the buttons & progress meters.
mediaPlayer.start();
startPlayProgressUpdater();
playButton.setEnabled(true);
} catch (IOException e) {
Log.e(getClass().getName(), "Error initializing the MediaPlayer.", e);
return;
}
}
private MediaPlayer createMediaPlayer(File mediaFile)
throws IOException {
MediaPlayer mPlayer = new MediaPlayer();
mPlayer.setOnErrorListener(
new MediaPlayer.OnErrorListener() {
public boolean onError(MediaPlayer mp, int what, int extra) {
Log.e(getClass().getName(), "Error in MediaPlayer: (" + what +") with extra (" +extra +")" );
return false;
}
});
// It appears that for security/permission reasons, it is better to pass a FileDescriptor rather than a direct path to the File.
// Also I have seen errors such as "PVMFErrNotSupported" and "Prepare failed.: status=0x1" if a file path String is passed to
// setDataSource(). So unless otherwise noted, we use a FileDescriptor here.
FileInputStream fis = new FileInputStream(mediaFile);
mPlayer.setDataSource(fis.getFD());
mPlayer.prepare();
return mPlayer;
}
/**
* Transfer buffered data to the MediaPlayer.
* NOTE: Interacting with a MediaPlayer on a non-main UI thread can cause thread-lock and crashes so
* this method should always be called using a Handler.
*/
private void transferBufferToMediaPlayer() {
try {
// First determine if we need to restart the player after transferring data...e.g. perhaps the user pressed pause
boolean wasPlaying = mediaPlayer.isPlaying();
int curPosition = mediaPlayer.getCurrentPosition();
// Copy the currently downloaded content to a new buffered File. Store the old File for deleting later.
File oldBufferedFile = new File(context.getCacheDir(),"playingMedia" + counter + ".dat");
File bufferedFile = new File(context.getCacheDir(),"playingMedia" + (counter++) + ".dat");
// This may be the last buffered File so ask that it be delete on exit. If it's already deleted, then this won't mean anything. If you want to
// keep and track fully downloaded files for later use, write caching code and please send me a copy.
bufferedFile.deleteOnExit();
moveFile(downloadingMediaFile,bufferedFile);
// Pause the current player now as we are about to create and start a new one. So far (Android v1.5),
// this always happens so quickly that the user never realized we've stopped the player and started a new one
mediaPlayer.pause();
// Create a new MediaPlayer rather than try to re-prepare the prior one.
mediaPlayer = createMediaPlayer(bufferedFile);
mediaPlayer.seekTo(curPosition);
// Restart if at end of prior buffered content or mediaPlayer was previously playing.
// NOTE: We test for < 1second of data because the media player can stop when there is still
// a few milliseconds of data left to play
boolean atEndOfFile = mediaPlayer.getDuration() - mediaPlayer.getCurrentPosition() <= 1000;
if (wasPlaying || atEndOfFile){
mediaPlayer.start();
}
// Lastly delete the previously playing buffered File as it's no longer needed.
oldBufferedFile.delete();
}catch (Exception e) {
Log.e(getClass().getName(), "Error updating to newly loaded content.", e);
}
}
private void fireDataLoadUpdate() {
Runnable updater = new Runnable() {
public void run() {
textStreamed.setText((totalKbRead + " Kb read"));
float loadProgress = ((float)totalKbRead/(float)mediaLengthInKb);
progressBar.setSecondaryProgress((int)(loadProgress*100));
}
};
handler.post(updater);
}
private void fireDataFullyLoaded() {
Runnable updater = new Runnable() {
public void run() {
transferBufferToMediaPlayer();
// Delete the downloaded File as it's now been transferred to the currently playing buffer file.
downloadingMediaFile.delete();
textStreamed.setText(("Audio full loaded: " + totalKbRead + " Kb read"));
}
};
handler.post(updater);
}
public MediaPlayer getMediaPlayer() {
return mediaPlayer;
}
public void startPlayProgressUpdater() {
float progress = (((float)mediaPlayer.getCurrentPosition()/1000)/mediaLengthInSeconds);
progressBar.setProgress((int)(progress*100));
if (mediaPlayer.isPlaying()) {
Runnable notification = new Runnable() {
public void run() {
startPlayProgressUpdater();
}
};
handler.postDelayed(notification,1000);
}
}
public void interrupt() {
playButton.setEnabled(false);
isInterrupted = true;
validateNotInterrupted();
}
/**
* Move the file in oldLocation to newLocation.
*/
public void moveFile(File oldLocation, File newLocation)
throws IOException {
if ( oldLocation.exists( )) {
BufferedInputStream reader = new BufferedInputStream( new FileInputStream(oldLocation) );
BufferedOutputStream writer = new BufferedOutputStream( new FileOutputStream(newLocation, false));
try {
byte[] buff = new byte[8192];
int numChars;
while ( (numChars = reader.read( buff, 0, buff.length ) ) != -1) {
writer.write( buff, 0, numChars );
}
} catch( IOException ex ) {
throw new IOException("IOException when transferring " + oldLocation.getPath() + " to " + newLocation.getPath());
} finally {
try {
if ( reader != null ){
writer.close();
reader.close();
}
} catch( IOException ex ){
Log.e(getClass().getName(),"Error closing files when transferring " + oldLocation.getPath() + " to " + newLocation.getPath() );
}
}
} else {
throw new IOException("Old location does not exist when transferring " + oldLocation.getPath() + " to " + newLocation.getPath() );
}
}
}
导入java.io.BufferedInputStream；
/**
*MediaPlayer还不支持来自外部URL的流，因此该类提供了一个伪流函数
*通过增量下载内容&在临时存储中获得足够的音频后立即播放。
*/
公共类流媒体播放器{
私有静态final int initial_KB_BUFFER=96*10/8；//假设每个字节96kbps*10secs/8位
私有文本视图文本流；
私人图像按钮播放按钮；
私人ProgressBar ProgressBar；
//通过progressBar显示的曲目
私人长媒体长度ThinkB，媒体长度秒；
私有int totalKbRead=0；
//创建处理程序以在主UI线程上调用视图更新。
私有最终处理程序=新处理程序（）；
私人媒体播放器；
私有文件下载媒体文件；
私有布尔值中断；
私人语境；
专用整数计数器=0；
公共流媒体播放器（上下文上下文、文本视图文本流、图像按钮播放按钮、按钮流按钮、进度条进度条）
{
this.context=上下文；
this.textStreamed=textStreamed；
this.playButton=playButton；
this.progressBar=progressBar；
}
/**
*渐进地将媒体下载到临时位置，并在新内容可用时更新MediaPlayer。
*/
public void startStreaming（最终字符串mediaUrl、long mediaLengthInKb、long mediaLengthInSeconds）引发IOException{
this.mediaLengthInKb=mediaLengthInKb；
this.medialenghthinseconds=medialenghthinseconds；
Runnable r=新的Runnable（）{
public void run（）{
试试{
下载音频增量（mediaUrl）；
}捕获（IOE异常）{
Log.e（getClass（）.getName（），“无法为fileUrl=“+mediaUrl，e）”初始化MediaPlayer；
返回；
}
}
};
新线程（r.start（）；
}
/**
*将url流下载到临时位置，然后调用setDataSource
*对于那个本地文件
*/
public void downloadAudioIncrement（字符串mediaUrl）引发IOException{
URLConnection cn=新URL（mediaUrl）.openConnection（）；
cn.connect（）；
InputStream=cn.getInputStream（）；
if（流==null）{
Log.e（getClass（）.getName（），“无法为mediaUrl创建InputStream:”+mediaUrl）；
}
downloadingMediaFile=新文件（context.getCacheDir（），“downloadingMedia.dat”）；
//为了防止先前的删除由于代码崩溃或其他原因而失败，我们也会删除以前的任何代码
//下载文件以确保我们重新开始。如果使用此代码，请始终删除
//不再使用下载，否则你会很快填满你的硬盘。当然，你也可以
//将以前下载的任何文件存储在单独的数据缓存中，以便在需要时进行即时重播。
if（下载MediaFile.exists（））{
下载MediaFile.delete（）；
}
FileOutputStream out=新的FileOutputStream（下载MediaFile）；
字节buf[]=新字节[16384]；
int totalBytesRead=0，incrementalBytesRead=0；
做{
int numread=stream.read（buf）；
if（numread=initial\u KB\u缓冲区）{
试一试{
startMediaPlayer（）；
}捕获（例外e）{
Log.e（getClass（）.getName（），“复制缓冲区内容时出错”，e）；
}
}
}else if（mediaPlayer.getDuration（）-mediaPlayer.getCurrentPosition（））正如我看到的，您首先下载文件，然后播放该文件；是否有直接播放网络UDP流的方法？我正在尝试这样做，但我不知道我需要使用特殊的应用程序；或者播放器，或者我可以通过类似这样的代码直接使用我平台的媒体解码功能。