VAVDA: Clarify curr_pic_ ownership in FinishPicture().

content/common/gpu/media/vaapi_h264_decoder.cc

 // 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 <dlfcn.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 1770 matching lines @@
     prev_ref_field_ = curr_pic_->field;
   }
 
   // Remove unused (for reference or later output) pictures from DPB.
   dpb_.RemoveUnused();
 
   DVLOG(4) << "Finishing picture, DPB entries: " << dpb_.size()
            << " Num available dec surfaces: "
            << num_available_decode_surfaces_;
 
+  // Whatever happens below, curr_pic_ will stop managing the pointer to the
+  // picture after this function returns. The ownership will either be
+  // transferred to DPB, if the image is still needed (for output and/or
+  // reference), or the memory will be released if we manage to output it here
+  // without having to store it for future reference.
+  scoped_ptr<H264Picture> pic(curr_pic_.release());
+
   if (dpb_.IsFull()) {
     // DPB is full, we have to make space for the new picture.
     // Get all pictures that haven't been outputted yet.
     H264Picture::PtrVector not_outputted;
     dpb_.GetNotOutputtedPicsAppending(not_outputted);
     std::sort(not_outputted.begin(), not_outputted.end(), POCAscCompare());
     H264Picture::PtrVector::iterator output_candidate = not_outputted.begin();
 
     // Keep outputting pictures until we can either output the picture being
     // finished and discard it (if it is not a reference picture), or until
     // we can discard an older picture that was just waiting for output and
     // is not a reference picture, thus making space for the current one.
     while (dpb_.IsFull()) {
       // Maybe outputted enough to output current picture.
-      if (!curr_pic_->ref && (output_candidate == not_outputted.end() ||
-          curr_pic_->pic_order_cnt < (*output_candidate)->pic_order_cnt)) {
-        // curr_pic_ is not a reference picture and no preceding pictures are
+      if (!pic->ref && (output_candidate == not_outputted.end() ||
+          pic->pic_order_cnt < (*output_candidate)->pic_order_cnt)) {
+        // pic is not a reference picture and no preceding pictures are
         // waiting for output in DPB, so it can be outputted and discarded
         // without storing in DPB.
-        if (!OutputPic(curr_pic_.get()))
+        if (!OutputPic(pic.get()))
           return false;
 
         // Managed to output current picture, return without adding to DPB.
+        // This will release current picture (stored in pic).
         return true;
       }
 
       // Couldn't output current picture, so try to output the lowest PoC
       // from DPB.
       if (output_candidate != not_outputted.end()) {
         if (!OutputPic(*output_candidate))
           return false;
 
         // If outputted picture wasn't a reference picture, it can be removed.
         if (!(*output_candidate)->ref)
           dpb_.RemoveByPOC((*output_candidate)->pic_order_cnt);
       } else {
         // Couldn't output current pic and couldn't do anything
         // with existing pictures in DPB, so we can't make space.
         // This should not happen.
         DVLOG(1) << "Could not free up space in DPB!";
         return false;
       }
+
+      ++output_candidate;
     }
-    ++output_candidate;
   }
 
   // Store current picture for later output and/or reference (ownership now
   // with the DPB).
-  dpb_.StorePic(curr_pic_.release());
+  dpb_.StorePic(pic.release());
 
   return true;
 }
 
 bool VaapiH264Decoder::ProcessSPS(int sps_id) {
   const H264SPS* sps = parser_.GetSPS(sps_id);
   DCHECK(sps);
 
   if (sps->frame_mbs_only_flag == 0) {
     // Fields/interlaced video not supported.
@@ skipping 312 matching lines @@
       VAAPI_SyncSurface &&
       VAAPI_BeginPicture &&
       VAAPI_RenderPicture &&
       VAAPI_EndPicture &&
       VAAPI_CreateBuffer &&
       VAAPI_DestroyBuffer &&
       VAAPI_ErrorStr;
 }
 
 }  // namespace content