Question

我正在尝试使用AudioInputStream跳过负数的字节 skip(long bytes)方法。

问题正在尝试（假设有少量字节...）：

int skipped = audioInputStream.skip(-bytes);

总是返回0...。我不知道该怎么办。

Here is the full code的github库。

我要做的是每当用户跳过音频时重新创建线路当我当然可以做得更好的时候，这会非常慢... ...向前还是向后。现在它仅支持转发...

/**                                                                                                                   
 * Skip bytes in the File input stream. It will skip N frames matching to bytes, so it will never skip given bytes len
 *                                                                                                                    
 * @param bytes                                                                                                       
 *            the bytes                                                                                               
 * @return value bigger than 0 for File and value = 0 for URL and InputStream                                         
 * @throws StreamPlayerException                                                                                      
 *             the stream player exception                                                                            
 */                                                                                                                   
public long seek(long bytes) throws StreamPlayerException {                                                           
    long totalSkipped = 0;                                                                                            

    //If it is File                                                                                                   
    if (dataSource instanceof File) {                                                                                 

        //Check if the requested bytes are more than totalBytes of Audio                                              
        long bytesLength = getTotalBytes();                                                                           
        System.out.println("Bytes: " + bytes + " BytesLength: " + bytesLength);                                       
        if ( ( bytesLength <= 0 ) || ( bytes >= bytesLength )) {                                                      
            generateEvent(Status.EOM, getEncodedStreamPosition(), null);                                              
            return totalSkipped;                                                                                      
        }                                                                                                             

        logger.info(() -> "Bytes to skip : " + bytes);                                                                
        Status previousStatus = status;                                                                               
        status = Status.SEEKING;                                                                                      

        try {                                                                                                         
            synchronized (audioLock) {                                                                                
                generateEvent(Status.SEEKING, AudioSystem.NOT_SPECIFIED, null);                                       
                initAudioInputStream();                                                                               
                if (audioInputStream != null) {                                                                       

                    long skipped;                                                                                     
                    // Loop until bytes are really skipped.                                                           
                    while (totalSkipped < ( bytes )) { //totalSkipped < (bytes-SKIP_INACCURACY_SIZE)))                
                        //System.out.println("Running");                                                              
                        skipped = audioInputStream.skip(bytes - totalSkipped);                                        
                        if (skipped == 0)                                                                             
                            break;                                                                                    
                        totalSkipped += skipped;                                                                      
                        logger.info("Skipped : " + totalSkipped + "/" + bytes);                                       
                        if (totalSkipped == -1)                                                                       
                            throw new StreamPlayerException(StreamPlayerException.PlayerException.SKIP_NOT_SUPPORTED);

                        logger.info("Skeeping:" + totalSkipped);                                                      
                    }                                                                                                 
                }                                                                                                     
            }                                                                                                         
            generateEvent(Status.SEEKED, getEncodedStreamPosition(), null);                                           
            status = Status.OPENED;                                                                                   
            if (previousStatus == Status.PLAYING)                                                                     
                play();                                                                                               
            else if (previousStatus == Status.PAUSED) {                                                               
                play();                                                                                               
                pause();                                                                                              
            }                                                                                                         

        } catch (IOException ex) {                                                                                    
            logger.log(Level.WARNING, ex.getMessage(), ex);                                                           
        }                                                                                                             
    }                                                                                                                 
    return totalSkipped;                                                                                              
}

这个问题的继续在这里... Java AudioInputStream how to support skip with negative number of bytes

Answer 1

AudioInputStream.skip不支持否定参数。如果您阅读InputStream.skip的Javadoc，则说（强调我的）：

跳过并丢弃此输入流中的n个字节的数据。出于各种原因，skip方法可能会跳过一些较小的字节，可能是0。这可能是由多种条件引起的；在跳过n个字节之前到达文件末尾只是一种可能。返回跳过的实际字节数。 如果n为负，则类skip的{{1}}方法始终返回InputStream，并且不会跳过任何字节。子类可以处理负值不一样。

它的确提到了子类可能会改变这种行为，但是0的文档没有给出任何指示。

类（AudioInputStream）javadoc：

音频输入流是具有指定音频格式和长度的输入流。长度以样本帧而不是字节表示。提供了几种方法来从流中读取一定数量的字节或未指定数量的字节。音频输入流会跟踪读取的最后一个字节。您可以跳过任意数量的字节以到达以后的位置进行读取。音频输入流可以支持标记。设置标记时，会记住当前位置，以便稍后返回。

AudioInputStream类包含许多操作AudioSystem对象的方法。例如，这些方法可让您：


从外部音频文件，流或AudioInputStream中获取音频输入流

从音频输入流中写入外部文件

将音频输入流转换为其他音频格式

URL javadoc：

跳过并丢弃此音频输入流中指定数量的字节。

此方法将始终跳过整数帧。如果AudioInputStream.skip未指定整数帧，则将最多跳过n个字节。

此外，如果查看n - (n % frameSize)的实现，则可以看到如果AudioInputStream.skip是if，第二条0语句将立即返回n。 / p>

<= 0

Java 10源代码。

负字节数的Java AudioInputStream跳过总是返回0

1 个答案: