JMF捕获音频

简介:
1. 捕获媒体数据的步骤:

(1) 查询CaptureDeviceManager,来定位你需要使用的媒体采集设备。

(2) 得到此设备的CaptureDeviceInfo实例。

(3) 从此CaptureDeviceInfo实例获得一个MediaLocator,并通过它来创建一个DataSource。

(4)用此DataSource创建一个Player或Processor。

(5) 启动此Player或Processor开始捕获媒体数据。

2.CaptureDeviceManager、CaptureDeviceInfo、MediaLocator

在JMF中,CaptureDeviceManager也是一个manager类,它提供给了一个列表,这个列表显示当前系统可以被使用的设备名称。同时CaptureDeviceManager可以通过查询的方法对设备进行定位并返回设备的配置信息对象CaptureDeviceInfo,它也可以通过注册的方法向列表加入一个新的设备信息,以便为JMF使用。

设备可通过CaptureDeviceManager的getDevice()方法直接获得设备控制权,设备的控制权一旦得到,就可以以此设备作为一个MediaLocator,可以通过CaptureDeviceInfo的getLocator()方法得到。

3.JMF识别的音频采集设备

200792401.jpg

4.一个实例实现音频捕获

实例有两个文件组成。CaptureDemo.java实现

①查询、获得音频采集设备。

②捕获音频。

③将音频保存到本地文件foo.wav。

StateHelper实现处理器(processor)的状态控制管理。以下为流程图:

200792401.jpg
import java.util.Vector;
import javax.media.CaptureDeviceInfo;
import javax.media.CaptureDeviceManager;
import javax.media.DataSink;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.NoDataSinkException;
import javax.media.NoProcessorException;
import javax.media.Processor;
import javax.media.control.StreamWriterControl;
import javax.media.format.AudioFormat;
import javax.media.protocol.DataSource;
import javax.media.protocol.FileTypeDescriptor;

public class CaptureDemo 
{

    /**
     * @param args
     */
    public static void main(String[] args) 
    {
        // TODO Auto-generated method stub
        CaptureDeviceInfo di = null;
        Processor p = null;
        StateHelper sh = null;
        Vector devList = CaptureDeviceManager.getDeviceList(new AudioFormat("linear",44100,16,2));
        if(devList.size()>0)
        {
            di = (CaptureDeviceInfo)devList.firstElement();
            System.out.println(di.getName());
            System.out.println(di.toString());
        }
        else
            System.exit(-1);
        try
        {
            
            p = Manager.createProcessor(di.getLocator());             
            sh = new StateHelper(p);
        }
        catch(java.io.IOException ex)
        {
            System.exit(-1);
        }
        catch (NoProcessorException e) 
        {
            // TODO Auto-generated catch block
            System.exit(-1);
        }

        if(!sh.configure(10000))
        {
            System.exit(-1);
        }
        p.setContentDescriptor(new FileTypeDescriptor(FileTypeDescriptor.WAVE));
        
        if(!sh.realize(10000))
        {
            System.exit(-1);
        }
        
        DataSource source = p.getDataOutput();
        MediaLocator dest = new MediaLocator("file:///c:/foo.wav");
        DataSink fileWriter = null;
        try
        {
            fileWriter = Manager.createDataSink(source, dest);
            fileWriter.open();
        }
        catch (NoDataSinkException e) 
        {
            // TODO Auto-generated catch block
            System.exit(-1);
        }
        catch(java.io.IOException ex)
        {
            System.exit(-1);
        }
        catch(SecurityException ex)
        {
            System.exit(-1);
        }
        
        StreamWriterControl swc = (StreamWriterControl) p.getControl("javax.media.control.StreamWriterControl");
        if(swc!=null)
        {
            swc.setStreamSizeLimit(500000000);
        }
        try
        {
            fileWriter.start();
        }
        catch(java.io.IOException ex)
        {
            System.exit(-1);
        }
        
        sh.playToEndOfMedia(5000*1000);
        sh.close();
        fileWriter.close();
    }

}


import javax.media.ConfigureCompleteEvent;
import javax.media.ControllerClosedEvent;
import javax.media.ControllerErrorEvent;
import javax.media.ControllerEvent;
import javax.media.ControllerListener;
import javax.media.EndOfMediaEvent;
import javax.media.Player;
import javax.media.Processor;
import javax.media.RealizeCompleteEvent;


public class StateHelper implements ControllerListener
{
    Player player = null;
    boolean configured = false;
    boolean realized = false;
    boolean prefetched = false;
    boolean endOfMedia = false;
    boolean failed = false;
    boolean closed = false;
    
    public StateHelper(Player p)
    {
        this.player = p;
        p.addControllerListener(this);
    }

    public boolean configure(int timeOutMillis)
    {
        long startTime = System.currentTimeMillis();
        synchronized(this)
        {
            if(this.player instanceof Processor)
            {
                ((Processor)player).configure();
            }
            else
                return false;
            while(!this.configured&&!this.failed)
            {
                try
                {
                    this.wait(timeOutMillis);
                }
                catch(InterruptedException ex)
                {
                    
                }
                if(System.currentTimeMillis()-startTime > timeOutMillis)
                    break;
            }
        }
        return this.configured;
    }
    public boolean realize(int timeOutMillis)
    {
        long startTime = System.currentTimeMillis();
        synchronized(this)
        {
            this.player.realize();
            while(!this.realized&&!this.failed)
            {
                try
                {
                    this.wait(timeOutMillis);
                }
                catch(InterruptedException ex)
                {
                    
                }
                if(System.currentTimeMillis()-startTime > timeOutMillis)
                    break;
            }
        }
        return this.realized;
    }
    
