blob: 703f5e3134f167895d2df73ab23d8eb3eeacd6e6 (
plain)
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
|
// 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.
//
// This file contains an implementation of an H.264 Decoded Picture Buffer
// used in H264 decoders.
#ifndef H264_DPB_H_
#define H264_DPB_H_
#include <stddef.h>
#include <vector>
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "h264_parser.h"
namespace media {
// A picture (a frame or a field) in the H.264 spec sense.
// See spec at http://www.itu.int/rec/T-REC-H.264
class H264Picture : public base::RefCounted<H264Picture> {
public:
using Vector = std::vector<scoped_refptr<H264Picture>>;
enum Field {
FIELD_NONE,
FIELD_TOP,
FIELD_BOTTOM,
};
H264Picture();
// Values calculated per H.264 specification or taken from slice header.
// See spec for more details on each (some names have been converted from
// CamelCase in spec to Chromium-style names).
int pic_order_cnt_type;
int top_field_order_cnt;
int bottom_field_order_cnt;
int pic_order_cnt;
int pic_order_cnt_msb;
int pic_order_cnt_lsb;
int delta_pic_order_cnt_bottom;
int delta_pic_order_cnt0;
int delta_pic_order_cnt1;
int pic_num;
int long_term_pic_num;
int frame_num; // from slice header
int frame_num_offset;
int frame_num_wrap;
int long_term_frame_idx;
H264SliceHeader::Type type;
int nal_ref_idc;
bool idr; // IDR picture?
int idr_pic_id; // Valid only if idr == true.
bool ref; // reference picture?
bool long_term; // long term reference picture?
bool outputted;
// Does memory management op 5 needs to be executed after this
// picture has finished decoding?
bool mem_mgmt_5;
// Created by the decoding process for gaps in frame_num.
// Not for decode or output.
bool nonexisting;
Field field;
// Values from slice_hdr to be used during reference marking and
// memory management after finishing this picture.
bool long_term_reference_flag;
bool adaptive_ref_pic_marking_mode_flag;
H264DecRefPicMarking ref_pic_marking[H264SliceHeader::kRefListSize];
// Position in DPB (i.e. index in DPB).
int dpb_position;
protected:
friend class base::RefCounted<H264Picture>;
virtual ~H264Picture();
private:
DISALLOW_COPY_AND_ASSIGN(H264Picture);
};
// DPB - Decoded Picture Buffer.
// Stores decoded pictures that will be used for future display
// and/or reference.
class H264DPB {
public:
H264DPB();
~H264DPB();
void set_max_num_pics(size_t max_num_pics);
size_t max_num_pics() const { return max_num_pics_; }
// Remove unused (not reference and already outputted) pictures from DPB
// and free it.
void DeleteUnused();
// Remove a picture by its pic_order_cnt and free it.
void DeleteByPOC(int poc);
// Clear DPB.
void Clear();
// Store picture in DPB. DPB takes ownership of its resources.
void StorePic(const scoped_refptr<H264Picture>& pic);
// Return the number of reference pictures in DPB.
int CountRefPics();
// Mark all pictures in DPB as unused for reference.
void MarkAllUnusedForRef();
// Return a short-term reference picture by its pic_num.
scoped_refptr<H264Picture> GetShortRefPicByPicNum(int pic_num);
// Return a long-term reference picture by its long_term_pic_num.
scoped_refptr<H264Picture> GetLongRefPicByLongTermPicNum(int pic_num);
// Return the short reference picture with lowest frame_num. Used for sliding
// window memory management.
scoped_refptr<H264Picture> GetLowestFrameNumWrapShortRefPic();
// Append all pictures that have not been outputted yet to the passed |out|
// vector, sorted by lowest pic_order_cnt (in output order).
void GetNotOutputtedPicsAppending(H264Picture::Vector* out);
// Append all short term reference pictures to the passed |out| vector.
void GetShortTermRefPicsAppending(H264Picture::Vector* out);
// Append all long term reference pictures to the passed |out| vector.
void GetLongTermRefPicsAppending(H264Picture::Vector* out);
// Iterators for direct access to DPB contents.
// Will be invalidated after any of Remove* calls.
H264Picture::Vector::iterator begin() { return pics_.begin(); }
H264Picture::Vector::iterator end() { return pics_.end(); }
H264Picture::Vector::const_iterator begin() const { return pics_.begin(); }
H264Picture::Vector::const_iterator end() const { return pics_.end(); }
H264Picture::Vector::const_reverse_iterator rbegin() const {
return pics_.rbegin();
}
H264Picture::Vector::const_reverse_iterator rend() const {
return pics_.rend();
}
size_t size() const { return pics_.size(); }
bool IsFull() const { return pics_.size() == max_num_pics_; }
// Per H264 spec, increase to 32 if interlaced video is supported.
enum {
kDPBMaxSize = 16,
};
private:
void UpdatePicPositions();
H264Picture::Vector pics_;
size_t max_num_pics_;
DISALLOW_COPY_AND_ASSIGN(H264DPB);
};
} // namespace media
#endif // H264_DPB_H_
|
