Build AVC decoder configuration record

content/common/gpu/media/mac_video_decode_accelerator.mm

 // 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 "content/common/gpu/media/mac_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #import "base/mac/foundation_util.h"
 #import "base/memory/ref_counted_memory.h"
@@ skipping 77 matching lines @@
           0) != kCGLNoError) {
     DVLOG(1) << "Failed to bind image to texture.";
     return false;
   }
   return glGetError() == GL_NO_ERROR;
 }
 
 MacVideoDecodeAccelerator::MacVideoDecodeAccelerator(
     media::VideoDecodeAccelerator::Client* client)
     : client_(client),
-      cgl_context_(NULL),
-      nalu_len_field_size_(0),
-      did_request_pictures_(false) {
+      cgl_context_(NULL) {
 }
 
 void MacVideoDecodeAccelerator::SetCGLContext(CGLContextObj cgl_context) {
   DCHECK(CalledOnValidThread());
   cgl_context_ = cgl_context;
 }
 
-bool MacVideoDecodeAccelerator::SetConfigInfo(
-    uint32_t frame_width,
-    uint32_t frame_height,
-    const std::vector<uint8_t>& avc_data) {
-  DCHECK(CalledOnValidThread());
-  frame_size_ = gfx::Size(frame_width, frame_height);
-  nalu_len_field_size_ = (avc_data[4] & 0x03) + 1;
-
-  DCHECK(!vda_support_.get());
-  vda_support_ = new gfx::VideoDecodeAccelerationSupport();
-  gfx::VideoDecodeAccelerationSupport::Status status = vda_support_->Create(
-      frame_size_.width(), frame_size_.height(), kCVPixelFormatType_422YpCbCr8,
-      &avc_data.front(), avc_data.size());
-  RETURN_ON_FAILURE(status == gfx::VideoDecodeAccelerationSupport::SUCCESS,
-                    "Creating video decoder failed with error: " << status,
-                    PLATFORM_FAILURE, false);
-  return true;
-}
-
 bool MacVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile) {
   DCHECK(CalledOnValidThread());
 
   IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
   if (!io_surface_support)
     return false;
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &MacVideoDecodeAccelerator::NotifyInitializeDone, this));
   return true;
 }
 
 void MacVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to Decode() during invalid state.", ILLEGAL_STATE,);
 
   base::SharedMemory memory(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(memory.Map(bitstream_buffer.size()),
                     "Failed to SharedMemory::Map().", UNREADABLE_INPUT,);
 
-  size_t buffer_size = bitstream_buffer.size();
-  RETURN_ON_FAILURE(buffer_size > nalu_len_field_size_,
-                    "Bitstream contains invalid data.", INVALID_ARGUMENT,);
-
-  // The decoder can only handle slice types 1-5.
-  const uint8_t* buffer = static_cast<const uint8_t*>(memory.memory());
-  uint8_t nalu_type = buffer[nalu_len_field_size_] & 0x1f;
-  if (nalu_type < 1 || nalu_type > 5) {
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &MacVideoDecodeAccelerator::NotifyInputBufferRead, this,
-        bitstream_buffer.id()));
-    return;
-  }
-
-  // Keep a ref counted copy of the buffer.
-  std::vector<uint8_t> vbuffer(buffer, buffer + buffer_size);
-  scoped_refptr<base::RefCountedBytes> bytes(
-      base::RefCountedBytes::TakeVector(&vbuffer));
-
-  // Store the buffer size at the beginning of the buffer as the decoder
-  // expects.
-  size_t frame_buffer_size = buffer_size - nalu_len_field_size_;
-  const uint64_t max_frame_buffer_size =
-      (1llu << (nalu_len_field_size_ * 8)) - 1;
-  DCHECK_LE(nalu_len_field_size_, 4u);
-  RETURN_ON_FAILURE(frame_buffer_size <= max_frame_buffer_size,
-                    "Bitstream buffer is too large.", INVALID_ARGUMENT,);
-  for (size_t i = 0; i < nalu_len_field_size_; ++i) {
-    size_t shift = nalu_len_field_size_ * 8 - (i + 1) * 8;
-    bytes->data()[i] = (frame_buffer_size >> shift) & 0xff;
-  }
-
-  vda_support_->Decode(bytes->front(), bytes->size(),
-                       base::Bind(&MacVideoDecodeAccelerator::OnFrameReady,
-                                  this, bitstream_buffer.id(), bytes));
-
-  if (!did_request_pictures_) {
-    did_request_pictures_ = true;
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &MacVideoDecodeAccelerator::RequestPictures, this));
+  h264_parser_.SetStream(static_cast<const uint8_t*>(memory.memory()),
+                         bitstream_buffer.size());
+  while (true) {
+    content::H264NALU nalu;
+    content::H264Parser::Result result = h264_parser_.AdvanceToNextNALU(&nalu);
+    if (result == content::H264Parser::kEOStream) {
+      MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+          &MacVideoDecodeAccelerator::NotifyInputBufferRead, this,
+          bitstream_buffer.id()));
+      return;
+    }
+    RETURN_ON_FAILURE(result == content::H264Parser::kOk,
+                      "Unable to parse bitstream.", UNREADABLE_INPUT,);
+    if (!did_build_config_record_) {
+      std::vector<uint8_t> config_record;
+      RETURN_ON_FAILURE(config_record_builder_.ProcessNALU(&h264_parser_, nalu,
+                                                           &config_record),
+                        "Unable to build AVC configuraiton record.",
+                        UNREADABLE_INPUT,);
+      if (!config_record.empty()) {
+        did_build_config_record_ = true;
+        if (!CreateDecoder(config_record))
+          return;
+      }
+    }
+    // If the decoder has been created and this is a slice type then pass it
+    // to the decoder.
+    if (vda_support_.get() && nalu.nal_unit_type >= 1 &&
+        nalu.nal_unit_type <= 5) {
+      DecodeNALU(nalu, bitstream_buffer.id());
+    }
   }
 }
 
 void MacVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to AssignPictureBuffers() during invalid state.",

