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