Motown: wholesale clang-format

services/media/framework_ffmpeg/av_codec_context.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_ffmpeg/av_codec_context.h"
 #include "services/media/framework_ffmpeg/ffmpeg_init.h"
 extern "C" {
 #include "third_party/ffmpeg/libavformat/avformat.h"
 }
@@ skipping 37 matching lines @@
   size_t byte_count = bytes.size();
   uint8_t* copy = reinterpret_cast<uint8_t*>(malloc(byte_count));
   std::memcpy(copy, bytes.data(), byte_count);
   context->extradata = copy;
   context->extradata_size = byte_count;
 }
 
 // Creates a StreamType from an AVCodecContext describing an LPCM type.
 std::unique_ptr<StreamType> StreamTypeFromLpcmCodecContext(
     const AVCodecContext& from) {
-  return LpcmStreamType::Create(
-      Convert(from.sample_fmt),
-      from.channels,
-      from.sample_rate);
+  return LpcmStreamType::Create(Convert(from.sample_fmt), from.channels,
+                                from.sample_rate);
 }
 
 // Creates a StreamType from an AVCodecContext describing a compressed audio
 // type.
-std::unique_ptr<StreamType>
-StreamTypeFromCompressedAudioCodecContext(const AVCodecContext& from) {
+std::unique_ptr<StreamType> StreamTypeFromCompressedAudioCodecContext(
+    const AVCodecContext& from) {
   CompressedAudioStreamType::AudioEncoding encoding;
   switch (from.codec_id) {
     case CODEC_ID_VORBIS:
       encoding = CompressedAudioStreamType::AudioEncoding::kVorbis;
       break;
     default:
       encoding = CompressedAudioStreamType::AudioEncoding::kUnknown;
       break;
   }
 
   return CompressedAudioStreamType::Create(
-      encoding,
-      Convert(from.sample_fmt),
-      from.channels,
-      from.sample_rate,
-      from.extradata_size == 0 ?
-          nullptr :
-          Bytes::Create(from.extradata, from.extradata_size));
+      encoding, Convert(from.sample_fmt), from.channels, from.sample_rate,
+      from.extradata_size == 0 ? nullptr : Bytes::Create(from.extradata,
+                                                         from.extradata_size));
 }
 
 // Converts AVColorSpace and AVColorRange to ColorSpace.
 VideoStreamType::ColorSpace ColorSpaceFromAVColorSpaceAndRange(
     AVColorSpace color_space,
     AVColorRange color_range) {
   // TODO(dalesat): Blindly copied from Chromium.
   if (color_range == AVCOL_RANGE_JPEG) {
     return VideoStreamType::ColorSpace::kJpeg;
   }
@@ skipping 30 matching lines @@
     case VideoStreamType::VideoProfile::kH264High444Predictive:
       return FF_PROFILE_H264_HIGH_444_PREDICTIVE;
     case VideoStreamType::VideoProfile::kUnknown:
     case VideoStreamType::VideoProfile::kNotApplicable:
     case VideoStreamType::VideoProfile::kH264ScalableBaseline:
     case VideoStreamType::VideoProfile::kH264ScalableHigh:
     case VideoStreamType::VideoProfile::kH264StereoHigh:
     case VideoStreamType::VideoProfile::kH264MultiviewHigh:
     default:
       return FF_PROFILE_UNKNOWN;
-   }
+  }
 }
 
 // Converts an AVPixelFormat to a PixelFormat.
 VideoStreamType::PixelFormat PixelFormatFromAVPixelFormat(
     AVPixelFormat av_pixel_format) {
   // TODO(dalesat): Blindly copied from Chromium.
   switch (av_pixel_format) {
     case AV_PIX_FMT_YUV422P:
     case AV_PIX_FMT_YUVJ422P:
       return VideoStreamType::PixelFormat::kYv16;
     case AV_PIX_FMT_YUV444P:
     case AV_PIX_FMT_YUVJ444P:
       return VideoStreamType::PixelFormat::kYv24;
     case AV_PIX_FMT_YUV420P:
     case AV_PIX_FMT_YUVJ420P:
       return VideoStreamType::PixelFormat::kYv12;
     case AV_PIX_FMT_YUVA420P:
       return VideoStreamType::PixelFormat::kYv12A;
     default:
-    return VideoStreamType::PixelFormat::kUnknown;
+      return VideoStreamType::PixelFormat::kUnknown;
   }
 }
 
 // Converts a PixelFormat to an AVPixelFormat.
 AVPixelFormat AVPixelFormatFromPixelFormat(
     VideoStreamType::PixelFormat pixel_format) {
   // TODO(dalesat): Blindly copied from Chromium.
   switch (pixel_format) {
     case VideoStreamType::PixelFormat::kYv12:
       return AV_PIX_FMT_YUV420P;
@@ skipping 18 matching lines @@
     default:
       return AV_PIX_FMT_NONE;
   }
 }
 
 // Creates a StreamType from an AVCodecContext describing a video type.
 std::unique_ptr<StreamType> StreamTypeFromVideoCodecContext(
     const AVCodecContext& from) {
   VideoStreamType::VideoEncoding encoding;
   switch (from.codec_id) {
-    case AV_CODEC_ID_THEORA :
+    case AV_CODEC_ID_THEORA:
       encoding = VideoStreamType::VideoEncoding::kTheora;
       break;
     case CODEC_ID_VP8:
       encoding = VideoStreamType::VideoEncoding::kVp8;
       break;
     default:
       encoding = VideoStreamType::VideoEncoding::kUnknown;
       break;
   }
 
   return VideoStreamType::Create(
-      encoding,
-      VideoStreamType::VideoProfile::kNotApplicable,
+      encoding, VideoStreamType::VideoProfile::kNotApplicable,
       PixelFormatFromAVPixelFormat(from.pix_fmt),
       ColorSpaceFromAVColorSpaceAndRange(from.colorspace, from.color_range),
-      from.width,
-      from.height,
-      from.coded_width,
-      from.coded_height,
-      from.extradata_size == 0 ?
-          nullptr :
-          Bytes::Create(from.extradata, from.extradata_size));
+      from.width, from.height, from.coded_width, from.coded_height,
+      from.extradata_size == 0 ? nullptr : Bytes::Create(from.extradata,
+                                                         from.extradata_size));
 }
 
 // Creates a StreamType from an AVCodecContext describing a data type.
 std::unique_ptr<StreamType> StreamTypeFromDataCodecContext(
     const AVCodecContext& from) {
   // TODO(dalesat): Implement.
   return StreamType::Create(StreamType::Scheme::kUnknown);
 }
 
 // Creates a StreamType from an AVCodecContext describing a subtitle type.
