标签: buffering

在使用.play()JavaScript函数加载页面几秒钟后,我正在尝试播放HTML5音轨.

有时,当音频加载缓慢时,当播放器看起来像这样时触发.play():

缓冲时音频不播放.

有时,当音频快速加载并且播放器看起来像这样时,.play()工作正常.

围绕这个问题最快的方法是什么？(使用监听器？我坚持'加载时播放'功能).

我正在使用HP-UX.我想在stdout上禁用缓冲,以确保在使用以下命令进行核心转储的情况下打印每行代码:

setvbuf(stdout, NULL, _IONBF, 0); // turn off buffering for stdout

在这种情况下,它是否也影响打印到stdout的其他进程被重定向到某个日志文件？我想知道这个更改是否仅对于正在执行的进程是本地的.此外,我可以在进程中禁用缓冲,然后再在代码中再次设置_IO_FBF吗？(每次通话前fflush)

PS:我知道这会禁用缓冲并且I/O性能更差,但我想这只是为了调试目的.

我使用对象缓冲来缓冲我的php页面的输出ob_start('ob_gzhandler');.这是否会影响CDN中存储的文件的性能？

提出这个问题的原因是因为,其中一个网站指出了以下内容:"输出缓冲是一种大大提高PHP脚本性能和速度的简单方法.如果没有输出缓冲,您的脚本将在页面上显示HTML它被处理 - 分片.添加输出缓冲允许PHP将HTML存储为变量并将其发送到一个块中的浏览器."

你能澄清一下吗？

我有一个产生数据流的仪器；我的代码通过回调访问这些数据onDataAcquisitionEvent(const InstrumentOutput &data)。数据处理算法可能比数据到达的速度慢得多，所以我不能希望处理每一条数据（我没有必要），但希望处理尽可能多的数据。感谢该仪器作为环境传感器，其数据采集速率是我无法控制的。InstrumentOutput例如，可以是包含三个在不同位置同时进行的压力测量的类。

我还需要保留一些简短的数据历史记录。例如，假设我可以合理地希望每 200 毫秒左右处理一个数据样本。大多数情况下，我很乐意只处理最后一个样本，但有时我需要查看在最新样本之前到达的几秒钟的数据，这取决于最后一个样本中是否存在异常读数。

另一个要求是尽快退出onDataAcquisitionEvent()回调，以避免传感器中的数据丢失。

数据采集​​库（第三方）在单独的线程上采集仪器数据。

我想到了以下设计；具有单个生产者/单个消费者队列，并在 onDataAcquisitionEvent() 回调中将数据令牌推送到同步队列中。
在接收端，有一个循环从队列中弹出数据。由于数据到达率很高，循环几乎不会休眠。在每次迭代中，会发生以下情况：

1. 从队列中弹出所有可用数据，
2. 弹出的数据被复制到一个循环缓冲区中（我使用了 boost 循环缓冲区），这样一些历史总是可用的，
3. 处理缓冲区中的最后一个元素（并可能查看之前的元素），
4. 重复循环。

问题：

1. 这个设计合理吗，有什么陷阱？和
2. 什么是更好的设计？

编辑：我想到的一个问题是，当循环缓冲区的大小不足以容纳所需的历史记录时；目前我只是重新分配循环缓冲区，将其大小加倍。我希望我只需要这样做一两次。

我正在编写一个需要通过网络发送文件的应用程序.我到目前为止只学过如何使用标准的java.net和java.io类(在我大学的第一年),所以我没有java.nio和netty以及所有那些好东西的经验.我使用Socket和ServerSocket类以及BufferedInput/OutputStreams和BufferedFile流设置了一个正常工作的服务器/客户端,如下所示:

服务器:

    public class FiletestServer {

    static ServerSocket server;
    static BufferedInputStream in;
    static BufferedOutputStream out;

    public static void main(String[] args) throws Exception {
    server = new ServerSocket(12354);
    System.out.println("Waiting for client...");
    Socket s = server.accept();
    in = new BufferedInputStream(s.getInputStream(), 8192);
    out = new BufferedOutputStream(s.getOutputStream(), 8192);
    File f = new File("test.avi");
    BufferedInputStream fin = new BufferedInputStream(new FileInputStream(f), 8192);

    System.out.println("Sending to client...");
    byte[] b = new byte[8192];
    while (fin.read(b) != -1) {
        out.write(b);
    }
    fin.close();
    out.close();
    in.close();
    s.close();
    server.close();
    System.out.println("done!");
    }
}

和客户: …

我在VideoView上加载了一个.mp4,一切正常,直到我将搜索栏点拖到一个新位置,所以MediaPlayer开始缓冲,然后应用程序冻结(不崩溃,只是冻结),并显示错误消息:

"无法播放视频"

这是代码:

try {
        // Start the MediaController
        controller.setAnchorView(videoView);
        // Get the URL from String VideoURL
        Uri video = Uri.parse(getIntent().getExtras().getString("video"));
        videoView.setMediaController(controller);
        videoView.setVideoURI(video);

    } catch (Exception e) {
        Log.e("Error", e.getMessage());
        e.printStackTrace();
    }

    videoView.requestFocus();
    videoView.setOnPreparedListener(new OnPreparedListener() {
        // Close the progress bar and play the video
        public void onPrepared(MediaPlayer mp) {
            pDialog.dismiss();
            videoView.start();
        }
    });

