Mercurial > hg > forks > libbpg
comparison x265/source/encoder/frameencoder.h @ 0:772086c29cc7
Initial import.
author | Matti Hamalainen <ccr@tnsp.org> |
---|---|
date | Wed, 16 Nov 2016 11:16:33 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:772086c29cc7 |
---|---|
1 /***************************************************************************** | |
2 * Copyright (C) 2013 x265 project | |
3 * | |
4 * Authors: Shin Yee <shinyee@multicorewareinc.com> | |
5 * Min Chen <chenm003@163.com> | |
6 * | |
7 * This program is free software; you can redistribute it and/or modify | |
8 * it under the terms of the GNU General Public License as published by | |
9 * the Free Software Foundation; either version 2 of the License, or | |
10 * (at your option) any later version. | |
11 * | |
12 * This program is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 * GNU General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU General Public License | |
18 * along with this program; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA. | |
20 * | |
21 * This program is also available under a commercial proprietary license. | |
22 * For more information, contact us at license @ x265.com. | |
23 *****************************************************************************/ | |
24 | |
25 #ifndef X265_FRAMEENCODER_H | |
26 #define X265_FRAMEENCODER_H | |
27 | |
28 #include "common.h" | |
29 #include "wavefront.h" | |
30 #include "bitstream.h" | |
31 #include "frame.h" | |
32 #include "picyuv.h" | |
33 #include "md5.h" | |
34 | |
35 #include "analysis.h" | |
36 #include "sao.h" | |
37 | |
38 #include "entropy.h" | |
39 #include "framefilter.h" | |
40 #include "ratecontrol.h" | |
41 #include "reference.h" | |
42 #include "nal.h" | |
43 | |
44 namespace X265_NS { | |
45 // private x265 namespace | |
46 | |
47 class ThreadPool; | |
48 class Encoder; | |
49 | |
50 #define ANGULAR_MODE_ID 2 | |
51 #define AMP_ID 3 | |
52 | |
53 struct StatisticLog | |
54 { | |
55 uint64_t cntInter[4]; | |
56 uint64_t cntIntra[4]; | |
57 uint64_t cuInterDistribution[4][INTER_MODES]; | |
58 uint64_t cuIntraDistribution[4][INTRA_MODES]; | |
59 uint64_t cntIntraNxN; | |
60 uint64_t cntSkipCu[4]; | |
61 uint64_t cntTotalCu[4]; | |
62 uint64_t totalCu; | |
63 | |
64 StatisticLog() | |
65 { | |
66 memset(this, 0, sizeof(StatisticLog)); | |
67 } | |
68 }; | |
69 | |
70 /* manages the state of encoding one row of CTU blocks. When | |
71 * WPP is active, several rows will be simultaneously encoded. */ | |
72 struct CTURow | |
73 { | |
74 Entropy bufferedEntropy; /* store CTU2 context for next row CTU0 */ | |
75 Entropy rowGoOnCoder; /* store context between CTUs, code bitstream if !SAO */ | |
76 | |
77 FrameStats rowStats; | |
78 | |
79 /* Threading variables */ | |
80 | |
81 /* This lock must be acquired when reading or writing m_active or m_busy */ | |
82 Lock lock; | |
83 | |
84 /* row is ready to run, has no neighbor dependencies. The row may have | |
85 * external dependencies (reference frame pixels) that prevent it from being | |
86 * processed, so it may stay with m_active=true for some time before it is | |
87 * encoded by a worker thread. */ | |
88 volatile bool active; | |
89 | |
90 /* row is being processed by a worker thread. This flag is only true when a | |
91 * worker thread is within the context of FrameEncoder::processRow(). This | |
92 * flag is used to detect multiple possible wavefront problems. */ | |
93 volatile bool busy; | |
94 | |
95 /* count of completed CUs in this row */ | |
96 volatile uint32_t completed; | |
97 | |
98 /* called at the start of each frame to initialize state */ | |
99 void init(Entropy& initContext) | |
100 { | |
101 active = false; | |
102 busy = false; | |
103 completed = 0; | |
104 memset(&rowStats, 0, sizeof(rowStats)); | |
105 rowGoOnCoder.load(initContext); | |
106 } | |
107 }; | |
108 | |
109 // Manages the wave-front processing of a single encoding frame | |
110 class FrameEncoder : public WaveFront, public Thread | |
111 { | |
112 public: | |
113 | |
114 FrameEncoder(); | |
115 | |
116 virtual ~FrameEncoder() {} | |
117 | |
118 virtual bool init(Encoder *top, int numRows, int numCols); | |
119 | |
120 void destroy(); | |
121 | |
122 /* triggers encode of a new frame by the worker thread */ | |
123 bool startCompressFrame(Frame* curFrame); | |
124 | |
125 /* blocks until worker thread is done, returns access unit */ | |
126 Frame *getEncodedPicture(NALList& list); | |
127 | |
128 Event m_enable; | |
129 Event m_done; | |
130 Event m_completionEvent; | |
131 int m_localTldIdx; | |
132 | |
133 volatile bool m_threadActive; | |
134 volatile bool m_bAllRowsStop; | |
135 volatile int m_completionCount; | |
136 volatile int m_vbvResetTriggerRow; | |
137 | |
138 uint32_t m_numRows; | |
139 uint32_t m_numCols; | |
140 uint32_t m_filterRowDelay; | |
141 uint32_t m_filterRowDelayCus; | |
142 uint32_t m_refLagRows; | |
143 | |
144 CTURow* m_rows; | |
145 RateControlEntry m_rce; | |
146 SEIDecodedPictureHash m_seiReconPictureDigest; | |
147 | |
148 uint64_t m_SSDY; | |
149 uint64_t m_SSDU; | |
150 uint64_t m_SSDV; | |
151 double m_ssim; | |
152 uint64_t m_accessUnitBits; | |
153 uint32_t m_ssimCnt; | |
154 MD5Context m_state[3]; | |
155 uint32_t m_crc[3]; | |
156 uint32_t m_checksum[3]; | |
157 | |
158 volatile int m_activeWorkerCount; // count of workers currently encoding or filtering CTUs | |
159 volatile int m_totalActiveWorkerCount; // sum of m_activeWorkerCount sampled at end of each CTU | |
160 volatile int m_activeWorkerCountSamples; // count of times m_activeWorkerCount was sampled (think vbv restarts) | |
161 volatile int m_countRowBlocks; // count of workers forced to abandon a row because of top dependency | |
162 int64_t m_startCompressTime; // timestamp when frame encoder is given a frame | |
163 int64_t m_row0WaitTime; // timestamp when row 0 is allowed to start | |
164 int64_t m_allRowsAvailableTime; // timestamp when all reference dependencies are resolved | |
165 int64_t m_endCompressTime; // timestamp after all CTUs are compressed | |
166 int64_t m_endFrameTime; // timestamp after RCEnd, NR updates, etc | |
167 int64_t m_stallStartTime; // timestamp when worker count becomes 0 | |
168 int64_t m_prevOutputTime; // timestamp when prev frame was retrieved by API thread | |
169 int64_t m_slicetypeWaitTime; // total elapsed time waiting for decided frame | |
170 int64_t m_totalWorkerElapsedTime; // total elapsed time spent by worker threads processing CTUs | |
171 int64_t m_totalNoWorkerTime; // total elapsed time without any active worker threads | |
172 #if DETAILED_CU_STATS | |
173 CUStats m_cuStats; | |
174 #endif | |
175 | |
176 Encoder* m_top; | |
177 x265_param* m_param; | |
178 Frame* m_frame; | |
179 NoiseReduction* m_nr; | |
180 ThreadLocalData* m_tld; /* for --no-wpp */ | |
181 Bitstream* m_outStreams; | |
182 uint32_t* m_substreamSizes; | |
183 | |
184 CUGeom* m_cuGeoms; | |
185 uint32_t* m_ctuGeomMap; | |
186 | |
187 Bitstream m_bs; | |
188 MotionReference m_mref[2][MAX_NUM_REF + 1]; | |
189 Entropy m_entropyCoder; | |
190 Entropy m_initSliceContext; | |
191 FrameFilter m_frameFilter; | |
192 NALList m_nalList; | |
193 | |
194 class WeightAnalysis : public BondedTaskGroup | |
195 { | |
196 public: | |
197 | |
198 FrameEncoder& master; | |
199 | |
200 WeightAnalysis(FrameEncoder& fe) : master(fe) {} | |
201 | |
202 void processTasks(int workerThreadId); | |
203 | |
204 protected: | |
205 | |
206 WeightAnalysis operator=(const WeightAnalysis&); | |
207 }; | |
208 | |
209 protected: | |
210 | |
211 bool initializeGeoms(); | |
212 | |
213 /* analyze / compress frame, can be run in parallel within reference constraints */ | |
214 void compressFrame(); | |
215 | |
216 /* called by compressFrame to generate final per-row bitstreams */ | |
217 void encodeSlice(); | |
218 | |
219 void threadMain(); | |
220 int collectCTUStatistics(const CUData& ctu, FrameStats* frameLog); | |
221 void noiseReductionUpdate(); | |
222 | |
223 /* Called by WaveFront::findJob() */ | |
224 virtual void processRow(int row, int threadId); | |
225 virtual void processRowEncoder(int row, ThreadLocalData& tld); | |
226 | |
227 void enqueueRowEncoder(int row) { WaveFront::enqueueRow(row * 2 + 0); } | |
228 void enqueueRowFilter(int row) { WaveFront::enqueueRow(row * 2 + 1); } | |
229 void enableRowEncoder(int row) { WaveFront::enableRow(row * 2 + 0); } | |
230 void enableRowFilter(int row) { WaveFront::enableRow(row * 2 + 1); } | |
231 }; | |
232 } | |
233 | |
234 #endif // ifndef X265_FRAMEENCODER_H |