Motown in-proc streaming framework used to implement media services.

services/media/framework/lpcm_util.h

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SERVICES_MEDIA_FRAMEWORK_LPCM_UTIL_H_
+#define SERVICES_MEDIA_FRAMEWORK_LPCM_UTIL_H_
+
+#include "services/media/framework/stream_type.h"
+
+namespace mojo {
+namespace media {
+
+// Helper class that performs various LPCM processing functions.
+class LpcmUtil {
+ public:
+  static LpcmUtil* Create(const LpcmStreamType& stream_type);

[johngro, 2016/01/25 18:55:43]

virtual ~LpcmUtil() { }

[dalesat, 2016/01/25 23:29:37]

Done.

+
+  // Fills the buffer with silence.
+  virtual void Silence(void* buffer, uint64_t frame_count) const = 0;
+
+  // Copies samples.
+  virtual void Copy(void* in, void* out, uint64_t frame_count) const = 0;
+
+  // Mixes samples.
+  virtual void Mix(void* in, void* out, uint64_t frame_count) const = 0;
+
+  // Interleaves non-interleaved samples.
+  virtual void Interleave(
+      void* in,

[johngro, 2016/01/25 18:55:43]

const void* for the in param, here and below

[dalesat, 2016/01/25 23:29:37]

Done for all inputs.

+      uint64_t in_byte_count,

[johngro, 2016/01/25 18:55:43]

in_byte_count seems redundant here.  Don't we know everything we need to know
(number of channels in a frame, number of bytes in a sample) from the stream
type which was specified at creation time?  It this to allow us to interleave
only part of a non-interleaved packet?  If so, how do we manage to interleave
the rest of the data later on (we will be offset into the first "plane" and
subsequent planes will be larger)

[dalesat, 2016/01/25 23:29:37]

The layout of non-interleaved samples we get from ffmpeg is such that the
payload is evenly divided into a buffer for each frame (so each buffer is
in_byte_count / frames_per_sample in size). The samples for a frame are
contiguous in the buffer starting at the beginning of the buffer, but they don't
necessarily fill the buffer.

[johngro, 2016/01/27 22:35:22]

k, This is an important detail/assertion; perhaps a comment outlining this would
be a good idea.

Somewhere there needs to be a
DCHECK((in_byte_count % bytes_per_frame()) == 0);
DCHECK((in_byte_count > bytes_per_frame()) >= frame_count);

Alternatively, you could keep things in units of frames and have something like
total_frame_count and active_frame_count, in which case all you would need would
be
DCHECK(total_frame_count >= active_frame_count);

[dalesat, 2016/01/28 18:49:15]

Done.

+      void* out,
+      uint64_t frame_count) const = 0;
+};
+
+// LpcmUtil implementation that processes samples of type T.
+template<typename T>
+class LpcmUtilImpl : public LpcmUtil {

[johngro, 2016/01/25 18:55:43]

In theory, you can bury the Impl class definition inside of the .cc file, since
everyone should be using LpcmUtil to create their Utils instances anyway. This
will give you the freedom to have all sorts of implementations, not just the
ones based on this particular template.

[dalesat, 2016/01/25 23:29:37]

Done.

+ public:
+  LpcmUtilImpl(const LpcmStreamType& stream_type);

[johngro, 2016/01/25 18:55:43]

probably want to make this private and make the interface class a friend so that
everyone is forced to use the interface's Create method.  Also might want to
consider having Create return a std::unique_ptr

[dalesat, 2016/01/25 23:29:37]

Done.

+
+  ~LpcmUtilImpl();
+
+  void Silence(void* buffer, uint64_t frame_count) const override;
+
+  void Copy(void* in, void* out, uint64_t frame_count) const override;
+
+  void Mix(void* in, void* out, uint64_t frame_count) const override;
+
+  void Interleave(
+      void* in,
+      uint64_t in_byte_count,
+      void* out,
+      uint64_t frame_count) const override;
+
+ private:
+  LpcmStreamType stream_type_;
+};
+
+}  // namespace media
+}  // namespace mojo
+
+#endif // SERVICES_MEDIA_FRAMEWORK_LPCM_UTIL_H_