Motown: wholesale clang-format

services/media/framework/parts/lpcm_reformatter.cc

 // 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.
 
 #include "base/logging.h"
 #include "services/media/framework/parts/lpcm_reformatter.h"
 
 namespace mojo {
 namespace media {
 
 // LpcmReformatter implementation that accepts samples of type TIn and
 // produces samples of type TOut.
-template<typename TIn, typename TOut>
+template <typename TIn, typename TOut>
 class LpcmReformatterImpl : public LpcmReformatter {
  public:
-  LpcmReformatterImpl(
-      const LpcmStreamType& in_type,
-      const LpcmStreamTypeSet& out_type);
+  LpcmReformatterImpl(const LpcmStreamType& in_type,
+                      const LpcmStreamTypeSet& out_type);
 
   ~LpcmReformatterImpl() override;
 
   // Transform implementation.
-  bool TransformPacket(
-      const PacketPtr& input,
-      bool new_input,
-      PayloadAllocator* allocator,
-      PacketPtr* output) override;
+  bool TransformPacket(const PacketPtr& input,
+                       bool new_input,
+                       PayloadAllocator* allocator,
+                       PacketPtr* output) override;
 
  private:
   LpcmStreamType in_type_;
   LpcmStreamType out_type_;
 };
 
 std::shared_ptr<LpcmReformatter> LpcmReformatter::Create(
     const LpcmStreamType& in_type,
     const LpcmStreamTypeSet& out_type) {
   LpcmReformatter* result = nullptr;
 
   switch (in_type.sample_format()) {
     case LpcmStreamType::SampleFormat::kUnsigned8:
       switch (out_type.sample_format()) {
         case LpcmStreamType::SampleFormat::kUnsigned8:
         case LpcmStreamType::SampleFormat::kAny:
-          result = new LpcmReformatterImpl<uint8_t, uint8_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<uint8_t, uint8_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned16:
-          result = new LpcmReformatterImpl<uint8_t, int16_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<uint8_t, int16_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned24In32:
-          result = new LpcmReformatterImpl<uint8_t, int32_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<uint8_t, int32_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kFloat:
-          result = new LpcmReformatterImpl<uint8_t, float>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<uint8_t, float>(in_type, out_type);
           break;
         default:
           NOTREACHED() << "unsupported sample format";
           result = nullptr;
           break;
       }
       break;
     case LpcmStreamType::SampleFormat::kSigned16:
       switch (out_type.sample_format()) {
         case LpcmStreamType::SampleFormat::kUnsigned8:
-          result = new LpcmReformatterImpl<int16_t, uint8_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int16_t, uint8_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned16:
         case LpcmStreamType::SampleFormat::kAny:
-          result = new LpcmReformatterImpl<int16_t, int16_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int16_t, int16_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned24In32:
-          result = new LpcmReformatterImpl<int16_t, int32_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int16_t, int32_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kFloat:
-          result = new LpcmReformatterImpl<int16_t, float>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int16_t, float>(in_type, out_type);
           break;
         default:
           NOTREACHED() << "unsupported sample format";
           result = nullptr;
           break;
       }
       break;
     case LpcmStreamType::SampleFormat::kSigned24In32:
       switch (out_type.sample_format()) {
         case LpcmStreamType::SampleFormat::kUnsigned8:
-          result = new LpcmReformatterImpl<int32_t, uint8_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int32_t, uint8_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned16:
-          result = new LpcmReformatterImpl<int32_t, int16_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int32_t, int16_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned24In32:
         case LpcmStreamType::SampleFormat::kAny:
-          result = new LpcmReformatterImpl<int32_t, int32_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int32_t, int32_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kFloat:
-          result = new LpcmReformatterImpl<int32_t, float>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<int32_t, float>(in_type, out_type);
           break;
         default:
           NOTREACHED() << "unsupported sample format";
           result = nullptr;
           break;
       }
       break;
     case LpcmStreamType::SampleFormat::kFloat:
       switch (out_type.sample_format()) {
         case LpcmStreamType::SampleFormat::kUnsigned8:
-          result = new LpcmReformatterImpl<float, uint8_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<float, uint8_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned16:
-          result = new LpcmReformatterImpl<float, int16_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<float, int16_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kSigned24In32:
-          result = new LpcmReformatterImpl<float, int32_t>(
-              in_type, out_type);
+          result = new LpcmReformatterImpl<float, int32_t>(in_type, out_type);
           break;
         case LpcmStreamType::SampleFormat::kFloat:
         case LpcmStreamType::SampleFormat::kAny:
           result = new LpcmReformatterImpl<float, float>(in_type, out_type);
           break;
         default:
           NOTREACHED() << "unsupported sample format";
           result = nullptr;
           break;
       }
       break;
     default:
       NOTREACHED() << "unsupported sample format";
       result = nullptr;
       break;
   }
 
   return std::shared_ptr<LpcmReformatter>(result);
 }
 
-template<typename TIn, typename TOut>
+template <typename TIn, typename TOut>
 LpcmReformatterImpl<TIn, TOut>::LpcmReformatterImpl(
     const LpcmStreamType& in_type,
-    const LpcmStreamTypeSet& out_type) :
-    in_type_(in_type),
-    out_type_(
-        out_type.sample_format() == LpcmStreamType::SampleFormat::kAny ?
-            in_type.sample_format() :
-            out_type.sample_format(),
-        in_type.channels(),
-        in_type.frames_per_second()) {}
+    const LpcmStreamTypeSet& out_type)
+    : in_type_(in_type),
+      out_type_(out_type.sample_format() == LpcmStreamType::SampleFormat::kAny
+                    ? in_type.sample_format()
+                    : out_type.sample_format(),
+                in_type.channels(),
+                in_type.frames_per_second()) {}
 
-template<typename TIn, typename TOut>
+template <typename TIn, typename TOut>
 LpcmReformatterImpl<TIn, TOut>::~LpcmReformatterImpl() {}
 
 namespace {
 
 template <typename T>
 inline constexpr T Clamp(T val, T min, T max) {
   return (val > max) ? max : ((val < min) ? min : val);
 }
 
 template <typename T>
 inline constexpr T Clamp(T val);
 
 template <>
 inline constexpr float Clamp(float val) {
   return Clamp(val, -1.0f, 1.0f);
 }
 
 template <>
 inline constexpr int32_t Clamp(int32_t val) {
   return Clamp(val, 1 << 23, -(1 << 23));
 }
 
-template<typename TIn, typename TOut>
+template <typename TIn, typename TOut>
 inline void CopySample(TOut* dest, const TIn* source) {
   *dest = static_cast<TOut>(*source);
 }
 
 inline void CopySample(uint8_t* dest, const int16_t* source) {
   *dest = static_cast<uint8_t>((*source >> 8) ^ 0x80);
 }
 
 inline void CopySample(uint8_t* dest, const int32_t* source) {
   *dest = static_cast<uint8_t>((Clamp(*source) >> 16) ^ 0x80);
@@ skipping 32 matching lines @@
 }
 
 inline void CopySample(float* dest, const int16_t* source) {
   *dest = static_cast<float>(*source) / 0x8000;
 }
 
 inline void CopySample(float* dest, const int32_t* source) {
   *dest = static_cast<float>(Clamp(*source)) / 0x800000;
 }
 
-} // namespace
+}  // namespace
 