    public boolean prefetch(int timeOutMillis)
    {
        long startTime = System.currentTimeMillis();
        synchronized(this)
        {
            this.player.prefetch();
            while(!this.prefetched&&!this.failed)
            {
                try
                {
                    this.wait(timeOutMillis);
                }
                catch(InterruptedException ex)
                {
                    
                }
                if(System.currentTimeMillis()-startTime > timeOutMillis)
                    break;
            }
        }
        return this.prefetched&&!this.failed;
    }
    
    public boolean playToEndOfMedia(int timeOutMillis)
    {
        long startTime = System.currentTimeMillis();
        this.endOfMedia = false;
        synchronized(this)
        {
            this.player.start();
            while(!this.endOfMedia&&!this.failed)
            {
                try
                {
                    this.wait(timeOutMillis);
                }
                catch(InterruptedException ex)
                {
                    
                }
                if(System.currentTimeMillis()-startTime > timeOutMillis)
                    break;
            }
        }
        return this.endOfMedia&&!this.failed;
    }
    
    public void close()
    {
        synchronized(this)
        {
            this.player.close();
            while(!this.closed)
            {
                try
                {
                    this.wait(100);
                }
                catch(InterruptedException ex)
                {
                    
                }
            }
        }
        this.player.removeControllerListener(this);
    }
    
    public synchronized void controllerUpdate(ControllerEvent ce) 
    {
        // TODO Auto-generated method stub
        if(ce instanceof RealizeCompleteEvent)
        {
            this.realized = true;
        }
        else if(ce instanceof ConfigureCompleteEvent)
        {
            this.configured = true;
        }
        else if(ce instanceof EndOfMediaEvent)
        {
            this.endOfMedia = true;
        }
        else if(ce instanceof ControllerErrorEvent)
        {
            this.failed = true;
        }
        else if(ce instanceof ControllerClosedEvent)
        {
            this.closed = true;
        }
        else 
        {
            return;
        }
        this.notifyAll();
    }

}



本文转自Phinecos(洞庭散人)博客园博客,原文链接:http://www.cnblogs.com/phinecos/archive/2007/09/24/904551.html,如需转载请自行联系原作者

目录
相关文章
|
存储 Oracle 安全
JDK 11 是发布了,但收费吗?
自 9 月 26 日,Oracle JDK 11 正式版本发布以来,一直被大家所看好,因为它是继 6、7、8之后,第一个长期支持的版本「见下图」,而 9 、10 估计多半会夭折了。。。
6614 0
JDK 11 是发布了,但收费吗?
|
存储 iOS开发
iOS 内购 payment.applicationUsername 的坑
iOS 内购 payment.applicationUsername 的坑
530 0
|
4月前
|
人工智能 安全 Java
掌握 Spring 中的 WebClient
本文介绍了 Spring Boot 开发中 WebClient 的使用场景及优势。WebClient 是非阻塞响应式 Web 客户端,适合高并发、流式数据处理和微服务通信。它支持事件驱动架构、大文件传输、超时重试机制,并可与 OAuth2 集成实现安全通信。相比 RestTemplate,WebClient 提供更高效的资源利用和灵活的并发处理能力,适用于现代响应式应用开发。文中通过代码示例详细对比了两者的区别,展示了 WebClient 在异步编程中的强大功能。
505 0
|
10月前
|
缓存 算法 API
查询域名WHOIS信息免费API接口教程
该API用于查询顶级域名的WHOIS信息,不支持国别域名和中文域名。通过POST或GET请求,需提供用户ID、KEY及待查询域名。返回信息包括域名状态、注册商、时间等详细数据。示例与文档见官网。
|
开发工具 数据安全/隐私保护
Kali如何root用户及系统中文?
Kali如何root用户及系统中文?
597 0
|
存储 机器学习/深度学习 算法
图论基础:从数学原理到C/C++实现
图论基础:从数学原理到C/C++实现
339 0
|
算法 Oracle Java
一文详解|从JDK8飞升到JDK17,再到未来的JDK21
本文深入浅出地解析了从JDK8到JDK17版本升级的新特性,并展望后续将会更新的JDK21.
11002 8
|
存储 程序员 调度
操作系统介绍(按发展顺序)人工操作方式、单道批处理系统、多道批处理系统、分时系统、实时系统、微机操作系统
程序员将事先已穿孔的纸带(或卡片),装入纸带输入机(或卡片输入机),再启动它们将纸带(或卡片)上的程序和数据输入计算机,然后启动计算机运行。
1399 0
操作系统介绍(按发展顺序)人工操作方式、单道批处理系统、多道批处理系统、分时系统、实时系统、微机操作系统
GE Fanuc IC200PWR002模块 Versamax系列的扩展电源单元(PSU)
GE Fanuc IC200PWR002模块 Versamax系列的扩展电源单元(PSU)
|
机器学习/深度学习 存储 编解码
MobileNetV3详细原理(含torch源码)
MobilneNetV3详细原理(含torch源码)—— cifar10
1474 0
MobileNetV3详细原理(含torch源码)