Lint

Author: NicolasHug

torchvision/csrc/io/decoder/gpu/gpu_decoder.cpp

@@ -46,8 +46,8 @@ void GPUDecoder::seek(double timestamp, bool keyframes_only) {
   demuxer.seek(timestamp, flag);
 }
 
-c10::Dict<std::string, c10::Dict<std::string, double>>
-GPUDecoder::get_metadata() const {
+c10::Dict<std::string, c10::Dict<std::string, double>> GPUDecoder::
+    get_metadata() const {
   c10::Dict<std::string, c10::Dict<std::string, double>> metadata;
   c10::Dict<std::string, double> video_metadata;
   video_metadata.insert("duration", demuxer.get_duration());

torchvision/csrc/io/decoder/util.cpp

@@ -12,8 +12,11 @@ inline size_t getSize(const T& x) {
 }
 
 template <typename T>
-inline bool
-serializeItem(uint8_t* dest, size_t len, size_t& pos, const T& src) {
+inline bool serializeItem(
+    uint8_t* dest,
+    size_t len,
+    size_t& pos,
+    const T& src) {
   VLOG(6) << "Generic serializeItem";
   const auto required = sizeof(src);
   if (len < pos + required) {
@@ -25,8 +28,11 @@ serializeItem(uint8_t* dest, size_t len, size_t& pos, const T& src) {
 }
 
 template <typename T>
-inline bool
-deserializeItem(const uint8_t* src, size_t len, size_t& pos, T& dest) {
+inline bool deserializeItem(
+    const uint8_t* src,
+    size_t len,
+    size_t& pos,
+    T& dest) {
   const auto required = sizeof(dest);
   if (len < pos + required) {
     return false;
@@ -135,8 +141,11 @@ inline bool serializeItem(
       rectSerialize(dest, len, pos, src);
 }
 
-inline bool
-serializeItem(uint8_t* dest, size_t len, size_t& pos, const AVSubtitle& src) {
+inline bool serializeItem(
+    uint8_t* dest,
+    size_t len,
+    size_t& pos,
+    const AVSubtitle& src) {
   auto rectSerialize =
       [](uint8_t* d, size_t l, size_t& p, const AVSubtitle& x) -> bool {
     bool res = serializeItem(d, l, p, x.num_rects);
@@ -217,8 +226,11 @@ inline bool deserializeItem(
       rectDeserialize(src, len, pos, dest);
 }
 
-inline bool
-deserializeItem(const uint8_t* src, size_t len, size_t& pos, AVSubtitle& dest) {
+inline bool deserializeItem(
+    const uint8_t* src,
+    size_t len,
+    size_t& pos,
+    AVSubtitle& dest) {
   auto rectDeserialize =
       [](const uint8_t* y, size_t l, size_t& p, AVSubtitle& x) -> bool {
     bool res = deserializeItem(y, l, p, x.num_rects);

torchvision/csrc/io/video/video.cpp

@@ -290,8 +290,8 @@ std::tuple<std::string, int64_t> Video::getCurrentStream() const {
   return current_stream;
 }
 
-c10::Dict<std::string, c10::Dict<std::string, std::vector<double>>>
-Video::getStreamMetadata() const {
+c10::Dict<std::string, c10::Dict<std::string, std::vector<double>>> Video::
+    getStreamMetadata() const {
   TORCH_CHECK(initialized, "Video object has to be initialized first");
   return streamsMetadata;
 }

torchvision/csrc/io/video/video.h

@@ -21,8 +21,10 @@ struct Video : torch::CustomClassHolder {
       std::string videoPath = std::string(),
       std::string stream = std::string("video"),
       int64_t numThreads = 0);
-  void
-  initFromFile(std::string videoPath, std::string stream, int64_t numThreads);
+  void initFromFile(
+      std::string videoPath,
+      std::string stream,
+      int64_t numThreads);
   void initFromMemory(
       torch::Tensor videoTensor,
       std::string stream,

torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu

@@ -245,7 +245,7 @@ void deformable_im2col(
   use_64bits_indexing |=
       ((int64_t)n_in_channels * weight_h * weight_w * parallel_imgs * out_h *
            out_w >
-           std::numeric_limits<int32_t>::max());
+       std::numeric_limits<int32_t>::max());
 
   if (use_64bits_indexing) {
     AT_DISPATCH_FLOATING_TYPES_AND_HALF(

torchvision/csrc/ops/cuda/nms_kernel.cu

@@ -14,8 +14,10 @@ namespace {
 int const threadsPerBlock = sizeof(unsigned long long) * 8;
 
 template <typename T>
-__device__ inline bool
-devIoU(T const* const a, T const* const b, const float threshold) {
+__device__ inline bool devIoU(
+    T const* const a,
+    T const* const b,
+    const float threshold) {
   T left = max(a[0], b[0]), right = min(a[2], b[2]);
   T top = max(a[1], b[1]), bottom = min(a[3], b[3]);
   T width = max(right - left, (T)0), height = max(bottom - top, (T)0);

torchvision/csrc/ops/nms.cpp

@@ -7,8 +7,10 @@
 namespace vision {
 namespace ops {
 
-at::Tensor
-nms(const at::Tensor& dets, const at::Tensor& scores, double iou_threshold) {
+at::Tensor nms(
+    const at::Tensor& dets,
+    const at::Tensor& scores,
+    double iou_threshold) {
   C10_LOG_API_USAGE_ONCE("torchvision.csrc.ops.nms.nms");
   static auto op = c10::Dispatcher::singleton()
                        .findSchemaOrThrow("torchvision::nms", "")

torchvision/csrc/ops/nms.h

@@ -6,8 +6,10 @@
 namespace vision {
 namespace ops {
 
-VISION_API at::Tensor
-nms(const at::Tensor& dets, const at::Tensor& scores, double iou_threshold);
+VISION_API at::Tensor nms(
+    const at::Tensor& dets,
+    const at::Tensor& scores,
+    double iou_threshold);
 
 } // namespace ops
 } // namespace vision