Home | History | Annotate | Download | only in media 
      1 // Copyright 2013 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 "content/renderer/media/rtc_video_decoder.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "base/memory/ref_counted.h"
     10 #include "base/message_loop/message_loop_proxy.h"
     11 #include "base/metrics/histogram.h"
     12 #include "base/numerics/safe_conversions.h"
     13 #include "base/stl_util.h"
     14 #include "base/synchronization/waitable_event.h"
     15 #include "base/task_runner_util.h"
     16 #include "content/child/child_thread.h"
     17 #include "content/renderer/media/native_handle_impl.h"
     18 #include "gpu/command_buffer/common/mailbox_holder.h"
     19 #include "media/base/bind_to_current_loop.h"
     20 #include "media/filters/gpu_video_accelerator_factories.h"
     21 #include "third_party/skia/include/core/SkBitmap.h"
     22 #include "third_party/webrtc/common_video/interface/texture_video_frame.h"
     23 #include "third_party/webrtc/system_wrappers/interface/ref_count.h"
     24 
     25 namespace content {
     26 
     27 const int32 RTCVideoDecoder::ID_LAST = 0x3FFFFFFF;
     28 const int32 RTCVideoDecoder::ID_HALF = 0x20000000;
     29 const int32 RTCVideoDecoder::ID_INVALID = -1;
     30 
     31 // Maximum number of concurrent VDA::Decode() operations RVD will maintain.
     32 // Higher values allow better pipelining in the GPU, but also require more
     33 // resources.
     34 static const size_t kMaxInFlightDecodes = 8;
     35 
     36 // Size of shared-memory segments we allocate.  Since we reuse them we let them
     37 // be on the beefy side.
     38 static const size_t kSharedMemorySegmentBytes = 100 << 10;
     39 
     40 // Maximum number of allocated shared-memory segments.
     41 static const int kMaxNumSharedMemorySegments = 16;
     42 
     43 // Maximum number of pending WebRTC buffers that are waiting for the shared
     44 // memory. 10 seconds for 30 fps.
     45 static const size_t kMaxNumOfPendingBuffers = 300;
     46 
     47 // A shared memory segment and its allocated size. This class has the ownership
     48 // of |shm|.
     49 class RTCVideoDecoder::SHMBuffer {
     50  public:
     51   SHMBuffer(base::SharedMemory* shm, size_t size);
     52   ~SHMBuffer();
     53   base::SharedMemory* const shm;
     54   const size_t size;
     55 };
     56 
     57 RTCVideoDecoder::SHMBuffer::SHMBuffer(base::SharedMemory* shm, size_t size)
     58     : shm(shm), size(size) {}
     59 
     60 RTCVideoDecoder::SHMBuffer::~SHMBuffer() { shm->Close(); }
     61 
     62 RTCVideoDecoder::BufferData::BufferData(int32 bitstream_buffer_id,
     63                                         uint32_t timestamp,
     64                                         size_t size)
     65     : bitstream_buffer_id(bitstream_buffer_id),
     66       timestamp(timestamp),
     67       size(size) {}
     68 
     69 RTCVideoDecoder::BufferData::BufferData() {}
     70 
     71 RTCVideoDecoder::BufferData::~BufferData() {}
     72 
     73 RTCVideoDecoder::RTCVideoDecoder(
     74     webrtc::VideoCodecType type,
     75     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories)
     76     : video_codec_type_(type),
     77       factories_(factories),
     78       decoder_texture_target_(0),
     79       next_picture_buffer_id_(0),
     80       state_(UNINITIALIZED),
     81       decode_complete_callback_(NULL),
     82       num_shm_buffers_(0),
     83       next_bitstream_buffer_id_(0),
     84       reset_bitstream_buffer_id_(ID_INVALID),
     85       weak_factory_(this) {
     86   DCHECK(!factories_->GetTaskRunner()->BelongsToCurrentThread());
     87 }
     88 
     89 RTCVideoDecoder::~RTCVideoDecoder() {
     90   DVLOG(2) << "~RTCVideoDecoder";
     91   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
     92   DestroyVDA();
     93 
     94   // Delete all shared memories.
     95   STLDeleteElements(&available_shm_segments_);
     96   STLDeleteValues(&bitstream_buffers_in_decoder_);
     97   STLDeleteContainerPairFirstPointers(decode_buffers_.begin(),
     98                                       decode_buffers_.end());
     99   decode_buffers_.clear();
    100 
    101   // Delete WebRTC input buffers.
    102   for (std::deque<std::pair<webrtc::EncodedImage, BufferData> >::iterator it =
    103            pending_buffers_.begin();
    104        it != pending_buffers_.end();
    105        ++it) {
    106     delete[] it->first._buffer;
    107   }
    108 }
    109 
    110 // static
    111 scoped_ptr<RTCVideoDecoder> RTCVideoDecoder::Create(
    112     webrtc::VideoCodecType type,
    113     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories) {
    114   scoped_ptr<RTCVideoDecoder> decoder;
    115   // Convert WebRTC codec type to media codec profile.
    116   media::VideoCodecProfile profile;
    117   switch (type) {
    118     case webrtc::kVideoCodecVP8:
    119       profile = media::VP8PROFILE_ANY;
    120       break;
    121     case webrtc::kVideoCodecH264:
    122       profile = media::H264PROFILE_MAIN;
    123       break;
    124     default:
    125       DVLOG(2) << "Video codec not supported:" << type;
    126       return decoder.Pass();
    127   }
    128 
    129   base::WaitableEvent waiter(true, false);
    130   decoder.reset(new RTCVideoDecoder(type, factories));
    131   decoder->factories_->GetTaskRunner()->PostTask(
    132       FROM_HERE,
    133       base::Bind(&RTCVideoDecoder::CreateVDA,
    134                  base::Unretained(decoder.get()),
    135                  profile,
    136                  &waiter));
    137   waiter.Wait();
    138   // vda can be NULL if the codec is not supported.
    139   if (decoder->vda_ != NULL) {
    140     decoder->state_ = INITIALIZED;
    141   } else {
    142     factories->GetTaskRunner()->DeleteSoon(FROM_HERE, decoder.release());
    143   }
    144   return decoder.Pass();
    145 }
    146 
    147 int32_t RTCVideoDecoder::InitDecode(const webrtc::VideoCodec* codecSettings,
    148                                     int32_t /*numberOfCores*/) {
    149   DVLOG(2) << "InitDecode";
    150   DCHECK_EQ(video_codec_type_, codecSettings->codecType);
    151   if (codecSettings->codecType == webrtc::kVideoCodecVP8 &&
    152       codecSettings->codecSpecific.VP8.feedbackModeOn) {
    153     LOG(ERROR) << "Feedback mode not supported";
    154     return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_ERROR);
    155   }
    156 
    157   base::AutoLock auto_lock(lock_);
    158   if (state_ == UNINITIALIZED || state_ == DECODE_ERROR) {
    159     LOG(ERROR) << "VDA is not initialized. state=" << state_;
    160     return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_UNINITIALIZED);
    161   }
    162   // Create some shared memory if the queue is empty.
    163   if (available_shm_segments_.size() == 0) {
    164     factories_->GetTaskRunner()->PostTask(
    165         FROM_HERE,
    166         base::Bind(&RTCVideoDecoder::CreateSHM,
    167                    weak_factory_.GetWeakPtr(),
    168                    kMaxInFlightDecodes,
    169                    kSharedMemorySegmentBytes));
    170   }
    171   return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_OK);
    172 }
    173 
    174 int32_t RTCVideoDecoder::Decode(
    175     const webrtc::EncodedImage& inputImage,
    176     bool missingFrames,
    177     const webrtc::RTPFragmentationHeader* /*fragmentation*/,
    178     const webrtc::CodecSpecificInfo* /*codecSpecificInfo*/,
    179     int64_t /*renderTimeMs*/) {
    180   DVLOG(3) << "Decode";
    181 
    182   base::AutoLock auto_lock(lock_);
    183 
    184   if (state_ == UNINITIALIZED || decode_complete_callback_ == NULL) {
    185     LOG(ERROR) << "The decoder has not initialized.";
    186     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
    187   }
    188 
    189   if (state_ == DECODE_ERROR) {
    190     LOG(ERROR) << "Decoding error occurred.";
    191     return WEBRTC_VIDEO_CODEC_ERROR;
    192   }
    193 
    194   if (missingFrames || !inputImage._completeFrame) {
    195     DLOG(ERROR) << "Missing or incomplete frames.";
    196     // Unlike the SW decoder in libvpx, hw decoder cannot handle broken frames.
    197     // Return an error to request a key frame.
    198     return WEBRTC_VIDEO_CODEC_ERROR;
    199   }
    200 
    201   // Most platforms' VDA implementations support mid-stream resolution change
    202   // internally.  Platforms whose VDAs fail to support mid-stream resolution
    203   // change gracefully need to have their clients cover for them, and we do that
    204   // here.
    205 #ifdef ANDROID
    206   const bool kVDACanHandleMidstreamResize = false;
    207 #else
    208   const bool kVDACanHandleMidstreamResize = true;
    209 #endif
    210 
    211   bool need_to_reset_for_midstream_resize = false;
    212   if (inputImage._frameType == webrtc::kKeyFrame) {
    213     DVLOG(2) << "Got key frame. size=" << inputImage._encodedWidth << "x"
    214              << inputImage._encodedHeight;
    215     gfx::Size prev_frame_size = frame_size_;
    216     frame_size_.SetSize(inputImage._encodedWidth, inputImage._encodedHeight);
    217     if (!kVDACanHandleMidstreamResize && !prev_frame_size.IsEmpty() &&
    218         prev_frame_size != frame_size_) {
    219       need_to_reset_for_midstream_resize = true;
    220     }
    221   } else if (IsFirstBufferAfterReset(next_bitstream_buffer_id_,
    222                                      reset_bitstream_buffer_id_)) {
    223     // TODO(wuchengli): VDA should handle it. Remove this when
    224     // http://crosbug.com/p/21913 is fixed.
    225     DVLOG(1) << "The first frame should be a key frame. Drop this.";
    226     return WEBRTC_VIDEO_CODEC_ERROR;
    227   }
    228 
    229   // Create buffer metadata.
    230   BufferData buffer_data(next_bitstream_buffer_id_,
    231                          inputImage._timeStamp,
    232                          inputImage._length);
    233   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
    234   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & ID_LAST;
    235 
    236   // If a shared memory segment is available, there are no pending buffers, and
    237   // this isn't a mid-stream resolution change, then send the buffer for decode
    238   // immediately. Otherwise, save the buffer in the queue for later decode.
    239   scoped_ptr<SHMBuffer> shm_buffer;
    240   if (!need_to_reset_for_midstream_resize && pending_buffers_.size() == 0)
    241     shm_buffer = GetSHM_Locked(inputImage._length);
    242   if (!shm_buffer) {
    243     if (!SaveToPendingBuffers_Locked(inputImage, buffer_data))
    244       return WEBRTC_VIDEO_CODEC_ERROR;
    245     if (need_to_reset_for_midstream_resize) {
    246       base::AutoUnlock auto_unlock(lock_);
    247       Reset();
    248     }
    249     return WEBRTC_VIDEO_CODEC_OK;
    250   }
    251 
    252   SaveToDecodeBuffers_Locked(inputImage, shm_buffer.Pass(), buffer_data);
    253   factories_->GetTaskRunner()->PostTask(
    254       FROM_HERE,
    255       base::Bind(&RTCVideoDecoder::RequestBufferDecode,
    256                  weak_factory_.GetWeakPtr()));
    257   return WEBRTC_VIDEO_CODEC_OK;
    258 }
    259 
    260 int32_t RTCVideoDecoder::RegisterDecodeCompleteCallback(
    261     webrtc::DecodedImageCallback* callback) {
    262   DVLOG(2) << "RegisterDecodeCompleteCallback";
    263   base::AutoLock auto_lock(lock_);
    264   decode_complete_callback_ = callback;
    265   return WEBRTC_VIDEO_CODEC_OK;
    266 }
    267 
    268 int32_t RTCVideoDecoder::Release() {
    269   DVLOG(2) << "Release";
    270   // Do not destroy VDA because WebRTC can call InitDecode and start decoding
    271   // again.
    272   return Reset();
    273 }
    274 
    275 int32_t RTCVideoDecoder::Reset() {
    276   DVLOG(2) << "Reset";
    277   base::AutoLock auto_lock(lock_);
    278   if (state_ == UNINITIALIZED) {
    279     LOG(ERROR) << "Decoder not initialized.";
    280     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
    281   }
    282   if (next_bitstream_buffer_id_ != 0)
    283     reset_bitstream_buffer_id_ = next_bitstream_buffer_id_ - 1;
    284   else
    285     reset_bitstream_buffer_id_ = ID_LAST;
    286   // If VDA is already resetting, no need to request the reset again.
    287   if (state_ != RESETTING) {
    288     state_ = RESETTING;
    289     factories_->GetTaskRunner()->PostTask(
    290         FROM_HERE,
    291         base::Bind(&RTCVideoDecoder::ResetInternal,
    292                    weak_factory_.GetWeakPtr()));
    293   }
    294   return WEBRTC_VIDEO_CODEC_OK;
    295 }
    296 
    297 void RTCVideoDecoder::ProvidePictureBuffers(uint32 count,
    298                                             const gfx::Size& size,
    299                                             uint32 texture_target) {
    300   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    301   DVLOG(3) << "ProvidePictureBuffers. texture_target=" << texture_target;
    302 
    303   if (!vda_)
    304     return;
    305 
    306   std::vector<uint32> texture_ids;
    307   std::vector<gpu::Mailbox> texture_mailboxes;
    308   decoder_texture_target_ = texture_target;
    309   if (!factories_->CreateTextures(count,
    310                                   size,
    311                                   &texture_ids,
    312                                   &texture_mailboxes,
    313                                   decoder_texture_target_)) {
    314     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
    315     return;
    316   }
    317   DCHECK_EQ(count, texture_ids.size());
    318   DCHECK_EQ(count, texture_mailboxes.size());
    319 
    320   std::vector<media::PictureBuffer> picture_buffers;
    321   for (size_t i = 0; i < texture_ids.size(); ++i) {
    322     picture_buffers.push_back(media::PictureBuffer(
    323         next_picture_buffer_id_++, size, texture_ids[i], texture_mailboxes[i]));
    324     bool inserted = assigned_picture_buffers_.insert(std::make_pair(
    325         picture_buffers.back().id(), picture_buffers.back())).second;
    326     DCHECK(inserted);
    327   }
    328   vda_->AssignPictureBuffers(picture_buffers);
    329 }
    330 
    331 void RTCVideoDecoder::DismissPictureBuffer(int32 id) {
    332   DVLOG(3) << "DismissPictureBuffer. id=" << id;
    333   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    334 
    335   std::map<int32, media::PictureBuffer>::iterator it =
    336       assigned_picture_buffers_.find(id);
    337   if (it == assigned_picture_buffers_.end()) {
    338     NOTREACHED() << "Missing picture buffer: " << id;
    339     return;
    340   }
    341 
    342   media::PictureBuffer buffer_to_dismiss = it->second;
    343   assigned_picture_buffers_.erase(it);
    344 
    345   if (!picture_buffers_at_display_.count(id)) {
    346     // We can delete the texture immediately as it's not being displayed.
    347     factories_->DeleteTexture(buffer_to_dismiss.texture_id());
    348     return;
    349   }
    350   // Not destroying a texture in display in |picture_buffers_at_display_|.
    351   // Postpone deletion until after it's returned to us.
    352 }
    353 
    354 void RTCVideoDecoder::PictureReady(const media::Picture& picture) {
    355   DVLOG(3) << "PictureReady";
    356   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    357 
    358   std::map<int32, media::PictureBuffer>::iterator it =
    359       assigned_picture_buffers_.find(picture.picture_buffer_id());
    360   if (it == assigned_picture_buffers_.end()) {
    361     NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
    362     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
    363     return;
    364   }
    365   const media::PictureBuffer& pb = it->second;
    366 
    367   // Validate picture rectangle from GPU.
    368   if (picture.visible_rect().IsEmpty() ||
    369       !gfx::Rect(pb.size()).Contains(picture.visible_rect())) {
    370     NOTREACHED() << "Invalid picture size from VDA: "
    371                  << picture.visible_rect().ToString() << " should fit in "
    372                  << pb.size().ToString();
    373     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
    374     return;
    375   }
    376 
    377   // Create a media::VideoFrame.
    378   uint32_t timestamp = 0;
    379   GetBufferData(picture.bitstream_buffer_id(), &timestamp);
    380   scoped_refptr<media::VideoFrame> frame =
    381       CreateVideoFrame(picture, pb, timestamp);
    382   bool inserted =
    383       picture_buffers_at_display_.insert(std::make_pair(
    384                                              picture.picture_buffer_id(),
    385                                              pb.texture_id())).second;
    386   DCHECK(inserted);
    387 
    388   // Create a WebRTC video frame.
    389   webrtc::RefCountImpl<NativeHandleImpl>* handle =
    390       new webrtc::RefCountImpl<NativeHandleImpl>(frame);
    391   webrtc::TextureVideoFrame decoded_image(handle,
    392                                           picture.visible_rect().width(),
    393                                           picture.visible_rect().height(),
    394                                           timestamp,
    395                                           0);
    396 
    397   // Invoke decode callback. WebRTC expects no callback after Reset or Release.
    398   {
    399     base::AutoLock auto_lock(lock_);
    400     DCHECK(decode_complete_callback_ != NULL);
    401     if (IsBufferAfterReset(picture.bitstream_buffer_id(),
    402                            reset_bitstream_buffer_id_)) {
    403       decode_complete_callback_->Decoded(decoded_image);
    404     }
    405   }
    406 }
    407 
    408 static void ReadPixelsSyncInner(
    409     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
    410     uint32 texture_id,
    411     const gfx::Rect& visible_rect,
    412     const SkBitmap& pixels,
    413     base::WaitableEvent* event) {
    414   factories->ReadPixels(texture_id, visible_rect, pixels);
    415   event->Signal();
    416 }
    417 
    418 static void ReadPixelsSync(
    419     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
    420     uint32 texture_id,
    421     const gfx::Rect& visible_rect,
    422     const SkBitmap& pixels) {
    423   base::WaitableEvent event(true, false);
    424   if (!factories->GetTaskRunner()->PostTask(FROM_HERE,
    425                                             base::Bind(&ReadPixelsSyncInner,
    426                                                        factories,
    427                                                        texture_id,
    428                                                        visible_rect,
    429                                                        pixels,
    430                                                        &event)))
    431     return;
    432   event.Wait();
    433 }
    434 
    435 scoped_refptr<media::VideoFrame> RTCVideoDecoder::CreateVideoFrame(
    436     const media::Picture& picture,
    437     const media::PictureBuffer& pb,
    438     uint32_t timestamp) {
    439   gfx::Rect visible_rect(picture.visible_rect());
    440   DCHECK(decoder_texture_target_);
    441   // Convert timestamp from 90KHz to ms.
    442   base::TimeDelta timestamp_ms = base::TimeDelta::FromInternalValue(
    443       base::checked_cast<uint64_t>(timestamp) * 1000 / 90);
    444   return media::VideoFrame::WrapNativeTexture(
    445       make_scoped_ptr(new gpu::MailboxHolder(
    446           pb.texture_mailbox(), decoder_texture_target_, 0)),
    447       media::BindToCurrentLoop(base::Bind(&RTCVideoDecoder::ReleaseMailbox,
    448                                           weak_factory_.GetWeakPtr(),
    449                                           factories_,
    450                                           picture.picture_buffer_id(),
    451                                           pb.texture_id())),
    452       pb.size(),
    453       visible_rect,
    454       visible_rect.size(),
    455       timestamp_ms,
    456       base::Bind(&ReadPixelsSync, factories_, pb.texture_id(), visible_rect));
    457 }
    458 
    459 void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
    460   DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
    461   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    462 
    463   std::map<int32, SHMBuffer*>::iterator it =
    464       bitstream_buffers_in_decoder_.find(id);
    465   if (it == bitstream_buffers_in_decoder_.end()) {
    466     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
    467     NOTREACHED() << "Missing bitstream buffer: " << id;
    468     return;
    469   }
    470 
    471   {
    472     base::AutoLock auto_lock(lock_);
    473     PutSHM_Locked(scoped_ptr<SHMBuffer>(it->second));
    474   }
    475   bitstream_buffers_in_decoder_.erase(it);
    476 
    477   RequestBufferDecode();
    478 }
    479 
    480 void RTCVideoDecoder::NotifyFlushDone() {
    481   DVLOG(3) << "NotifyFlushDone";
    482   NOTREACHED() << "Unexpected flush done notification.";
    483 }
    484 
    485 void RTCVideoDecoder::NotifyResetDone() {
    486   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    487   DVLOG(3) << "NotifyResetDone";
    488 
    489   if (!vda_)
    490     return;
    491 
    492   input_buffer_data_.clear();
    493   {
    494     base::AutoLock auto_lock(lock_);
    495     state_ = INITIALIZED;
    496   }
    497   // Send the pending buffers for decoding.
    498   RequestBufferDecode();
    499 }
    500 
    501 void RTCVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
    502   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    503   if (!vda_)
    504     return;
    505 
    506   LOG(ERROR) << "VDA Error:" << error;
    507   UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoDecoderError",
    508                             error,
    509                             media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
    510   DestroyVDA();
    511 
    512   base::AutoLock auto_lock(lock_);
    513   state_ = DECODE_ERROR;
    514 }
    515 
    516 void RTCVideoDecoder::RequestBufferDecode() {
    517   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    518   if (!vda_)
    519     return;
    520 
    521   MovePendingBuffersToDecodeBuffers();
    522 
    523   while (CanMoreDecodeWorkBeDone()) {
    524     // Get a buffer and data from the queue.
    525     SHMBuffer* shm_buffer = NULL;
    526     BufferData buffer_data;
    527     {
    528       base::AutoLock auto_lock(lock_);
    529       // Do not request decode if VDA is resetting.
    530       if (decode_buffers_.size() == 0 || state_ == RESETTING)
    531         return;
    532       shm_buffer = decode_buffers_.front().first;
    533       buffer_data = decode_buffers_.front().second;
    534       decode_buffers_.pop_front();
    535       // Drop the buffers before Reset or Release is called.
    536       if (!IsBufferAfterReset(buffer_data.bitstream_buffer_id,
    537                               reset_bitstream_buffer_id_)) {
    538         PutSHM_Locked(scoped_ptr<SHMBuffer>(shm_buffer));
    539         continue;
    540       }
    541     }
    542 
    543     // Create a BitstreamBuffer and send to VDA to decode.
    544     media::BitstreamBuffer bitstream_buffer(buffer_data.bitstream_buffer_id,
    545                                             shm_buffer->shm->handle(),
    546                                             buffer_data.size);
    547     bool inserted = bitstream_buffers_in_decoder_
    548         .insert(std::make_pair(bitstream_buffer.id(), shm_buffer)).second;
    549     DCHECK(inserted);
    550     RecordBufferData(buffer_data);
    551     vda_->Decode(bitstream_buffer);
    552   }
    553 }
    554 
    555 bool RTCVideoDecoder::CanMoreDecodeWorkBeDone() {
    556   return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
    557 }
    558 
    559 bool RTCVideoDecoder::IsBufferAfterReset(int32 id_buffer, int32 id_reset) {
    560   if (id_reset == ID_INVALID)
    561     return true;
    562   int32 diff = id_buffer - id_reset;
    563   if (diff <= 0)
    564     diff += ID_LAST + 1;
    565   return diff < ID_HALF;
    566 }
    567 
    568 bool RTCVideoDecoder::IsFirstBufferAfterReset(int32 id_buffer, int32 id_reset) {
    569   if (id_reset == ID_INVALID)
    570     return id_buffer == 0;
    571   return id_buffer == ((id_reset + 1) & ID_LAST);
    572 }
    573 
    574 void RTCVideoDecoder::SaveToDecodeBuffers_Locked(
    575     const webrtc::EncodedImage& input_image,
    576     scoped_ptr<SHMBuffer> shm_buffer,
    577     const BufferData& buffer_data) {
    578   memcpy(shm_buffer->shm->memory(), input_image._buffer, input_image._length);
    579   std::pair<SHMBuffer*, BufferData> buffer_pair =
    580       std::make_pair(shm_buffer.release(), buffer_data);
    581 
    582   // Store the buffer and the metadata to the queue.
    583   decode_buffers_.push_back(buffer_pair);
    584 }
    585 
    586 bool RTCVideoDecoder::SaveToPendingBuffers_Locked(
    587     const webrtc::EncodedImage& input_image,
    588     const BufferData& buffer_data) {
    589   DVLOG(2) << "SaveToPendingBuffers_Locked"
    590            << ". pending_buffers size=" << pending_buffers_.size()
    591            << ". decode_buffers_ size=" << decode_buffers_.size()
    592            << ". available_shm size=" << available_shm_segments_.size();
    593   // Queued too many buffers. Something goes wrong.
    594   if (pending_buffers_.size() >= kMaxNumOfPendingBuffers) {
    595     LOG(WARNING) << "Too many pending buffers!";
    596     return false;
    597   }
    598 
    599   // Clone the input image and save it to the queue.
    600   uint8_t* buffer = new uint8_t[input_image._length];
    601   // TODO(wuchengli): avoid memcpy. Extend webrtc::VideoDecoder::Decode()
    602   // interface to take a non-const ptr to the frame and add a method to the
    603   // frame that will swap buffers with another.
    604   memcpy(buffer, input_image._buffer, input_image._length);
    605   webrtc::EncodedImage encoded_image(
    606       buffer, input_image._length, input_image._length);
    607   std::pair<webrtc::EncodedImage, BufferData> buffer_pair =
    608       std::make_pair(encoded_image, buffer_data);
    609 
    610   pending_buffers_.push_back(buffer_pair);
    611   return true;
    612 }
    613 
    614 void RTCVideoDecoder::MovePendingBuffersToDecodeBuffers() {
    615   base::AutoLock auto_lock(lock_);
    616   while (pending_buffers_.size() > 0) {
    617     // Get a pending buffer from the queue.
    618     const webrtc::EncodedImage& input_image = pending_buffers_.front().first;
    619     const BufferData& buffer_data = pending_buffers_.front().second;
    620 
    621     // Drop the frame if it comes before Reset or Release.
    622     if (!IsBufferAfterReset(buffer_data.bitstream_buffer_id,
    623                             reset_bitstream_buffer_id_)) {
    624       delete[] input_image._buffer;
    625       pending_buffers_.pop_front();
    626       continue;
    627     }
    628     // Get shared memory and save it to decode buffers.
    629     scoped_ptr<SHMBuffer> shm_buffer = GetSHM_Locked(input_image._length);
    630     if (!shm_buffer)
    631       return;
    632     SaveToDecodeBuffers_Locked(input_image, shm_buffer.Pass(), buffer_data);
    633     delete[] input_image._buffer;
    634     pending_buffers_.pop_front();
    635   }
    636 }
    637 
    638 void RTCVideoDecoder::ResetInternal() {
    639   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    640   DVLOG(2) << "ResetInternal";
    641   if (vda_)
    642     vda_->Reset();
    643 }
    644 
    645 // static
    646 void RTCVideoDecoder::ReleaseMailbox(
    647     base::WeakPtr<RTCVideoDecoder> decoder,
    648     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
    649     int64 picture_buffer_id,
    650     uint32 texture_id,
    651     uint32 release_sync_point) {
    652   DCHECK(factories->GetTaskRunner()->BelongsToCurrentThread());
    653   factories->WaitSyncPoint(release_sync_point);
    654 
    655   if (decoder) {
    656     decoder->ReusePictureBuffer(picture_buffer_id);
    657     return;
    658   }
    659   // It's the last chance to delete the texture after display,
    660   // because RTCVideoDecoder was destructed.
    661   factories->DeleteTexture(texture_id);
    662 }
    663 
    664 void RTCVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id) {
    665   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    666   DVLOG(3) << "ReusePictureBuffer. id=" << picture_buffer_id;
    667 
    668   DCHECK(!picture_buffers_at_display_.empty());
    669   PictureBufferTextureMap::iterator display_iterator =
    670       picture_buffers_at_display_.find(picture_buffer_id);
    671   uint32 texture_id = display_iterator->second;
    672   DCHECK(display_iterator != picture_buffers_at_display_.end());
    673   picture_buffers_at_display_.erase(display_iterator);
    674 
    675   if (!assigned_picture_buffers_.count(picture_buffer_id)) {
    676     // This picture was dismissed while in display, so we postponed deletion.
    677     factories_->DeleteTexture(texture_id);
    678     return;
    679   }
    680 
    681   // DestroyVDA() might already have been called.
    682   if (vda_)
    683     vda_->ReusePictureBuffer(picture_buffer_id);
    684 }
    685 
    686 void RTCVideoDecoder::CreateVDA(media::VideoCodecProfile profile,
    687                                 base::WaitableEvent* waiter) {
    688   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    689   vda_ = factories_->CreateVideoDecodeAccelerator();
    690   if (vda_ && !vda_->Initialize(profile, this))
    691     vda_.release()->Destroy();
    692   waiter->Signal();
    693 }
    694 
    695 void RTCVideoDecoder::DestroyTextures() {
    696   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    697 
    698   // Not destroying PictureBuffers in |picture_buffers_at_display_| yet, since
    699   // their textures may still be in use by the user of this RTCVideoDecoder.
    700   for (PictureBufferTextureMap::iterator it =
    701            picture_buffers_at_display_.begin();
    702        it != picture_buffers_at_display_.end();
    703        ++it) {
    704     assigned_picture_buffers_.erase(it->first);
    705   }
    706 
    707   for (std::map<int32, media::PictureBuffer>::iterator it =
    708            assigned_picture_buffers_.begin();
    709        it != assigned_picture_buffers_.end();
    710        ++it) {
    711     factories_->DeleteTexture(it->second.texture_id());
    712   }
    713   assigned_picture_buffers_.clear();
    714 }
    715 
    716 void RTCVideoDecoder::DestroyVDA() {
    717   DVLOG(2) << "DestroyVDA";
    718   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    719   if (vda_)
    720     vda_.release()->Destroy();
    721   DestroyTextures();
    722   base::AutoLock auto_lock(lock_);
    723   state_ = UNINITIALIZED;
    724 }
    725 
    726 scoped_ptr<RTCVideoDecoder::SHMBuffer> RTCVideoDecoder::GetSHM_Locked(
    727     size_t min_size) {
    728   // Reuse a SHM if possible.
    729   SHMBuffer* ret = NULL;
    730   if (!available_shm_segments_.empty() &&
    731       available_shm_segments_.back()->size >= min_size) {
    732     ret = available_shm_segments_.back();
    733     available_shm_segments_.pop_back();
    734   }
    735   // Post to vda thread to create shared memory if SHM cannot be reused or the
    736   // queue is almost empty.
    737   if (num_shm_buffers_ < kMaxNumSharedMemorySegments &&
    738       (ret == NULL || available_shm_segments_.size() <= 1)) {
    739     factories_->GetTaskRunner()->PostTask(
    740         FROM_HERE,
    741         base::Bind(&RTCVideoDecoder::CreateSHM,
    742                    weak_factory_.GetWeakPtr(),
    743                    1,
    744                    min_size));
    745   }
    746   return scoped_ptr<SHMBuffer>(ret);
    747 }
    748 
    749 void RTCVideoDecoder::PutSHM_Locked(scoped_ptr<SHMBuffer> shm_buffer) {
    750   available_shm_segments_.push_back(shm_buffer.release());
    751 }
    752 
    753 void RTCVideoDecoder::CreateSHM(int number, size_t min_size) {
    754   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    755   DVLOG(2) << "CreateSHM. size=" << min_size;
    756   int number_to_allocate;
    757   {
    758     base::AutoLock auto_lock(lock_);
    759     number_to_allocate =
    760         std::min(kMaxNumSharedMemorySegments - num_shm_buffers_, number);
    761   }
    762   size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
    763   for (int i = 0; i < number_to_allocate; i++) {
    764     base::SharedMemory* shm = factories_->CreateSharedMemory(size_to_allocate);
    765     if (shm != NULL) {
    766       base::AutoLock auto_lock(lock_);
    767       num_shm_buffers_++;
    768       PutSHM_Locked(
    769           scoped_ptr<SHMBuffer>(new SHMBuffer(shm, size_to_allocate)));
    770     }
    771   }
    772   // Kick off the decoding.
    773   RequestBufferDecode();
    774 }
    775 
    776 void RTCVideoDecoder::RecordBufferData(const BufferData& buffer_data) {
    777   input_buffer_data_.push_front(buffer_data);
    778   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
    779   // that's too small for some pathological B-frame test videos.  The cost of
    780   // using too-high a value is low (192 bits per extra slot).
    781   static const size_t kMaxInputBufferDataSize = 128;
    782   // Pop from the back of the list, because that's the oldest and least likely
    783   // to be useful in the future data.
    784   if (input_buffer_data_.size() > kMaxInputBufferDataSize)
    785     input_buffer_data_.pop_back();
    786 }
    787 
    788 void RTCVideoDecoder::GetBufferData(int32 bitstream_buffer_id,
    789                                     uint32_t* timestamp) {
    790   for (std::list<BufferData>::iterator it = input_buffer_data_.begin();
    791        it != input_buffer_data_.end();
    792        ++it) {
    793     if (it->bitstream_buffer_id != bitstream_buffer_id)
    794       continue;
    795     *timestamp = it->timestamp;
    796     return;
    797   }
    798   NOTREACHED() << "Missing bitstream buffer id: " << bitstream_buffer_id;
    799 }
    800 
    801 int32_t RTCVideoDecoder::RecordInitDecodeUMA(int32_t status) {
    802   // Logging boolean is enough to know if HW decoding has been used. Also,
    803   // InitDecode is less likely to return an error so enum is not used here.
    804   bool sample = (status == WEBRTC_VIDEO_CODEC_OK) ? true : false;
    805   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoDecoderInitDecodeSuccess", sample);
    806   return status;
    807 }
    808 
    809 void RTCVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
    810     const {
    811   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
    812 }
    813 
    814 }  // namespace content
    815