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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
// Copyright (c) 2006-2008 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.
// Defines various types of timestamped media buffers used for transporting
// data between filters. Every buffer contains a timestamp in microseconds
// describing the relative position of the buffer within the media stream, and
// the duration in microseconds for the length of time the buffer will be
// rendered.
//
// Timestamps are derived directly from the encoded media file and are commonly
// known as the presentation timestamp (PTS). Durations are a best-guess and
// are usually derived from the sample/frame rate of the media file.
//
// Due to encoding and transmission errors, it is not guaranteed that timestamps
// arrive in a monotonically increasing order nor that the next timestamp will
// be equal to the previous timestamp plus the duration.
//
// In the ideal scenario for a 25fps movie, buffers are timestamped as followed:
//
// Buffer0 Buffer1 Buffer2 ... BufferN
// Timestamp: 0us 40000us 80000us ... (N*40000)us
// Duration*: 40000us 40000us 40000us ... 40000us
//
// *25fps = 0.04s per frame = 40000us per frame
#ifndef MEDIA_BASE_BUFFERS_H_
#define MEDIA_BASE_BUFFERS_H_
#include "base/basictypes.h"
#include "base/logging.h"
#include "base/ref_counted.h"
#include "base/time.h"
namespace media {
class StreamSample : public base::RefCountedThreadSafe<StreamSample> {
public:
// Returns the timestamp of this buffer in microseconds.
virtual base::TimeDelta GetTimestamp() const = 0;
// Returns the duration of this buffer in microseconds.
virtual base::TimeDelta GetDuration() const = 0;
// Sets the timestamp of this buffer in microseconds.
virtual void SetTimestamp(const base::TimeDelta& timestamp) = 0;
// Sets the duration of this buffer in microseconds.
virtual void SetDuration(const base::TimeDelta& duration) = 0;
protected:
friend class base::RefCountedThreadSafe<StreamSample>;
virtual ~StreamSample() {}
};
class Buffer : public StreamSample {
public:
// Returns a read only pointer to the buffer data.
virtual const char* GetData() const = 0;
// Returns the size of valid data in bytes.
virtual size_t GetDataSize() const = 0;
};
class WritableBuffer : public Buffer {
public:
// Returns a read-write pointer to the buffer data.
virtual char* GetWritableData() = 0;
// Updates the size of valid data in bytes, which must be less than or equal
// to GetBufferSize.
virtual void SetDataSize(size_t data_size) = 0;
// Returns the maximum allocated size for this buffer.
virtual size_t GetBufferSize() const = 0;
};
struct VideoSurface {
static const size_t kMaxPlanes = 3;
// Surface formats roughly based on FOURCC labels, see:
// http://www.fourcc.org/rgb.php
// http://www.fourcc.org/yuv.php
enum Format {
RGB555, // 16bpp RGB packed 5:5:5
RGB565, // 16bpp RGB packed 5:6:5
RGB24, // 24bpp RGB packed 8:8:8
RGB32, // 32bpp RGB packed with extra byte 8:8:8
RGBA, // 32bpp RGBA packed 8:8:8:8
YV12, // 12bpp YVU planar 1x1 Y, 2x2 VU samples
YV16, // 16bpp YVU planar 1x1 Y, 2x1 VU samples
};
// Surface format.
Format format;
// Width and height of surface.
size_t width;
size_t height;
// Number of planes, typically 1 for packed RGB formats and 3 for planar
// YUV formats.
size_t planes;
// Array of strides for each plane, typically greater or equal to the width
// of the surface divided by the horizontal sampling period.
size_t strides[kMaxPlanes];
// Array of data pointers to each plane.
char* data[kMaxPlanes];
};
class VideoFrame : public StreamSample {
public:
// Locks the underlying surface and fills out the given VideoSurface and
// returns true if successful, false otherwise. Any additional calls to Lock
// will fail.
virtual bool Lock(VideoSurface* surface) = 0;
// Unlocks the underlying surface, the VideoSurface acquired from Lock is no
// longer guaranteed to be valid.
virtual void Unlock() = 0;
};
// An interface for receiving the results of an asynchronous read. Downstream
// filters typically implement this interface or use AssignableBuffer and
// provide it to upstream filters as a read request. When the upstream filter
// has completed the read, they call SetBuffer/OnAssignment to notify the
// downstream filter.
//
// TODO(scherkus): rethink the Assignable interface -- it's a bit kludgy.
template <class BufferType>
class Assignable :
public base::RefCountedThreadSafe< Assignable<BufferType> > {
public:
// Assigns a buffer to the owner.
virtual void SetBuffer(BufferType* buffer) = 0;
// Notifies the owner that an assignment has been completed.
virtual void OnAssignment() = 0;
// TODO(scherkus): figure out a solution to friending a template.
// See http://www.comeaucomputing.com/techtalk/templates/#friendclassT for
// an explanation.
//protected:
// friend class base::RefCountedThreadSafe< Assignable<class T> >;
virtual ~Assignable() {}
};
// Template for easily creating Assignable buffers. Pass in the pointer of the
// object to receive the OnAssignment callback.
template <class OwnerType, class BufferType>
class AssignableBuffer : public Assignable<BufferType> {
public:
explicit AssignableBuffer(OwnerType* owner)
: owner_(owner),
buffer_(NULL) {
DCHECK(owner_);
}
// AssignableBuffer<BufferType> implementation.
virtual void SetBuffer(BufferType* buffer) {
buffer_ = buffer;
}
virtual void OnAssignment() {
owner_->OnAssignment(buffer_.get());
}
private:
OwnerType* owner_;
scoped_refptr<BufferType> buffer_;
DISALLOW_COPY_AND_ASSIGN(AssignableBuffer);
};
} // namespace media
#endif // MEDIA_BASE_BUFFERS_H_
|
