blob: fe15c700fec762322c021c0f3715bb6401d8435f (
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
|
// 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 CONTENT_COMMON_GPU_MEDIA_H264_DPB_H_
#define CONTENT_COMMON_GPU_MEDIA_H264_DPB_H_
#include <vector>
#include "base/basictypes.h"
#include "base/memory/scoped_vector.h"
#include "content/common/gpu/media/h264_parser.h"
namespace content {
// 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
struct H264Picture {
enum Field {
FIELD_NONE,
FIELD_TOP,
FIELD_BOTTOM,
};
// 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 top_field_order_cnt;
int bottom_field_order_cnt;
int pic_order_cnt;
int pic_order_cnt_msb;
int pic_order_cnt_lsb;
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;
bool idr; // IDR picture?
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;
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];
typedef std::vector<H264Picture*> PtrVector;
};
// 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() { 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(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.
H264Picture* GetShortRefPicByPicNum(int pic_num);
// Return a long-term reference picture by its long_term_pic_num.
H264Picture* GetLongRefPicByLongTermPicNum(int pic_num);
// Return the short reference picture with lowest frame_num. Used for sliding
// window memory management.
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::PtrVector& out);
// Append all short term reference pictures to the passed |out| vector.
void GetShortTermRefPicsAppending(H264Picture::PtrVector& out);
// Append all long term reference pictures to the passed |out| vector.
void GetLongTermRefPicsAppending(H264Picture::PtrVector& out);
// Iterators for direct access to DPB contents.
// Will be invalidated after any of Remove* calls.
typedef ScopedVector<H264Picture> Pictures;
Pictures::iterator begin() { return pics_.begin(); }
Pictures::iterator end() { return pics_.end(); }
Pictures::reverse_iterator rbegin() { return pics_.rbegin(); }
Pictures::reverse_iterator rend() { 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:
Pictures pics_;
size_t max_num_pics_;
DISALLOW_COPY_AND_ASSIGN(H264DPB);
};
} // namespace content
#endif // CONTENT_COMMON_GPU_MEDIA_H264_DPB_H_
|
