Add support for redundant streams to VTVideoDecodeAccelerator.

content/common/gpu/media/vt_video_decode_accelerator.cc

 // Copyright 2014 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 <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
@@ skipping 341 matching lines @@
   }
   const uint8_t* buf = static_cast<uint8_t*>(memory.memory());
 
   // NALUs are stored with Annex B format in the bitstream buffer (start codes),
   // but VideoToolbox expects AVC format (length headers), so we must rewrite
   // the data.
   //
   // Locate relevant NALUs and compute the size of the rewritten data. Also
   // record any parameter sets for VideoToolbox initialization.
   bool config_changed = false;
+  bool has_slice = false;
   size_t data_size = 0;
   std::vector<media::H264NALU> nalus;
   parser_.SetStream(buf, size);
   media::H264NALU nalu;
   while (true) {
     media::H264Parser::Result result = parser_.AdvanceToNextNALU(&nalu);
     if (result == media::H264Parser::kEOStream)
       break;
     if (result != media::H264Parser::kOk) {
       DLOG(ERROR) << "Failed to find H.264 NALU";
@@ skipping 24 matching lines @@
         if (parser_.ParsePPS(&last_pps_id_) != media::H264Parser::kOk) {
           DLOG(ERROR) << "Could not parse PPS";
           NotifyError(UNREADABLE_INPUT);
           return;
         }
         break;
 
       case media::H264NALU::kSliceDataA:
       case media::H264NALU::kSliceDataB:
       case media::H264NALU::kSliceDataC:
-        DLOG(ERROR) << "Coded slide data partitions not implemented.";
-        NotifyError(PLATFORM_FAILURE);
-        return;
-
       case media::H264NALU::kNonIDRSlice:
         // TODO(sandersd): Check that there has been an IDR slice since the
         // last reset.
       case media::H264NALU::kIDRSlice:
-        {
-          // TODO(sandersd): Make sure this only happens once per frame.
-          DCHECK_EQ(frame->pic_order_cnt, 0);
-
+        // Compute the |pic_order_cnt| for the picture from the first slice.
+        // TODO(sandersd): Make sure that any further slices are part of the
+        // same picture or a redundant coded picture.
+        if (!has_slice) {
           media::H264SliceHeader slice_hdr;
           result = parser_.ParseSliceHeader(nalu, &slice_hdr);
           if (result != media::H264Parser::kOk) {
             DLOG(ERROR) << "Could not parse slice header";
             NotifyError(UNREADABLE_INPUT);
             return;
           }
 
           // TODO(sandersd): Maintain a cache of configurations and reconfigure
           // only when a slice references a new config.
@@ skipping 18 matching lines @@
             NotifyError(UNREADABLE_INPUT);
             return;
           }
 
           if (sps->vui_parameters_present_flag &&
               sps->bitstream_restriction_flag) {
             frame->reorder_window = std::min(sps->max_num_reorder_frames,
                                              kMaxReorderQueueSize - 1);
           }
         }
+        has_slice = true;
       default:
         nalus.push_back(nalu);
         data_size += kNALUHeaderLength + nalu.size;
         break;
     }
   }
 
   // Initialize VideoToolbox.
   // TODO(sandersd): Instead of assuming that the last SPS and PPS units are
   // always the correct ones, maintain a cache of recent SPS and PPS units and
   // select from them using the slice header.
   if (config_changed) {
     if (last_sps_.size() == 0 || last_pps_.size() == 0) {
       DLOG(ERROR) << "Invalid configuration data";
       NotifyError(INVALID_ARGUMENT);
       return;
     }
     if (!ConfigureDecoder())
       return;
   }
 
-  // If there are no non-configuration units, drop the bitstream buffer by
-  // returning an empty frame.
-  if (!data_size) {
+  // If there are no image slices, drop the bitstream buffer by returning an
+  // empty frame.
+  if (!has_slice) {
     if (!FinishDelayedFrames())
       return;
     gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VTVideoDecodeAccelerator::DecodeDone, weak_this_, frame));
     return;
   }
 
   // If the session is not configured by this point, fail.
   if (!session_) {
     DLOG(ERROR) << "Image slice without configuration";
@@ skipping 397 matching lines @@
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content