media/blink/websourcebuffer_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/blink/websourcebuffer_impl.h"
   6
   7 #include <limits>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/callback_helpers.h"
  12 #include "base/float_util.h"
  13 #include "media/filters/chunk_demuxer.h"
  14 #include "third_party/WebKit/public/platform/WebSourceBufferClient.h"
  15
  16 namespace media {
  17
  18 static base::TimeDelta DoubleToTimeDelta(double time) {
  19   DCHECK(!base::IsNaN(time));
  20   DCHECK_NE(time, -std::numeric_limits<double>::infinity());
  21
  22   if (time == std::numeric_limits<double>::infinity())
  23     return kInfiniteDuration();
  24
  25   // Don't use base::TimeDelta::Max() here, as we want the largest finite time
  26   // delta.
  27   base::TimeDelta max_time = base::TimeDelta::FromInternalValue(kint64max - 1);
  28   double max_time_in_seconds = max_time.InSecondsF();
  29
  30   if (time >= max_time_in_seconds)
  31     return max_time;
  32
  33   return base::TimeDelta::FromMicroseconds(
  34       time * base::Time::kMicrosecondsPerSecond);
  35 }
  36
  37 WebSourceBufferImpl::WebSourceBufferImpl(
  38     const std::string& id, ChunkDemuxer* demuxer)
  39     : id_(id),
  40       demuxer_(demuxer),
  41       client_(NULL),
  42       append_window_end_(kInfiniteDuration()) {
  43   DCHECK(demuxer_);
  44 }
  45
  46 WebSourceBufferImpl::~WebSourceBufferImpl() {
  47   DCHECK(!demuxer_) << "Object destroyed w/o removedFromMediaSource() call";
  48   DCHECK(!client_);
  49 }
  50
  51 void WebSourceBufferImpl::setClient(blink::WebSourceBufferClient* client) {
  52   DCHECK(client);
  53   DCHECK(!client_);
  54   client_ = client;
  55 }
  56
  57 bool WebSourceBufferImpl::setMode(WebSourceBuffer::AppendMode mode) {
  58   if (demuxer_->IsParsingMediaSegment(id_))
  59     return false;
  60
  61   switch (mode) {
  62     case WebSourceBuffer::AppendModeSegments:
  63       demuxer_->SetSequenceMode(id_, false);
  64       return true;
  65     case WebSourceBuffer::AppendModeSequence:
  66       demuxer_->SetSequenceMode(id_, true);
  67       return true;
  68   }
  69
  70   NOTREACHED();
  71   return false;
  72 }
  73
  74 blink::WebTimeRanges WebSourceBufferImpl::buffered() {
  75   Ranges<base::TimeDelta> ranges = demuxer_->GetBufferedRanges(id_);
  76   blink::WebTimeRanges result(ranges.size());
  77   for (size_t i = 0; i < ranges.size(); i++) {
  78     result[i].start = ranges.start(i).InSecondsF();
  79     result[i].end = ranges.end(i).InSecondsF();
  80   }
  81   return result;
  82 }
  83
  84 void WebSourceBufferImpl::append(
  85     const unsigned char* data,
  86     unsigned length,
  87     double* timestamp_offset) {
  88   base::TimeDelta old_offset = timestamp_offset_;
  89   demuxer_->AppendData(id_, data, length,
  90                        append_window_start_, append_window_end_,
  91                        &timestamp_offset_,
  92                        base::Bind(&WebSourceBufferImpl::InitSegmentReceived,
  93                                   base::Unretained(this)));
  94
  95   // Coded frame processing may update the timestamp offset. If the caller
  96   // provides a non-NULL |timestamp_offset| and frame processing changes the
  97   // timestamp offset, report the new offset to the caller. Do not update the
  98   // caller's offset otherwise, to preserve any pre-existing value that may have
  99   // more than microsecond precision.
 100   if (timestamp_offset && old_offset != timestamp_offset_)
 101     *timestamp_offset = timestamp_offset_.InSecondsF();
 102 }
 103
 104 void WebSourceBufferImpl::abort() {
 105   demuxer_->Abort(id_,
 106                   append_window_start_, append_window_end_,
 107                   &timestamp_offset_);
 108
 109   // TODO(wolenetz): abort should be able to modify the caller timestamp offset
 110   // (just like WebSourceBufferImpl::append).
 111   // See http://crbug.com/370229 for further details.
 112 }
 113
 114 void WebSourceBufferImpl::remove(double start, double end) {
 115   DCHECK_GE(start, 0);
 116   DCHECK_GE(end, 0);
 117   demuxer_->Remove(id_, DoubleToTimeDelta(start), DoubleToTimeDelta(end));
 118 }
 119
 120 bool WebSourceBufferImpl::setTimestampOffset(double offset) {
 121   if (demuxer_->IsParsingMediaSegment(id_))
 122     return false;
 123
 124   timestamp_offset_ = DoubleToTimeDelta(offset);
 125
 126   // http://www.w3.org/TR/media-source/#widl-SourceBuffer-timestampOffset
 127   // Step 6: If the mode attribute equals "sequence", then set the group start
 128   // timestamp to new timestamp offset.
 129   demuxer_->SetGroupStartTimestampIfInSequenceMode(id_, timestamp_offset_);
 130   return true;
 131 }
 132
 133 void WebSourceBufferImpl::setAppendWindowStart(double start) {
 134   DCHECK_GE(start, 0);
 135   append_window_start_ = DoubleToTimeDelta(start);
 136 }
 137
 138 void WebSourceBufferImpl::setAppendWindowEnd(double end) {
 139   DCHECK_GE(end, 0);
 140   append_window_end_ = DoubleToTimeDelta(end);
 141 }
 142
 143 void WebSourceBufferImpl::removedFromMediaSource() {
 144   demuxer_->RemoveId(id_);
 145   demuxer_ = NULL;
 146   client_ = NULL;
 147 }
 148
 149 void WebSourceBufferImpl::InitSegmentReceived() {
 150   DVLOG(1) << __FUNCTION__;
 151   client_->initializationSegmentReceived();
 152 }
 153
 154 }  // namespace media