Reland: Refactor Vaapi video decoder/encoder in preparation of Freon support

content/common/gpu/media/vaapi_video_encode_accelerator.cc

 // Copyright 2014 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 "content/common/gpu/media/vaapi_video_encode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 95 matching lines @@
 
 std::vector<media::VideoEncodeAccelerator::SupportedProfile>
 VaapiVideoEncodeAccelerator::GetSupportedProfiles() {
   std::vector<SupportedProfile> profiles;
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kDisableVaapiAcceleratedVideoEncode))
     return profiles;
 
   std::vector<media::VideoCodecProfile> hw_profiles =
-      VaapiWrapper::GetSupportedEncodeProfiles(
-          x_display_, base::Bind(&base::DoNothing));
+      VaapiWrapper::GetSupportedEncodeProfiles(base::Bind(&base::DoNothing));
 
   media::VideoEncodeAccelerator::SupportedProfile profile;
   profile.max_resolution.SetSize(1920, 1088);
   profile.max_framerate_numerator = kDefaultFramerate;
   profile.max_framerate_denominator = 1;
   for (size_t i = 0; i < hw_profiles.size(); i++) {
     profile.profile = hw_profiles[i];
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 static unsigned int Log2OfPowerOf2(unsigned int x) {
   CHECK_GT(x, 0u);
   DCHECK_EQ(x & (x - 1), 0u);
 
   int log = 0;
   while (x) {
     x >>= 1;
     ++log;
   }
   return log;
 }
 
-VaapiVideoEncodeAccelerator::VaapiVideoEncodeAccelerator(Display* x_display)
+VaapiVideoEncodeAccelerator::VaapiVideoEncodeAccelerator()
     : profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
       mb_width_(0),
       mb_height_(0),
       output_buffer_byte_size_(0),
-      x_display_(x_display),
       state_(kUninitialized),
       frame_num_(0),
       last_idr_frame_num_(0),
       bitrate_(0),
       framerate_(0),
       cpb_size_(0),
       encoding_parameters_changed_(false),
       encoder_thread_("VAVEAEncoderThread"),
       child_message_loop_proxy_(base::MessageLoopProxy::current()),
       weak_this_ptr_factory_(this) {
@@ skipping 52 matching lines @@
   coded_size_ = gfx::Size(RoundUpToPowerOf2(visible_size_.width(), 16),
                           RoundUpToPowerOf2(visible_size_.height(), 16));
   mb_width_ = coded_size_.width() / 16;
   mb_height_ = coded_size_.height() / 16;
   output_buffer_byte_size_ = coded_size_.GetArea();
 
   UpdateRates(initial_bitrate, kDefaultFramerate);
 
   vaapi_wrapper_ = VaapiWrapper::Create(VaapiWrapper::kEncode,
                                         output_profile,
-                                        x_display_,
                                         base::Bind(&ReportToUMA, VAAPI_ERROR));
-  if (!vaapi_wrapper_) {
+  if (!vaapi_wrapper_.get()) {
     LOG(ERROR) << "Failed initializing VAAPI";
     return false;
   }
 
   if (!encoder_thread_.Start()) {
     LOG(ERROR) << "Failed to start encoder thread";
     return false;
   }
   encoder_thread_proxy_ = encoder_thread_.message_loop_proxy();
 
@@ skipping 364 matching lines @@
 
   DCHECK(!current_encode_job_);
   current_encode_job_.reset(new EncodeJob());
 
   if (!vaapi_wrapper_->CreateCodedBuffer(output_buffer_byte_size_,
                                          &current_encode_job_->coded_buffer)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed creating coded buffer");
     return false;
   }
 
-  current_encode_job_->input_surface =
-      new VASurface(available_va_surface_ids_.back(), va_surface_release_cb_);
+  current_encode_job_->input_surface = new VASurface(
+      available_va_surface_ids_.back(), coded_size_, va_surface_release_cb_);
   available_va_surface_ids_.pop_back();
 
-  current_encode_job_->recon_surface =
-      new VASurface(available_va_surface_ids_.back(), va_surface_release_cb_);
+  current_encode_job_->recon_surface = new VASurface(
+      available_va_surface_ids_.back(), coded_size_, va_surface_release_cb_);
   available_va_surface_ids_.pop_back();
 
   // Reference surfaces are needed until the job is done, but they get
   // removed from ref_pic_list0_ when it's full at the end of job submission.
   // Keep refs to them along with the job and only release after sync.
   current_encode_job_->reference_surfaces = ref_pic_list0_;
 
   return true;
 }
 
@@ skipping 435 matching lines @@
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
     : coded_buffer(VA_INVALID_ID), keyframe(false) {
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {
 }
 
 }  // namespace content