1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
// Copyright 2013 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 MEDIA_BASE_AUDIO_BUFFER_H_
#define MEDIA_BASE_AUDIO_BUFFER_H_
#include <vector>
#include "base/memory/aligned_memory.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/time/time.h"
#include "media/base/media_export.h"
#include "media/base/sample_format.h"
namespace media {
class AudioBus;
// An audio buffer that takes a copy of the data passed to it, holds it, and
// copies it into an AudioBus when needed. Also supports an end of stream
// marker.
class MEDIA_EXPORT AudioBuffer
: public base::RefCountedThreadSafe<AudioBuffer> {
public:
// Create an AudioBuffer whose channel data is copied from |data|. For
// interleaved data, only the first buffer is used. For planar data, the
// number of buffers must be equal to |channel_count|. |frame_count| is the
// number of frames in each buffer. |data| must not be null and |frame_count|
// must be >= 0.
//
// TODO(jrummell): Compute duration rather than pass it in.
static scoped_refptr<AudioBuffer> CopyFrom(SampleFormat sample_format,
int channel_count,
int frame_count,
const uint8* const* data,
const base::TimeDelta timestamp,
const base::TimeDelta duration);
// Create an empty AudioBuffer with |frame_count| frames.
static scoped_refptr<AudioBuffer> CreateEmptyBuffer(
int channel_count,
int frame_count,
const base::TimeDelta timestamp,
const base::TimeDelta duration);
// Create a AudioBuffer indicating we've reached end of stream.
// Calling any method other than end_of_stream() on the resulting buffer
// is disallowed.
static scoped_refptr<AudioBuffer> CreateEOSBuffer();
// Copy frames into |dest|. |frames_to_copy| is the number of frames to copy.
// |source_frame_offset| specifies how many frames in the buffer to skip
// first. |dest_frame_offset| is the frame offset in |dest|. The frames are
// converted from their source format into planar float32 data (which is all
// that AudioBus handles).
void ReadFrames(int frames_to_copy,
int source_frame_offset,
int dest_frame_offset,
AudioBus* dest);
// Trim an AudioBuffer by removing |frames_to_trim| frames from the start.
// Note that repeated calls to TrimStart() may result in timestamp() and
// duration() being off by a few microseconds due to rounding issues.
void TrimStart(int frames_to_trim);
// Return the number of channels.
int channel_count() const { return channel_count_; }
// Return the number of frames held.
int frame_count() const { return adjusted_frame_count_; }
// Access to constructor parameters.
base::TimeDelta timestamp() const { return timestamp_; }
base::TimeDelta duration() const { return duration_; }
// TODO(jrummell): Remove set_timestamp() and set_duration() once
// DecryptingAudioDecoder::EnqueueFrames() is changed to set them when
// creating the buffer. See http://crbug.com/255261.
void set_timestamp(base::TimeDelta timestamp) { timestamp_ = timestamp; }
void set_duration(base::TimeDelta duration) { duration_ = duration; }
// If there's no data in this buffer, it represents end of stream.
bool end_of_stream() const { return end_of_stream_; }
private:
friend class base::RefCountedThreadSafe<AudioBuffer>;
// Allocates aligned contiguous buffer to hold all channel data (1 block for
// interleaved data, |channel_count| blocks for planar data), copies
// [data,data+data_size) to the allocated buffer(s). If |data| is null an end
// of stream buffer is created.
AudioBuffer(SampleFormat sample_format,
int channel_count,
int frame_count,
const uint8* const* data,
const base::TimeDelta timestamp,
const base::TimeDelta duration);
virtual ~AudioBuffer();
const SampleFormat sample_format_;
const int channel_count_;
const int frame_count_;
int adjusted_frame_count_;
int trim_start_;
const bool end_of_stream_;
base::TimeDelta timestamp_;
base::TimeDelta duration_;
// Contiguous block of channel data.
scoped_ptr_malloc<uint8, base::ScopedPtrAlignedFree> data_;
// For planar data, points to each channels data.
std::vector<uint8*> channel_data_;
DISALLOW_IMPLICIT_CONSTRUCTORS(AudioBuffer);
};
} // namespace media
#endif // MEDIA_BASE_AUDIO_BUFFER_H_
|
