content/common/gpu/media/vaapi_video_decode_accelerator.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/debug/trace_event.h"
   7 #include "base/logging.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/stl_util.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/synchronization/waitable_event.h"
  12 #include "content/child/child_thread.h"
  13 #include "content/common/gpu/gpu_channel.h"
  14 #include "content/common/gpu/media/vaapi_video_decode_accelerator.h"
  15 #include "media/base/bind_to_loop.h"
  16 #include "media/video/picture.h"
  17 #include "ui/gl/gl_bindings.h"
  18 #include "ui/gl/scoped_binders.h"
  19
  20 static void ReportToUMA(
  21     content::VaapiH264Decoder::VAVDAH264DecoderFailure failure) {
  22   UMA_HISTOGRAM_ENUMERATION(
  23       "Media.VAVDAH264.DecoderFailure",
  24       failure,
  25       content::VaapiH264Decoder::VAVDA_H264_DECODER_FAILURES_MAX);
  26 }
  27
  28 namespace content {
  29
  30 #define RETURN_AND_NOTIFY_ON_FAILURE(result, log, error_code, ret)  \
  31   do {                                                              \
  32     if (!(result)) {                                                \
  33       DVLOG(1) << log;                                              \
  34       NotifyError(error_code);                                      \
  35       return ret;                                                   \
  36     }                                                               \
  37   } while (0)
  38
  39 VaapiVideoDecodeAccelerator::InputBuffer::InputBuffer() : id(0), size(0) {
  40 }
  41
  42 VaapiVideoDecodeAccelerator::InputBuffer::~InputBuffer() {
  43 }
  44
  45 void VaapiVideoDecodeAccelerator::NotifyError(Error error) {
  46   if (message_loop_ != base::MessageLoop::current()) {
  47     DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
  48     message_loop_->PostTask(FROM_HERE, base::Bind(
  49         &VaapiVideoDecodeAccelerator::NotifyError, weak_this_, error));
  50     return;
  51   }
  52
  53   // Post Cleanup() as a task so we don't recursively acquire lock_.
  54   message_loop_->PostTask(FROM_HERE, base::Bind(
  55       &VaapiVideoDecodeAccelerator::Cleanup, weak_this_));
  56
  57   DVLOG(1) << "Notifying of error " << error;
  58   if (client_) {
  59     client_->NotifyError(error);
  60     client_ptr_factory_.InvalidateWeakPtrs();
  61   }
  62 }
  63
  64 // TFPPicture allocates X Pixmaps and binds them to textures passed
  65 // in PictureBuffers from clients to them. TFPPictures are created as
  66 // a consequence of receiving a set of PictureBuffers from clients and released
  67 // at the end of decode (or when a new set of PictureBuffers is required).
  68 //
  69 // TFPPictures are used for output, contents of VASurfaces passed from decoder
  70 // are put into the associated pixmap memory and sent to client.
  71 class VaapiVideoDecodeAccelerator::TFPPicture {
  72  public:
  73   ~TFPPicture();
  74
  75   static linked_ptr<TFPPicture> Create(
  76       const base::Callback<bool(void)>& make_context_current,
  77       const GLXFBConfig& fb_config,
  78       Display* x_display,
  79       int32 picture_buffer_id,
  80       uint32 texture_id,
  81       gfx::Size size);
  82
  83   int32 picture_buffer_id() {
  84     return picture_buffer_id_;
  85   }
  86
  87   uint32 texture_id() {
  88     return texture_id_;
  89   }
  90
  91   gfx::Size size() {
  92     return size_;
  93   }
  94
  95   int x_pixmap() {
  96     return x_pixmap_;
  97   }
  98
  99   // Bind texture to pixmap. Needs to be called every frame.
 100   bool Bind();
 101
 102  private:
 103   TFPPicture(const base::Callback<bool(void)>& make_context_current,
 104              Display* x_display,
 105              int32 picture_buffer_id,
 106              uint32 texture_id,
 107              gfx::Size size);
 108
 109   bool Initialize(const GLXFBConfig& fb_config);
 110
 111   base::Callback<bool(void)> make_context_current_;
 112
 113   Display* x_display_;
 114
 115   // Output id for the client.
 116   int32 picture_buffer_id_;
 117   uint32 texture_id_;
 118
 119   gfx::Size size_;
 120
 121   // Pixmaps bound to this texture.
 122   Pixmap x_pixmap_;
 123   GLXPixmap glx_pixmap_;
 124
 125   DISALLOW_COPY_AND_ASSIGN(TFPPicture);
 126 };
 127
 128 VaapiVideoDecodeAccelerator::TFPPicture::TFPPicture(
 129     const base::Callback<bool(void)>& make_context_current,
 130     Display* x_display,
 131     int32 picture_buffer_id,
 132     uint32 texture_id,
 133     gfx::Size size)
 134     : make_context_current_(make_context_current),
 135       x_display_(x_display),
 136       picture_buffer_id_(picture_buffer_id),
 137       texture_id_(texture_id),
 138       size_(size),
 139       x_pixmap_(0),
 140       glx_pixmap_(0) {
 141   DCHECK(!make_context_current_.is_null());
 142 };
 143
 144 linked_ptr<VaapiVideoDecodeAccelerator::TFPPicture>
 145 VaapiVideoDecodeAccelerator::TFPPicture::Create(
 146     const base::Callback<bool(void)>& make_context_current,
 147     const GLXFBConfig& fb_config,
 148     Display* x_display,
 149     int32 picture_buffer_id,
 150     uint32 texture_id,
 151     gfx::Size size) {
 152
 153   linked_ptr<TFPPicture> tfp_picture(
 154       new TFPPicture(make_context_current, x_display, picture_buffer_id,
 155                      texture_id, size));
 156
 157   if (!tfp_picture->Initialize(fb_config))
 158     tfp_picture.reset();
 159
 160   return tfp_picture;
 161 }
 162
 163 bool VaapiVideoDecodeAccelerator::TFPPicture::Initialize(
 164     const GLXFBConfig& fb_config) {
 165   // Check for NULL prevents unittests from crashing on nonexistent ChildThread.
 166   DCHECK(ChildThread::current() == NULL ||
 167       ChildThread::current()->message_loop() == base::MessageLoop::current());
 168
 169   if (!make_context_current_.Run())
 170     return false;
 171
 172   XWindowAttributes win_attr;
 173   int screen = DefaultScreen(x_display_);
 174   XGetWindowAttributes(x_display_, RootWindow(x_display_, screen), &win_attr);
 175   //TODO(posciak): pass the depth required by libva, not the RootWindow's depth
 176   x_pixmap_ = XCreatePixmap(x_display_, RootWindow(x_display_, screen),
 177                             size_.width(), size_.height(), win_attr.depth);
 178   if (!x_pixmap_) {
 179     DVLOG(1) << "Failed creating an X Pixmap for TFP";
 180     return false;
 181   }
 182
 183   static const int pixmap_attr[] = {
 184     GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
 185     GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
 186     GL_NONE,
 187   };
 188
 189   glx_pixmap_ = glXCreatePixmap(x_display_, fb_config, x_pixmap_, pixmap_attr);
 190   if (!glx_pixmap_) {
 191     // x_pixmap_ will be freed in the destructor.
 192     DVLOG(1) << "Failed creating a GLX Pixmap for TFP";
 193     return false;
 194   }
 195
 196   return true;
 197 }
 198
 199 VaapiVideoDecodeAccelerator::TFPPicture::~TFPPicture() {
 200   // Check for NULL prevents unittests from crashing on nonexistent ChildThread.
 201   DCHECK(ChildThread::current() == NULL ||
 202       ChildThread::current()->message_loop() == base::MessageLoop::current());
 203
 204   // Unbind surface from texture and deallocate resources.
 205   if (glx_pixmap_ && make_context_current_.Run()) {
 206     glXReleaseTexImageEXT(x_display_, glx_pixmap_, GLX_FRONT_LEFT_EXT);
 207     glXDestroyPixmap(x_display_, glx_pixmap_);
 208   }
 209
 210   if (x_pixmap_)
 211     XFreePixmap(x_display_, x_pixmap_);
 212   XSync(x_display_, False);  // Needed to work around buggy vdpau-driver.
 213 }
 214
 215 bool VaapiVideoDecodeAccelerator::TFPPicture::Bind() {
 216   DCHECK(x_pixmap_);
 217   DCHECK(glx_pixmap_);
 218   // Check for NULL prevents unittests from crashing on nonexistent ChildThread.
 219   DCHECK(ChildThread::current() == NULL ||
 220       ChildThread::current()->message_loop() == base::MessageLoop::current());
 221
 222   if (!make_context_current_.Run())
 223     return false;
 224
 225   gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, texture_id_);
 226   glXBindTexImageEXT(x_display_, glx_pixmap_, GLX_FRONT_LEFT_EXT, NULL);
 227
 228   return true;
 229 }
 230
 231 VaapiVideoDecodeAccelerator::TFPPicture*
 232     VaapiVideoDecodeAccelerator::TFPPictureById(int32 picture_buffer_id) {
 233   TFPPictures::iterator it = tfp_pictures_.find(picture_buffer_id);
 234   if (it == tfp_pictures_.end()) {
 235     DVLOG(1) << "Picture id " << picture_buffer_id << " does not exist";
 236     return NULL;
 237   }
 238
 239   return it->second.get();
 240 }
 241
 242 VaapiVideoDecodeAccelerator::VaapiVideoDecodeAccelerator(
 243     Display* x_display, GLXContext glx_context,
 244     Client* client,
 245     const base::Callback<bool(void)>& make_context_current)
 246     : x_display_(x_display),
 247       glx_context_(glx_context),
 248       make_context_current_(make_context_current),
 249       state_(kUninitialized),
 250       input_ready_(&lock_),
 251       surfaces_available_(&lock_),
 252       message_loop_(base::MessageLoop::current()),
 253       weak_this_(base::AsWeakPtr(this)),
 254       client_ptr_factory_(client),
 255       client_(client_ptr_factory_.GetWeakPtr()),
 256       decoder_thread_("VaapiDecoderThread"),
 257       num_frames_at_client_(0),
 258       num_stream_bufs_at_decoder_(0),
 259       finish_flush_pending_(false),
 260       awaiting_va_surfaces_recycle_(false),
 261       requested_num_pics_(0) {
 262   DCHECK(client);
 263 }
 264
 265 VaapiVideoDecodeAccelerator::~VaapiVideoDecodeAccelerator() {
 266   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 267 }
 268
 269 class ScopedPtrXFree {
 270  public:
 271   void operator()(void* x) const {
 272     ::XFree(x);
 273   }
 274 };
 275
 276 bool VaapiVideoDecodeAccelerator::InitializeFBConfig() {
 277   const int fbconfig_attr[] = {
 278     GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
 279     GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
 280     GLX_BIND_TO_TEXTURE_RGB_EXT, GL_TRUE,
 281     GLX_Y_INVERTED_EXT, GL_TRUE,
 282     GL_NONE,
 283   };
 284
 285   int num_fbconfigs;
 286   scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> glx_fb_configs(
 287       glXChooseFBConfig(x_display_, DefaultScreen(x_display_), fbconfig_attr,
 288                         &num_fbconfigs));
 289   if (!glx_fb_configs)
 290     return false;
 291   if (!num_fbconfigs)
 292     return false;
 293
 294   fb_config_ = glx_fb_configs.get()[0];
 295   return true;
 296 }
 297
 298 bool VaapiVideoDecodeAccelerator::Initialize(
 299     media::VideoCodecProfile profile) {
 300   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 301
 302   base::AutoLock auto_lock(lock_);
 303   DCHECK_EQ(state_, kUninitialized);
 304   DVLOG(2) << "Initializing VAVDA, profile: " << profile;
 305
 306   if (!make_context_current_.Run())
 307     return false;
 308
 309   if (!InitializeFBConfig()) {
 310     DVLOG(1) << "Could not get a usable FBConfig";
 311     return false;
 312   }
 313
 314   vaapi_wrapper_ = VaapiWrapper::Create(
 315       profile, x_display_,
 316       base::Bind(&ReportToUMA, content::VaapiH264Decoder::VAAPI_ERROR));
 317
 318   if (!vaapi_wrapper_.get()) {
 319     DVLOG(1) << "Failed initializing VAAPI";
 320     return false;
 321   }
 322
 323   decoder_.reset(
 324       new VaapiH264Decoder(
 325           vaapi_wrapper_.get(),
 326           media::BindToLoop(message_loop_->message_loop_proxy(), base::Bind(
 327               &VaapiVideoDecodeAccelerator::SurfaceReady, weak_this_)),
 328           base::Bind(&ReportToUMA)));
 329
 330   CHECK(decoder_thread_.Start());
 331
 332   state_ = kIdle;
 333
 334   message_loop_->PostTask(FROM_HERE, base::Bind(
 335       &Client::NotifyInitializeDone, client_));
 336   return true;
 337 }
 338
 339 void VaapiVideoDecodeAccelerator::SurfaceReady(
 340     int32 input_id,
 341     const scoped_refptr<VASurface>& va_surface) {
 342   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 343   DCHECK(!awaiting_va_surfaces_recycle_);
 344
 345   // Drop any requests to output if we are resetting or being destroyed.
 346   if (state_ == kResetting || state_ == kDestroying)
 347     return;
 348
 349   pending_output_cbs_.push(
 350       base::Bind(&VaapiVideoDecodeAccelerator::OutputPicture,
 351                  weak_this_, va_surface, input_id));
 352
 353   TryOutputSurface();
 354 }
 355
 356 void VaapiVideoDecodeAccelerator::OutputPicture(
 357     const scoped_refptr<VASurface>& va_surface,
 358     int32 input_id,
 359     TFPPicture* tfp_picture) {
 360   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 361
 362   int32 output_id  = tfp_picture->picture_buffer_id();
 363
 364   TRACE_EVENT2("Video Decoder", "VAVDA::OutputSurface",
 365                "input_id", input_id,
 366                "output_id", output_id);
 367
 368   DVLOG(3) << "Outputting VASurface " << va_surface->id()
 369            << " into pixmap bound to picture buffer id " << output_id;
 370
 371   RETURN_AND_NOTIFY_ON_FAILURE(tfp_picture->Bind(),
 372                                "Failed binding texture to pixmap",
 373                                PLATFORM_FAILURE, );
 374
 375   RETURN_AND_NOTIFY_ON_FAILURE(
 376       vaapi_wrapper_->PutSurfaceIntoPixmap(va_surface->id(),
 377                                            tfp_picture->x_pixmap(),
 378                                            tfp_picture->size()),
 379       "Failed putting surface into pixmap", PLATFORM_FAILURE, );
 380
 381   // Notify the client a picture is ready to be displayed.
 382   ++num_frames_at_client_;
 383   TRACE_COUNTER1("Video Decoder", "Textures at client", num_frames_at_client_);
 384   DVLOG(4) << "Notifying output picture id " << output_id
 385            << " for input "<< input_id << " is ready";
 386   client_->PictureReady(media::Picture(output_id, input_id));
 387 }
 388
 389 void VaapiVideoDecodeAccelerator::TryOutputSurface() {
 390   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 391
 392   // Handle Destroy() arriving while pictures are queued for output.
 393   if (!client_)
 394     return;
 395
 396   if (pending_output_cbs_.empty() || output_buffers_.empty())
 397     return;
 398
 399   OutputCB output_cb = pending_output_cbs_.front();
 400   pending_output_cbs_.pop();
 401
 402   TFPPicture* tfp_picture = TFPPictureById(output_buffers_.front());
 403   DCHECK(tfp_picture);
 404   output_buffers_.pop();
 405
 406   output_cb.Run(tfp_picture);
 407
 408   if (finish_flush_pending_ && pending_output_cbs_.empty())
 409     FinishFlush();
 410 }
 411
 412 void VaapiVideoDecodeAccelerator::MapAndQueueNewInputBuffer(
 413     const media::BitstreamBuffer& bitstream_buffer) {
 414   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 415   TRACE_EVENT1("Video Decoder", "MapAndQueueNewInputBuffer", "input_id",
 416       bitstream_buffer.id());
 417
 418   DVLOG(4) << "Mapping new input buffer id: " << bitstream_buffer.id()
 419            << " size: " << (int)bitstream_buffer.size();
 420
 421   scoped_ptr<base::SharedMemory> shm(
 422       new base::SharedMemory(bitstream_buffer.handle(), true));
 423   RETURN_AND_NOTIFY_ON_FAILURE(shm->Map(bitstream_buffer.size()),
 424                               "Failed to map input buffer", UNREADABLE_INPUT,);
 425
 426   base::AutoLock auto_lock(lock_);
 427
 428   // Set up a new input buffer and queue it for later.
 429   linked_ptr<InputBuffer> input_buffer(new InputBuffer());
 430   input_buffer->shm.reset(shm.release());
 431   input_buffer->id = bitstream_buffer.id();
 432   input_buffer->size = bitstream_buffer.size();
 433
 434   ++num_stream_bufs_at_decoder_;
 435   TRACE_COUNTER1("Video Decoder", "Stream buffers at decoder",
 436                  num_stream_bufs_at_decoder_);
 437
 438   input_buffers_.push(input_buffer);
 439   input_ready_.Signal();
 440 }
 441
 442 bool VaapiVideoDecodeAccelerator::GetInputBuffer_Locked() {
 443   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 444   lock_.AssertAcquired();
 445
 446   if (curr_input_buffer_.get())
 447     return true;
 448
 449   // Will only wait if it is expected that in current state new buffers will
 450   // be queued from the client via Decode(). The state can change during wait.
 451   while (input_buffers_.empty() && (state_ == kDecoding || state_ == kIdle)) {
 452     input_ready_.Wait();
 453   }
 454
 455   // We could have got woken up in a different state or never got to sleep
 456   // due to current state; check for that.
 457   switch (state_) {
 458     case kFlushing:
 459       // Here we are only interested in finishing up decoding buffers that are
 460       // already queued up. Otherwise will stop decoding.
 461       if (input_buffers_.empty())
 462         return false;
 463       // else fallthrough
 464     case kDecoding:
 465     case kIdle:
 466       DCHECK(!input_buffers_.empty());
 467
 468       curr_input_buffer_ = input_buffers_.front();
 469       input_buffers_.pop();
 470
 471       DVLOG(4) << "New current bitstream buffer, id: "
 472                << curr_input_buffer_->id
 473                << " size: " << curr_input_buffer_->size;
 474
 475       decoder_->SetStream(
 476           static_cast<uint8*>(curr_input_buffer_->shm->memory()),
 477           curr_input_buffer_->size, curr_input_buffer_->id);
 478       return true;
 479
 480     default:
 481       // We got woken up due to being destroyed/reset, ignore any already
 482       // queued inputs.
 483       return false;
 484   }
 485 }
 486
 487 void VaapiVideoDecodeAccelerator::ReturnCurrInputBuffer_Locked() {
 488   lock_.AssertAcquired();
 489   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 490   DCHECK(curr_input_buffer_.get());
 491
 492   int32 id = curr_input_buffer_->id;
 493   curr_input_buffer_.reset();
 494   DVLOG(4) << "End of input buffer " << id;
 495   message_loop_->PostTask(FROM_HERE, base::Bind(
 496       &Client::NotifyEndOfBitstreamBuffer, client_, id));
 497
 498   --num_stream_bufs_at_decoder_;
 499   TRACE_COUNTER1("Video Decoder", "Stream buffers at decoder",
 500                  num_stream_bufs_at_decoder_);
 501 }
 502
 503 bool VaapiVideoDecodeAccelerator::FeedDecoderWithOutputSurfaces_Locked() {
 504   lock_.AssertAcquired();
 505   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 506
 507   while (available_va_surfaces_.empty() &&
 508          (state_ == kDecoding || state_ == kFlushing || state_ == kIdle)) {
 509     surfaces_available_.Wait();
 510   }
 511
 512   if (state_ != kDecoding && state_ != kFlushing && state_ != kIdle)
 513     return false;
 514
 515   VASurface::ReleaseCB va_surface_release_cb =
 516       media::BindToLoop(message_loop_->message_loop_proxy(), base::Bind(
 517           &VaapiVideoDecodeAccelerator::RecycleVASurfaceID, weak_this_));
 518
 519   while (!available_va_surfaces_.empty()) {
 520     scoped_refptr<VASurface> va_surface(
 521         new VASurface(available_va_surfaces_.front(), va_surface_release_cb));
 522     available_va_surfaces_.pop_front();
 523     decoder_->ReuseSurface(va_surface);
 524   }
 525
 526   return true;
 527 }
 528
 529 void VaapiVideoDecodeAccelerator::DecodeTask() {
 530   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 531   TRACE_EVENT0("Video Decoder", "VAVDA::DecodeTask");
 532   base::AutoLock auto_lock(lock_);
 533
 534   if (state_ != kDecoding)
 535     return;
 536
 537   // Main decode task.
 538   DVLOG(4) << "Decode task";
 539
 540   // Try to decode what stream data is (still) in the decoder until we run out
 541   // of it.
 542   while (GetInputBuffer_Locked()) {
 543     DCHECK(curr_input_buffer_.get());
 544
 545     VaapiH264Decoder::DecResult res;
 546     {
 547       // We are OK releasing the lock here, as decoder never calls our methods
 548       // directly and we will reacquire the lock before looking at state again.
 549       // This is the main decode function of the decoder and while keeping
 550       // the lock for its duration would be fine, it would defeat the purpose
 551       // of having a separate decoder thread.
 552       base::AutoUnlock auto_unlock(lock_);
 553       res = decoder_->Decode();
 554     }
 555
 556     switch (res) {
 557       case VaapiH264Decoder::kAllocateNewSurfaces:
 558         DVLOG(1) << "Decoder requesting a new set of surfaces";
 559         message_loop_->PostTask(FROM_HERE, base::Bind(
 560             &VaapiVideoDecodeAccelerator::InitiateSurfaceSetChange, weak_this_,
 561                 decoder_->GetRequiredNumOfPictures(),
 562                 decoder_->GetPicSize()));
 563         // We'll get rescheduled once ProvidePictureBuffers() finishes.
 564         return;
 565
 566       case VaapiH264Decoder::kRanOutOfStreamData:
 567         ReturnCurrInputBuffer_Locked();
 568         break;
 569
 570       case VaapiH264Decoder::kRanOutOfSurfaces:
 571         // No more output buffers in the decoder, try getting more or go to
 572         // sleep waiting for them.
 573         if (!FeedDecoderWithOutputSurfaces_Locked())
 574           return;
 575
 576         break;
 577
 578       case VaapiH264Decoder::kDecodeError:
 579         RETURN_AND_NOTIFY_ON_FAILURE(false, "Error decoding stream",
 580                                      PLATFORM_FAILURE, );
 581         return;
 582     }
 583   }
 584 }
 585
 586 void VaapiVideoDecodeAccelerator::InitiateSurfaceSetChange(size_t num_pics,
 587                                                            gfx::Size size) {
 588   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 589   DCHECK(!awaiting_va_surfaces_recycle_);
 590
 591   // At this point decoder has stopped running and has already posted onto our
 592   // loop any remaining output request callbacks, which executed before we got
 593   // here. Some of them might have been pended though, because we might not
 594   // have had enough TFPictures to output surfaces to. Initiate a wait cycle,
 595   // which will wait for client to return enough PictureBuffers to us, so that
 596   // we can finish all pending output callbacks, releasing associated surfaces.
 597   DVLOG(1) << "Initiating surface set change";
 598   awaiting_va_surfaces_recycle_ = true;
 599
 600   requested_num_pics_ = num_pics;
 601   requested_pic_size_ = size;
 602
 603   TryFinishSurfaceSetChange();
 604 }
 605
 606 void VaapiVideoDecodeAccelerator::TryFinishSurfaceSetChange() {
 607   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 608
 609   if (!awaiting_va_surfaces_recycle_)
 610     return;
 611
 612   if (!pending_output_cbs_.empty() ||
 613       tfp_pictures_.size() != available_va_surfaces_.size()) {
 614     // Either:
 615     // 1. Not all pending pending output callbacks have been executed yet.
 616     // Wait for the client to return enough pictures and retry later.
 617     // 2. The above happened and all surface release callbacks have been posted
 618     // as the result, but not all have executed yet. Post ourselves after them
 619     // to let them release surfaces.
 620     DVLOG(2) << "Awaiting pending output/surface release callbacks to finish";
 621     message_loop_->PostTask(FROM_HERE, base::Bind(
 622         &VaapiVideoDecodeAccelerator::TryFinishSurfaceSetChange, weak_this_));
 623     return;
 624   }
 625
 626   // All surfaces released, destroy them and dismiss all PictureBuffers.
 627   awaiting_va_surfaces_recycle_ = false;
 628   available_va_surfaces_.clear();
 629   vaapi_wrapper_->DestroySurfaces();
 630
 631   for (TFPPictures::iterator iter = tfp_pictures_.begin();
 632        iter != tfp_pictures_.end(); ++iter) {
 633     DVLOG(2) << "Dismissing picture id: " << iter->first;
 634     client_->DismissPictureBuffer(iter->first);
 635   }
 636   tfp_pictures_.clear();
 637
 638   // And ask for a new set as requested.
 639   DVLOG(1) << "Requesting " << requested_num_pics_ << " pictures of size: "
 640            << requested_pic_size_.ToString();
 641
 642   message_loop_->PostTask(FROM_HERE, base::Bind(
 643       &Client::ProvidePictureBuffers, client_,
 644       requested_num_pics_, requested_pic_size_, GL_TEXTURE_2D));
 645 }
 646
 647 void VaapiVideoDecodeAccelerator::Decode(
 648     const media::BitstreamBuffer& bitstream_buffer) {
 649   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 650
 651   TRACE_EVENT1("Video Decoder", "VAVDA::Decode", "Buffer id",
 652                bitstream_buffer.id());
 653
 654   // We got a new input buffer from the client, map it and queue for later use.
 655   MapAndQueueNewInputBuffer(bitstream_buffer);
 656
 657   base::AutoLock auto_lock(lock_);
 658   switch (state_) {
 659     case kIdle:
 660       state_ = kDecoding;
 661       decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
 662           &VaapiVideoDecodeAccelerator::DecodeTask,
 663           base::Unretained(this)));
 664       break;
 665
 666     case kDecoding:
 667       // Decoder already running, fallthrough.
 668     case kResetting:
 669       // When resetting, allow accumulating bitstream buffers, so that
 670       // the client can queue after-seek-buffers while we are finishing with
 671       // the before-seek one.
 672       break;
 673
 674     default:
 675       RETURN_AND_NOTIFY_ON_FAILURE(false,
 676           "Decode request from client in invalid state: " << state_,
 677           PLATFORM_FAILURE, );
 678       break;
 679   }
 680 }
 681
 682 void VaapiVideoDecodeAccelerator::RecycleVASurfaceID(
 683     VASurfaceID va_surface_id) {
 684   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 685   base::AutoLock auto_lock(lock_);
 686
 687   available_va_surfaces_.push_back(va_surface_id);
 688   surfaces_available_.Signal();
 689 }
 690
 691 void VaapiVideoDecodeAccelerator::AssignPictureBuffers(
 692     const std::vector<media::PictureBuffer>& buffers) {
 693   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 694
 695   base::AutoLock auto_lock(lock_);
 696   DCHECK(tfp_pictures_.empty());
 697
 698   while (!output_buffers_.empty())
 699     output_buffers_.pop();
 700
 701   RETURN_AND_NOTIFY_ON_FAILURE(
 702       buffers.size() == requested_num_pics_,
 703       "Got an invalid number of picture buffers. (Got " << buffers.size()
 704       << ", requested " << requested_num_pics_ << ")", INVALID_ARGUMENT, );
 705   DCHECK(requested_pic_size_ == buffers[0].size());
 706
 707   std::vector<VASurfaceID> va_surface_ids;
 708   RETURN_AND_NOTIFY_ON_FAILURE(
 709       vaapi_wrapper_->CreateSurfaces(requested_pic_size_,
 710                                      buffers.size(),
 711                                      &va_surface_ids),
 712       "Failed creating VA Surfaces", PLATFORM_FAILURE, );
 713   DCHECK_EQ(va_surface_ids.size(), buffers.size());
 714
 715   for (size_t i = 0; i < buffers.size(); ++i) {
 716     DVLOG(2) << "Assigning picture id: " << buffers[i].id()
 717              << " to texture id: " << buffers[i].texture_id()
 718              << " VASurfaceID: " << va_surface_ids[i];
 719
 720     linked_ptr<TFPPicture> tfp_picture(
 721         TFPPicture::Create(make_context_current_, fb_config_, x_display_,
 722                            buffers[i].id(), buffers[i].texture_id(),
 723                            requested_pic_size_));
 724
 725     RETURN_AND_NOTIFY_ON_FAILURE(
 726         tfp_picture.get(), "Failed assigning picture buffer to a texture.",
 727         PLATFORM_FAILURE, );
 728
 729     bool inserted = tfp_pictures_.insert(std::make_pair(
 730         buffers[i].id(), tfp_picture)).second;
 731     DCHECK(inserted);
 732
 733     output_buffers_.push(buffers[i].id());
 734     available_va_surfaces_.push_back(va_surface_ids[i]);
 735     surfaces_available_.Signal();
 736   }
 737
 738   state_ = kDecoding;
 739   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
 740       &VaapiVideoDecodeAccelerator::DecodeTask, base::Unretained(this)));
 741 }
 742
 743 void VaapiVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
 744   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 745   TRACE_EVENT1("Video Decoder", "VAVDA::ReusePictureBuffer", "Picture id",
 746                picture_buffer_id);
 747
 748   --num_frames_at_client_;
 749   TRACE_COUNTER1("Video Decoder", "Textures at client", num_frames_at_client_);
 750
 751   output_buffers_.push(picture_buffer_id);
 752   TryOutputSurface();
 753 }
 754
 755 void VaapiVideoDecodeAccelerator::FlushTask() {
 756   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 757   DVLOG(1) << "Flush task";
 758
 759   // First flush all the pictures that haven't been outputted, notifying the
 760   // client to output them.
 761   bool res = decoder_->Flush();
 762   RETURN_AND_NOTIFY_ON_FAILURE(res, "Failed flushing the decoder.",
 763                                PLATFORM_FAILURE, );
 764
 765   // Put the decoder in idle state, ready to resume.
 766   decoder_->Reset();
 767
 768   message_loop_->PostTask(FROM_HERE, base::Bind(
 769       &VaapiVideoDecodeAccelerator::FinishFlush, weak_this_));
 770 }
 771
 772 void VaapiVideoDecodeAccelerator::Flush() {
 773   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 774   DVLOG(1) << "Got flush request";
 775
 776   base::AutoLock auto_lock(lock_);
 777   state_ = kFlushing;
 778   // Queue a flush task after all existing decoding tasks to clean up.
 779   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
 780       &VaapiVideoDecodeAccelerator::FlushTask, base::Unretained(this)));
 781
 782   input_ready_.Signal();
 783   surfaces_available_.Signal();
 784 }
 785
 786 void VaapiVideoDecodeAccelerator::FinishFlush() {
 787   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 788
 789   finish_flush_pending_ = false;
 790
 791   base::AutoLock auto_lock(lock_);
 792   if (state_ != kFlushing) {
 793     DCHECK_EQ(state_, kDestroying);
 794     return;  // We could've gotten destroyed already.
 795   }
 796
 797   // Still waiting for textures from client to finish outputting all pending
 798   // frames. Try again later.
 799   if (!pending_output_cbs_.empty()) {
 800     finish_flush_pending_ = true;
 801     return;
 802   }
 803
 804   state_ = kIdle;
 805
 806   message_loop_->PostTask(FROM_HERE, base::Bind(
 807       &Client::NotifyFlushDone, client_));
 808
 809   DVLOG(1) << "Flush finished";
 810 }
 811
 812 void VaapiVideoDecodeAccelerator::ResetTask() {
 813   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 814   DVLOG(1) << "ResetTask";
 815
 816   // All the decoding tasks from before the reset request from client are done
 817   // by now, as this task was scheduled after them and client is expected not
 818   // to call Decode() after Reset() and before NotifyResetDone.
 819   decoder_->Reset();
 820
 821   base::AutoLock auto_lock(lock_);
 822
 823   // Return current input buffer, if present.
 824   if (curr_input_buffer_.get())
 825     ReturnCurrInputBuffer_Locked();
 826
 827   // And let client know that we are done with reset.
 828   message_loop_->PostTask(FROM_HERE, base::Bind(
 829       &VaapiVideoDecodeAccelerator::FinishReset, weak_this_));
 830 }
 831
 832 void VaapiVideoDecodeAccelerator::Reset() {
 833   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 834   DVLOG(1) << "Got reset request";
 835
 836   // This will make any new decode tasks exit early.
 837   base::AutoLock auto_lock(lock_);
 838   state_ = kResetting;
 839   finish_flush_pending_ = false;
 840
 841   // Drop all remaining input buffers, if present.
 842   while (!input_buffers_.empty()) {
 843     message_loop_->PostTask(FROM_HERE, base::Bind(
 844         &Client::NotifyEndOfBitstreamBuffer, client_,
 845         input_buffers_.front()->id));
 846     input_buffers_.pop();
 847   }
 848
 849   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
 850       &VaapiVideoDecodeAccelerator::ResetTask, base::Unretained(this)));
 851
 852   input_ready_.Signal();
 853   surfaces_available_.Signal();
 854 }
 855
 856 void VaapiVideoDecodeAccelerator::FinishReset() {
 857   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 858   DVLOG(1) << "FinishReset";
 859   base::AutoLock auto_lock(lock_);
 860
 861   if (state_ != kResetting) {
 862     DCHECK(state_ == kDestroying || state_ == kUninitialized) << state_;
 863     return;  // We could've gotten destroyed already.
 864   }
 865
 866   // Drop pending outputs.
 867   while (!pending_output_cbs_.empty())
 868     pending_output_cbs_.pop();
 869
 870   if (awaiting_va_surfaces_recycle_) {
 871     // Decoder requested a new surface set while we were waiting for it to
 872     // finish the last DecodeTask, running at the time of Reset().
 873     // Let the surface set change finish first before resetting.
 874     message_loop_->PostTask(FROM_HERE, base::Bind(
 875         &VaapiVideoDecodeAccelerator::FinishReset, weak_this_));
 876     return;
 877   }
 878
 879   num_stream_bufs_at_decoder_ = 0;
 880   state_ = kIdle;
 881
 882   message_loop_->PostTask(FROM_HERE, base::Bind(
 883       &Client::NotifyResetDone, client_));
 884
 885   // The client might have given us new buffers via Decode() while we were
 886   // resetting and might be waiting for our move, and not call Decode() anymore
 887   // until we return something. Post a DecodeTask() so that we won't
 888   // sleep forever waiting for Decode() in that case. Having two of them
 889   // in the pipe is harmless, the additional one will return as soon as it sees
 890   // that we are back in kDecoding state.
 891   if (!input_buffers_.empty()) {
 892     state_ = kDecoding;
 893     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
 894       &VaapiVideoDecodeAccelerator::DecodeTask,
 895       base::Unretained(this)));
 896   }
 897
 898   DVLOG(1) << "Reset finished";
 899 }
 900
 901 void VaapiVideoDecodeAccelerator::Cleanup() {
 902   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 903
 904   if (state_ == kUninitialized || state_ == kDestroying)
 905     return;
 906
 907   DVLOG(1) << "Destroying VAVDA";
 908   base::AutoLock auto_lock(lock_);
 909   state_ = kDestroying;
 910
 911   client_ptr_factory_.InvalidateWeakPtrs();
 912
 913   {
 914     base::AutoUnlock auto_unlock(lock_);
 915     // Post a dummy task to the decoder_thread_ to ensure it is drained.
 916     base::WaitableEvent waiter(false, false);
 917     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
 918         &base::WaitableEvent::Signal, base::Unretained(&waiter)));
 919     input_ready_.Signal();
 920     surfaces_available_.Signal();
 921     waiter.Wait();
 922     decoder_thread_.Stop();
 923   }
 924
 925   state_ = kUninitialized;
 926 }
 927
 928 void VaapiVideoDecodeAccelerator::Destroy() {
 929   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 930   Cleanup();
 931   delete this;
 932 }
 933
 934 }  // namespace content