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
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#if !defined(NesteggPacketHolder_h_)
#define NesteggPacketHolder_h_
#include <stdint.h>
#include "nsAutoRef.h"
#include "nestegg/nestegg.h"
namespace mozilla {
// Holds a nestegg_packet, and its file offset. This is needed so we
// know the offset in the file we've played up to, in order to calculate
// whether it's likely we can play through to the end without needing
// to stop to buffer, given the current download rate.
class NesteggPacketHolder {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(NesteggPacketHolder)
NesteggPacketHolder()
: mPacket(nullptr)
, mOffset(-1)
, mTimestamp(-1)
, mDuration(-1)
, mIsKeyframe(false) {}
bool Init(nestegg_packet* aPacket, int64_t aOffset, unsigned aTrack, bool aIsKeyframe)
{
uint64_t timestamp_ns;
if (nestegg_packet_tstamp(aPacket, ×tamp_ns) == -1) {
return false;
}
// We store the timestamp as signed microseconds so that it's easily
// comparable to other timestamps we have in the system.
mTimestamp = timestamp_ns / 1000;
mPacket = aPacket;
mOffset = aOffset;
mTrack = aTrack;
mIsKeyframe = aIsKeyframe;
uint64_t duration_ns;
if (!nestegg_packet_duration(aPacket, &duration_ns)) {
mDuration = duration_ns / 1000;
}
return true;
}
nestegg_packet* Packet() { MOZ_ASSERT(IsInitialized()); return mPacket; }
int64_t Offset() { MOZ_ASSERT(IsInitialized()); return mOffset; }
int64_t Timestamp() { MOZ_ASSERT(IsInitialized()); return mTimestamp; }
int64_t Duration() { MOZ_ASSERT(IsInitialized()); return mDuration; }
unsigned Track() { MOZ_ASSERT(IsInitialized()); return mTrack; }
bool IsKeyframe() { MOZ_ASSERT(IsInitialized()); return mIsKeyframe; }
private:
~NesteggPacketHolder()
{
nestegg_free_packet(mPacket);
}
bool IsInitialized() { return mOffset >= 0; }
nestegg_packet* mPacket;
// Offset in bytes. This is the offset of the end of the Block
// which contains the packet.
int64_t mOffset;
// Packet presentation timestamp in microseconds.
int64_t mTimestamp;
// Packet duration in microseconds; -1 if unknown or retrieval failed.
int64_t mDuration;
// Track ID.
unsigned mTrack;
// Does this packet contain a keyframe?
bool mIsKeyframe;
// Copy constructor and assignment operator not implemented. Don't use them!
NesteggPacketHolder(const NesteggPacketHolder &aOther);
NesteggPacketHolder& operator= (NesteggPacketHolder const& aOther);
};
// Queue for holding nestegg packets.
class WebMPacketQueue {
public:
int32_t GetSize() {
return mQueue.size();
}
void Push(NesteggPacketHolder* aItem) {
mQueue.push_back(aItem);
}
void PushFront(NesteggPacketHolder* aItem) {
mQueue.push_front(Move(aItem));
}
already_AddRefed<NesteggPacketHolder> PopFront() {
RefPtr<NesteggPacketHolder> result = mQueue.front().forget();
mQueue.pop_front();
return result.forget();
}
void Reset() {
while (!mQueue.empty()) {
mQueue.pop_front();
}
}
private:
std::deque<RefPtr<NesteggPacketHolder>> mQueue;
};
} // namespace mozilla
#endif
|
