Debian Codegraph @

src/gen6_mfc_common.c

raw
1 /*
2 * Copyright © 2012 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Xiang Haihao <[email protected]>
26 * Zhao Yakui <[email protected]>
27 *
28 */
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <assert.h>
34 #include <math.h>
35
36 #include "intel_batchbuffer.h"
37 #include "i965_defines.h"
38 #include "i965_structs.h"
39 #include "i965_drv_video.h"
40 #include "i965_encoder.h"
41 #include "i965_encoder_utils.h"
42 #include "gen6_mfc.h"
43 #include "gen6_vme.h"
44 #include "gen9_mfc.h"
45 #include "intel_media.h"
46
47 #ifndef HAVE_LOG2F
48 #define log2f(x) (logf(x)/(float)M_LN2)
49 #endif
50
51 int intel_avc_enc_slice_type_fixup(int slice_type)
52 {
53 if (slice_type == SLICE_TYPE_SP ||
54 slice_type == SLICE_TYPE_P)
55 slice_type = SLICE_TYPE_P;
56 else if (slice_type == SLICE_TYPE_SI ||
57 slice_type == SLICE_TYPE_I)
58 slice_type = SLICE_TYPE_I;
59 else {
60 if (slice_type != SLICE_TYPE_B)
61 WARN_ONCE("Invalid slice type for H.264 encoding!\n");
62
63 slice_type = SLICE_TYPE_B;
64 }
65
66 return slice_type;
67 }
68
69 static void
70 intel_mfc_bit_rate_control_context_init(struct encode_state *encode_state,
71 struct intel_encoder_context *encoder_context)
72 {
73 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
74 int i;
75
76 for (i = 0 ; i < 3; i++) {
77 mfc_context->bit_rate_control_context[i].MaxQpNegModifier = 6;
78 mfc_context->bit_rate_control_context[i].MaxQpPosModifier = 6;
79 mfc_context->bit_rate_control_context[i].GrowInit = 6;
80 mfc_context->bit_rate_control_context[i].GrowResistance = 4;
81 mfc_context->bit_rate_control_context[i].ShrinkInit = 6;
82 mfc_context->bit_rate_control_context[i].ShrinkResistance = 4;
83
84 mfc_context->bit_rate_control_context[i].Correct[0] = 8;
85 mfc_context->bit_rate_control_context[i].Correct[1] = 4;
86 mfc_context->bit_rate_control_context[i].Correct[2] = 2;
87 mfc_context->bit_rate_control_context[i].Correct[3] = 2;
88 mfc_context->bit_rate_control_context[i].Correct[4] = 4;
89 mfc_context->bit_rate_control_context[i].Correct[5] = 8;
90 }
91 }
92
93 static void intel_mfc_brc_init(struct encode_state *encode_state,
94 struct intel_encoder_context* encoder_context)
95 {
96 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
97 double bitrate, framerate;
98 double frame_per_bits = 8 * 3 * encoder_context->frame_width_in_pixel * encoder_context->frame_height_in_pixel / 2;
99 double qp1_size = 0.1 * frame_per_bits;
100 double qp51_size = 0.001 * frame_per_bits;
101 int min_qp = MAX(1, encoder_context->brc.min_qp);
102 double bpf, factor, hrd_factor;
103 int inum = encoder_context->brc.num_iframes_in_gop,
104 pnum = encoder_context->brc.num_pframes_in_gop,
105 bnum = encoder_context->brc.num_bframes_in_gop; /* Gop structure: number of I, P, B frames in the Gop. */
106 int intra_period = encoder_context->brc.gop_size;
107 int i;
108 int tmp_min_qp = 0;
109
110 if (encoder_context->layer.num_layers > 1)
111 qp1_size = 0.15 * frame_per_bits;
112
113 mfc_context->brc.mode = encoder_context->rate_control_mode;
114
115 mfc_context->hrd.violation_noted = 0;
116
117 for (i = 0; i < encoder_context->layer.num_layers; i++) {
118 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I] = 26;
119 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 26;
120 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B] = 26;
121
122 if (i == 0) {
123 bitrate = encoder_context->brc.bits_per_second[0];
124 framerate = (double)encoder_context->brc.framerate[0].num / (double)encoder_context->brc.framerate[0].den;
125 } else {
126 bitrate = (encoder_context->brc.bits_per_second[i] - encoder_context->brc.bits_per_second[i - 1]);
127 framerate = ((double)encoder_context->brc.framerate[i].num / (double)encoder_context->brc.framerate[i].den) -
128 ((double)encoder_context->brc.framerate[i - 1].num / (double)encoder_context->brc.framerate[i - 1].den);
129 }
130
131 if (mfc_context->brc.mode == VA_RC_VBR && encoder_context->brc.target_percentage[i])
132 bitrate = bitrate * encoder_context->brc.target_percentage[i] / 100;
133
134 if (i == encoder_context->layer.num_layers - 1)
135 factor = 1.0;
136 else {
137 factor = ((double)encoder_context->brc.framerate[i].num / (double)encoder_context->brc.framerate[i].den) /
138 ((double)encoder_context->brc.framerate[i - 1].num / (double)encoder_context->brc.framerate[i - 1].den);
139 }
140
141 hrd_factor = (double)bitrate / encoder_context->brc.bits_per_second[encoder_context->layer.num_layers - 1];
142
143 mfc_context->hrd.buffer_size[i] = (unsigned int)(encoder_context->brc.hrd_buffer_size * hrd_factor);
144 mfc_context->hrd.current_buffer_fullness[i] =
145 (double)(encoder_context->brc.hrd_initial_buffer_fullness < encoder_context->brc.hrd_buffer_size) ?
146 encoder_context->brc.hrd_initial_buffer_fullness : encoder_context->brc.hrd_buffer_size / 2.;
147 mfc_context->hrd.current_buffer_fullness[i] *= hrd_factor;
148 mfc_context->hrd.target_buffer_fullness[i] = (double)encoder_context->brc.hrd_buffer_size * hrd_factor / 2.;
149 mfc_context->hrd.buffer_capacity[i] = (double)encoder_context->brc.hrd_buffer_size * hrd_factor / qp1_size;
150
151 if (encoder_context->layer.num_layers > 1) {
152 if (i == 0) {
153 intra_period = (int)(encoder_context->brc.gop_size * factor);
154 inum = 1;
155 pnum = (int)(encoder_context->brc.num_pframes_in_gop * factor);
156 bnum = intra_period - inum - pnum;
157 } else {
158 intra_period = (int)(encoder_context->brc.gop_size * factor) - intra_period;
159 inum = 0;
160 pnum = (int)(encoder_context->brc.num_pframes_in_gop * factor) - pnum;
161 bnum = intra_period - inum - pnum;
162 }
163 }
164
165 mfc_context->brc.gop_nums[i][SLICE_TYPE_I] = inum;
166 mfc_context->brc.gop_nums[i][SLICE_TYPE_P] = pnum;
167 mfc_context->brc.gop_nums[i][SLICE_TYPE_B] = bnum;
168
169 mfc_context->brc.target_frame_size[i][SLICE_TYPE_I] = (int)((double)((bitrate * intra_period) / framerate) /
170 (double)(inum + BRC_PWEIGHT * pnum + BRC_BWEIGHT * bnum));
171 mfc_context->brc.target_frame_size[i][SLICE_TYPE_P] = BRC_PWEIGHT * mfc_context->brc.target_frame_size[i][SLICE_TYPE_I];
172 mfc_context->brc.target_frame_size[i][SLICE_TYPE_B] = BRC_BWEIGHT * mfc_context->brc.target_frame_size[i][SLICE_TYPE_I];
173
174 bpf = mfc_context->brc.bits_per_frame[i] = bitrate / framerate;
175
176 if (encoder_context->brc.initial_qp) {
177 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I] = encoder_context->brc.initial_qp;
178 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = encoder_context->brc.initial_qp;
179 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B] = encoder_context->brc.initial_qp;
180
181 BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I], min_qp, 51);
182 BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P], min_qp, 51);
183 BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B], min_qp, 51);
184 } else {
185 if ((bpf > qp51_size) && (bpf < qp1_size)) {
186 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 51 - 50 * (bpf - qp51_size) / (qp1_size - qp51_size);
187 } else if (bpf >= qp1_size)
188 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 1;
189 else if (bpf <= qp51_size)
190 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 51;
191
192 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I] = mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P];
193 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B] = mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I];
194
195 tmp_min_qp = (min_qp < 36) ? min_qp : 36;
196 BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I], tmp_min_qp, 36);
197 tmp_min_qp = (min_qp < 40) ? min_qp : 40;
198 BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P], tmp_min_qp, 40);
199 tmp_min_qp = (min_qp < 45) ? min_qp : 45;
200 BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B], tmp_min_qp, 45);
201 }
202 }
203 }
204
205 int intel_mfc_update_hrd(struct encode_state *encode_state,
206 struct intel_encoder_context *encoder_context,
207 int frame_bits)
208 {
209 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
210 int layer_id = encoder_context->layer.curr_frame_layer_id;
211 double prev_bf = mfc_context->hrd.current_buffer_fullness[layer_id];
212
213 mfc_context->hrd.current_buffer_fullness[layer_id] -= frame_bits;
214
215 if (mfc_context->hrd.buffer_size[layer_id] > 0 && mfc_context->hrd.current_buffer_fullness[layer_id] <= 0.) {
216 mfc_context->hrd.current_buffer_fullness[layer_id] = prev_bf;
217 return BRC_UNDERFLOW;
218 }
219
220 mfc_context->hrd.current_buffer_fullness[layer_id] += mfc_context->brc.bits_per_frame[layer_id];
221 if (mfc_context->hrd.buffer_size[layer_id] > 0 && mfc_context->hrd.current_buffer_fullness[layer_id] > mfc_context->hrd.buffer_size[layer_id]) {
222 if (mfc_context->brc.mode == VA_RC_VBR)
223 mfc_context->hrd.current_buffer_fullness[layer_id] = mfc_context->hrd.buffer_size[layer_id];
224 else {
225 mfc_context->hrd.current_buffer_fullness[layer_id] = prev_bf;
226 return BRC_OVERFLOW;
227 }
228 }
229 return BRC_NO_HRD_VIOLATION;
230 }
231
232 static int intel_mfc_brc_postpack_cbr(struct encode_state *encode_state,
233 struct intel_encoder_context *encoder_context,
234 int frame_bits)
235 {
236 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
237 gen6_brc_status sts = BRC_NO_HRD_VIOLATION;
238 VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
239 int slicetype = intel_avc_enc_slice_type_fixup(pSliceParameter->slice_type);
240 int curr_frame_layer_id, next_frame_layer_id;
241 int qpi, qpp, qpb;
242 int qp; // quantizer of previously encoded slice of current type
243 int qpn; // predicted quantizer for next frame of current type in integer format
244 double qpf; // predicted quantizer for next frame of current type in float format
245 double delta_qp; // QP correction
246 int min_qp = MAX(1, encoder_context->brc.min_qp);
247 int target_frame_size, frame_size_next;
248 /* Notes:
249 * x - how far we are from HRD buffer borders
250 * y - how far we are from target HRD buffer fullness
251 */
252 double x, y;
253 double frame_size_alpha;
254
255 if (encoder_context->layer.num_layers < 2 || encoder_context->layer.size_frame_layer_ids == 0) {
256 curr_frame_layer_id = 0;
257 next_frame_layer_id = 0;
258 } else {
259 curr_frame_layer_id = encoder_context->layer.curr_frame_layer_id;
260 next_frame_layer_id = encoder_context->layer.frame_layer_ids[encoder_context->num_frames_in_sequence % encoder_context->layer.size_frame_layer_ids];
261 }
262
263 /* checking wthether HRD compliance first */
264 sts = intel_mfc_update_hrd(encode_state, encoder_context, frame_bits);
265
266 if (sts == BRC_NO_HRD_VIOLATION) { // no HRD violation
267 /* nothing */
268 } else {
269 next_frame_layer_id = curr_frame_layer_id;
270 }
271
272 mfc_context->brc.bits_prev_frame[curr_frame_layer_id] = frame_bits;
273 frame_bits = mfc_context->brc.bits_prev_frame[next_frame_layer_id];
274
275 mfc_context->brc.prev_slice_type[curr_frame_layer_id] = slicetype;
276 slicetype = mfc_context->brc.prev_slice_type[next_frame_layer_id];
277
278 /* 0 means the next frame is the first frame of next layer */
279 if (frame_bits == 0)
280 return sts;
281
282 qpi = mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I];
283 qpp = mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P];
284 qpb = mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B];
285
286 qp = mfc_context->brc.qp_prime_y[next_frame_layer_id][slicetype];
287
288 target_frame_size = mfc_context->brc.target_frame_size[next_frame_layer_id][slicetype];
289 if (mfc_context->hrd.buffer_capacity[next_frame_layer_id] < 5)
290 frame_size_alpha = 0;
291 else
292 frame_size_alpha = (double)mfc_context->brc.gop_nums[next_frame_layer_id][slicetype];
293 if (frame_size_alpha > 30) frame_size_alpha = 30;
294 frame_size_next = target_frame_size + (double)(target_frame_size - frame_bits) /
295 (double)(frame_size_alpha + 1.);
296
297 /* frame_size_next: avoiding negative number and too small value */
298 if ((double)frame_size_next < (double)(target_frame_size * 0.25))
299 frame_size_next = (int)((double)target_frame_size * 0.25);
300
301 qpf = (double)qp * target_frame_size / frame_size_next;
302 qpn = (int)(qpf + 0.5);
303
304 if (qpn == qp) {
305 /* setting qpn we round qpf making mistakes: now we are trying to compensate this */
306 mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] += qpf - qpn;
307 if (mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] > 1.0) {
308 qpn++;
309 mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] = 0.;
310 } else if (mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] < -1.0) {
311 qpn--;
312 mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] = 0.;
313 }
314 }
315 /* making sure that QP is not changing too fast */
316 if ((qpn - qp) > BRC_QP_MAX_CHANGE) qpn = qp + BRC_QP_MAX_CHANGE;
317 else if ((qpn - qp) < -BRC_QP_MAX_CHANGE) qpn = qp - BRC_QP_MAX_CHANGE;
318 /* making sure that with QP predictions we did do not leave QPs range */
319 BRC_CLIP(qpn, 1, 51);
320
321 /* calculating QP delta as some function*/
322 x = mfc_context->hrd.target_buffer_fullness[next_frame_layer_id] - mfc_context->hrd.current_buffer_fullness[next_frame_layer_id];
323 if (x > 0) {
324 x /= mfc_context->hrd.target_buffer_fullness[next_frame_layer_id];
325 y = mfc_context->hrd.current_buffer_fullness[next_frame_layer_id];
326 } else {
327 x /= (mfc_context->hrd.buffer_size[next_frame_layer_id] - mfc_context->hrd.target_buffer_fullness[next_frame_layer_id]);
328 y = mfc_context->hrd.buffer_size[next_frame_layer_id] - mfc_context->hrd.current_buffer_fullness[next_frame_layer_id];
329 }
330 if (y < 0.01) y = 0.01;
331 if (x > 1) x = 1;
332 else if (x < -1) x = -1;
333
334 delta_qp = BRC_QP_MAX_CHANGE * exp(-1 / y) * sin(BRC_PI_0_5 * x);
335 qpn = (int)(qpn + delta_qp + 0.5);
336
337 /* making sure that with QP predictions we did do not leave QPs range */
338 BRC_CLIP(qpn, min_qp, 51);
339
340 if (sts == BRC_NO_HRD_VIOLATION) { // no HRD violation
341 /* correcting QPs of slices of other types */
342 if (slicetype == SLICE_TYPE_P) {
343 if (abs(qpn + BRC_P_B_QP_DIFF - qpb) > 2)
344 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B] += (qpn + BRC_P_B_QP_DIFF - qpb) >> 1;
345 if (abs(qpn - BRC_I_P_QP_DIFF - qpi) > 2)
346 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I] += (qpn - BRC_I_P_QP_DIFF - qpi) >> 1;
347 } else if (slicetype == SLICE_TYPE_I) {
348 if (abs(qpn + BRC_I_B_QP_DIFF - qpb) > 4)
349 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B] += (qpn + BRC_I_B_QP_DIFF - qpb) >> 2;
350 if (abs(qpn + BRC_I_P_QP_DIFF - qpp) > 2)
351 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P] += (qpn + BRC_I_P_QP_DIFF - qpp) >> 2;
352 } else { // SLICE_TYPE_B
353 if (abs(qpn - BRC_P_B_QP_DIFF - qpp) > 2)
354 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P] += (qpn - BRC_P_B_QP_DIFF - qpp) >> 1;
355 if (abs(qpn - BRC_I_B_QP_DIFF - qpi) > 4)
356 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I] += (qpn - BRC_I_B_QP_DIFF - qpi) >> 2;
357 }
358 BRC_CLIP(mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I], min_qp, 51);
359 BRC_CLIP(mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P], min_qp, 51);
360 BRC_CLIP(mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B], min_qp, 51);
361 } else if (sts == BRC_UNDERFLOW) { // underflow
362 if (qpn <= qp) qpn = qp + 1;
363 if (qpn > 51) {
364 qpn = 51;
365 sts = BRC_UNDERFLOW_WITH_MAX_QP; //underflow with maxQP
366 }
367 } else if (sts == BRC_OVERFLOW) {
368 if (qpn >= qp) qpn = qp - 1;
369 if (qpn < min_qp) { // overflow with minQP
370 qpn = min_qp;
371 sts = BRC_OVERFLOW_WITH_MIN_QP; // bit stuffing to be done
372 }
373 }
374
375 mfc_context->brc.qp_prime_y[next_frame_layer_id][slicetype] = qpn;
376
377 return sts;
378 }
379
380 static int intel_mfc_brc_postpack_vbr(struct encode_state *encode_state,
381 struct intel_encoder_context *encoder_context,
382 int frame_bits)
383 {
384 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
385 gen6_brc_status sts;
386 VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
387 int slice_type = intel_avc_enc_slice_type_fixup(pSliceParameter->slice_type);
388 int *qp = mfc_context->brc.qp_prime_y[0];
389 int min_qp = MAX(1, encoder_context->brc.min_qp);
390 int qp_delta, large_frame_adjustment;
391
392 // This implements a simple reactive VBR rate control mode for single-layer H.264. The primary
393 // aim here is to avoid the problematic behaviour that the CBR rate controller displays on
394 // scene changes, where the QP can get pushed up by a large amount in a short period and
395 // compromise the quality of following frames to a very visible degree.
396 // The main idea, then, is to try to keep the HRD buffering above the target level most of the
397 // time, so that when a large frame is generated (on a scene change or when the stream
398 // complexity increases) we have plenty of slack to be able to encode the more difficult region
399 // without compromising quality immediately on the following frames. It is optimistic about
400 // the complexity of future frames, so even after generating one or more large frames on a
401 // significant change it will try to keep the QP at its current level until the HRD buffer
402 // bounds force a change to maintain the intended rate.
403
404 sts = intel_mfc_update_hrd(encode_state, encoder_context, frame_bits);
405
406 // This adjustment is applied to increase the QP by more than we normally would if a very
407 // large frame is encountered and we are in danger of running out of slack.
408 large_frame_adjustment = rint(2.0 * log(frame_bits / mfc_context->brc.target_frame_size[0][slice_type]));
409
410 if (sts == BRC_UNDERFLOW) {
411 // The frame is far too big and we don't have the bits available to send it, so it will
412 // have to be re-encoded at a higher QP.
413 qp_delta = +2;
414 if (frame_bits > mfc_context->brc.target_frame_size[0][slice_type])
415 qp_delta += large_frame_adjustment;
416 } else if (sts == BRC_OVERFLOW) {
417 // The frame is very small and we are now overflowing the HRD buffer. Currently this case
418 // does not occur because we ignore overflow in VBR mode.
419 assert(0 && "Overflow in VBR mode");
420 } else if (frame_bits <= mfc_context->brc.target_frame_size[0][slice_type]) {
421 // The frame is smaller than the average size expected for this frame type.
422 if (mfc_context->hrd.current_buffer_fullness[0] >
423 (mfc_context->hrd.target_buffer_fullness[0] + mfc_context->hrd.buffer_size[0]) / 2.0) {
424 // We currently have lots of bits available, so decrease the QP slightly for the next
425 // frame.
426 qp_delta = -1;
427 } else {
428 // The HRD buffer fullness is increasing, so do nothing. (We may be under the target
429 // level here, but are moving in the right direction.)
430 qp_delta = 0;
431 }
432 } else {
433 // The frame is larger than the average size expected for this frame type.
434 if (mfc_context->hrd.current_buffer_fullness[0] > mfc_context->hrd.target_buffer_fullness[0]) {
435 // We are currently over the target level, so do nothing.
436 qp_delta = 0;
437 } else if (mfc_context->hrd.current_buffer_fullness[0] > mfc_context->hrd.target_buffer_fullness[0] / 2.0) {
438 // We are under the target level, but not critically. Increase the QP by one step if
439 // continuing like this would underflow soon (currently within one second).
440 if (mfc_context->hrd.current_buffer_fullness[0] /
441 (double)(frame_bits - mfc_context->brc.target_frame_size[0][slice_type] + 1) <
442 ((double)encoder_context->brc.framerate[0].num / (double)encoder_context->brc.framerate[0].den))
443 qp_delta = +1;
444 else
445 qp_delta = 0;
446 } else {
447 // We are a long way under the target level. Always increase the QP, possibly by a
448 // larger amount dependent on how big the frame we just made actually was.
449 qp_delta = +1 + large_frame_adjustment;
450 }
451 }
452
453 switch (slice_type) {
454 case SLICE_TYPE_I:
455 qp[SLICE_TYPE_I] += qp_delta;
456 qp[SLICE_TYPE_P] = qp[SLICE_TYPE_I] + BRC_I_P_QP_DIFF;
457 qp[SLICE_TYPE_B] = qp[SLICE_TYPE_I] + BRC_I_B_QP_DIFF;
458 break;
459 case SLICE_TYPE_P:
460 qp[SLICE_TYPE_P] += qp_delta;
461 qp[SLICE_TYPE_I] = qp[SLICE_TYPE_P] - BRC_I_P_QP_DIFF;
462 qp[SLICE_TYPE_B] = qp[SLICE_TYPE_P] + BRC_P_B_QP_DIFF;
463 break;
464 case SLICE_TYPE_B:
465 qp[SLICE_TYPE_B] += qp_delta;
466 qp[SLICE_TYPE_I] = qp[SLICE_TYPE_B] - BRC_I_B_QP_DIFF;
467 qp[SLICE_TYPE_P] = qp[SLICE_TYPE_B] - BRC_P_B_QP_DIFF;
468 break;
469 }
470 BRC_CLIP(mfc_context->brc.qp_prime_y[0][SLICE_TYPE_I], min_qp, 51);
471 BRC_CLIP(mfc_context->brc.qp_prime_y[0][SLICE_TYPE_P], min_qp, 51);
472 BRC_CLIP(mfc_context->brc.qp_prime_y[0][SLICE_TYPE_B], min_qp, 51);
473
474 if (sts == BRC_UNDERFLOW && qp[slice_type] == 51)
475 sts = BRC_UNDERFLOW_WITH_MAX_QP;
476 if (sts == BRC_OVERFLOW && qp[slice_type] == min_qp)
477 sts = BRC_OVERFLOW_WITH_MIN_QP;
478
479 return sts;
480 }
481
482 int intel_mfc_brc_postpack(struct encode_state *encode_state,
483 struct intel_encoder_context *encoder_context,
484 int frame_bits)
485 {
486 switch (encoder_context->rate_control_mode) {
487 case VA_RC_CBR:
488 return intel_mfc_brc_postpack_cbr(encode_state, encoder_context, frame_bits);
489 case VA_RC_VBR:
490 return intel_mfc_brc_postpack_vbr(encode_state, encoder_context, frame_bits);
491 }
492 assert(0 && "Invalid RC mode");
493 return 1;
494 }
495
496 static void intel_mfc_hrd_context_init(struct encode_state *encode_state,
497 struct intel_encoder_context *encoder_context)
498 {
499 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
500 unsigned int rate_control_mode = encoder_context->rate_control_mode;
501 int target_bit_rate = encoder_context->brc.bits_per_second[encoder_context->layer.num_layers - 1];
502
503 // current we only support CBR mode.
504 if (rate_control_mode == VA_RC_CBR) {
505 mfc_context->vui_hrd.i_bit_rate_value = target_bit_rate >> 10;
506 mfc_context->vui_hrd.i_initial_cpb_removal_delay = ((target_bit_rate * 8) >> 10) * 0.5 * 1024 / target_bit_rate * 90000;
507 mfc_context->vui_hrd.i_cpb_removal_delay = 2;
508 mfc_context->vui_hrd.i_frame_number = 0;
509
510 mfc_context->vui_hrd.i_initial_cpb_removal_delay_length = 24;
511 mfc_context->vui_hrd.i_cpb_removal_delay_length = 24;
512 mfc_context->vui_hrd.i_dpb_output_delay_length = 24;
513 }
514
515 }
516
517 void
518 intel_mfc_hrd_context_update(struct encode_state *encode_state,
519 struct gen6_mfc_context *mfc_context)
520 {
521 mfc_context->vui_hrd.i_frame_number++;
522 }
523
524 int intel_mfc_interlace_check(VADriverContextP ctx,
525 struct encode_state *encode_state,
526 struct intel_encoder_context *encoder_context)
527 {
528 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
529 VAEncSliceParameterBufferH264 *pSliceParameter;
530 int i;
531 int mbCount = 0;
532 int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
533 int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
534
535 for (i = 0; i < encode_state->num_slice_params_ext; i++) {
536 pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[i]->buffer;
537 mbCount += pSliceParameter->num_macroblocks;
538 }
539
540 if (mbCount == (width_in_mbs * height_in_mbs))
541 return 0;
542
543 return 1;
544 }
545
546 void intel_mfc_brc_prepare(struct encode_state *encode_state,
547 struct intel_encoder_context *encoder_context)
548 {
549 unsigned int rate_control_mode = encoder_context->rate_control_mode;
550
551 if (encoder_context->codec != CODEC_H264 &&
552 encoder_context->codec != CODEC_H264_MVC)
553 return;
554
555 if (rate_control_mode != VA_RC_CQP) {
556 /*Programing bit rate control */
557 if (encoder_context->brc.need_reset) {
558 intel_mfc_bit_rate_control_context_init(encode_state, encoder_context);
559 intel_mfc_brc_init(encode_state, encoder_context);
560 }
561
562 /*Programing HRD control */
563 if (encoder_context->brc.need_reset)
564 intel_mfc_hrd_context_init(encode_state, encoder_context);
565 }
566 }
567
568 void intel_mfc_avc_pipeline_header_programing(VADriverContextP ctx,
569 struct encode_state *encode_state,
570 struct intel_encoder_context *encoder_context,
571 struct intel_batchbuffer *slice_batch)
572 {
573 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
574 int idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_SPS);
575 unsigned int skip_emul_byte_cnt;
576
577 if (encode_state->packed_header_data[idx]) {
578 VAEncPackedHeaderParameterBuffer *param = NULL;
579 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
580 unsigned int length_in_bits;
581
582 assert(encode_state->packed_header_param[idx]);
583 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
584 length_in_bits = param->bit_length;
585
586 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
587 mfc_context->insert_object(ctx,
588 encoder_context,
589 header_data,
590 ALIGN(length_in_bits, 32) >> 5,
591 length_in_bits & 0x1f,
592 skip_emul_byte_cnt,
593 0,
594 0,
595 !param->has_emulation_bytes,
596 slice_batch);
597 }
598
599 idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_PPS);
600
601 if (encode_state->packed_header_data[idx]) {
602 VAEncPackedHeaderParameterBuffer *param = NULL;
603 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
604 unsigned int length_in_bits;
605
606 assert(encode_state->packed_header_param[idx]);
607 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
608 length_in_bits = param->bit_length;
609
610 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
611
612 mfc_context->insert_object(ctx,
613 encoder_context,
614 header_data,
615 ALIGN(length_in_bits, 32) >> 5,
616 length_in_bits & 0x1f,
617 skip_emul_byte_cnt,
618 0,
619 0,
620 !param->has_emulation_bytes,
621 slice_batch);
622 }
623
624 idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_SEI);
625
626 if (encode_state->packed_header_data[idx]) {
627 VAEncPackedHeaderParameterBuffer *param = NULL;
628 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
629 unsigned int length_in_bits;
630
631 assert(encode_state->packed_header_param[idx]);
632 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
633 length_in_bits = param->bit_length;
634
635 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
636 mfc_context->insert_object(ctx,
637 encoder_context,
638 header_data,
639 ALIGN(length_in_bits, 32) >> 5,
640 length_in_bits & 0x1f,
641 skip_emul_byte_cnt,
642 0,
643 0,
644 !param->has_emulation_bytes,
645 slice_batch);
646 }
647 }
648
649 VAStatus intel_mfc_avc_prepare(VADriverContextP ctx,
650 struct encode_state *encode_state,
651 struct intel_encoder_context *encoder_context)
652 {
653 struct i965_driver_data *i965 = i965_driver_data(ctx);
654 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
655 struct object_surface *obj_surface;
656 struct object_buffer *obj_buffer;
657 GenAvcSurface *gen6_avc_surface;
658 dri_bo *bo;
659 VAStatus vaStatus = VA_STATUS_SUCCESS;
660 int i, j, enable_avc_ildb = 0;
661 VAEncSliceParameterBufferH264 *slice_param;
662 struct i965_coded_buffer_segment *coded_buffer_segment;
663 VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
664 int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
665 int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
666
667 if (IS_GEN6(i965->intel.device_info)) {
668 /* On the SNB it should be fixed to 128 for the DMV buffer */
669 width_in_mbs = 128;
670 }
671
672 for (j = 0; j < encode_state->num_slice_params_ext && enable_avc_ildb == 0; j++) {
673 assert(encode_state->slice_params_ext && encode_state->slice_params_ext[j]->buffer);
674 slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[j]->buffer;
675
676 for (i = 0; i < encode_state->slice_params_ext[j]->num_elements; i++) {
677 assert((slice_param->slice_type == SLICE_TYPE_I) ||
678 (slice_param->slice_type == SLICE_TYPE_SI) ||
679 (slice_param->slice_type == SLICE_TYPE_P) ||
680 (slice_param->slice_type == SLICE_TYPE_SP) ||
681 (slice_param->slice_type == SLICE_TYPE_B));
682
683 if (slice_param->disable_deblocking_filter_idc != 1) {
684 enable_avc_ildb = 1;
685 break;
686 }
687
688 slice_param++;
689 }
690 }
691
692 /*Setup all the input&output object*/
693
694 /* Setup current frame and current direct mv buffer*/
695 obj_surface = encode_state->reconstructed_object;
696 i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
697
698 if (obj_surface->private_data == NULL) {
699 gen6_avc_surface = calloc(sizeof(GenAvcSurface), 1);
700 assert(gen6_avc_surface);
701 gen6_avc_surface->dmv_top =
702 dri_bo_alloc(i965->intel.bufmgr,
703 "Buffer",
704 68 * width_in_mbs * height_in_mbs,
705 64);
706 gen6_avc_surface->dmv_bottom =
707 dri_bo_alloc(i965->intel.bufmgr,
708 "Buffer",
709 68 * width_in_mbs * height_in_mbs,
710 64);
711 assert(gen6_avc_surface->dmv_top);
712 assert(gen6_avc_surface->dmv_bottom);
713 obj_surface->private_data = (void *)gen6_avc_surface;
714 obj_surface->free_private_data = (void *)gen_free_avc_surface;
715 }
716 gen6_avc_surface = (GenAvcSurface *) obj_surface->private_data;
717 mfc_context->direct_mv_buffers[NUM_MFC_DMV_BUFFERS - 2].bo = gen6_avc_surface->dmv_top;
718 mfc_context->direct_mv_buffers[NUM_MFC_DMV_BUFFERS - 1].bo = gen6_avc_surface->dmv_bottom;
719 dri_bo_reference(gen6_avc_surface->dmv_top);
720 dri_bo_reference(gen6_avc_surface->dmv_bottom);
721
722 if (enable_avc_ildb) {
723 mfc_context->post_deblocking_output.bo = obj_surface->bo;
724 dri_bo_reference(mfc_context->post_deblocking_output.bo);
725 } else {
726 mfc_context->pre_deblocking_output.bo = obj_surface->bo;
727 dri_bo_reference(mfc_context->pre_deblocking_output.bo);
728 }
729
730 mfc_context->surface_state.width = obj_surface->orig_width;
731 mfc_context->surface_state.height = obj_surface->orig_height;
732 mfc_context->surface_state.w_pitch = obj_surface->width;
733 mfc_context->surface_state.h_pitch = obj_surface->height;
734
735 /* Setup reference frames and direct mv buffers*/
736 for (i = 0; i < MAX_MFC_REFERENCE_SURFACES; i++) {
737 obj_surface = encode_state->reference_objects[i];
738
739 if (obj_surface && obj_surface->bo) {
740 mfc_context->reference_surfaces[i].bo = obj_surface->bo;
741 dri_bo_reference(obj_surface->bo);
742
743 /* Check DMV buffer */
744 if (obj_surface->private_data == NULL) {
745
746 gen6_avc_surface = calloc(sizeof(GenAvcSurface), 1);
747 assert(gen6_avc_surface);
748 gen6_avc_surface->dmv_top =
749 dri_bo_alloc(i965->intel.bufmgr,
750 "Buffer",
751 68 * width_in_mbs * height_in_mbs,
752 64);
753 gen6_avc_surface->dmv_bottom =
754 dri_bo_alloc(i965->intel.bufmgr,
755 "Buffer",
756 68 * width_in_mbs * height_in_mbs,
757 64);
758 assert(gen6_avc_surface->dmv_top);
759 assert(gen6_avc_surface->dmv_bottom);
760 obj_surface->private_data = gen6_avc_surface;
761 obj_surface->free_private_data = gen_free_avc_surface;
762 }
763
764 gen6_avc_surface = (GenAvcSurface *) obj_surface->private_data;
765 /* Setup DMV buffer */
766 mfc_context->direct_mv_buffers[i * 2].bo = gen6_avc_surface->dmv_top;
767 mfc_context->direct_mv_buffers[i * 2 + 1].bo = gen6_avc_surface->dmv_bottom;
768 dri_bo_reference(gen6_avc_surface->dmv_top);
769 dri_bo_reference(gen6_avc_surface->dmv_bottom);
770 } else {
771 break;
772 }
773 }
774
775 mfc_context->uncompressed_picture_source.bo = encode_state->input_yuv_object->bo;
776 dri_bo_reference(mfc_context->uncompressed_picture_source.bo);
777
778 obj_buffer = encode_state->coded_buf_object;
779 bo = obj_buffer->buffer_store->bo;
780 mfc_context->mfc_indirect_pak_bse_object.bo = bo;
781 mfc_context->mfc_indirect_pak_bse_object.offset = I965_CODEDBUFFER_HEADER_SIZE;
782 mfc_context->mfc_indirect_pak_bse_object.end_offset = ALIGN(obj_buffer->size_element - 0x1000, 0x1000);
783 dri_bo_reference(mfc_context->mfc_indirect_pak_bse_object.bo);
784
785 dri_bo_map(bo, 1);
786 coded_buffer_segment = (struct i965_coded_buffer_segment *)bo->virtual;
787 coded_buffer_segment->mapped = 0;
788 coded_buffer_segment->codec = encoder_context->codec;
789 dri_bo_unmap(bo);
790
791 return vaStatus;
792 }
793 /*
794 * The LUT uses the pair of 4-bit units: (shift, base) structure.
795 * 2^K * X = value .
796 * So it is necessary to convert one cost into the nearest LUT format.
797 * The derivation is:
798 * 2^K *x = 2^n * (1 + deltaX)
799 * k + log2(x) = n + log2(1 + deltaX)
800 * log2(x) = n - k + log2(1 + deltaX)
801 * As X is in the range of [1, 15]
802 * 4 > n - k + log2(1 + deltaX) >= 0
803 * => n + log2(1 + deltaX) >= k > n - 4 + log2(1 + deltaX)
804 * Then we can derive the corresponding K and get the nearest LUT format.
805 */
806 int intel_format_lutvalue(int value, int max)
807 {
808 int ret;
809 int logvalue, temp1, temp2;
810
811 if (value <= 0)
812 return 0;
813
814 logvalue = (int)(log2f((float)value));
815 if (logvalue < 4) {
816 ret = value;
817 } else {
818 int error, temp_value, base, j, temp_err;
819 error = value;
820 j = logvalue - 4 + 1;
821 ret = -1;
822 for (; j <= logvalue; j++) {
823 if (j == 0) {
824 base = value >> j;
825 } else {
826 base = (value + (1 << (j - 1)) - 1) >> j;
827 }
828 if (base >= 16)
829 continue;
830
831 temp_value = base << j;
832 temp_err = abs(value - temp_value);
833 if (temp_err < error) {
834 error = temp_err;
835 ret = (j << 4) | base;
836 if (temp_err == 0)
837 break;
838 }
839 }
840 }
841 temp1 = (ret & 0xf) << ((ret & 0xf0) >> 4);
842 temp2 = (max & 0xf) << ((max & 0xf0) >> 4);
843 if (temp1 > temp2)
844 ret = max;
845 return ret;
846
847 }
848
849
850 #define QP_MAX 52
851 #define VP8_QP_MAX 128
852
853
854 static float intel_lambda_qp(int qp)
855 {
856 float value, lambdaf;
857 value = qp;
858 value = value / 6 - 2;
859 if (value < 0)
860 value = 0;
861 lambdaf = roundf(powf(2, value));
862 return lambdaf;
863 }
864
865 static
866 void intel_h264_calc_mbmvcost_qp(int qp,
867 int slice_type,
868 uint8_t *vme_state_message)
869 {
870 int m_cost, j, mv_count;
871 float lambda, m_costf;
872
873 assert(qp <= QP_MAX);
874 lambda = intel_lambda_qp(qp);
875
876 m_cost = lambda;
877 vme_state_message[MODE_CHROMA_INTRA] = 0;
878 vme_state_message[MODE_REFID_COST] = intel_format_lutvalue(m_cost, 0x8f);
879
880 if (slice_type == SLICE_TYPE_I) {
881 vme_state_message[MODE_INTRA_16X16] = 0;
882 m_cost = lambda * 4;
883 vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
884 m_cost = lambda * 16;
885 vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
886 m_cost = lambda * 3;
887 vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
888 } else {
889 m_cost = 0;
890 vme_state_message[MODE_INTER_MV0] = intel_format_lutvalue(m_cost, 0x6f);
891 for (j = 1; j < 3; j++) {
892 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
893 m_cost = (int)m_costf;
894 vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
895 }
896 mv_count = 3;
897 for (j = 4; j <= 64; j *= 2) {
898 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
899 m_cost = (int)m_costf;
900 vme_state_message[MODE_INTER_MV0 + mv_count] = intel_format_lutvalue(m_cost, 0x6f);
901 mv_count++;
902 }
903
904 if (qp <= 25) {
905 vme_state_message[MODE_INTRA_16X16] = 0x4a;
906 vme_state_message[MODE_INTRA_8X8] = 0x4a;
907 vme_state_message[MODE_INTRA_4X4] = 0x4a;
908 vme_state_message[MODE_INTRA_NONPRED] = 0x4a;
909 vme_state_message[MODE_INTER_16X16] = 0x4a;
910 vme_state_message[MODE_INTER_16X8] = 0x4a;
911 vme_state_message[MODE_INTER_8X8] = 0x4a;
912 vme_state_message[MODE_INTER_8X4] = 0x4a;
913 vme_state_message[MODE_INTER_4X4] = 0x4a;
914 vme_state_message[MODE_INTER_BWD] = 0x2a;
915 return;
916 }
917 m_costf = lambda * 10;
918 vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
919 m_cost = lambda * 14;
920 vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
921 m_cost = lambda * 24;
922 vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
923 m_costf = lambda * 3.5;
924 m_cost = m_costf;
925 vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
926 if (slice_type == SLICE_TYPE_P) {
927 m_costf = lambda * 2.5;
928 m_cost = m_costf;
929 vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
930 m_costf = lambda * 4;
931 m_cost = m_costf;
932 vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
933 m_costf = lambda * 1.5;
934 m_cost = m_costf;
935 vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
936 m_costf = lambda * 3;
937 m_cost = m_costf;
938 vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
939 m_costf = lambda * 5;
940 m_cost = m_costf;
941 vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
942 /* BWD is not used in P-frame */
943 vme_state_message[MODE_INTER_BWD] = 0;
944 } else {
945 m_costf = lambda * 2.5;
946 m_cost = m_costf;
947 vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
948 m_costf = lambda * 5.5;
949 m_cost = m_costf;
950 vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
951 m_costf = lambda * 3.5;
952 m_cost = m_costf;
953 vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
954 m_costf = lambda * 5.0;
955 m_cost = m_costf;
956 vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
957 m_costf = lambda * 6.5;
958 m_cost = m_costf;
959 vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
960 m_costf = lambda * 1.5;
961 m_cost = m_costf;
962 vme_state_message[MODE_INTER_BWD] = intel_format_lutvalue(m_cost, 0x6f);
963 }
964 }
965 return;
966 }
967
968 void intel_vme_update_mbmv_cost(VADriverContextP ctx,
969 struct encode_state *encode_state,
970 struct intel_encoder_context *encoder_context)
971 {
972 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
973 struct gen6_vme_context *vme_context = encoder_context->vme_context;
974 VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
975 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
976 int qp;
977 uint8_t *vme_state_message = (uint8_t *)(vme_context->vme_state_message);
978
979 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
980
981 if (encoder_context->rate_control_mode == VA_RC_CQP)
982 qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
983 else
984 qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
985
986 if (vme_state_message == NULL)
987 return;
988
989 intel_h264_calc_mbmvcost_qp(qp, slice_type, vme_state_message);
990 }
991
992 void intel_vme_vp8_update_mbmv_cost(VADriverContextP ctx,
993 struct encode_state *encode_state,
994 struct intel_encoder_context *encoder_context)
995 {
996 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
997 struct gen6_vme_context *vme_context = encoder_context->vme_context;
998 VAEncPictureParameterBufferVP8 *pic_param = (VAEncPictureParameterBufferVP8 *)encode_state->pic_param_ext->buffer;
999 VAQMatrixBufferVP8 *q_matrix = (VAQMatrixBufferVP8 *)encode_state->q_matrix->buffer;
1000 int qp, m_cost, j, mv_count;
1001 uint8_t *vme_state_message = (uint8_t *)(vme_context->vme_state_message);
1002 float lambda, m_costf;
1003
1004 int is_key_frame = !pic_param->pic_flags.bits.frame_type;
1005 int slice_type = (is_key_frame ? SLICE_TYPE_I : SLICE_TYPE_P);
1006
1007 if (vme_state_message == NULL)
1008 return;
1009
1010 if (encoder_context->rate_control_mode == VA_RC_CQP)
1011 qp = q_matrix->quantization_index[0];
1012 else
1013 qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
1014
1015 lambda = intel_lambda_qp(qp * QP_MAX / VP8_QP_MAX);
1016
1017 m_cost = lambda;
1018 vme_state_message[MODE_CHROMA_INTRA] = intel_format_lutvalue(m_cost, 0x8f);
1019
1020 if (is_key_frame) {
1021 vme_state_message[MODE_INTRA_16X16] = 0;
1022 m_cost = lambda * 16;
1023 vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
1024 m_cost = lambda * 3;
1025 vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
1026 } else {
1027 m_cost = 0;
1028 vme_state_message[MODE_INTER_MV0] = intel_format_lutvalue(m_cost, 0x6f);
1029 for (j = 1; j < 3; j++) {
1030 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1031 m_cost = (int)m_costf;
1032 vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
1033 }
1034 mv_count = 3;
1035 for (j = 4; j <= 64; j *= 2) {
1036 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1037 m_cost = (int)m_costf;
1038 vme_state_message[MODE_INTER_MV0 + mv_count] = intel_format_lutvalue(m_cost, 0x6f);
1039 mv_count++;
1040 }
1041
1042 if (qp < 92) {
1043 vme_state_message[MODE_INTRA_16X16] = 0x4a;
1044 vme_state_message[MODE_INTRA_4X4] = 0x4a;
1045 vme_state_message[MODE_INTRA_NONPRED] = 0x4a;
1046 vme_state_message[MODE_INTER_16X16] = 0x4a;
1047 vme_state_message[MODE_INTER_16X8] = 0x4a;
1048 vme_state_message[MODE_INTER_8X8] = 0x4a;
1049 vme_state_message[MODE_INTER_4X4] = 0x4a;
1050 vme_state_message[MODE_INTER_BWD] = 0;
1051 return;
1052 }
1053 m_costf = lambda * 10;
1054 vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1055 m_cost = lambda * 24;
1056 vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
1057
1058 m_costf = lambda * 3.5;
1059 m_cost = m_costf;
1060 vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
1061
1062 m_costf = lambda * 2.5;
1063 m_cost = m_costf;
1064 vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1065 m_costf = lambda * 4;
1066 m_cost = m_costf;
1067 vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
1068 m_costf = lambda * 1.5;
1069 m_cost = m_costf;
1070 vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
1071 m_costf = lambda * 5;
1072 m_cost = m_costf;
1073 vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
1074 /* BWD is not used in P-frame */
1075 vme_state_message[MODE_INTER_BWD] = 0;
1076 }
1077 }
1078
1079 #define MB_SCOREBOARD_A (1 << 0)
1080 #define MB_SCOREBOARD_B (1 << 1)
1081 #define MB_SCOREBOARD_C (1 << 2)
1082 void
1083 gen7_vme_scoreboard_init(VADriverContextP ctx, struct gen6_vme_context *vme_context)
1084 {
1085 vme_context->gpe_context.vfe_desc5.scoreboard0.enable = 1;
1086 vme_context->gpe_context.vfe_desc5.scoreboard0.type = SCOREBOARD_STALLING;
1087 vme_context->gpe_context.vfe_desc5.scoreboard0.mask = (MB_SCOREBOARD_A |
1088 MB_SCOREBOARD_B |
1089 MB_SCOREBOARD_C);
1090
1091 /* In VME prediction the current mb depends on the neighbour
1092 * A/B/C macroblock. So the left/up/up-right dependency should
1093 * be considered.
1094 */
1095 vme_context->gpe_context.vfe_desc6.scoreboard1.delta_x0 = -1;
1096 vme_context->gpe_context.vfe_desc6.scoreboard1.delta_y0 = 0;
1097 vme_context->gpe_context.vfe_desc6.scoreboard1.delta_x1 = 0;
1098 vme_context->gpe_context.vfe_desc6.scoreboard1.delta_y1 = -1;
1099 vme_context->gpe_context.vfe_desc6.scoreboard1.delta_x2 = 1;
1100 vme_context->gpe_context.vfe_desc6.scoreboard1.delta_y2 = -1;
1101
1102 vme_context->gpe_context.vfe_desc7.dword = 0;
1103 return;
1104 }
1105
1106 /* check whether the mb of (x_index, y_index) is out of bound */
1107 static inline int loop_in_bounds(int x_index, int y_index, int first_mb, int num_mb, int mb_width, int mb_height)
1108 {
1109 int mb_index;
1110 if (x_index < 0 || x_index >= mb_width)
1111 return -1;
1112 if (y_index < 0 || y_index >= mb_height)
1113 return -1;
1114
1115 mb_index = y_index * mb_width + x_index;
1116 if (mb_index < first_mb || mb_index > (first_mb + num_mb))
1117 return -1;
1118 return 0;
1119 }
1120
1121 void
1122 gen7_vme_walker_fill_vme_batchbuffer(VADriverContextP ctx,
1123 struct encode_state *encode_state,
1124 int mb_width, int mb_height,
1125 int kernel,
1126 int transform_8x8_mode_flag,
1127 struct intel_encoder_context *encoder_context)
1128 {
1129 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1130 int mb_row;
1131 int s;
1132 unsigned int *command_ptr;
1133 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1134 VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1135 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1136 int qp, qp_mb, qp_index;
1137 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1138
1139 if (encoder_context->rate_control_mode == VA_RC_CQP)
1140 qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
1141 else
1142 qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
1143
1144 #define USE_SCOREBOARD (1 << 21)
1145
1146 dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
1147 command_ptr = vme_context->vme_batchbuffer.bo->virtual;
1148
1149 for (s = 0; s < encode_state->num_slice_params_ext; s++) {
1150 VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
1151 int first_mb = pSliceParameter->macroblock_address;
1152 int num_mb = pSliceParameter->num_macroblocks;
1153 unsigned int mb_intra_ub, score_dep;
1154 int x_outer, y_outer, x_inner, y_inner;
1155 int xtemp_outer = 0;
1156
1157 x_outer = first_mb % mb_width;
1158 y_outer = first_mb / mb_width;
1159 mb_row = y_outer;
1160
1161 for (; x_outer < (mb_width - 2) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1162 x_inner = x_outer;
1163 y_inner = y_outer;
1164 for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1165 mb_intra_ub = 0;
1166 score_dep = 0;
1167 if (x_inner != 0) {
1168 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1169 score_dep |= MB_SCOREBOARD_A;
1170 }
1171 if (y_inner != mb_row) {
1172 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1173 score_dep |= MB_SCOREBOARD_B;
1174 if (x_inner != 0)
1175 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1176 if (x_inner != (mb_width - 1)) {
1177 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1178 score_dep |= MB_SCOREBOARD_C;
1179 }
1180 }
1181
1182 *command_ptr++ = (CMD_MEDIA_OBJECT | (9 - 2));
1183 *command_ptr++ = kernel;
1184 *command_ptr++ = USE_SCOREBOARD;
1185 /* Indirect data */
1186 *command_ptr++ = 0;
1187 /* the (X, Y) term of scoreboard */
1188 *command_ptr++ = ((y_inner << 16) | x_inner);
1189 *command_ptr++ = score_dep;
1190 /*inline data */
1191 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1192 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
1193 /* QP occupies one byte */
1194 if (vme_context->roi_enabled) {
1195 qp_index = y_inner * mb_width + x_inner;
1196 qp_mb = *(vme_context->qp_per_mb + qp_index);
1197 } else
1198 qp_mb = qp;
1199 *command_ptr++ = qp_mb;
1200 x_inner -= 2;
1201 y_inner += 1;
1202 }
1203 x_outer += 1;
1204 }
1205
1206 xtemp_outer = mb_width - 2;
1207 if (xtemp_outer < 0)
1208 xtemp_outer = 0;
1209 x_outer = xtemp_outer;
1210 y_outer = first_mb / mb_width;
1211 for (; !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1212 y_inner = y_outer;
1213 x_inner = x_outer;
1214 for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1215 mb_intra_ub = 0;
1216 score_dep = 0;
1217 if (x_inner != 0) {
1218 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1219 score_dep |= MB_SCOREBOARD_A;
1220 }
1221 if (y_inner != mb_row) {
1222 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1223 score_dep |= MB_SCOREBOARD_B;
1224 if (x_inner != 0)
1225 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1226
1227 if (x_inner != (mb_width - 1)) {
1228 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1229 score_dep |= MB_SCOREBOARD_C;
1230 }
1231 }
1232
1233 *command_ptr++ = (CMD_MEDIA_OBJECT | (9 - 2));
1234 *command_ptr++ = kernel;
1235 *command_ptr++ = USE_SCOREBOARD;
1236 /* Indirect data */
1237 *command_ptr++ = 0;
1238 /* the (X, Y) term of scoreboard */
1239 *command_ptr++ = ((y_inner << 16) | x_inner);
1240 *command_ptr++ = score_dep;
1241 /*inline data */
1242 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1243 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
1244 /* qp occupies one byte */
1245 if (vme_context->roi_enabled) {
1246 qp_index = y_inner * mb_width + x_inner;
1247 qp_mb = *(vme_context->qp_per_mb + qp_index);
1248 } else
1249 qp_mb = qp;
1250 *command_ptr++ = qp_mb;
1251
1252 x_inner -= 2;
1253 y_inner += 1;
1254 }
1255 x_outer++;
1256 if (x_outer >= mb_width) {
1257 y_outer += 1;
1258 x_outer = xtemp_outer;
1259 }
1260 }
1261 }
1262
1263 *command_ptr++ = 0;
1264 *command_ptr++ = MI_BATCH_BUFFER_END;
1265
1266 dri_bo_unmap(vme_context->vme_batchbuffer.bo);
1267 }
1268
1269 static uint8_t
1270 intel_get_ref_idx_state_1(VAPictureH264 *va_pic, unsigned int frame_store_id)
1271 {
1272 unsigned int is_long_term =
1273 !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);
1274 unsigned int is_top_field =
1275 !!(va_pic->flags & VA_PICTURE_H264_TOP_FIELD);
1276 unsigned int is_bottom_field =
1277 !!(va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD);
1278
1279 return ((is_long_term << 6) |
1280 ((is_top_field ^ is_bottom_field ^ 1) << 5) |
1281 (frame_store_id << 1) |
1282 ((is_top_field ^ 1) & is_bottom_field));
1283 }
1284
1285 void
1286 intel_mfc_avc_ref_idx_state(VADriverContextP ctx,
1287 struct encode_state *encode_state,
1288 struct intel_encoder_context *encoder_context)
1289 {
1290 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1291 struct intel_batchbuffer *batch = encoder_context->base.batch;
1292 int slice_type;
1293 struct object_surface *obj_surface;
1294 unsigned int fref_entry, bref_entry;
1295 int frame_index, i;
1296 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1297
1298 fref_entry = 0x80808080;
1299 bref_entry = 0x80808080;
1300 slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1301
1302 if (slice_type == SLICE_TYPE_P || slice_type == SLICE_TYPE_B) {
1303 int ref_idx_l0 = (vme_context->ref_index_in_mb[0] & 0xff);
1304
1305 if (ref_idx_l0 > 3) {
1306 WARN_ONCE("ref_idx_l0 is out of range\n");
1307 ref_idx_l0 = 0;
1308 }
1309
1310 obj_surface = vme_context->used_reference_objects[0];
1311 frame_index = -1;
1312 for (i = 0; i < 16; i++) {
1313 if (obj_surface &&
1314 obj_surface == encode_state->reference_objects[i]) {
1315 frame_index = i;
1316 break;
1317 }
1318 }
1319 if (frame_index == -1) {
1320 WARN_ONCE("RefPicList0 is not found in DPB!\n");
1321 } else {
1322 int ref_idx_l0_shift = ref_idx_l0 * 8;
1323 fref_entry &= ~(0xFF << ref_idx_l0_shift);
1324 fref_entry += (intel_get_ref_idx_state_1(vme_context->used_references[0], frame_index) << ref_idx_l0_shift);
1325 }
1326 }
1327
1328 if (slice_type == SLICE_TYPE_B) {
1329 int ref_idx_l1 = (vme_context->ref_index_in_mb[1] & 0xff);
1330
1331 if (ref_idx_l1 > 3) {
1332 WARN_ONCE("ref_idx_l1 is out of range\n");
1333 ref_idx_l1 = 0;
1334 }
1335
1336 obj_surface = vme_context->used_reference_objects[1];
1337 frame_index = -1;
1338 for (i = 0; i < 16; i++) {
1339 if (obj_surface &&
1340 obj_surface == encode_state->reference_objects[i]) {
1341 frame_index = i;
1342 break;
1343 }
1344 }
1345 if (frame_index == -1) {
1346 WARN_ONCE("RefPicList1 is not found in DPB!\n");
1347 } else {
1348 int ref_idx_l1_shift = ref_idx_l1 * 8;
1349 bref_entry &= ~(0xFF << ref_idx_l1_shift);
1350 bref_entry += (intel_get_ref_idx_state_1(vme_context->used_references[1], frame_index) << ref_idx_l1_shift);
1351 }
1352 }
1353
1354 BEGIN_BCS_BATCH(batch, 10);
1355 OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | 8);
1356 OUT_BCS_BATCH(batch, 0); //Select L0
1357 OUT_BCS_BATCH(batch, fref_entry); //Only 1 reference
1358 for (i = 0; i < 7; i++) {
1359 OUT_BCS_BATCH(batch, 0x80808080);
1360 }
1361 ADVANCE_BCS_BATCH(batch);
1362
1363 BEGIN_BCS_BATCH(batch, 10);
1364 OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | 8);
1365 OUT_BCS_BATCH(batch, 1); //Select L1
1366 OUT_BCS_BATCH(batch, bref_entry); //Only 1 reference
1367 for (i = 0; i < 7; i++) {
1368 OUT_BCS_BATCH(batch, 0x80808080);
1369 }
1370 ADVANCE_BCS_BATCH(batch);
1371 }
1372
1373
1374 void intel_vme_mpeg2_state_setup(VADriverContextP ctx,
1375 struct encode_state *encode_state,
1376 struct intel_encoder_context *encoder_context)
1377 {
1378 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1379 uint32_t *vme_state_message = (uint32_t *)(vme_context->vme_state_message);
1380 VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
1381 int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
1382 int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
1383 uint32_t mv_x, mv_y;
1384 VAEncSliceParameterBufferMPEG2 *slice_param = NULL;
1385 VAEncPictureParameterBufferMPEG2 *pic_param = NULL;
1386 slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[0]->buffer;
1387 pic_param = (VAEncPictureParameterBufferMPEG2 *)encode_state->pic_param_ext->buffer;
1388
1389 mv_x = 1 << (2 + pic_param->f_code[0][0]);
1390 mv_y = 1 << (2 + pic_param->f_code[0][1]);
1391
1392 if (pic_param->picture_type != VAEncPictureTypeIntra) {
1393 int qp, m_cost, j, mv_count;
1394 float lambda, m_costf;
1395 slice_param = (VAEncSliceParameterBufferMPEG2 *)
1396 encode_state->slice_params_ext[0]->buffer;
1397 qp = slice_param->quantiser_scale_code;
1398 lambda = intel_lambda_qp(qp);
1399 /* No Intra prediction. So it is zero */
1400 vme_state_message[MODE_INTRA_8X8] = 0;
1401 vme_state_message[MODE_INTRA_4X4] = 0;
1402 vme_state_message[MODE_INTER_MV0] = 0;
1403 for (j = 1; j < 3; j++) {
1404 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1405 m_cost = (int)m_costf;
1406 vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
1407 }
1408 mv_count = 3;
1409 for (j = 4; j <= 64; j *= 2) {
1410 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1411 m_cost = (int)m_costf;
1412 vme_state_message[MODE_INTER_MV0 + mv_count] =
1413 intel_format_lutvalue(m_cost, 0x6f);
1414 mv_count++;
1415 }
1416 m_cost = lambda;
1417 /* It can only perform the 16x16 search. So mode cost can be ignored for
1418 * the other mode. for example: 16x8/8x8
1419 */
1420 vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1421 vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1422
1423 vme_state_message[MODE_INTER_16X8] = 0;
1424 vme_state_message[MODE_INTER_8X8] = 0;
1425 vme_state_message[MODE_INTER_8X4] = 0;
1426 vme_state_message[MODE_INTER_4X4] = 0;
1427 vme_state_message[MODE_INTER_BWD] = intel_format_lutvalue(m_cost, 0x6f);
1428
1429 }
1430 vme_state_message[MPEG2_MV_RANGE] = (mv_y << 16) | (mv_x);
1431
1432 vme_state_message[MPEG2_PIC_WIDTH_HEIGHT] = (height_in_mbs << 16) |
1433 width_in_mbs;
1434 }
1435
1436 void
1437 gen7_vme_mpeg2_walker_fill_vme_batchbuffer(VADriverContextP ctx,
1438 struct encode_state *encode_state,
1439 int mb_width, int mb_height,
1440 int kernel,
1441 struct intel_encoder_context *encoder_context)
1442 {
1443 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1444 unsigned int *command_ptr;
1445
1446 #define MPEG2_SCOREBOARD (1 << 21)
1447
1448 dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
1449 command_ptr = vme_context->vme_batchbuffer.bo->virtual;
1450
1451 {
1452 unsigned int mb_intra_ub, score_dep;
1453 int x_outer, y_outer, x_inner, y_inner;
1454 int xtemp_outer = 0;
1455 int first_mb = 0;
1456 int num_mb = mb_width * mb_height;
1457
1458 x_outer = 0;
1459 y_outer = 0;
1460
1461
1462 for (; x_outer < (mb_width - 2) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1463 x_inner = x_outer;
1464 y_inner = y_outer;
1465 for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1466 mb_intra_ub = 0;
1467 score_dep = 0;
1468 if (x_inner != 0) {
1469 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1470 score_dep |= MB_SCOREBOARD_A;
1471 }
1472 if (y_inner != 0) {
1473 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1474 score_dep |= MB_SCOREBOARD_B;
1475
1476 if (x_inner != 0)
1477 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1478
1479 if (x_inner != (mb_width - 1)) {
1480 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1481 score_dep |= MB_SCOREBOARD_C;
1482 }
1483 }
1484
1485 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
1486 *command_ptr++ = kernel;
1487 *command_ptr++ = MPEG2_SCOREBOARD;
1488 /* Indirect data */
1489 *command_ptr++ = 0;
1490 /* the (X, Y) term of scoreboard */
1491 *command_ptr++ = ((y_inner << 16) | x_inner);
1492 *command_ptr++ = score_dep;
1493 /*inline data */
1494 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1495 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
1496 x_inner -= 2;
1497 y_inner += 1;
1498 }
1499 x_outer += 1;
1500 }
1501
1502 xtemp_outer = mb_width - 2;
1503 if (xtemp_outer < 0)
1504 xtemp_outer = 0;
1505 x_outer = xtemp_outer;
1506 y_outer = 0;
1507 for (; !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1508 y_inner = y_outer;
1509 x_inner = x_outer;
1510 for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1511 mb_intra_ub = 0;
1512 score_dep = 0;
1513 if (x_inner != 0) {
1514 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1515 score_dep |= MB_SCOREBOARD_A;
1516 }
1517 if (y_inner != 0) {
1518 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1519 score_dep |= MB_SCOREBOARD_B;
1520
1521 if (x_inner != 0)
1522 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1523
1524 if (x_inner != (mb_width - 1)) {
1525 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1526 score_dep |= MB_SCOREBOARD_C;
1527 }
1528 }
1529
1530 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
1531 *command_ptr++ = kernel;
1532 *command_ptr++ = MPEG2_SCOREBOARD;
1533 /* Indirect data */
1534 *command_ptr++ = 0;
1535 /* the (X, Y) term of scoreboard */
1536 *command_ptr++ = ((y_inner << 16) | x_inner);
1537 *command_ptr++ = score_dep;
1538 /*inline data */
1539 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1540 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
1541
1542 x_inner -= 2;
1543 y_inner += 1;
1544 }
1545 x_outer++;
1546 if (x_outer >= mb_width) {
1547 y_outer += 1;
1548 x_outer = xtemp_outer;
1549 }
1550 }
1551 }
1552
1553 *command_ptr++ = 0;
1554 *command_ptr++ = MI_BATCH_BUFFER_END;
1555
1556 dri_bo_unmap(vme_context->vme_batchbuffer.bo);
1557 return;
1558 }
1559
1560 static int
1561 avc_temporal_find_surface(VAPictureH264 *curr_pic,
1562 VAPictureH264 *ref_list,
1563 int num_pictures,
1564 int dir)
1565 {
1566 int i, found = -1, min = 0x7FFFFFFF;
1567
1568 for (i = 0; i < num_pictures; i++) {
1569 int tmp;
1570
1571 if ((ref_list[i].flags & VA_PICTURE_H264_INVALID) ||
1572 (ref_list[i].picture_id == VA_INVALID_SURFACE))
1573 break;
1574
1575 tmp = curr_pic->TopFieldOrderCnt - ref_list[i].TopFieldOrderCnt;
1576
1577 if (dir)
1578 tmp = -tmp;
1579
1580 if (tmp > 0 && tmp < min) {
1581 min = tmp;
1582 found = i;
1583 }
1584 }
1585
1586 return found;
1587 }
1588
1589 void
1590 intel_avc_vme_reference_state(VADriverContextP ctx,
1591 struct encode_state *encode_state,
1592 struct intel_encoder_context *encoder_context,
1593 int list_index,
1594 int surface_index,
1595 void (* vme_source_surface_state)(
1596 VADriverContextP ctx,
1597 int index,
1598 struct object_surface *obj_surface,
1599 struct intel_encoder_context *encoder_context))
1600 {
1601 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1602 struct object_surface *obj_surface = NULL;
1603 struct i965_driver_data *i965 = i965_driver_data(ctx);
1604 VASurfaceID ref_surface_id;
1605 VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1606 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1607 int max_num_references;
1608 VAPictureH264 *curr_pic;
1609 VAPictureH264 *ref_list;
1610 int ref_idx;
1611
1612 if (list_index == 0) {
1613 max_num_references = pic_param->num_ref_idx_l0_active_minus1 + 1;
1614 ref_list = slice_param->RefPicList0;
1615 } else {
1616 max_num_references = pic_param->num_ref_idx_l1_active_minus1 + 1;
1617 ref_list = slice_param->RefPicList1;
1618 }
1619
1620 if (max_num_references == 1) {
1621 if (list_index == 0) {
1622 ref_surface_id = slice_param->RefPicList0[0].picture_id;
1623 vme_context->used_references[0] = &slice_param->RefPicList0[0];
1624 } else {
1625 ref_surface_id = slice_param->RefPicList1[0].picture_id;
1626 vme_context->used_references[1] = &slice_param->RefPicList1[0];
1627 }
1628
1629 if (ref_surface_id != VA_INVALID_SURFACE)
1630 obj_surface = SURFACE(ref_surface_id);
1631
1632 if (!obj_surface ||
1633 !obj_surface->bo) {
1634 obj_surface = encode_state->reference_objects[list_index];
1635 vme_context->used_references[list_index] = &pic_param->ReferenceFrames[list_index];
1636 }
1637
1638 ref_idx = 0;
1639 } else {
1640 curr_pic = &pic_param->CurrPic;
1641
1642 /* select the reference frame in temporal space */
1643 ref_idx = avc_temporal_find_surface(curr_pic, ref_list, max_num_references, list_index == 1);
1644 ref_surface_id = ref_list[ref_idx].picture_id;
1645
1646 if (ref_surface_id != VA_INVALID_SURFACE) /* otherwise warning later */
1647 obj_surface = SURFACE(ref_surface_id);
1648
1649 vme_context->used_reference_objects[list_index] = obj_surface;
1650 vme_context->used_references[list_index] = &ref_list[ref_idx];
1651 }
1652
1653 if (obj_surface &&
1654 obj_surface->bo) {
1655 assert(ref_idx >= 0);
1656 vme_context->used_reference_objects[list_index] = obj_surface;
1657 vme_source_surface_state(ctx, surface_index, obj_surface, encoder_context);
1658 vme_context->ref_index_in_mb[list_index] = (ref_idx << 24 |
1659 ref_idx << 16 |
1660 ref_idx << 8 |
1661 ref_idx);
1662 } else {
1663 vme_context->used_reference_objects[list_index] = NULL;
1664 vme_context->used_references[list_index] = NULL;
1665 vme_context->ref_index_in_mb[list_index] = 0;
1666 }
1667 }
1668
1669 #define AVC_NAL_DELIMITER 9
1670 void
1671 intel_avc_insert_aud_packed_data(VADriverContextP ctx,
1672 struct encode_state *encode_state,
1673 struct intel_encoder_context *encoder_context,
1674 struct intel_batchbuffer *batch)
1675 {
1676 VAEncPackedHeaderParameterBuffer *param = NULL;
1677 unsigned int length_in_bits;
1678 unsigned int *header_data = NULL;
1679 unsigned char *nal_type = NULL;
1680 int count, i, start_index;
1681 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1682
1683 count = encode_state->slice_rawdata_count[0];
1684 start_index = (encode_state->slice_rawdata_index[0] & SLICE_PACKED_DATA_INDEX_MASK);
1685
1686 for (i = 0; i < count; i++) {
1687 unsigned int skip_emul_byte_cnt;
1688
1689 header_data = (unsigned int *)encode_state->packed_header_data_ext[start_index + i]->buffer;
1690 nal_type = (unsigned char *)header_data;
1691
1692 param = (VAEncPackedHeaderParameterBuffer *)(encode_state->packed_header_params_ext[start_index + i]->buffer);
1693
1694 length_in_bits = param->bit_length;
1695
1696 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
1697
1698 if ((*(nal_type + skip_emul_byte_cnt - 1) & 0x1f) == AVC_NAL_DELIMITER) {
1699 mfc_context->insert_object(ctx,
1700 encoder_context,
1701 header_data,
1702 ALIGN(length_in_bits, 32) >> 5,
1703 length_in_bits & 0x1f,
1704 skip_emul_byte_cnt,
1705 0,
1706 0,
1707 !param->has_emulation_bytes,
1708 batch);
1709 break;
1710 }
1711 }
1712 }
1713
1714
1715 void intel_avc_slice_insert_packed_data(VADriverContextP ctx,
1716 struct encode_state *encode_state,
1717 struct intel_encoder_context *encoder_context,
1718 int slice_index,
1719 struct intel_batchbuffer *slice_batch)
1720 {
1721 int count, i, start_index;
1722 unsigned int length_in_bits;
1723 VAEncPackedHeaderParameterBuffer *param = NULL;
1724 unsigned int *header_data = NULL;
1725 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1726 int slice_header_index;
1727 unsigned char *nal_type = NULL;
1728
1729 if (encode_state->slice_header_index[slice_index] == 0)
1730 slice_header_index = -1;
1731 else
1732 slice_header_index = (encode_state->slice_header_index[slice_index] & SLICE_PACKED_DATA_INDEX_MASK);
1733
1734 count = encode_state->slice_rawdata_count[slice_index];
1735 start_index = (encode_state->slice_rawdata_index[slice_index] & SLICE_PACKED_DATA_INDEX_MASK);
1736
1737 for (i = 0; i < count; i++) {
1738 unsigned int skip_emul_byte_cnt;
1739
1740 header_data = (unsigned int *)encode_state->packed_header_data_ext[start_index + i]->buffer;
1741 nal_type = (unsigned char *)header_data;
1742
1743 param = (VAEncPackedHeaderParameterBuffer *)
1744 (encode_state->packed_header_params_ext[start_index + i]->buffer);
1745
1746 length_in_bits = param->bit_length;
1747
1748 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
1749
1750 /* skip the slice header/AUD packed data type as it is lastly inserted */
1751 if (param->type == VAEncPackedHeaderSlice || (*(nal_type + skip_emul_byte_cnt - 1) & 0x1f) == AVC_NAL_DELIMITER)
1752 continue;
1753
1754 /* as the slice header is still required, the last header flag is set to
1755 * zero.
1756 */
1757 mfc_context->insert_object(ctx,
1758 encoder_context,
1759 header_data,
1760 ALIGN(length_in_bits, 32) >> 5,
1761 length_in_bits & 0x1f,
1762 skip_emul_byte_cnt,
1763 0,
1764 0,
1765 !param->has_emulation_bytes,
1766 slice_batch);
1767 }
1768
1769 if (slice_header_index == -1) {
1770 unsigned char *slice_header = NULL;
1771 int slice_header_length_in_bits = 0;
1772 VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
1773 VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1774 VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[slice_index]->buffer;
1775
1776 /* No slice header data is passed. And the driver needs to generate it */
1777 /* For the Normal H264 */
1778 slice_header_length_in_bits = build_avc_slice_header(pSequenceParameter,
1779 pPicParameter,
1780 pSliceParameter,
1781 &slice_header);
1782 mfc_context->insert_object(ctx, encoder_context,
1783 (unsigned int *)slice_header,
1784 ALIGN(slice_header_length_in_bits, 32) >> 5,
1785 slice_header_length_in_bits & 0x1f,
1786 5, /* first 5 bytes are start code + nal unit type */
1787 1, 0, 1, slice_batch);
1788
1789 free(slice_header);
1790 } else {
1791 unsigned int skip_emul_byte_cnt;
1792
1793 header_data = (unsigned int *)encode_state->packed_header_data_ext[slice_header_index]->buffer;
1794
1795 param = (VAEncPackedHeaderParameterBuffer *)
1796 (encode_state->packed_header_params_ext[slice_header_index]->buffer);
1797 length_in_bits = param->bit_length;
1798
1799 /* as the slice header is the last header data for one slice,
1800 * the last header flag is set to one.
1801 */
1802 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
1803
1804 mfc_context->insert_object(ctx,
1805 encoder_context,
1806 header_data,
1807 ALIGN(length_in_bits, 32) >> 5,
1808 length_in_bits & 0x1f,
1809 skip_emul_byte_cnt,
1810 1,
1811 0,
1812 !param->has_emulation_bytes,
1813 slice_batch);
1814 }
1815
1816 return;
1817 }
1818
1819 void
1820 intel_h264_initialize_mbmv_cost(VADriverContextP ctx,
1821 struct encode_state *encode_state,
1822 struct intel_encoder_context *encoder_context)
1823 {
1824 struct i965_driver_data *i965 = i965_driver_data(ctx);
1825 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1826 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1827 int qp;
1828 dri_bo *bo;
1829 uint8_t *cost_table;
1830
1831 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1832
1833
1834 if (slice_type == SLICE_TYPE_I) {
1835 if (vme_context->i_qp_cost_table)
1836 return;
1837 } else if (slice_type == SLICE_TYPE_P) {
1838 if (vme_context->p_qp_cost_table)
1839 return;
1840 } else {
1841 if (vme_context->b_qp_cost_table)
1842 return;
1843 }
1844
1845 /* It is enough to allocate 32 bytes for each qp. */
1846 bo = dri_bo_alloc(i965->intel.bufmgr,
1847 "cost_table ",
1848 QP_MAX * 32,
1849 64);
1850
1851 dri_bo_map(bo, 1);
1852 assert(bo->virtual);
1853 cost_table = (uint8_t *)(bo->virtual);
1854 for (qp = 0; qp < QP_MAX; qp++) {
1855 intel_h264_calc_mbmvcost_qp(qp, slice_type, cost_table);
1856 cost_table += 32;
1857 }
1858
1859 dri_bo_unmap(bo);
1860
1861 if (slice_type == SLICE_TYPE_I) {
1862 vme_context->i_qp_cost_table = bo;
1863 } else if (slice_type == SLICE_TYPE_P) {
1864 vme_context->p_qp_cost_table = bo;
1865 } else {
1866 vme_context->b_qp_cost_table = bo;
1867 }
1868
1869 vme_context->cost_table_size = QP_MAX * 32;
1870 return;
1871 }
1872
1873 extern void
1874 intel_h264_setup_cost_surface(VADriverContextP ctx,
1875 struct encode_state *encode_state,
1876 struct intel_encoder_context *encoder_context,
1877 unsigned long binding_table_offset,
1878 unsigned long surface_state_offset)
1879 {
1880 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1881 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1882 dri_bo *bo;
1883
1884
1885 struct i965_buffer_surface cost_table;
1886
1887 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1888
1889
1890 if (slice_type == SLICE_TYPE_I) {
1891 bo = vme_context->i_qp_cost_table;
1892 } else if (slice_type == SLICE_TYPE_P) {
1893 bo = vme_context->p_qp_cost_table;
1894 } else {
1895 bo = vme_context->b_qp_cost_table;
1896 }
1897
1898 cost_table.bo = bo;
1899 cost_table.num_blocks = QP_MAX;
1900 cost_table.pitch = 16;
1901 cost_table.size_block = 32;
1902
1903 vme_context->vme_buffer_suface_setup(ctx,
1904 &vme_context->gpe_context,
1905 &cost_table,
1906 binding_table_offset,
1907 surface_state_offset);
1908 }
1909
1910 /*
1911 * the idea of conversion between qp and qstep comes from scaling process
1912 * of transform coeff for Luma component in H264 spec.
1913 * 2^(Qpy / 6 - 6)
1914 * In order to avoid too small qstep, it is multiplied by 16.
1915 */
1916 static float intel_h264_qp_qstep(int qp)
1917 {
1918 float value, qstep;
1919 value = qp;
1920 value = value / 6 - 2;
1921 qstep = powf(2, value);
1922 return qstep;
1923 }
1924
1925 static int intel_h264_qstep_qp(float qstep)
1926 {
1927 float qp;
1928
1929 qp = 12.0f + 6.0f * log2f(qstep);
1930
1931 return floorf(qp);
1932 }
1933
1934 /*
1935 * Currently it is based on the following assumption:
1936 * SUM(roi_area * 1 / roi_qstep) + non_area * 1 / nonroi_qstep =
1937 * total_aread * 1 / baseqp_qstep
1938 *
1939 * qstep is the linearized quantizer of H264 quantizer
1940 */
1941 typedef struct {
1942 int row_start_in_mb;
1943 int row_end_in_mb;
1944 int col_start_in_mb;
1945 int col_end_in_mb;
1946
1947 int width_mbs;
1948 int height_mbs;
1949
1950 int roi_qp;
1951 } ROIRegionParam;
1952
1953 static VAStatus
1954 intel_h264_enc_roi_cbr(VADriverContextP ctx,
1955 int base_qp,
1956 struct encode_state *encode_state,
1957 struct intel_encoder_context *encoder_context)
1958 {
1959 int nonroi_qp;
1960 int min_qp = MAX(1, encoder_context->brc.min_qp);
1961 bool quickfill = 0;
1962
1963 ROIRegionParam param_regions[I965_MAX_NUM_ROI_REGIONS];
1964 int num_roi = 0;
1965 int i, j;
1966
1967 float temp;
1968 float qstep_nonroi, qstep_base;
1969 float roi_area, total_area, nonroi_area;
1970 float sum_roi;
1971
1972 VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
1973 int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
1974 int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
1975 int mbs_in_picture = width_in_mbs * height_in_mbs;
1976
1977 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1978 VAStatus vaStatus = VA_STATUS_SUCCESS;
1979
1980 /* currently roi_value_is_qp_delta is the only supported mode of priority.
1981 *
1982 * qp_delta set by user is added to base_qp, which is then clapped by
1983 * [base_qp-min_delta, base_qp+max_delta].
1984 */
1985 ASSERT_RET(encoder_context->brc.roi_value_is_qp_delta, VA_STATUS_ERROR_INVALID_PARAMETER);
1986
1987 num_roi = encoder_context->brc.num_roi;
1988
1989 /* when the base_qp is lower than 12, the quality is quite good based
1990 * on the H264 test experience.
1991 * In such case it is unnecessary to adjust the quality for ROI region.
1992 */
1993 if (base_qp <= 12) {
1994 nonroi_qp = base_qp;
1995 quickfill = 1;
1996 goto qp_fill;
1997 }
1998
1999 sum_roi = 0.0f;
2000 roi_area = 0;
2001 for (i = 0; i < num_roi; i++) {
2002 int row_start, row_end, col_start, col_end;
2003 int roi_width_mbs, roi_height_mbs;
2004 int mbs_in_roi;
2005 int roi_qp;
2006 float qstep_roi;
2007
2008 col_start = encoder_context->brc.roi[i].left;
2009 col_end = encoder_context->brc.roi[i].right;
2010 row_start = encoder_context->brc.roi[i].top;
2011 row_end = encoder_context->brc.roi[i].bottom;
2012
2013 col_start = col_start / 16;
2014 col_end = (col_end + 15) / 16;
2015 row_start = row_start / 16;
2016 row_end = (row_end + 15) / 16;
2017
2018 roi_width_mbs = col_end - col_start;
2019 roi_height_mbs = row_end - row_start;
2020 mbs_in_roi = roi_width_mbs * roi_height_mbs;
2021
2022 param_regions[i].row_start_in_mb = row_start;
2023 param_regions[i].row_end_in_mb = row_end;
2024 param_regions[i].col_start_in_mb = col_start;
2025 param_regions[i].col_end_in_mb = col_end;
2026 param_regions[i].width_mbs = roi_width_mbs;
2027 param_regions[i].height_mbs = roi_height_mbs;
2028
2029 roi_qp = base_qp + encoder_context->brc.roi[i].value;
2030 BRC_CLIP(roi_qp, min_qp, 51);
2031
2032 param_regions[i].roi_qp = roi_qp;
2033 qstep_roi = intel_h264_qp_qstep(roi_qp);
2034
2035 roi_area += mbs_in_roi;
2036 sum_roi += mbs_in_roi / qstep_roi;
2037 }
2038
2039 total_area = mbs_in_picture;
2040 nonroi_area = total_area - roi_area;
2041
2042 qstep_base = intel_h264_qp_qstep(base_qp);
2043 temp = (total_area / qstep_base - sum_roi);
2044
2045 if (temp < 0) {
2046 nonroi_qp = 51;
2047 } else {
2048 qstep_nonroi = nonroi_area / temp;
2049 nonroi_qp = intel_h264_qstep_qp(qstep_nonroi);
2050 }
2051
2052 BRC_CLIP(nonroi_qp, min_qp, 51);
2053
2054 qp_fill:
2055 memset(vme_context->qp_per_mb, nonroi_qp, mbs_in_picture);
2056 if (!quickfill) {
2057 char *qp_ptr;
2058
2059 for (i = 0; i < num_roi; i++) {
2060 for (j = param_regions[i].row_start_in_mb; j < param_regions[i].row_end_in_mb; j++) {
2061 qp_ptr = vme_context->qp_per_mb + (j * width_in_mbs) + param_regions[i].col_start_in_mb;
2062 memset(qp_ptr, param_regions[i].roi_qp, param_regions[i].width_mbs);
2063 }
2064 }
2065 }
2066 return vaStatus;
2067 }
2068
2069 extern void
2070 intel_h264_enc_roi_config(VADriverContextP ctx,
2071 struct encode_state *encode_state,
2072 struct intel_encoder_context *encoder_context)
2073 {
2074 char *qp_ptr;
2075 int i, j;
2076 struct i965_driver_data *i965 = i965_driver_data(ctx);
2077 struct gen6_vme_context *vme_context = encoder_context->vme_context;
2078 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
2079 VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
2080 int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
2081 int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
2082
2083 int row_start, row_end, col_start, col_end;
2084 int num_roi = 0;
2085
2086 vme_context->roi_enabled = 0;
2087 /* Restriction: Disable ROI when multi-slice is enabled */
2088 if (encode_state->num_slice_params_ext > 1)
2089 return;
2090
2091 vme_context->roi_enabled = !!encoder_context->brc.num_roi;
2092
2093 if (!vme_context->roi_enabled)
2094 return;
2095
2096 num_roi = encoder_context->brc.num_roi;
2097
2098 if ((vme_context->saved_width_mbs != width_in_mbs) ||
2099 (vme_context->saved_height_mbs != height_in_mbs)) {
2100 free(vme_context->qp_per_mb);
2101 vme_context->qp_per_mb = calloc(1, width_in_mbs * height_in_mbs);
2102
2103 vme_context->saved_width_mbs = width_in_mbs;
2104 vme_context->saved_height_mbs = height_in_mbs;
2105 assert(vme_context->qp_per_mb);
2106 }
2107 if (encoder_context->rate_control_mode == VA_RC_CBR) {
2108 /*
2109 * TODO: More complex Qp adjust needs to be added.
2110 * Currently it is initialized to slice_qp.
2111 */
2112 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
2113 int qp;
2114 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
2115
2116 qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
2117 intel_h264_enc_roi_cbr(ctx, qp, encode_state, encoder_context);
2118
2119 } else if (encoder_context->rate_control_mode == VA_RC_CQP) {
2120 VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
2121 VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
2122 int qp;
2123 int min_qp = MAX(1, encoder_context->brc.min_qp);
2124
2125 qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
2126 memset(vme_context->qp_per_mb, qp, width_in_mbs * height_in_mbs);
2127
2128
2129 for (j = num_roi - 1; j >= 0; j--) {
2130 int qp_delta, qp_clip;
2131
2132 col_start = encoder_context->brc.roi[j].left;
2133 col_end = encoder_context->brc.roi[j].right;
2134 row_start = encoder_context->brc.roi[j].top;
2135 row_end = encoder_context->brc.roi[j].bottom;
2136
2137 col_start = col_start / 16;
2138 col_end = (col_end + 15) / 16;
2139 row_start = row_start / 16;
2140 row_end = (row_end + 15) / 16;
2141
2142 qp_delta = encoder_context->brc.roi[j].value;
2143 qp_clip = qp + qp_delta;
2144
2145 BRC_CLIP(qp_clip, min_qp, 51);
2146
2147 for (i = row_start; i < row_end; i++) {
2148 qp_ptr = vme_context->qp_per_mb + (i * width_in_mbs) + col_start;
2149 memset(qp_ptr, qp_clip, (col_end - col_start));
2150 }
2151 }
2152 } else {
2153 /*
2154 * TODO: Disable it for non CBR-CQP.
2155 */
2156 vme_context->roi_enabled = 0;
2157 }
2158
2159 if (vme_context->roi_enabled && IS_GEN7(i965->intel.device_info))
2160 encoder_context->soft_batch_force = 1;
2161
2162 return;
2163 }
2164
2165 /* HEVC */
2166 static int
2167 hevc_temporal_find_surface(VAPictureHEVC *curr_pic,
2168 VAPictureHEVC *ref_list,
2169 int num_pictures,
2170 int dir)
2171 {
2172 int i, found = -1, min = 0x7FFFFFFF;
2173
2174 for (i = 0; i < num_pictures; i++) {
2175 int tmp;
2176
2177 if ((ref_list[i].flags & VA_PICTURE_HEVC_INVALID) ||
2178 (ref_list[i].picture_id == VA_INVALID_SURFACE))
2179 break;
2180
2181 tmp = curr_pic->pic_order_cnt - ref_list[i].pic_order_cnt;
2182
2183 if (dir)
2184 tmp = -tmp;
2185
2186 if (tmp > 0 && tmp < min) {
2187 min = tmp;
2188 found = i;
2189 }
2190 }
2191
2192 return found;
2193 }
2194 void
2195 intel_hevc_vme_reference_state(VADriverContextP ctx,
2196 struct encode_state *encode_state,
2197 struct intel_encoder_context *encoder_context,
2198 int list_index,
2199 int surface_index,
2200 void (* vme_source_surface_state)(
2201 VADriverContextP ctx,
2202 int index,
2203 struct object_surface *obj_surface,
2204 struct intel_encoder_context *encoder_context))
2205 {
2206 struct gen6_vme_context *vme_context = encoder_context->vme_context;
2207 struct object_surface *obj_surface = NULL;
2208 struct i965_driver_data *i965 = i965_driver_data(ctx);
2209 VASurfaceID ref_surface_id;
2210 VAEncSequenceParameterBufferHEVC *pSequenceParameter = (VAEncSequenceParameterBufferHEVC *)encode_state->seq_param_ext->buffer;
2211 VAEncPictureParameterBufferHEVC *pic_param = (VAEncPictureParameterBufferHEVC *)encode_state->pic_param_ext->buffer;
2212 VAEncSliceParameterBufferHEVC *slice_param = (VAEncSliceParameterBufferHEVC *)encode_state->slice_params_ext[0]->buffer;
2213 int max_num_references;
2214 VAPictureHEVC *curr_pic;
2215 VAPictureHEVC *ref_list;
2216 int ref_idx;
2217 unsigned int is_hevc10 = 0;
2218 GenHevcSurface *hevc_encoder_surface = NULL;
2219
2220 if ((pSequenceParameter->seq_fields.bits.bit_depth_luma_minus8 > 0)
2221 || (pSequenceParameter->seq_fields.bits.bit_depth_chroma_minus8 > 0))
2222 is_hevc10 = 1;
2223
2224 if (list_index == 0) {
2225 max_num_references = pic_param->num_ref_idx_l0_default_active_minus1 + 1;
2226 ref_list = slice_param->ref_pic_list0;
2227 } else {
2228 max_num_references = pic_param->num_ref_idx_l1_default_active_minus1 + 1;
2229 ref_list = slice_param->ref_pic_list1;
2230 }
2231
2232 if (max_num_references == 1) {
2233 if (list_index == 0) {
2234 ref_surface_id = slice_param->ref_pic_list0[0].picture_id;
2235 vme_context->used_references[0] = &slice_param->ref_pic_list0[0];
2236 } else {
2237 ref_surface_id = slice_param->ref_pic_list1[0].picture_id;
2238 vme_context->used_references[1] = &slice_param->ref_pic_list1[0];
2239 }
2240
2241 if (ref_surface_id != VA_INVALID_SURFACE)
2242 obj_surface = SURFACE(ref_surface_id);
2243
2244 if (!obj_surface ||
2245 !obj_surface->bo) {
2246 obj_surface = encode_state->reference_objects[list_index];
2247 vme_context->used_references[list_index] = &pic_param->reference_frames[list_index];
2248 }
2249
2250 ref_idx = 0;
2251 } else {
2252 curr_pic = &pic_param->decoded_curr_pic;
2253
2254 /* select the reference frame in temporal space */
2255 ref_idx = hevc_temporal_find_surface(curr_pic, ref_list, max_num_references, list_index == 1);
2256 ref_surface_id = ref_list[ref_idx].picture_id;
2257
2258 if (ref_surface_id != VA_INVALID_SURFACE) /* otherwise warning later */
2259 obj_surface = SURFACE(ref_surface_id);
2260
2261 vme_context->used_reference_objects[list_index] = obj_surface;
2262 vme_context->used_references[list_index] = &ref_list[ref_idx];
2263 }
2264
2265 if (obj_surface &&
2266 obj_surface->bo) {
2267 assert(ref_idx >= 0);
2268 vme_context->used_reference_objects[list_index] = obj_surface;
2269
2270 if (is_hevc10) {
2271 hevc_encoder_surface = (GenHevcSurface *) obj_surface->private_data;
2272 assert(hevc_encoder_surface);
2273 obj_surface = hevc_encoder_surface->nv12_surface_obj;
2274 }
2275 vme_source_surface_state(ctx, surface_index, obj_surface, encoder_context);
2276 vme_context->ref_index_in_mb[list_index] = (ref_idx << 24 |
2277 ref_idx << 16 |
2278 ref_idx << 8 |
2279 ref_idx);
2280 } else {
2281 vme_context->used_reference_objects[list_index] = NULL;
2282 vme_context->used_references[list_index] = NULL;
2283 vme_context->ref_index_in_mb[list_index] = 0;
2284 }
2285 }
2286
2287 void intel_vme_hevc_update_mbmv_cost(VADriverContextP ctx,
2288 struct encode_state *encode_state,
2289 struct intel_encoder_context *encoder_context)
2290 {
2291 struct gen9_hcpe_context *mfc_context = encoder_context->mfc_context;
2292 struct gen6_vme_context *vme_context = encoder_context->vme_context;
2293 VAEncPictureParameterBufferHEVC *pic_param = (VAEncPictureParameterBufferHEVC *)encode_state->pic_param_ext->buffer;
2294 VAEncSliceParameterBufferHEVC *slice_param = (VAEncSliceParameterBufferHEVC *)encode_state->slice_params_ext[0]->buffer;
2295 VAEncSequenceParameterBufferHEVC *pSequenceParameter = (VAEncSequenceParameterBufferHEVC *)encode_state->seq_param_ext->buffer;
2296 int qp, m_cost, j, mv_count;
2297 uint8_t *vme_state_message = (uint8_t *)(vme_context->vme_state_message);
2298 float lambda, m_costf;
2299
2300 /* here no SI SP slice for HEVC, do not need slice fixup */
2301 int slice_type = slice_param->slice_type;
2302
2303
2304 qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
2305
2306 if (encoder_context->rate_control_mode == VA_RC_CBR) {
2307 qp = mfc_context->bit_rate_control_context[slice_type].QpPrimeY;
2308 if (slice_type == HEVC_SLICE_B) {
2309 if (pSequenceParameter->ip_period == 1) {
2310 slice_type = HEVC_SLICE_P;
2311 qp = mfc_context->bit_rate_control_context[HEVC_SLICE_P].QpPrimeY;
2312
2313 } else if (mfc_context->vui_hrd.i_frame_number % pSequenceParameter->ip_period == 1) {
2314 slice_type = HEVC_SLICE_P;
2315 qp = mfc_context->bit_rate_control_context[HEVC_SLICE_P].QpPrimeY;
2316 }
2317 }
2318
2319 }
2320
2321 if (vme_state_message == NULL)
2322 return;
2323
2324 assert(qp <= QP_MAX);
2325 lambda = intel_lambda_qp(qp);
2326 if (slice_type == HEVC_SLICE_I) {
2327 vme_state_message[MODE_INTRA_16X16] = 0;
2328 m_cost = lambda * 4;
2329 vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
2330 m_cost = lambda * 16;
2331 vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
2332 m_cost = lambda * 3;
2333 vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
2334 } else {
2335 m_cost = 0;
2336 vme_state_message[MODE_INTER_MV0] = intel_format_lutvalue(m_cost, 0x6f);
2337 for (j = 1; j < 3; j++) {
2338 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
2339 m_cost = (int)m_costf;
2340 vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
2341 }
2342 mv_count = 3;
2343 for (j = 4; j <= 64; j *= 2) {
2344 m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
2345 m_cost = (int)m_costf;
2346 vme_state_message[MODE_INTER_MV0 + mv_count] = intel_format_lutvalue(m_cost, 0x6f);
2347 mv_count++;
2348 }
2349
2350 if (qp <= 25) {
2351 vme_state_message[MODE_INTRA_16X16] = 0x4a;
2352 vme_state_message[MODE_INTRA_8X8] = 0x4a;
2353 vme_state_message[MODE_INTRA_4X4] = 0x4a;
2354 vme_state_message[MODE_INTRA_NONPRED] = 0x4a;
2355 vme_state_message[MODE_INTER_16X16] = 0x4a;
2356 vme_state_message[MODE_INTER_16X8] = 0x4a;
2357 vme_state_message[MODE_INTER_8X8] = 0x4a;
2358 vme_state_message[MODE_INTER_8X4] = 0x4a;
2359 vme_state_message[MODE_INTER_4X4] = 0x4a;
2360 vme_state_message[MODE_INTER_BWD] = 0x2a;
2361 return;
2362 }
2363 m_costf = lambda * 10;
2364 vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
2365 m_cost = lambda * 14;
2366 vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
2367 m_cost = lambda * 24;
2368 vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
2369 m_costf = lambda * 3.5;
2370 m_cost = m_costf;
2371 vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
2372 if (slice_type == HEVC_SLICE_P) {
2373 m_costf = lambda * 2.5;
2374 m_cost = m_costf;
2375 vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
2376 m_costf = lambda * 4;
2377 m_cost = m_costf;
2378 vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
2379 m_costf = lambda * 1.5;
2380 m_cost = m_costf;
2381 vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
2382 m_costf = lambda * 3;
2383 m_cost = m_costf;
2384 vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
2385 m_costf = lambda * 5;
2386 m_cost = m_costf;
2387 vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
2388 /* BWD is not used in P-frame */
2389 vme_state_message[MODE_INTER_BWD] = 0;
2390 } else {
2391 m_costf = lambda * 2.5;
2392 m_cost = m_costf;
2393 vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
2394 m_costf = lambda * 5.5;
2395 m_cost = m_costf;
2396 vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
2397 m_costf = lambda * 3.5;
2398 m_cost = m_costf;
2399 vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
2400 m_costf = lambda * 5.0;
2401 m_cost = m_costf;
2402 vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
2403 m_costf = lambda * 6.5;
2404 m_cost = m_costf;
2405 vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
2406 m_costf = lambda * 1.5;
2407 m_cost = m_costf;
2408 vme_state_message[MODE_INTER_BWD] = intel_format_lutvalue(m_cost, 0x6f);
2409 }
2410 }
2411 }