[Ami GONE FROM CHROMIUM, 2012/06/05 15:47:43]

I think you missed this comment I made on a previous review: 

This pattern generally is incorrect because of queuing.
For example if the client queues two IPCs and the first errors out, the
component will be in an error state when the second is executed, even though the
client couldn't have retracted it by the time the error was reported.

[Ami GONE FROM CHROMIUM, 2012/06/05 16:10:18]

Oops; I was reading this as a DCHECK, not a R_O_F.  Ignore this comment.

                     ILLEGAL_STATE,);
   available_pictures_.insert(
       available_pictures_.end(), buffers.begin(), buffers.end());
   SendImages();
 }
 
 void MacVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to ReusePictureBuffe() during invalid state.",
                     ILLEGAL_STATE,);
 
   std::map<int32, UsedPictureInfo>::iterator it =
       used_pictures_.find(picture_buffer_id);
   RETURN_ON_FAILURE(it != used_pictures_.end(),
                     "Missing picture buffer id: " << picture_buffer_id,
                     INVALID_ARGUMENT,);
   UsedPictureInfo info = it->second;
   used_pictures_.erase(it);
   available_pictures_.push_back(info.picture_buffer);
   SendImages();
 }
 
 void MacVideoDecodeAccelerator::Flush() {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,

[Ami GONE FROM CHROMIUM, 2012/06/05 15:47:43]

I don't think it is.

[sail, 2012/06/05 16:42:53]

Fixed. I changed Flush() and Reset() to check for vda_support_.

                     "Call to Flush() during invalid state.", ILLEGAL_STATE,);
   vda_support_->Flush(true);
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &MacVideoDecodeAccelerator::NotifyFlushDone, this));
 }
 
 void MacVideoDecodeAccelerator::Reset() {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to Reset() during invalid state.", ILLEGAL_STATE,);
@@ skipping 29 matching lines @@
   if (!client_)
     return;
   if (image) {
     DecodedImageInfo info;
     info.image.reset(image, base::scoped_policy::RETAIN);
     info.bitstream_buffer_id = bitstream_buffer_id;
     decoded_images_.push_back(info);
     SendImages();
   }
   // TODO(sail): this assumes Decode() is handed a single NALU at a time. Make
   // that assumption go away.

[Ami GONE FROM CHROMIUM, 2012/06/05 15:47:43]

Can you refer to the specific test that doesn't pass, here?

[sail, 2012/06/05 16:42:53]

Done.

   client_->NotifyEndOfBitstreamBuffer(bitstream_buffer_id);
 }
 
 void MacVideoDecodeAccelerator::SendImages() {
   if (!client_) {
     DCHECK(decoded_images_.empty());
     return;
   }
 
   while (available_pictures_.size() && decoded_images_.size()) {
@@ skipping 13 matching lines @@
   }
 }
 
 void MacVideoDecodeAccelerator::StopOnError(
     media::VideoDecodeAccelerator::Error error) {
   if (client_)
     client_->NotifyError(error);
   Destroy();
 }
 
