Add texture target field to video frame (for use by native textures).

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "media/base/demuxer_stream.h"
@@ skipping 30 matching lines @@
 GpuVideoDecoder::BufferTimeData::~BufferTimeData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     MessageLoop* message_loop,
     const scoped_refptr<Factories>& factories)
     : gvd_loop_proxy_(message_loop->message_loop_proxy()),
       render_loop_proxy_(base::MessageLoopProxy::current()),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
+      decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       shutting_down_(false) {
   DCHECK(gvd_loop_proxy_ && factories_);
 }
 
 GpuVideoDecoder::~GpuVideoDecoder() {
   DCHECK(!vda_);  // Stop should have been already called.
   DCHECK(pending_read_cb_.is_null());
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
@@ skipping 258 matching lines @@
 
 void GpuVideoDecoder::ProvidePictureBuffers(uint32 count,
                                             const gfx::Size& size) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::ProvidePictureBuffers, this, count, size));
     return;
   }
 
   std::vector<uint32> texture_ids;
-  if (!factories_->CreateTextures(count, size, &texture_ids)) {
+  if (!factories_->CreateTextures(
+      count, size, &texture_ids, &decoder_texture_target_)) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
 
   if (!vda_)
     return;
 
   std::vector<PictureBuffer> picture_buffers;
   for (size_t i = 0; i < texture_ids.size(); ++i) {
     picture_buffers.push_back(PictureBuffer(
@@ skipping 35 matching lines @@
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   const PictureBuffer& pb = it->second;
 
   // Update frame's timestamp.
   base::TimeDelta timestamp;
   base::TimeDelta duration;
   GetBufferTimeData(picture.bitstream_buffer_id(), &timestamp, &duration);
 
+  DCHECK(decoder_texture_target_);
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
-      pb.texture_id(), pb.size().width(),
+      pb.texture_id(), decoder_texture_target_, pb.size().width(),
       pb.size().height(), timestamp, duration,
       base::Bind(&GpuVideoDecoder::ReusePictureBuffer, this,
                  picture.picture_buffer_id())));
 
   EnqueueFrameAndTriggerFrameDelivery(frame);
 }
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
@@ skipping 129 matching lines @@
         &GpuVideoDecoder::NotifyError, this, error));
     return;
   }
   vda_ = NULL;
   DLOG(ERROR) << "VDA Error: " << error;
   if (host())
     host()->SetError(PIPELINE_ERROR_DECODE);
 }
 
 }  // namespace media