media/gpu: restore some of the reformatting done during migration to media/gpu.

media/gpu/v4l2_slice_video_decode_accelerator.cc

 // Copyright 2015 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 "media/gpu/v4l2_slice_video_decode_accelerator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
@@ skipping 495 matching lines @@
   } else {
     DVLOG(1) << "No GL callbacks provided, initializing without GL support";
   }
 
   // Capabilities check.
   struct v4l2_capability caps;
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP"
-                  ", caps check failed: 0x"
-               << std::hex << caps.capabilities;
+               << ", caps check failed: 0x" << std::hex << caps.capabilities;
     return false;
   }
 
   if (!SetupFormats())
     return false;
 
   if (!decoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): device thread failed to start";
     return false;
   }
@@ skipping 163 matching lines @@
     struct v4l2_plane planes[VIDEO_MAX_PLANES];
     struct v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     memset(planes, 0, sizeof(planes));
     buffer.index = i;
     buffer.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     buffer.memory = V4L2_MEMORY_MMAP;
     buffer.m.planes = planes;
     buffer.length = input_planes_count_;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
-    void* address = device_->Mmap(nullptr, buffer.m.planes[0].length,
-                                  PROT_READ | PROT_WRITE, MAP_SHARED,
+    void* address = device_->Mmap(nullptr,
+                                  buffer.m.planes[0].length,
+                                  PROT_READ | PROT_WRITE,
+                                  MAP_SHARED,
                                   buffer.m.planes[0].m.mem_offset);
     if (address == MAP_FAILED) {
       PLOG(ERROR) << "CreateInputBuffers(): mmap() failed";
       return false;
     }
     input_buffer_map_[i].address = address;
     input_buffer_map_[i].length = buffer.m.planes[0].length;
   }
 
   return true;
@@ skipping 138 matching lines @@
   }
 
   DVLOGF(4) << "Scheduling device poll task";
 
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DevicePollTask,
                             base::Unretained(this), true));
 
   DVLOGF(2) << "buffer counts: "
             << "INPUT[" << decoder_input_queue_.size() << "]"
-            << " => DEVICE[" << free_input_buffers_.size() << "+"
-            << input_buffer_queued_count_ << "/" << input_buffer_map_.size()
-            << "]->[" << free_output_buffers_.size() << "+"
-            << output_buffer_queued_count_ << "/" << output_buffer_map_.size()
-            << "]"
+            << " => DEVICE["
+            << free_input_buffers_.size() << "+"
+            << input_buffer_queued_count_ << "/"
+            << input_buffer_map_.size() << "]->["
+            << free_output_buffers_.size() << "+"
+            << output_buffer_queued_count_ << "/"
+            << output_buffer_map_.size() << "]"
             << " => DISPLAYQ[" << decoder_display_queue_.size() << "]"
             << " => CLIENT[" << surfaces_at_display_.size() << "]";
 }
 
 void V4L2SliceVideoDecodeAccelerator::Enqueue(
     const scoped_refptr<V4L2DecodeSurface>& dec_surface) {
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   const int old_inputs_queued = input_buffer_queued_count_;
   const int old_outputs_queued = output_buffer_queued_count_;
@@ skipping 69 matching lines @@
         break;
       }
       PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
     DCHECK(output_record.at_device);
     output_record.at_device = false;
     output_buffer_queued_count_--;
-    DVLOGF(3) << "Dequeued output=" << dqbuf.index << " count "
-              << output_buffer_queued_count_;
+    DVLOGF(3) << "Dequeued output=" << dqbuf.index
+              << " count " << output_buffer_queued_count_;
 
     V4L2DecodeSurfaceByOutputId::iterator it =
         surfaces_at_device_.find(dqbuf.index);
     if (it == surfaces_at_device_.end()) {
       DLOG(ERROR) << "Got invalid surface from device.";
       NOTIFY_ERROR(PLATFORM_FAILURE);
     }
 
     it->second->SetDecoded();
     surfaces_at_device_.erase(it);
@@ skipping 530 matching lines @@
 void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffersTask(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kAwaitingPictureBuffers);
 
   const uint32_t req_buffer_count = decoder_->GetRequiredNumOfPictures();
 
   if (buffers.size() < req_buffer_count) {
     DLOG(ERROR) << "Failed to provide requested picture buffers. "
-                << "(Got " << buffers.size() << ", requested "
-                << req_buffer_count << ")";
+                << "(Got " << buffers.size()
+                << ", requested " << req_buffer_count << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   // Allocate the output buffers.
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = buffers.size();
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory =
@@ skipping 534 matching lines @@
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
     const scoped_refptr<H264Picture>& pic) {
   struct v4l2_ext_control ctrl;
   std::vector<struct v4l2_ext_control> ctrls;
 
   struct v4l2_ctrl_h264_sps v4l2_sps;
   memset(&v4l2_sps, 0, sizeof(v4l2_sps));
   v4l2_sps.constraint_set_flags =
-      sps->constraint_set0_flag
-          ? V4L2_H264_SPS_CONSTRAINT_SET0_FLAG
-          : 0 | sps->constraint_set1_flag
-                ? V4L2_H264_SPS_CONSTRAINT_SET1_FLAG
-                : 0 | sps->constraint_set2_flag
-                      ? V4L2_H264_SPS_CONSTRAINT_SET2_FLAG
-                      : 0 | sps->constraint_set3_flag
-                            ? V4L2_H264_SPS_CONSTRAINT_SET3_FLAG
-                            : 0 | sps->constraint_set4_flag
-                                  ? V4L2_H264_SPS_CONSTRAINT_SET4_FLAG
-                                  : 0 | sps->constraint_set5_flag
-                                        ? V4L2_H264_SPS_CONSTRAINT_SET5_FLAG
-                                        : 0;
+    sps->constraint_set0_flag ? V4L2_H264_SPS_CONSTRAINT_SET0_FLAG : 0 |

[kcwu, 2016/05/12 09:42:42]

Will git cl format be happier with parentheses?

I mean
(a?b:c) |
(a?b:c) |
(a?b:c) |
...

[Pawel Osciak, 2016/05/13 06:07:22]

Indeed! Thank you.

+    sps->constraint_set1_flag ? V4L2_H264_SPS_CONSTRAINT_SET1_FLAG : 0 |
+    sps->constraint_set2_flag ? V4L2_H264_SPS_CONSTRAINT_SET2_FLAG : 0 |
+    sps->constraint_set3_flag ? V4L2_H264_SPS_CONSTRAINT_SET3_FLAG : 0 |
+    sps->constraint_set4_flag ? V4L2_H264_SPS_CONSTRAINT_SET4_FLAG : 0 |
+    sps->constraint_set5_flag ? V4L2_H264_SPS_CONSTRAINT_SET5_FLAG : 0;
 #define SPS_TO_V4L2SPS(a) v4l2_sps.a = sps->a
   SPS_TO_V4L2SPS(profile_idc);
   SPS_TO_V4L2SPS(level_idc);
   SPS_TO_V4L2SPS(seq_parameter_set_id);
   SPS_TO_V4L2SPS(chroma_format_idc);
   SPS_TO_V4L2SPS(bit_depth_luma_minus8);
   SPS_TO_V4L2SPS(bit_depth_chroma_minus8);
   SPS_TO_V4L2SPS(log2_max_frame_num_minus4);
   SPS_TO_V4L2SPS(pic_order_cnt_type);
   SPS_TO_V4L2SPS(log2_max_pic_order_cnt_lsb_minus4);
@@ skipping 719 matching lines @@
 V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
 }  // namespace media