-template<typename TIn, typename TOut>
+template <typename TIn, typename TOut>
 bool LpcmReformatterImpl<TIn, TOut>::TransformPacket(
     const PacketPtr& input,
     bool new_input,
     PayloadAllocator* allocator,
     PacketPtr* output) {
   DCHECK(input);
   DCHECK(allocator);
   DCHECK(output);
 
   uint64_t in_size = input->size();
   if (in_size == 0) {
     // Zero-sized input packet. Make a copy.
-    *output = Packet::Create(
-        input->pts(),
-        input->end_of_stream(),
-        0,
-        nullptr,
-        nullptr);
+    *output = Packet::Create(input->pts(), input->end_of_stream(), 0, nullptr,
+                             nullptr);
     return true;
   }
 
   size_t frame_count = in_type_.frame_count(in_size);
   uint64_t out_size = out_type_.min_buffer_size(frame_count);
 
   void* buffer = allocator->AllocatePayloadBuffer(out_size);
   if (buffer == nullptr) {
     LOG(WARNING) << "lpcm reformatter starved for buffers";
     // Starved for buffer space. Can't process now.
     *output = nullptr;
     return false;
   }
 
   const TIn* in_channel = static_cast<const TIn*>(input->payload());
   TOut* out_channel = static_cast<TOut*>(buffer);
 
   for (uint32_t channel = 0; channel < in_type_.channels(); channel++) {
     const TIn* in_sample = in_channel;
     TOut* out_sample = out_channel;
     for (size_t sample = 0; sample < frame_count; sample++) {
       CopySample(out_sample, in_sample);
       in_sample += in_type_.channels();
       out_sample += out_type_.channels();
     }
     ++in_channel;
     ++out_channel;
   }
 
-  *output = Packet::Create(
-      input->pts(),
-      input->end_of_stream(),
-      out_size,
-      buffer,
-      allocator);
+  *output = Packet::Create(input->pts(), input->end_of_stream(), out_size,
+                           buffer, allocator);
 
   return true;
 }
 
 }  // namespace media
 }  // namespace mojo