+bool MacVideoDecodeAccelerator::CreateDecoder(
+    const std::vector<uint8_t>& extra_data) {
+  DCHECK(client_);
+  DCHECK(!vda_support_.get());
+
+  vda_support_ = new gfx::VideoDecodeAccelerationSupport();
+  gfx::VideoDecodeAccelerationSupport::Status status = vda_support_->Create(
+      config_record_builder_.coded_width(),
+      config_record_builder_.coded_height(),
+      kCVPixelFormatType_422YpCbCr8,
+      &extra_data[0], extra_data.size());
+  RETURN_ON_FAILURE(status == gfx::VideoDecodeAccelerationSupport::SUCCESS,
+                    "Creating video decoder failed with error: " << status,
+                    PLATFORM_FAILURE, false);
+
+  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+      &MacVideoDecodeAccelerator::RequestPictures, this));
+  return true;
+}
+
+void MacVideoDecodeAccelerator::DecodeNALU(const content::H264NALU& nalu,
+                                           int32 bitstream_buffer_id) {
+  // Assume the NALU length field size is 4 bytes.
+  const int kNALULengthFieldSize = 4;
+  std::vector<uint8_t> data(kNALULengthFieldSize + nalu.size);
+
+  // Store the buffer size at the beginning of the buffer as the decoder
+  // expects.
+  for (size_t i = 0; i < kNALULengthFieldSize; ++i) {
+    size_t shift = kNALULengthFieldSize * 8 - (i + 1) * 8;
+    data[i] = (nalu.size >> shift) & 0xff;
+  }
+
+  // Copy the NALU data.
+  memcpy(&data[kNALULengthFieldSize], nalu.data, nalu.size);
+
+  // Keep a ref counted copy of the buffer.
+  scoped_refptr<base::RefCountedBytes> bytes(
+      base::RefCountedBytes::TakeVector(&data));
+  vda_support_->Decode(bytes->front(), bytes->size(),
+                       base::Bind(&MacVideoDecodeAccelerator::OnFrameReady,
+                                  this, bitstream_buffer_id, bytes));
+}
+
 void MacVideoDecodeAccelerator::NotifyInitializeDone() {
   if (client_)
     client_->NotifyInitializeDone();
 }
 
 void MacVideoDecodeAccelerator::RequestPictures() {
-  if (client_)
-    client_->ProvidePictureBuffers(kNumPictureBuffers, frame_size_);
+  if (client_) {
+    client_->ProvidePictureBuffers(
+        kNumPictureBuffers,
+        gfx::Size(config_record_builder_.coded_width(),
+                  config_record_builder_.coded_height()));
+  }
 }
 
 void MacVideoDecodeAccelerator::NotifyFlushDone() {
   if (client_)
     client_->NotifyFlushDone();
 }
 
 void MacVideoDecodeAccelerator::NotifyResetDone() {
   decoded_images_.clear();
   if (client_)
@@ skipping 13 matching lines @@
 }
 
 MacVideoDecodeAccelerator::UsedPictureInfo::~UsedPictureInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::DecodedImageInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::~DecodedImageInfo() {
 }