使用 JMF 将多路复用的音频/视频录制到文件中

Posted 2023-02-16

【中文标题】使用 JMF 将多路复用的音频/视频录制到文件中

【英文标题】：Recording multiplexed Audio/Video to a file using JMF

【发布时间】：2011-07-01 01:26:47

【问题描述】：

我有一个使用 JMF 的项目，并在短时间内（几秒到几分钟）记录网络摄像头和音频输入，然后将结果写入文件。

我的项目的问题是这个文件从来没有正确生成，并且无法播放。

虽然我找到了许多关于如何通过 RTP 进行音频和视频的多路复用传输，或将输入文件从一种格式转换为另一种格式的示例，但我还没有看到捕获音频和视频的有效示例，并将其写入文件。

有没有人有执行此操作的代码示例？

【参考方案1】：

我找到了无法从 JMF 下的两个单独捕获设备生成文件的原因，这与启动命令的顺序有关。特别是，处理器之类的东西将采用数据源，或合并数据源，分配和同步时基并为您启动/停止源，所以我试图手动启动数据源的额外工作是完全多余的，并在工作中使用扳手。

这是一个痛苦的尝试和错误，我建议您阅读每一行代码，了解顺序，了解包含的内容，遗漏的内容以及原因，然后再尝试自己实现。如果你不小心的话，JMF 就是熊。

哦，记住要捕获异常。由于长度限制，我不得不省略该代码。

这是我的最终解决方案：

public void doRecordingDemo() 

        // Get the default media capture device for audio and video
        DataSource[] sources = new DataSource[2];
        sources[0] = Manager.createDataSource(audioDevice.getLocator());
        sources[1] = Manager.createDataSource(videoDevice.getLocator());

        // Merge the audio and video streams
        DataSource source = Manager.createMergingDataSource(sources);

        // Create a processor to convert from raw format to a file format
        // Notice that we are NOT starting the datasources, but letting the
        //  processor take care of this for us.
        Processor processor = Manager.createProcessor(source);

        // Need a configured processor for this next step
        processor.configure();
        waitForState(processor, Processor.Configured);

        // Modify this to suit your needs, but pay attention to what formats can go in what containers
        processor.setContentDescriptor(new FileTypeDescriptor(FileTypeDescriptor.QUICKTIME));

        // Use the processor to convert the audio and video into reasonable formats and sizes
        // There are probably better ways to do this, but you should NOT make any assumptions
        // about what formats are supported, and instead use a generic method of checking the
        // available formats and sizes.  You have been warned!
        for (TrackControl control : processor.getTrackControls()) 
            if (control.getFormat() instanceof VideoFormat || control.getFormat() instanceof AudioFormat) 
                if (control.getFormat() instanceof AudioFormat) 
                    // In general, this is safe for audio, but do not make assumptions for video.
                    // Things get a little wonky for video because of how complex the options are.
                    control.setFormat(new AudioFormat(AudioFormat.GSM));
                

                if (control.getFormat() instanceof VideoFormat) 
                    VideoFormat desiredVideoFormat = null;
                    Dimension targetDimension = new Dimension(352, 288);

                    // Search sequentially through this array of formats
                    VideoFormat[] desiredFormats = new VideoFormat[] new H263Format(), new JPEGFormat(), new RGBFormat(), new YUVFormat();
                    for (VideoFormat checkFormat : desiredFormats) 
                        // Search the video formats looking for a match.
                        List<VideoFormat> candidates = new LinkedList<VideoFormat>();
                        for (Format format : control.getSupportedFormats()) 
                            if (format.isSameEncoding(checkFormat)) 
                                candidates.add((VideoFormat) format);
                            
                        
                        if (!candidates.isEmpty()) 
                            // Get the first candidate for now since we have at least a format match
                            desiredVideoFormat = candidates.get(0);

                            for (VideoFormat format : candidates) 
                                if (targetDimension.equals(format.getSize())) 
                                    // Found exactly what we're looking for
                                    desiredVideoFormat = format;
                                    break;
                                
                            
                        

                        if (desiredVideoFormat != null) 
                            // If we found a match, stop searching formats
                            break;
                        
                    

                    if (desiredVideoFormat != null) 
                        // It's entirely possible (but not likely) that we got here without a format
                        //  selected, so this null check is unfortunately necessary.
                        control.setFormat(desiredVideoFormat);
                    
                
                control.setEnabled(true);
                System.out.println("Enabled track: " + control + " (" + control.getFormat() + ")");
            

        

        // To get the output from a processor, we need it to be realized.
        processor.realize();
        waitForState(processor, Processor.Realized);

        // Get the data output so we can output it to a file.
        DataSource dataOutput = processor.getDataOutput();

        // Create a file to receive the media
        File answerFile = new File("recording.mov");
        MediaLocator dest = new MediaLocator(answerFile.toURI().toURL());

        // Create a data sink to write to the disk
        DataSink answerSink = Manager.createDataSink(dataOutput, dest);

        // Start the processor spinning
        processor.start();

        // Open the file
        answerSink.open();

        // Start writing data
        answerSink.start();

        // SUCCESS!  We are now recording
        Thread.sleep(10000);  // Wait for 10 seconds so we record 10 seconds of video

        try 
            // Stop the processor. This will also stop and close the datasources
            processor.stop();
            processor.close();

            try 
                // Let the buffer run dry.  Event Listeners never seem to get called,
                // so this seems to be the most effective way.
                Thread.sleep(1000);
             catch (InterruptedException ex) 
                Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
            

            try 
                // Stop recording to the file.
                answerSink.stop();
             catch (IOException ex) 
                Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
            
         finally 
            try 
                // Whatever else we do, close the file if we can to avoid leaking.
                answerSink.close();
             catch (Exception ex) 
                Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
            

            try 
                // Deallocate the native processor resources.
                processor.deallocate();
             catch (Exception ex) 
                Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
            
        


// My little utility function to wait for a given state.
private void waitForState(Player player, int state) 
    // Fast abort
    if (player.getState() == state) 
        return;
    

    long startTime = new Date().getTime();

    long timeout = 10 * 1000;

    final Object waitListener = new Object();

    ControllerListener cl = new ControllerListener() 

        @Override
        public void controllerUpdate(ControllerEvent ce) 
            synchronized (waitListener) 
                waitListener.notifyAll();
            
        
    ;
    try 
        player.addControllerListener(cl);

        // Make sure we wake up every 500ms to check for timeouts and in case we miss a signal
        synchronized (waitListener) 
            while (player.getState() != state && new Date().getTime() - startTime < timeout) 
                try 
                    waitListener.wait(500);
                 catch (InterruptedException ex) 
                    Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
                
            
        
     finally 
        // No matter what else happens, we want to remove this
        player.removeControllerListener(cl);