如果我寻找已经缓冲的位置,没有错误.只有没有缓冲的位置.

错误日志:

Attempt to perform seekTo in wrong state: mPlayer=0x5c149090, mCurrentState=0
E/MediaPlayer(17339): error (1, -110)
E/MediaPlayer(17339): Error (1,-110)
D/VideoView(17339): Error: 1,-110

我有一个MediaPlayer用于流式传输互联网广播的服务:

public class MediaPlayerService extends Service implements 
    MediaPlayer.OnPreparedListener,
    MediaPlayer.OnBufferingUpdateListener {

    private MediaPlayer mMediaPlayer;
    private WifiLock mWifiLock;

    public int onStartCommand(Intent intent, int flags, int startId) {
        mMediaPlayer = new MediaPlayer();

        mMediaPlayer.setOnBufferingUpdateListener(this);
        mMediaPlayer.setOnPreparedListener(this);

        mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
        mMediaPlayer.setDataSource(MY_URL);

        // Acquire CPU lock and wi-fi lock

        mMediaPlayer.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
        mWifiLock = ((WifiManager) getSystemService(Context.WIFI_SERVICE))
             .createWifiLock(WifiManager.WIFI_MODE_FULL, "Media Player Wi-Fi Lock");
        mWifiLock.acquire();

        mMediaPlayer.prepareAsync();

        return START_STICKY;
    }

    @Override
    public void onPrepared(MediaPlayer mediaPlayer) {
        mMediaPlayer.start();
    }

    @Override
    public void onBufferingUpdate(MediaPlayer mp, int percent) {
        Log.d("Buffered " + percent);
    }
} …

我正在写一个相当复杂的脚本正在使用

asyncio.create_subprocess_exec(sub_cmd, *sub_cmd_args, stdout=PIPE, stderr=PIPE)

包装另一个Python程序 - 我无法永久修改或直接包含 - 捕获其stdout/err进行日志记录.包装的Python脚本没有使用-u(unbuffered)选项,因此包装器程序倾向于登录大缓冲块.如果这是常规子进程.Popen我可以传递bufsize=1给我想要的东西,即行缓冲.但是,如果我将它添加到asyncio.create_subprocess_exec(),他们会特意陷阱,我得到:

<snip>
  File "/usr/lib64/python3.4/asyncio/subprocess.py", line 193, in create_subprocess_exec
    stderr=stderr, **kwds)
  File "/usr/lib64/python3.4/asyncio/base_events.py", line 642, in subprocess_exec
    raise ValueError("bufsize must be 0")
ValueError: bufsize must be 0

我认为他们的陷阱是有充分理由的,所以我想知道是否还有其他一些方法可以影响传输缓冲.

如果我们使用下面的代码：

var media = new Media('url://...mp3', null, null, mediaStatusCallback);
media.play();

那么这将首先下载洞 mp3 文件，然后播放它。但问题是，如果我们有一个大尺寸的音频文件，它会被卡住，直到它完成下载洞文件，这会延迟播放器或无法使用，但我想异步下载部分 mp3 文件作为数组缓冲区并使用cordova 媒体插件，直到音频文件的下一部分被下载。这将一直持续到在播放部分音频时下载了洞文件。

基本上它就像网络音频 API 用来缓冲音频但使用cordova媒体插件播放它一样。

  var url = "sample_audio.mp3"; 

  var request = new XMLHttpRequest();
  request.open("GET", url, true);
  request.responseType = "arraybuffer";

  /* Asynchronous callback */
  request.onload = function()
  {
     /* Create the sound source */
     soundSource = context.createBufferSource();

     /* Import callback function that provides PCM audio data decoded as an audio buffer */
     context.decodeAudioData(request.response, function(buffer)
     {
        bufferData = buffer;
        soundSource.buffer = bufferData;
     }, this.onDecodeError);
  };
  request.send();

有没有人可以帮助我实现这一目标？我已经被这个问题困住了一段时间。 …

C++ iostreams控制C++流是否必须与C流同步std::ios_base::sync_with_stdio().关闭流同步允许标准库实现为C++流和C流使用独立的非同步缓冲区,以潜在地提高性能.

为实施者使用单独的独立io缓冲区用于C和C++流,为什么要打开一扇门是重要的？与一组io缓冲区相比,我没有看到这可能如何提高性能.在程序级别允许标准库一组io缓冲区可以减少通常昂贵的对底层OS io工具的调用次数,但是两组io缓冲区的优势是什么呢？

是否存在技术原因,C和C++流的单独缓冲区可以使性能受益,或者设计只是一个历史工件？

它是否与委员会有什么关系,希望C++实现者能够通过构建现有的C标准库实现来实现C++标准库？

我正在寻找的不仅仅是"标准这么说".

如果需要操作系统特性来解释基本原理,欢迎使用答案作为实际操作系统提供的io工具的示例,或者解释假设但合理的操作系统.

编辑:为了澄清,问题不是同步流可能会损害性能的原因.问题是为什么C++标准的设计假设可能有两组io缓冲区,为什么保持开放这种可能性对实现者有用.std::ios_base::sync_with_stdio()恰好是这种假设的结果.