Move key frame flag from StreamParserBuffer to DecoderBuffer

media/filters/ffmpeg_demuxer.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 "media/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 178 matching lines @@
     LOG(ERROR) << "Format conversion failed.";
   }
 #endif
 
   // Get side data if any. For now, the only type of side_data is VP8 Alpha. We
   // keep this generic so that other side_data types in the future can be
   // handled the same way as well.
   av_packet_split_side_data(packet.get());
 
   scoped_refptr<DecoderBuffer> buffer;
+  bool is_keyframe = packet.get()->flags & AV_PKT_FLAG_KEY;
 
   if (type() == DemuxerStream::TEXT) {
     int id_size = 0;
     uint8* id_data = av_packet_get_side_data(
         packet.get(),
         AV_PKT_DATA_WEBVTT_IDENTIFIER,
         &id_size);
 
     int settings_size = 0;
     uint8* settings_data = av_packet_get_side_data(
         packet.get(),
         AV_PKT_DATA_WEBVTT_SETTINGS,
         &settings_size);
 
     std::vector<uint8> side_data;
     MakeSideData(id_data, id_data + id_size,
                  settings_data, settings_data + settings_size,
                  &side_data);
 
     buffer = DecoderBuffer::CopyFrom(packet.get()->data, packet.get()->size,
-                                     side_data.data(), side_data.size());
+                                     side_data.data(), side_data.size(),
+                                     is_keyframe);
   } else {
     int side_data_size = 0;
     uint8* side_data = av_packet_get_side_data(
         packet.get(),
         AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
         &side_data_size);
 
     scoped_ptr<DecryptConfig> decrypt_config;
     int data_offset = 0;
     if ((type() == DemuxerStream::AUDIO && audio_config_.is_encrypted()) ||
         (type() == DemuxerStream::VIDEO && video_config_.is_encrypted())) {
       if (!WebMCreateDecryptConfig(
           packet->data, packet->size,
           reinterpret_cast<const uint8*>(encryption_key_id_.data()),
           encryption_key_id_.size(),
           &decrypt_config,
           &data_offset)) {
         LOG(ERROR) << "Creation of DecryptConfig failed.";
       }
     }
 
     // If a packet is returned by FFmpeg's av_parser_parse2() the packet will
     // reference inner memory of FFmpeg.  As such we should transfer the packet
     // into memory we control.
     if (side_data_size > 0) {
       buffer = DecoderBuffer::CopyFrom(packet.get()->data + data_offset,
                                        packet.get()->size - data_offset,
-                                       side_data, side_data_size);
+                                       side_data, side_data_size,
+                                       is_keyframe);
     } else {
       buffer = DecoderBuffer::CopyFrom(packet.get()->data + data_offset,
-                                       packet.get()->size - data_offset);
+                                       packet.get()->size - data_offset,
+                                       is_keyframe);
     }
 
     int skip_samples_size = 0;
     const uint32* skip_samples_ptr =
         reinterpret_cast<const uint32*>(av_packet_get_side_data(
             packet.get(), AV_PKT_DATA_SKIP_SAMPLES, &skip_samples_size));
     const int kSkipSamplesValidSize = 10;
     const int kSkipEndSamplesOffset = 1;
     if (skip_samples_size >= kSkipSamplesValidSize) {
       // Because FFmpeg rolls codec delay and skip samples into one we can only
@@ skipping 1003 matching lines @@
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
 }  // namespace media