@@ skipping 122 matching lines @@
         default:
           if (from.codec == nullptr) {
             return StreamTypeFromCompressedAudioCodecContext(from);
           } else {
             return StreamTypeFromLpcmCodecContext(from);
           }
       }
     case AVMEDIA_TYPE_VIDEO:
       return StreamTypeFromVideoCodecContext(from);
     case AVMEDIA_TYPE_UNKNOWN:
-      // Treated as AVMEDIA_TYPE_DATA.
+    // Treated as AVMEDIA_TYPE_DATA.
     case AVMEDIA_TYPE_DATA:
       return StreamTypeFromDataCodecContext(from);
     case AVMEDIA_TYPE_SUBTITLE:
       return StreamTypeFromSubtitleCodecContext(from);
     case AVMEDIA_TYPE_ATTACHMENT:
     case AVMEDIA_TYPE_NB:
     default:
       return StreamType::Create(StreamType::Scheme::kUnknown);
   }
 }
 
 // static
 AvCodecContextPtr AvCodecContext::Create(const StreamType& stream_type) {
   InitFfmpeg();
 
   switch (stream_type.scheme()) {
     case StreamType::Scheme::kLpcm:
       return CodecContextFromLpcmDetails(*stream_type.lpcm());
     case StreamType::Scheme::kCompressedAudio:
       return AVCodecContextFromCompressedAudioStreamType(
           *stream_type.compressed_audio());
     case StreamType::Scheme::kVideo:
       return AVCodecContextFromVideoStreamType(*stream_type.video());
     default:
       return nullptr;
   }
 }
 
-} // namespace media
-} // namespace mojo
+}  // namespace media
+}  // namespace mojo