Use data pipe for encoded buffers in MojoAudioDecoder

media/mojo/services/mojo_audio_decoder.cc

Index: media/mojo/services/mojo_audio_decoder.cc
diff --git a/media/mojo/services/mojo_audio_decoder.cc b/media/mojo/services/mojo_audio_decoder.cc
index ee6fe3cdded26c4be697798da442fa4d1e099ba6..49d11329044c22b41f9b5cd15a7c60fddd5594b4 100644
--- a/media/mojo/services/mojo_audio_decoder.cc
+++ b/media/mojo/services/mojo_audio_decoder.cc
@@ -87,10 +87,8 @@ void MojoAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
   DCHECK(decode_cb_.is_null());
   decode_cb_ = decode_cb;
 
-  // This code won't work because |buffer| is not serialized.
-  // TODO(timav): Serialize DecodeBuffer into data pipe.
   remote_decoder_->Decode(
-      interfaces::DecoderBuffer::From(buffer),
+      TransferDecoderBuffer(buffer),
       base::Bind(&MojoAudioDecoder::OnDecodeStatus, base::Unretained(this)));
 }
 
@@ -153,6 +151,9 @@ void MojoAudioDecoder::OnInitialized(bool status,
 
   needs_bitstream_conversion_ = needs_bitstream_conversion;
 
+  if (status)
+    CreateDataPipe();
+
   task_runner_->PostTask(FROM_HERE, base::Bind(init_cb_, status));
 }
 
@@ -190,4 +191,38 @@ void MojoAudioDecoder::OnResetDone() {
   base::ResetAndReturn(&reset_cb_).Run();
 }
 
+void MojoAudioDecoder::CreateDataPipe() {
+  // Allocate DataPipe size based on audio content. 100kb should suffice.
+  MojoCreateDataPipeOptions options;
+  options.struct_size = sizeof(MojoCreateDataPipeOptions);
+  options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
+  options.element_num_bytes = 1;
+  options.capacity_num_bytes = 100 * 1024;

[xhwang, 2016/03/19 04:57:25]

We use 512k for audio in mojo_demuxer_stream:
https://code.google.com/p/chromium/codesearch#chromium/src/media/mojo/service...

[Tima Vaisburd, 2016/03/19 22:04:46]

We can calculate from the configuration if we know the frame duration in
advance. But we probably won't?
The maximal unencrypted frame size in 20 ms case is
48 samples/ms * 20 ms * 4 bytes/sample * 7 channels = 26880 bytes. Way less than
512k?

[xhwang, 2016/03/20 16:15:57]

Why 48k is the limit and why 20ms? We'll have only one DataPipe per audio
decoder so I don't think the size here would affect any performance. I was
trying to be consistent with the Renderer, and try to err on the safer side.

[Tima Vaisburd, 2016/03/21 19:08:26]

Used 512k and added TODO to evaluate a smaller size.

+
+  mojo::DataPipe write_pipe(options);
+
+  // Keep producer end.
+  producer_handle_ = std::move(write_pipe.producer_handle);
+
+  // Pass consumer end to |remote_decoder_|.
+  remote_decoder_->SetDataSource(std::move(write_pipe.consumer_handle));
+}
+
+interfaces::DecoderBufferPtr MojoAudioDecoder::TransferDecoderBuffer(
+    const scoped_refptr<DecoderBuffer>& media_buffer) {
+  interfaces::DecoderBufferPtr buffer =
+      interfaces::DecoderBuffer::From(media_buffer);
+  if (media_buffer->end_of_stream())
+    return buffer;
+
+  // Serialize the data section of the DecoderBuffer into our pipe.
+  uint32_t num_bytes = base::checked_cast<uint32_t>(media_buffer->data_size());
+  DCHECK_GT(num_bytes, 0u);
+  CHECK_EQ(WriteDataRaw(producer_handle_.get(), media_buffer->data(),
+                        &num_bytes, MOJO_READ_DATA_FLAG_ALL_OR_NONE),
+           MOJO_RESULT_OK);
+  CHECK_EQ(num_bytes, static_cast<uint32_t>(media_buffer->data_size()));
+  return buffer;
+}
+
 }  // namespace media