Implement |pic_order_cnt| computation for VTVideoDecode accelerator.

content/common/gpu/media/h264_poc.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 "base/logging.h"
+#include "content/common/gpu/media/h264_poc.h"
+#include "media/filters/h264_parser.h"
+
+namespace content {
+
+H264POC::H264POC() {
+  Reset();
+}
+
+H264POC::~H264POC() {
+}
+
+void H264POC::Reset() {
+  // It shouldn't be necessary to reset these values, but doing so will improve
+  // reproducibility for buggy streams.
+  ref_pic_order_cnt_msb_ = 0;
+  ref_pic_order_cnt_lsb_ = 0;
+  prev_frame_num_ = 0;
+  prev_frame_num_offset_ = 0;
+}
+
+// Check if a slice includes memory management control operation 5, which
+// results in some |pic_order_cnt| state being cleared.
+static bool HasMMCO5(const media::H264SliceHeader& slice_hdr) {
+  // Require that the frame actually has memory management control operations.
+  if (slice_hdr.nal_ref_idc == 0 ||
+      slice_hdr.idr_pic_flag ||
+      !slice_hdr.adaptive_ref_pic_marking_mode_flag) {
+    return false;
+  }
+
+  for (size_t i = 0; i < arraysize(slice_hdr.ref_pic_marking); i++) {
+    int32_t op = slice_hdr.ref_pic_marking[i].memory_mgmnt_control_operation;
+    if (op == 5)
+      return true;
+
+    // Stop at the end of the list.

[DaleCurtis, 2014/11/21 21:42:05]

Is this really the end of the list always? If so, just let it fall out of the
loop?

[sandersd (OOO until July 31), 2014/11/21 23:33:16]

Well, the list is zero-terminated, but it might not be as long as the storage
allocated for it.

+    if (op == 0)
+      return false;
+  }
+
+  // Should not get here, the list is always zero terminated.
+  return false;
+}
+
+bool H264POC::ComputePicOrderCnt(
+    const media::H264SPS* sps,
+    const media::H264SliceHeader& slice_hdr,
+    int32_t *pic_order_cnt) {
+  if (slice_hdr.field_pic_flag) {
+    DLOG(ERROR) << "Interlaced frames are not supported";
+    return false;
+  }
+
+  // TODO(sandersd): Handle |gaps_in_frame_num_value|.
+  if (prev_frame_num_ > 0 && prev_frame_num_ < slice_hdr.frame_num - 1) {
+    DLOG(ERROR) << "Gaps in frame_num are not supported";
+    return false;
+  }
+
+  bool mmco5 = HasMMCO5(slice_hdr);
+  int32_t max_frame_num = 1 << (sps->log2_max_frame_num_minus4 + 4);
+  int32_t max_pic_order_cnt_lsb =
+      1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
+
+  // Based on T-REC-H.264 8.2.1, "Decoding process for picture order
+  // count", available from http://www.itu.int/rec/T-REC-H.264.
+  //
+  // Reorganized slightly from spec pseudocode to handle MMCO5 when storing
+  // state instead of when loading it.
+  switch (sps->pic_order_cnt_type) {
+    case 0: {
+      int32_t prev_pic_order_cnt_msb = ref_pic_order_cnt_msb_;
+      int32_t prev_pic_order_cnt_lsb = ref_pic_order_cnt_lsb_;
+
+      // For an IDR picture, clear the state.
+      if (slice_hdr.idr_pic_flag) {
+        prev_pic_order_cnt_msb = 0;
+        prev_pic_order_cnt_lsb = 0;
+      }
+
+      // 8-3. Derive |pic_order_cnt_msb|.
+      int32_t pic_order_cnt_msb;
+      if ((slice_hdr.pic_order_cnt_lsb < prev_pic_order_cnt_lsb) &&
+          (prev_pic_order_cnt_lsb - slice_hdr.pic_order_cnt_lsb >=
+           max_pic_order_cnt_lsb / 2)) {
+        pic_order_cnt_msb = prev_pic_order_cnt_msb + max_pic_order_cnt_lsb;
+      } else if ((slice_hdr.pic_order_cnt_lsb > prev_pic_order_cnt_lsb) &&
+          (slice_hdr.pic_order_cnt_lsb - prev_pic_order_cnt_lsb >
+           max_pic_order_cnt_lsb / 2)) {
+        pic_order_cnt_msb = prev_pic_order_cnt_msb - max_pic_order_cnt_lsb;
+      } else {
+        pic_order_cnt_msb = prev_pic_order_cnt_msb;
+      }
+
+      // 8-4, 8-5. Derive |top_field_order_count| and |bottom_field_order_cnt|.
+      int32_t top_foc = pic_order_cnt_msb + slice_hdr.pic_order_cnt_lsb;
+      int32_t bottom_foc = top_foc + slice_hdr.delta_pic_order_cnt_bottom;
+      *pic_order_cnt = std::min(top_foc, bottom_foc);
+
+      // Store state.
+      prev_frame_num_ = slice_hdr.frame_num;
+      if (slice_hdr.nal_ref_idc != 0) {
+        if (mmco5) {
+          ref_pic_order_cnt_msb_ = 0;
+          ref_pic_order_cnt_lsb_ = top_foc;
+        } else {
+          ref_pic_order_cnt_msb_ = pic_order_cnt_msb;
+          ref_pic_order_cnt_lsb_ = slice_hdr.pic_order_cnt_lsb;
+        }
+      }
+
+      break;
+    }
+
+    case 1: {
+      // 8-6. Derive |frame_num_offset|.
+      int32_t frame_num_offset;
+      if (slice_hdr.idr_pic_flag)
+        frame_num_offset = 0;
+      else if (prev_frame_num_ > slice_hdr.frame_num)
+        frame_num_offset = prev_frame_num_offset_ + max_frame_num;
+      else
+        frame_num_offset = prev_frame_num_offset_;
+
+      // 8-7. Derive |abs_frame_num|.
+      int32_t abs_frame_num;
+      if (sps->num_ref_frames_in_pic_order_cnt_cycle != 0)
+        abs_frame_num = frame_num_offset + slice_hdr.frame_num;
+      else
+        abs_frame_num = 0;
+
+      if (slice_hdr.nal_ref_idc == 0 && abs_frame_num > 0)
+        abs_frame_num--;
+
+      // 8-9. Derive |expected_pic_order_cnt| (the |pic_order_cnt| indicated
+      //      by the cycle described in the SPS).
+      int32_t expected_pic_order_cnt = 0;
+      if (abs_frame_num > 0) {
+        // 8-8. Derive pic_order_cnt_cycle_cnt and
+        //      frame_num_in_pic_order_cnt_cycle.
+        // Moved inside 8-9 to avoid division when this check is not done.
+        if (sps->num_ref_frames_in_pic_order_cnt_cycle == 0) {
+          DLOG(ERROR) << "Invalid num_ref_frames_in_pic_order_cnt_cycle";
+          return false;
+        }
+
+        // H264Parser checks that num_ref_frames_in_pic_order_cnt_cycle < 255.
+        int32_t pic_order_cnt_cycle_cnt =
+            (abs_frame_num - 1) / sps->num_ref_frames_in_pic_order_cnt_cycle;
+        int32_t frame_num_in_pic_order_cnt_cycle =
+            (abs_frame_num - 1) % sps->num_ref_frames_in_pic_order_cnt_cycle;
+
+        // 8-9 continued.
+        expected_pic_order_cnt = pic_order_cnt_cycle_cnt *
+                                 sps->expected_delta_per_pic_order_cnt_cycle;
+        for (int32_t i = 0; i <= frame_num_in_pic_order_cnt_cycle; i++)
+          expected_pic_order_cnt += sps->offset_for_ref_frame[i];
+      }
+      if (slice_hdr.nal_ref_idc == 0)
+        expected_pic_order_cnt += sps->offset_for_non_ref_pic;
+
+      // 8-10. Derive |top_field_order_cnt| and |bottom_field_order_cnt|.
+      int32_t top_foc = expected_pic_order_cnt +
+                        slice_hdr.delta_pic_order_cnt[0];
+      int32_t bottom_foc = top_foc + sps->offset_for_top_to_bottom_field +
+                           slice_hdr.delta_pic_order_cnt[1];
+      *pic_order_cnt = std::min(top_foc, bottom_foc);
+
+      // Store state.
+      prev_frame_num_ = slice_hdr.frame_num;
+      prev_frame_num_offset_ = frame_num_offset;
+      if (mmco5)
+        prev_frame_num_offset_ = 0;
+
+      break;
+    }
+
+    case 2: {
+      // 8-11. Derive |frame_num_offset|.
+      int32_t frame_num_offset;
+      if (slice_hdr.idr_pic_flag)
+        frame_num_offset = 0;
+      else if (prev_frame_num_ > slice_hdr.frame_num)
+        frame_num_offset = prev_frame_num_offset_ + max_frame_num;
+      else
+        frame_num_offset = prev_frame_num_offset_;
+
+      // 8-12, 8-13. Derive |temp_pic_order_count| (it's always the
+      // |pic_order_cnt|).
+      if (slice_hdr.idr_pic_flag)
+        *pic_order_cnt = 0;
+      else if (slice_hdr.nal_ref_idc == 0)
+        *pic_order_cnt = 2 * (frame_num_offset + slice_hdr.frame_num) - 1;
+      else
+        *pic_order_cnt = 2 * (frame_num_offset + slice_hdr.frame_num);
+
+      // Store state.
+      prev_frame_num_ = slice_hdr.frame_num;
+      prev_frame_num_offset_ = frame_num_offset;
+      if (mmco5)
+        prev_frame_num_offset_ = 0;
+
+      break;
+    }
+
+    default:
+      DLOG(ERROR) << "Invalid pic_order_cnt_type: " << sps->pic_order_cnt_type;
+      return false;
+  }
+
+  return true;
+}
+
+}  // namespace content