Drop DecryptConfig::data_offset_.

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 98 matching lines @@
   // Convert the packet if there is a bitstream filter.
   if (packet->data && bitstream_converter_enabled_ &&
       !bitstream_converter_->ConvertPacket(packet.get())) {
     LOG(ERROR) << "Format conversion failed.";
   }
 
   // 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;
 
   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());
   } 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, packet.get()->size,
+      buffer = DecoderBuffer::CopyFrom(packet.get()->data + data_offset,
+                                       packet.get()->size - data_offset,
                                        side_data, side_data_size);
     } else {
-      buffer = DecoderBuffer::CopyFrom(packet.get()->data, packet.get()->size);
+      buffer = DecoderBuffer::CopyFrom(packet.get()->data + data_offset,
+                                       packet.get()->size - data_offset);
     }
 
     int skip_samples_size = 0;
     uint8* skip_samples = av_packet_get_side_data(packet.get(),
                                                   AV_PKT_DATA_SKIP_SAMPLES,
                                                   &skip_samples_size);
     const int kSkipSamplesValidSize = 10;
     const int kSkipSamplesOffset = 4;
     if (skip_samples_size >= kSkipSamplesValidSize) {
       int discard_padding_samples = base::ByteSwapToLE32(
           *(reinterpret_cast<const uint32*>(skip_samples +
                                             kSkipSamplesOffset)));
       // TODO(vigneshv): Change decoder buffer to use number of samples so that
       // this conversion can be avoided.
       buffer->set_discard_padding(base::TimeDelta::FromMicroseconds(
           discard_padding_samples * 1000000.0 /
           audio_decoder_config().samples_per_second()));
     }
-  }
 
-  if ((type() == DemuxerStream::AUDIO && audio_config_.is_encrypted()) ||
-      (type() == DemuxerStream::VIDEO && video_config_.is_encrypted())) {
-    scoped_ptr<DecryptConfig> config(WebMCreateDecryptConfig(
-        packet->data, packet->size,
-        reinterpret_cast<const uint8*>(encryption_key_id_.data()),
-        encryption_key_id_.size()));
-    if (!config)
-      LOG(ERROR) << "Creation of DecryptConfig failed.";
-    buffer->set_decrypt_config(config.Pass());
+    if (decrypt_config)
+      buffer->set_decrypt_config(decrypt_config.Pass());
   }
 
   buffer->set_timestamp(ConvertStreamTimestamp(
       stream_->time_base, packet->pts));
   buffer->set_duration(ConvertStreamTimestamp(
       stream_->time_base, packet->duration));
   if (buffer->timestamp() != kNoTimestamp() &&
       last_packet_timestamp_ != kNoTimestamp() &&
       last_packet_timestamp_ < buffer->timestamp()) {
     buffered_ranges_.Add(last_packet_timestamp_, buffer->timestamp());
@@ skipping 739 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