Detect H264 slices of the same frame in VEAUnittest

media/gpu/h264_decoder.h

 // 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.
 
 #ifndef MEDIA_GPU_H264_DECODER_H_
 #define MEDIA_GPU_H264_DECODER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 93 matching lines @@
   ~H264Decoder() override;
 
   // AcceleratedVideoDecoder implementation.
   bool Flush() override WARN_UNUSED_RESULT;
   void Reset() override;
   void SetStream(const uint8_t* ptr, size_t size) override;
   DecodeResult Decode() override WARN_UNUSED_RESULT;
   gfx::Size GetPicSize() const override;
   size_t GetRequiredNumOfPictures() const override;
 
+  // Return true if we need to start a new picture.
+  static bool IsNewPrimaryCodedPicture(scoped_refptr<H264Picture> curr_pic,
+                                       int curr_pps_id,
+                                       int curr_sps_id,
+                                       const H264Parser& parser,
+                                       const H264SliceHeader* slice_hdr);
+
+  // Return true if we can initialize |pic| with the given info.
+  static bool InitPictureFromSliceHeader(int curr_sps_id,
+                                         const H264Parser& parser,
+                                         const H264SliceHeader* slice_hdr,
+                                         scoped_refptr<H264Picture> pic);
+
  private:
   // We need to keep at most kDPBMaxSize pictures in DPB for
   // reference/to display later and an additional one for the one currently
   // being decoded. We also ask for some additional ones since VDA needs
   // to accumulate a few ready-to-output pictures before it actually starts
   // displaying and giving them back. +2 instead of +1 because of subjective
   // smoothness improvement during testing.
   enum {
     kPicsInPipeline = limits::kMaxVideoFrames + 2,
     kMaxNumReqPictures = H264DPB::kDPBMaxSize + kPicsInPipeline,
   };
 
   // Internal state of the decoder.
   enum State {
     kNeedStreamMetadata,  // After initialization, need an SPS.
     kDecoding,            // Ready to decode from any point.
     kAfterReset,          // After Reset(), need a resume point.
     kError,               // Error in decode, can't continue.
   };
 
   // Process H264 stream structures.
   bool ProcessSPS(int sps_id, bool* need_new_buffers);
   // Process current slice header to discover if we need to start a new picture,
   // finishing up the current one.
   bool PreprocessCurrentSlice();
   // Process current slice as a slice of the current picture.
   bool ProcessCurrentSlice();
 
-  // Return true if we need to start a new picture.
-  bool IsNewPrimaryCodedPicture(const H264SliceHeader* slice_hdr) const;
-
   // Initialize the current picture according to data in |slice_hdr|.
   bool InitCurrPicture(const H264SliceHeader* slice_hdr);
 
   // Initialize |pic| as a "non-existing" picture (see spec) with |frame_num|,
   // to be used for frame gap concealment.
   bool InitNonexistingPicture(scoped_refptr<H264Picture> pic, int frame_num);
 
   // Calculate picture order counts for |pic| on initialization
   // of a new frame (see spec).
   bool CalculatePicOrderCounts(scoped_refptr<H264Picture> pic);
@@ skipping 116 matching lines @@
   int last_output_poc_;
 
   H264Accelerator* accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(H264Decoder);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_H264_DECODER_H_