H264Decoder: Handle gaps in frame_num.

content/common/gpu/media/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 CONTENT_COMMON_GPU_MEDIA_H264_DECODER_H_
 #define CONTENT_COMMON_GPU_MEDIA_H264_DECODER_H_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
@@ skipping 111 matching lines @@
   // 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);
-  bool ProcessPPS(int pps_id);
-  bool PreprocessSlice(media::H264SliceHeader* slice_hdr);
-  bool ProcessSlice(media::H264SliceHeader* slice_hdr);
+  // 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 media::H264SliceHeader* slice_hdr);

[kcwu, 2015/10/02 13:06:03]

const method

[Pawel Osciak, 2015/10/09 06:39:25]

Done.

 
   // Initialize the current picture according to data in |slice_hdr|.
-  bool InitCurrPicture(media::H264SliceHeader* slice_hdr);
+  bool InitCurrPicture(const media::H264SliceHeader* slice_hdr);
 
-  // Calculate picture order counts for the new picture
-  // on initialization of a new frame (see spec).
-  bool CalculatePicOrderCounts(media::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);
 
-  // Update PicNum values in pictures stored in DPB on creation of new
-  // frame (see spec).
-  void UpdatePicNums();
+  // Calculate picture order counts for |pic| on initialization
+  // of a new frame (see spec).
+  bool CalculatePicOrderCounts(scoped_refptr<H264Picture> pic);
+
+  // Update PicNum values in pictures stored in DPB on creation of
+  // a picture with |frame_num|.
+  void UpdatePicNums(int frame_num);
 
   bool UpdateMaxNumReorderFrames(const media::H264SPS* sps);
 
   // Prepare reference picture lists for the current frame.
-  void PrepareRefPicLists(media::H264SliceHeader* slice_hdr);
+  void PrepareRefPicLists(const media::H264SliceHeader* slice_hdr);
   // Prepare reference picture lists for the given slice.
-  bool ModifyReferencePicLists(media::H264SliceHeader* slice_hdr,
+  bool ModifyReferencePicLists(const media::H264SliceHeader* slice_hdr,
                                H264Picture::Vector* ref_pic_list0,
                                H264Picture::Vector* ref_pic_list1);
 
   // Construct initial reference picture lists for use in decoding of
   // P and B pictures (see 8.2.4 in spec).
-  void ConstructReferencePicListsP(media::H264SliceHeader* slice_hdr);
-  void ConstructReferencePicListsB(media::H264SliceHeader* slice_hdr);
+  void ConstructReferencePicListsP(const media::H264SliceHeader* slice_hdr);
+  void ConstructReferencePicListsB(const media::H264SliceHeader* slice_hdr);
 
   // Helper functions for reference list construction, per spec.
   int PicNumF(const scoped_refptr<H264Picture>& pic);
   int LongTermPicNumF(const scoped_refptr<H264Picture>& pic);
 
   // Perform the reference picture lists' modification (reordering), as
   // specified in spec (8.2.4).
   //
   // |list| indicates list number and should be either 0 or 1.
-  bool ModifyReferencePicList(media::H264SliceHeader* slice_hdr,
+  bool ModifyReferencePicList(const media::H264SliceHeader* slice_hdr,
                               int list,
                               H264Picture::Vector* ref_pic_listx);
 
   // Perform reference picture memory management operations (marking/unmarking
   // of reference pictures, long term picture management, discarding, etc.).
   // See 8.2.5 in spec.
-  bool HandleMemoryManagementOps();
-  void ReferencePictureMarking();
+  bool HandleMemoryManagementOps(scoped_refptr<H264Picture> pic);
+  bool ReferencePictureMarking(scoped_refptr<H264Picture> pic);
+  bool SlidingWindowPictureMarking();
+
+  // Handle a gap in frame_num in the stream up to |frame_num|, by creating
+  // "non-existing" pictures (see spec).
+  bool HandleFrameNumGap(int frame_num);
 
   // Start processing a new frame.
-  bool StartNewFrame(media::H264SliceHeader* slice_hdr);
+  bool StartNewFrame(const media::H264SliceHeader* slice_hdr);
 
   // All data for a frame received, process it and decode.
   bool FinishPrevFrameIfPresent();
 
-  // Called after decoding, performs all operations to be done after decoding,
-  // including DPB management, reference picture marking and memory management
-  // operations.
-  // This will also output a picture if one is ready for output.
-  bool FinishPicture();
+  // Called after we are done processing |pic|. Performs all operations to be
+  // done after decoding, including DPB management, reference picture marking
+  // and memory management operations.
+  // This will also output pictures if any have become ready to be outputted
+  // after processing |pic|.
+  bool FinishPicture(scoped_refptr<H264Picture> pic);
 
   // Clear DPB contents and remove all surfaces in DPB from *in_use_ list.
   // Cleared pictures will be made available for decode, unless they are
   // at client waiting to be displayed.
   void ClearDPB();
 
   // Commits all pending data for HW decoder and starts HW decoder.
   bool DecodePicture();
 
   // Notifies client that a picture is ready for output.
@@ skipping 13 matching lines @@
 
   // Picture currently being processed/decoded.
   scoped_refptr<H264Picture> curr_pic_;
 
   // Reference picture lists, constructed for each frame.
   H264Picture::Vector ref_pic_list_p0_;
   H264Picture::Vector ref_pic_list_b0_;
   H264Picture::Vector ref_pic_list_b1_;
 
   // Global state values, needed in decoding. See spec.
-  int max_pic_order_cnt_lsb_;
   int max_frame_num_;
   int max_pic_num_;
   int max_long_term_frame_idx_;
   size_t max_num_reorder_frames_;
 
-  int frame_num_;
   int prev_frame_num_;
+  int prev_ref_frame_num_;
   int prev_frame_num_offset_;
   bool prev_has_memmgmnt5_;
 
   // Values related to previously decoded reference picture.
   bool prev_ref_has_memmgmnt5_;
   int prev_ref_top_field_order_cnt_;
   int prev_ref_pic_order_cnt_msb_;
   int prev_ref_pic_order_cnt_lsb_;
   H264Picture::Field prev_ref_field_;
 
   // Currently active SPS and PPS.
   int curr_sps_id_;
-  int curr_pps_id_;
 
   // Current NALU and slice header being processed.
   scoped_ptr<media::H264NALU> curr_nalu_;
   scoped_ptr<media::H264SliceHeader> curr_slice_hdr_;
 
   // Output picture size.
   gfx::Size pic_size_;
 
   // PicOrderCount of the previously outputted frame.
   int last_output_poc_;
 
   H264Accelerator* accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(H264Decoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_H264_DECODER_H_