]>
Commit | Line | Data |
---|---|---|
ba4616b7 JCT |
1 | /* |
2 | * Copyright (C) STMicroelectronics SA 2015 | |
3 | * Authors: Yannick Fertre <yannick.fertre@st.com> | |
4 | * Hugues Fruchet <hugues.fruchet@st.com> | |
5 | * License terms: GNU General Public License (GPL), version 2 | |
6 | */ | |
7 | ||
8 | #include "hva.h" | |
9 | #include "hva-hw.h" | |
10 | ||
11 | #define MAX_SPS_PPS_SIZE 128 | |
12 | ||
13 | #define BITSTREAM_OFFSET_MASK 0x7F | |
14 | ||
15 | /* video max size*/ | |
16 | #define H264_MAX_SIZE_W 1920 | |
17 | #define H264_MAX_SIZE_H 1920 | |
18 | ||
19 | /* macroBlocs number (width & height) */ | |
20 | #define MB_W(w) ((w + 0xF) / 0x10) | |
21 | #define MB_H(h) ((h + 0xF) / 0x10) | |
22 | ||
23 | /* formula to get temporal or spatial data size */ | |
24 | #define DATA_SIZE(w, h) (MB_W(w) * MB_H(h) * 16) | |
25 | ||
26 | #define SEARCH_WINDOW_BUFFER_MAX_SIZE(w) ((4 * MB_W(w) + 42) * 256 * 3 / 2) | |
27 | #define CABAC_CONTEXT_BUFFER_MAX_SIZE(w) (MB_W(w) * 16) | |
28 | #define CTX_MB_BUFFER_MAX_SIZE(w) (MB_W(w) * 16 * 8) | |
29 | #define SLICE_HEADER_SIZE (4 * 16) | |
30 | #define BRC_DATA_SIZE (5 * 16) | |
31 | ||
32 | /* source buffer copy in YUV 420 MB-tiled format with size=16*256*3/2 */ | |
33 | #define CURRENT_WINDOW_BUFFER_MAX_SIZE (16 * 256 * 3 / 2) | |
34 | ||
35 | /* | |
36 | * 4 lines of pixels (in Luma, Chroma blue and Chroma red) of top MB | |
37 | * for deblocking with size=4*16*MBx*2 | |
38 | */ | |
39 | #define LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(w) (4 * 16 * MB_W(w) * 2) | |
40 | ||
41 | /* factor for bitrate and cpb buffer size max values if profile >= high */ | |
42 | #define H264_FACTOR_HIGH 1200 | |
43 | ||
44 | /* factor for bitrate and cpb buffer size max values if profile < high */ | |
45 | #define H264_FACTOR_BASELINE 1000 | |
46 | ||
47 | /* number of bytes for NALU_TYPE_FILLER_DATA header and footer */ | |
48 | #define H264_FILLER_DATA_SIZE 6 | |
49 | ||
50 | struct h264_profile { | |
51 | enum v4l2_mpeg_video_h264_level level; | |
52 | u32 max_mb_per_seconds; | |
53 | u32 max_frame_size; | |
54 | u32 max_bitrate; | |
55 | u32 max_cpb_size; | |
56 | u32 min_comp_ratio; | |
57 | }; | |
58 | ||
59 | static const struct h264_profile h264_infos_list[] = { | |
60 | {V4L2_MPEG_VIDEO_H264_LEVEL_1_0, 1485, 99, 64, 175, 2}, | |
61 | {V4L2_MPEG_VIDEO_H264_LEVEL_1B, 1485, 99, 128, 350, 2}, | |
62 | {V4L2_MPEG_VIDEO_H264_LEVEL_1_1, 3000, 396, 192, 500, 2}, | |
63 | {V4L2_MPEG_VIDEO_H264_LEVEL_1_2, 6000, 396, 384, 1000, 2}, | |
64 | {V4L2_MPEG_VIDEO_H264_LEVEL_1_3, 11880, 396, 768, 2000, 2}, | |
65 | {V4L2_MPEG_VIDEO_H264_LEVEL_2_0, 11880, 396, 2000, 2000, 2}, | |
66 | {V4L2_MPEG_VIDEO_H264_LEVEL_2_1, 19800, 792, 4000, 4000, 2}, | |
67 | {V4L2_MPEG_VIDEO_H264_LEVEL_2_2, 20250, 1620, 4000, 4000, 2}, | |
68 | {V4L2_MPEG_VIDEO_H264_LEVEL_3_0, 40500, 1620, 10000, 10000, 2}, | |
69 | {V4L2_MPEG_VIDEO_H264_LEVEL_3_1, 108000, 3600, 14000, 14000, 4}, | |
70 | {V4L2_MPEG_VIDEO_H264_LEVEL_3_2, 216000, 5120, 20000, 20000, 4}, | |
71 | {V4L2_MPEG_VIDEO_H264_LEVEL_4_0, 245760, 8192, 20000, 25000, 4}, | |
72 | {V4L2_MPEG_VIDEO_H264_LEVEL_4_1, 245760, 8192, 50000, 62500, 2}, | |
73 | {V4L2_MPEG_VIDEO_H264_LEVEL_4_2, 522240, 8704, 50000, 62500, 2}, | |
74 | {V4L2_MPEG_VIDEO_H264_LEVEL_5_0, 589824, 22080, 135000, 135000, 2}, | |
75 | {V4L2_MPEG_VIDEO_H264_LEVEL_5_1, 983040, 36864, 240000, 240000, 2} | |
76 | }; | |
77 | ||
78 | enum hva_brc_type { | |
79 | BRC_TYPE_NONE = 0, | |
80 | BRC_TYPE_CBR = 1, | |
81 | BRC_TYPE_VBR = 2, | |
82 | BRC_TYPE_VBR_LOW_DELAY = 3 | |
83 | }; | |
84 | ||
85 | enum hva_entropy_coding_mode { | |
86 | CAVLC = 0, | |
87 | CABAC = 1 | |
88 | }; | |
89 | ||
90 | enum hva_picture_coding_type { | |
91 | PICTURE_CODING_TYPE_I = 0, | |
92 | PICTURE_CODING_TYPE_P = 1, | |
93 | PICTURE_CODING_TYPE_B = 2 | |
94 | }; | |
95 | ||
96 | enum hva_h264_sampling_mode { | |
97 | SAMPLING_MODE_NV12 = 0, | |
98 | SAMPLING_MODE_UYVY = 1, | |
99 | SAMPLING_MODE_RGB3 = 3, | |
100 | SAMPLING_MODE_XRGB4 = 4, | |
101 | SAMPLING_MODE_NV21 = 8, | |
102 | SAMPLING_MODE_VYUY = 9, | |
103 | SAMPLING_MODE_BGR3 = 11, | |
104 | SAMPLING_MODE_XBGR4 = 12, | |
105 | SAMPLING_MODE_RGBX4 = 20, | |
106 | SAMPLING_MODE_BGRX4 = 28 | |
107 | }; | |
108 | ||
109 | enum hva_h264_nalu_type { | |
110 | NALU_TYPE_UNKNOWN = 0, | |
111 | NALU_TYPE_SLICE = 1, | |
112 | NALU_TYPE_SLICE_DPA = 2, | |
113 | NALU_TYPE_SLICE_DPB = 3, | |
114 | NALU_TYPE_SLICE_DPC = 4, | |
115 | NALU_TYPE_SLICE_IDR = 5, | |
116 | NALU_TYPE_SEI = 6, | |
117 | NALU_TYPE_SPS = 7, | |
118 | NALU_TYPE_PPS = 8, | |
119 | NALU_TYPE_AU_DELIMITER = 9, | |
120 | NALU_TYPE_SEQ_END = 10, | |
121 | NALU_TYPE_STREAM_END = 11, | |
122 | NALU_TYPE_FILLER_DATA = 12, | |
123 | NALU_TYPE_SPS_EXT = 13, | |
124 | NALU_TYPE_PREFIX_UNIT = 14, | |
125 | NALU_TYPE_SUBSET_SPS = 15, | |
126 | NALU_TYPE_SLICE_AUX = 19, | |
127 | NALU_TYPE_SLICE_EXT = 20 | |
128 | }; | |
129 | ||
130 | enum hva_h264_sei_payload_type { | |
131 | SEI_BUFFERING_PERIOD = 0, | |
132 | SEI_PICTURE_TIMING = 1, | |
133 | SEI_STEREO_VIDEO_INFO = 21, | |
134 | SEI_FRAME_PACKING_ARRANGEMENT = 45 | |
135 | }; | |
136 | ||
137 | /** | |
138 | * stereo Video Info struct | |
139 | */ | |
140 | struct hva_h264_stereo_video_sei { | |
141 | u8 field_views_flag; | |
142 | u8 top_field_is_left_view_flag; | |
143 | u8 current_frame_is_left_view_flag; | |
144 | u8 next_frame_is_second_view_flag; | |
145 | u8 left_view_self_contained_flag; | |
146 | u8 right_view_self_contained_flag; | |
147 | }; | |
148 | ||
149 | /** | |
150 | * @frame_width: width in pixels of the buffer containing the input frame | |
151 | * @frame_height: height in pixels of the buffer containing the input frame | |
152 | * @frame_num: the parameter to be written in the slice header | |
153 | * @picture_coding_type: type I, P or B | |
154 | * @pic_order_cnt_type: POC mode, as defined in H264 std : can be 0,1,2 | |
155 | * @first_picture_in_sequence: flag telling to encoder that this is the | |
156 | * first picture in a video sequence. | |
157 | * Used for VBR | |
158 | * @slice_size_type: 0 = no constraint to close the slice | |
159 | * 1= a slice is closed as soon as the slice_mb_size limit | |
160 | * is reached | |
161 | * 2= a slice is closed as soon as the slice_byte_size limit | |
162 | * is reached | |
163 | * 3= a slice is closed as soon as either the slice_byte_size | |
164 | * limit or the slice_mb_size limit is reached | |
165 | * @slice_mb_size: defines the slice size in number of macroblocks | |
166 | * (used when slice_size_type=1 or slice_size_type=3) | |
167 | * @ir_param_option: defines the number of macroblocks per frame to be | |
168 | * refreshed by AIR algorithm OR the refresh period | |
169 | * by CIR algorithm | |
170 | * @intra_refresh_type: enables the adaptive intra refresh algorithm. | |
171 | * Disable=0 / Adaptative=1 and Cycle=2 as intra refresh | |
172 | * @use_constrained_intra_flag: constrained_intra_pred_flag from PPS | |
173 | * @transform_mode: controls the use of 4x4/8x8 transform mode | |
174 | * @disable_deblocking_filter_idc: | |
175 | * 0: specifies that all luma and chroma block edges of | |
176 | * the slice are filtered. | |
177 | * 1: specifies that deblocking is disabled for all block | |
178 | * edges of the slice. | |
179 | * 2: specifies that all luma and chroma block edges of | |
180 | * the slice are filtered with exception of the block edges | |
181 | * that coincide with slice boundaries | |
182 | * @slice_alpha_c0_offset_div2: to be written in slice header, | |
183 | * controls deblocking | |
184 | * @slice_beta_offset_div2: to be written in slice header, | |
185 | * controls deblocking | |
186 | * @encoder_complexity: encoder complexity control (IME). | |
187 | * 0 = I_16x16, P_16x16, Full ME Complexity | |
188 | * 1 = I_16x16, I_NxN, P_16x16, Full ME Complexity | |
189 | * 2 = I_16x16, I_NXN, P_16x16, P_WxH, Full ME Complexity | |
190 | * 4 = I_16x16, P_16x16, Reduced ME Complexity | |
191 | * 5 = I_16x16, I_NxN, P_16x16, Reduced ME Complexity | |
192 | * 6 = I_16x16, I_NXN, P_16x16, P_WxH, Reduced ME Complexity | |
193 | * @chroma_qp_index_offset: coming from picture parameter set | |
194 | * (PPS see [H.264 STD] 7.4.2.2) | |
195 | * @entropy_coding_mode: entropy coding mode. | |
196 | * 0 = CAVLC | |
197 | * 1 = CABAC | |
198 | * @brc_type: selects the bit-rate control algorithm | |
199 | * 0 = constant Qp, (no BRC) | |
200 | * 1 = CBR | |
201 | * 2 = VBR | |
202 | * @quant: Quantization param used in case of fix QP encoding (no BRC) | |
203 | * @non_VCL_NALU_Size: size of non-VCL NALUs (SPS, PPS, filler), | |
204 | * used by BRC | |
205 | * @cpb_buffer_size: size of Coded Picture Buffer, used by BRC | |
206 | * @bit_rate: target bitrate, for BRC | |
207 | * @qp_min: min QP threshold | |
208 | * @qp_max: max QP threshold | |
209 | * @framerate_num: target framerate numerator , used by BRC | |
210 | * @framerate_den: target framerate denomurator , used by BRC | |
211 | * @delay: End-to-End Initial Delay | |
212 | * @strict_HRD_compliancy: flag for HDR compliancy (1) | |
213 | * May impact quality encoding | |
214 | * @addr_source_buffer: address of input frame buffer for current frame | |
215 | * @addr_fwd_Ref_Buffer: address of reference frame buffer | |
216 | * @addr_rec_buffer: address of reconstructed frame buffer | |
217 | * @addr_output_bitstream_start: output bitstream start address | |
218 | * @addr_output_bitstream_end: output bitstream end address | |
219 | * @addr_external_sw : address of external search window | |
220 | * @addr_lctx : address of context picture buffer | |
221 | * @addr_local_rec_buffer: address of local reconstructed buffer | |
222 | * @addr_spatial_context: address of spatial context buffer | |
223 | * @bitstream_offset: offset in bits between aligned bitstream start | |
224 | * address and first bit to be written by HVA. | |
225 | * Range value is [0..63] | |
226 | * @sampling_mode: Input picture format . | |
227 | * 0: YUV420 semi_planar Interleaved | |
228 | * 1: YUV422 raster Interleaved | |
229 | * @addr_param_out: address of output parameters structure | |
230 | * @addr_scaling_matrix: address to the coefficient of | |
231 | * the inverse scaling matrix | |
232 | * @addr_scaling_matrix_dir: address to the coefficient of | |
233 | * the direct scaling matrix | |
234 | * @addr_cabac_context_buffer: address of cabac context buffer | |
235 | * @GmvX: Input information about the horizontal global displacement of | |
236 | * the encoded frame versus the previous one | |
237 | * @GmvY: Input information about the vertical global displacement of | |
238 | * the encoded frame versus the previous one | |
239 | * @window_width: width in pixels of the window to be encoded inside | |
240 | * the input frame | |
241 | * @window_height: width in pixels of the window to be encoded inside | |
242 | * the input frame | |
243 | * @window_horizontal_offset: horizontal offset in pels for input window | |
244 | * within input frame | |
245 | * @window_vertical_offset: vertical offset in pels for input window | |
246 | * within input frame | |
247 | * @addr_roi: Map of QP offset for the Region of Interest algorithm and | |
248 | * also used for Error map. | |
249 | * Bit 0-6 used for qp offset (value -64 to 63). | |
250 | * Bit 7 used to force intra | |
251 | * @addr_slice_header: address to slice header | |
252 | * @slice_header_size_in_bits: size in bits of the Slice header | |
253 | * @slice_header_offset0: Slice header offset where to insert | |
254 | * first_Mb_in_slice | |
255 | * @slice_header_offset1: Slice header offset where to insert | |
256 | * slice_qp_delta | |
257 | * @slice_header_offset2: Slice header offset where to insert | |
258 | * num_MBs_in_slice | |
259 | * @slice_synchro_enable: enable "slice ready" interrupt after each slice | |
260 | * @max_slice_number: Maximum number of slice in a frame | |
261 | * (0 is strictly forbidden) | |
262 | * @rgb2_yuv_y_coeff: Four coefficients (C0C1C2C3) to convert from RGB to | |
263 | * YUV for the Y component. | |
264 | * Y = C0*R + C1*G + C2*B + C3 (C0 is on byte 0) | |
265 | * @rgb2_yuv_u_coeff: four coefficients (C0C1C2C3) to convert from RGB to | |
266 | * YUV for the Y component. | |
267 | * Y = C0*R + C1*G + C2*B + C3 (C0 is on byte 0) | |
268 | * @rgb2_yuv_v_coeff: Four coefficients (C0C1C2C3) to convert from RGB to | |
269 | * YUV for the U (Cb) component. | |
270 | * U = C0*R + C1*G + C2*B + C3 (C0 is on byte 0) | |
271 | * @slice_byte_size: maximum slice size in bytes | |
272 | * (used when slice_size_type=2 or slice_size_type=3) | |
273 | * @max_air_intra_mb_nb: Maximum number of intra macroblock in a frame | |
274 | * for the AIR algorithm | |
275 | * @brc_no_skip: Disable skipping in the Bitrate Controller | |
276 | * @addr_brc_in_out_parameter: address of static buffer for BRC parameters | |
277 | */ | |
278 | struct hva_h264_td { | |
279 | u16 frame_width; | |
280 | u16 frame_height; | |
281 | u32 frame_num; | |
282 | u16 picture_coding_type; | |
283 | u16 reserved1; | |
284 | u16 pic_order_cnt_type; | |
285 | u16 first_picture_in_sequence; | |
286 | u16 slice_size_type; | |
287 | u16 reserved2; | |
288 | u32 slice_mb_size; | |
289 | u16 ir_param_option; | |
290 | u16 intra_refresh_type; | |
291 | u16 use_constrained_intra_flag; | |
292 | u16 transform_mode; | |
293 | u16 disable_deblocking_filter_idc; | |
294 | s16 slice_alpha_c0_offset_div2; | |
295 | s16 slice_beta_offset_div2; | |
296 | u16 encoder_complexity; | |
297 | s16 chroma_qp_index_offset; | |
298 | u16 entropy_coding_mode; | |
299 | u16 brc_type; | |
300 | u16 quant; | |
301 | u32 non_vcl_nalu_size; | |
302 | u32 cpb_buffer_size; | |
303 | u32 bit_rate; | |
304 | u16 qp_min; | |
305 | u16 qp_max; | |
306 | u16 framerate_num; | |
307 | u16 framerate_den; | |
308 | u16 delay; | |
309 | u16 strict_hrd_compliancy; | |
310 | u32 addr_source_buffer; | |
311 | u32 addr_fwd_ref_buffer; | |
312 | u32 addr_rec_buffer; | |
313 | u32 addr_output_bitstream_start; | |
314 | u32 addr_output_bitstream_end; | |
315 | u32 addr_external_sw; | |
316 | u32 addr_lctx; | |
317 | u32 addr_local_rec_buffer; | |
318 | u32 addr_spatial_context; | |
319 | u16 bitstream_offset; | |
320 | u16 sampling_mode; | |
321 | u32 addr_param_out; | |
322 | u32 addr_scaling_matrix; | |
323 | u32 addr_scaling_matrix_dir; | |
324 | u32 addr_cabac_context_buffer; | |
325 | u32 reserved3; | |
326 | u32 reserved4; | |
327 | s16 gmv_x; | |
328 | s16 gmv_y; | |
329 | u16 window_width; | |
330 | u16 window_height; | |
331 | u16 window_horizontal_offset; | |
332 | u16 window_vertical_offset; | |
333 | u32 addr_roi; | |
334 | u32 addr_slice_header; | |
335 | u16 slice_header_size_in_bits; | |
336 | u16 slice_header_offset0; | |
337 | u16 slice_header_offset1; | |
338 | u16 slice_header_offset2; | |
339 | u32 reserved5; | |
340 | u32 reserved6; | |
341 | u16 reserved7; | |
342 | u16 reserved8; | |
343 | u16 slice_synchro_enable; | |
344 | u16 max_slice_number; | |
345 | u32 rgb2_yuv_y_coeff; | |
346 | u32 rgb2_yuv_u_coeff; | |
347 | u32 rgb2_yuv_v_coeff; | |
348 | u32 slice_byte_size; | |
349 | u16 max_air_intra_mb_nb; | |
350 | u16 brc_no_skip; | |
351 | u32 addr_temporal_context; | |
352 | u32 addr_brc_in_out_parameter; | |
353 | }; | |
354 | ||
355 | /** | |
356 | * @ slice_size: slice size | |
357 | * @ slice_start_time: start time | |
358 | * @ slice_stop_time: stop time | |
359 | * @ slice_num: slice number | |
360 | */ | |
361 | struct hva_h264_slice_po { | |
362 | u32 slice_size; | |
363 | u32 slice_start_time; | |
364 | u32 slice_end_time; | |
365 | u32 slice_num; | |
366 | }; | |
367 | ||
368 | /** | |
369 | * @ bitstream_size: bitstream size | |
370 | * @ dct_bitstream_size: dtc bitstream size | |
371 | * @ stuffing_bits: number of stuffing bits inserted by the encoder | |
372 | * @ removal_time: removal time of current frame (nb of ticks 1/framerate) | |
373 | * @ hvc_start_time: hvc start time | |
374 | * @ hvc_stop_time: hvc stop time | |
375 | * @ slice_count: slice count | |
376 | */ | |
377 | struct hva_h264_po { | |
378 | u32 bitstream_size; | |
379 | u32 dct_bitstream_size; | |
380 | u32 stuffing_bits; | |
381 | u32 removal_time; | |
382 | u32 hvc_start_time; | |
383 | u32 hvc_stop_time; | |
384 | u32 slice_count; | |
385 | u32 reserved0; | |
386 | struct hva_h264_slice_po slice_params[16]; | |
387 | }; | |
388 | ||
389 | struct hva_h264_task { | |
390 | struct hva_h264_td td; | |
391 | struct hva_h264_po po; | |
392 | }; | |
393 | ||
394 | /** | |
395 | * @seq_info: sequence information buffer | |
396 | * @ref_frame: reference frame buffer | |
397 | * @rec_frame: reconstructed frame buffer | |
398 | * @task: task descriptor | |
399 | */ | |
400 | struct hva_h264_ctx { | |
401 | struct hva_buffer *seq_info; | |
402 | struct hva_buffer *ref_frame; | |
403 | struct hva_buffer *rec_frame; | |
404 | struct hva_buffer *task; | |
405 | }; | |
406 | ||
407 | static int hva_h264_fill_slice_header(struct hva_ctx *pctx, | |
408 | u8 *slice_header_addr, | |
409 | struct hva_controls *ctrls, | |
410 | int frame_num, | |
411 | u16 *header_size, | |
412 | u16 *header_offset0, | |
413 | u16 *header_offset1, | |
414 | u16 *header_offset2) | |
415 | { | |
416 | /* | |
417 | * with this HVA hardware version, part of the slice header is computed | |
418 | * on host and part by hardware. | |
419 | * The part of host is precomputed and available through this array. | |
420 | */ | |
421 | struct device *dev = ctx_to_dev(pctx); | |
422 | int cabac = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC; | |
423 | const unsigned char slice_header[] = { 0x00, 0x00, 0x00, 0x01, | |
424 | 0x41, 0x34, 0x07, 0x00}; | |
425 | int idr_pic_id = frame_num % 2; | |
426 | enum hva_picture_coding_type type; | |
427 | u32 frame_order = frame_num % ctrls->gop_size; | |
428 | ||
429 | if (!(frame_num % ctrls->gop_size)) | |
430 | type = PICTURE_CODING_TYPE_I; | |
431 | else | |
432 | type = PICTURE_CODING_TYPE_P; | |
433 | ||
434 | memcpy(slice_header_addr, slice_header, sizeof(slice_header)); | |
435 | ||
436 | *header_size = 56; | |
437 | *header_offset0 = 40; | |
438 | *header_offset1 = 13; | |
439 | *header_offset2 = 0; | |
440 | ||
441 | if (type == PICTURE_CODING_TYPE_I) { | |
442 | slice_header_addr[4] = 0x65; | |
443 | slice_header_addr[5] = 0x11; | |
444 | ||
445 | /* toggle the I frame */ | |
446 | if ((frame_num / ctrls->gop_size) % 2) { | |
447 | *header_size += 4; | |
448 | *header_offset1 += 4; | |
449 | slice_header_addr[6] = 0x04; | |
450 | slice_header_addr[7] = 0x70; | |
451 | ||
452 | } else { | |
453 | *header_size += 2; | |
454 | *header_offset1 += 2; | |
455 | slice_header_addr[6] = 0x09; | |
456 | slice_header_addr[7] = 0xC0; | |
457 | } | |
458 | } else { | |
459 | if (ctrls->entropy_mode == cabac) { | |
460 | *header_size += 1; | |
461 | *header_offset1 += 1; | |
462 | slice_header_addr[7] = 0x80; | |
463 | } | |
464 | /* | |
465 | * update slice header with P frame order | |
466 | * frame order is limited to 16 (coded on 4bits only) | |
467 | */ | |
468 | slice_header_addr[5] += ((frame_order & 0x0C) >> 2); | |
469 | slice_header_addr[6] += ((frame_order & 0x03) << 6); | |
470 | } | |
471 | ||
472 | dev_dbg(dev, | |
473 | "%s %s slice header order %d idrPicId %d header size %d\n", | |
474 | pctx->name, __func__, frame_order, idr_pic_id, *header_size); | |
475 | return 0; | |
476 | } | |
477 | ||
478 | static int hva_h264_fill_data_nal(struct hva_ctx *pctx, | |
479 | unsigned int stuffing_bytes, u8 *addr, | |
480 | unsigned int stream_size, unsigned int *size) | |
481 | { | |
482 | struct device *dev = ctx_to_dev(pctx); | |
483 | const u8 start[] = { 0x00, 0x00, 0x00, 0x01 }; | |
484 | ||
485 | dev_dbg(dev, "%s %s stuffing bytes %d\n", pctx->name, __func__, | |
486 | stuffing_bytes); | |
487 | ||
488 | if ((*size + stuffing_bytes + H264_FILLER_DATA_SIZE) > stream_size) { | |
489 | dev_dbg(dev, "%s %s too many stuffing bytes %d\n", | |
490 | pctx->name, __func__, stuffing_bytes); | |
491 | return 0; | |
492 | } | |
493 | ||
494 | /* start code */ | |
495 | memcpy(addr + *size, start, sizeof(start)); | |
496 | *size += sizeof(start); | |
497 | ||
498 | /* nal_unit_type */ | |
499 | addr[*size] = NALU_TYPE_FILLER_DATA; | |
500 | *size += 1; | |
501 | ||
502 | memset(addr + *size, 0xff, stuffing_bytes); | |
503 | *size += stuffing_bytes; | |
504 | ||
505 | addr[*size] = 0x80; | |
506 | *size += 1; | |
507 | ||
508 | return 0; | |
509 | } | |
510 | ||
511 | static int hva_h264_fill_sei_nal(struct hva_ctx *pctx, | |
512 | enum hva_h264_sei_payload_type type, | |
513 | u8 *addr, u32 *size) | |
514 | { | |
515 | struct device *dev = ctx_to_dev(pctx); | |
516 | const u8 start[] = { 0x00, 0x00, 0x00, 0x01 }; | |
517 | struct hva_h264_stereo_video_sei info; | |
518 | u8 offset = 7; | |
519 | u8 msg = 0; | |
520 | ||
521 | /* start code */ | |
522 | memcpy(addr + *size, start, sizeof(start)); | |
523 | *size += sizeof(start); | |
524 | ||
525 | /* nal_unit_type */ | |
526 | addr[*size] = NALU_TYPE_SEI; | |
527 | *size += 1; | |
528 | ||
529 | /* payload type */ | |
530 | addr[*size] = type; | |
531 | *size += 1; | |
532 | ||
533 | switch (type) { | |
534 | case SEI_STEREO_VIDEO_INFO: | |
535 | memset(&info, 0, sizeof(info)); | |
536 | ||
537 | /* set to top/bottom frame packing arrangement */ | |
538 | info.field_views_flag = 1; | |
539 | info.top_field_is_left_view_flag = 1; | |
540 | ||
541 | /* payload size */ | |
542 | addr[*size] = 1; | |
543 | *size += 1; | |
544 | ||
545 | /* payload */ | |
546 | msg = info.field_views_flag << offset--; | |
547 | ||
548 | if (info.field_views_flag) { | |
549 | msg |= info.top_field_is_left_view_flag << | |
550 | offset--; | |
551 | } else { | |
552 | msg |= info.current_frame_is_left_view_flag << | |
553 | offset--; | |
554 | msg |= info.next_frame_is_second_view_flag << | |
555 | offset--; | |
556 | } | |
557 | msg |= info.left_view_self_contained_flag << offset--; | |
558 | msg |= info.right_view_self_contained_flag << offset--; | |
559 | ||
560 | addr[*size] = msg; | |
561 | *size += 1; | |
562 | ||
563 | addr[*size] = 0x80; | |
564 | *size += 1; | |
565 | ||
566 | return 0; | |
567 | case SEI_BUFFERING_PERIOD: | |
568 | case SEI_PICTURE_TIMING: | |
569 | case SEI_FRAME_PACKING_ARRANGEMENT: | |
570 | default: | |
571 | dev_err(dev, "%s sei nal type not supported %d\n", | |
572 | pctx->name, type); | |
573 | return -EINVAL; | |
574 | } | |
575 | } | |
576 | ||
577 | static int hva_h264_prepare_task(struct hva_ctx *pctx, | |
578 | struct hva_h264_task *task, | |
579 | struct hva_frame *frame, | |
580 | struct hva_stream *stream) | |
581 | { | |
582 | struct hva_dev *hva = ctx_to_hdev(pctx); | |
583 | struct device *dev = ctx_to_dev(pctx); | |
584 | struct hva_h264_ctx *ctx = (struct hva_h264_ctx *)pctx->priv; | |
585 | struct hva_buffer *seq_info = ctx->seq_info; | |
586 | struct hva_buffer *fwd_ref_frame = ctx->ref_frame; | |
587 | struct hva_buffer *loc_rec_frame = ctx->rec_frame; | |
588 | struct hva_h264_td *td = &task->td; | |
589 | struct hva_controls *ctrls = &pctx->ctrls; | |
590 | struct v4l2_fract *time_per_frame = &pctx->ctrls.time_per_frame; | |
591 | int cavlc = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC; | |
592 | u32 frame_num = pctx->stream_num; | |
593 | u32 addr_esram = hva->esram_addr; | |
594 | enum v4l2_mpeg_video_h264_level level; | |
595 | dma_addr_t paddr = 0; | |
596 | u8 *slice_header_vaddr; | |
597 | u32 frame_width = frame->info.aligned_width; | |
598 | u32 frame_height = frame->info.aligned_height; | |
599 | u32 max_cpb_buffer_size; | |
600 | unsigned int payload = stream->bytesused; | |
601 | u32 max_bitrate; | |
602 | ||
603 | /* check width and height parameters */ | |
604 | if ((frame_width > max(H264_MAX_SIZE_W, H264_MAX_SIZE_H)) || | |
605 | (frame_height > max(H264_MAX_SIZE_W, H264_MAX_SIZE_H))) { | |
606 | dev_err(dev, | |
607 | "%s width(%d) or height(%d) exceeds limits (%dx%d)\n", | |
608 | pctx->name, frame_width, frame_height, | |
609 | H264_MAX_SIZE_W, H264_MAX_SIZE_H); | |
610 | return -EINVAL; | |
611 | } | |
612 | ||
613 | level = ctrls->level; | |
614 | ||
615 | memset(td, 0, sizeof(struct hva_h264_td)); | |
616 | ||
617 | td->frame_width = frame_width; | |
618 | td->frame_height = frame_height; | |
619 | ||
620 | /* set frame alignement */ | |
621 | td->window_width = frame_width; | |
622 | td->window_height = frame_height; | |
623 | td->window_horizontal_offset = 0; | |
624 | td->window_vertical_offset = 0; | |
625 | ||
626 | td->first_picture_in_sequence = (!frame_num) ? 1 : 0; | |
627 | ||
628 | /* pic_order_cnt_type hard coded to '2' as only I & P frames */ | |
629 | td->pic_order_cnt_type = 2; | |
630 | ||
631 | /* useConstrainedIntraFlag set to false for better coding efficiency */ | |
632 | td->use_constrained_intra_flag = false; | |
633 | td->brc_type = (ctrls->bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) | |
634 | ? BRC_TYPE_CBR : BRC_TYPE_VBR; | |
635 | ||
636 | td->entropy_coding_mode = (ctrls->entropy_mode == cavlc) ? CAVLC : | |
637 | CABAC; | |
638 | ||
639 | td->bit_rate = ctrls->bitrate; | |
640 | ||
641 | /* set framerate, framerate = 1 n/ time per frame */ | |
642 | if (time_per_frame->numerator >= 536) { | |
643 | /* | |
644 | * due to a hardware bug, framerate denominator can't exceed | |
645 | * 536 (BRC overflow). Compute nearest framerate | |
646 | */ | |
647 | td->framerate_den = 1; | |
648 | td->framerate_num = (time_per_frame->denominator + | |
649 | (time_per_frame->numerator >> 1) - 1) / | |
650 | time_per_frame->numerator; | |
651 | ||
652 | /* | |
653 | * update bitrate to introduce a correction due to | |
654 | * the new framerate | |
655 | * new bitrate = (old bitrate * new framerate) / old framerate | |
656 | */ | |
657 | td->bit_rate /= time_per_frame->numerator; | |
658 | td->bit_rate *= time_per_frame->denominator; | |
659 | td->bit_rate /= td->framerate_num; | |
660 | } else { | |
661 | td->framerate_den = time_per_frame->numerator; | |
662 | td->framerate_num = time_per_frame->denominator; | |
663 | } | |
664 | ||
665 | /* compute maximum bitrate depending on profile */ | |
666 | if (ctrls->profile >= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) | |
667 | max_bitrate = h264_infos_list[level].max_bitrate * | |
668 | H264_FACTOR_HIGH; | |
669 | else | |
670 | max_bitrate = h264_infos_list[level].max_bitrate * | |
671 | H264_FACTOR_BASELINE; | |
672 | ||
673 | /* check if bitrate doesn't exceed max size */ | |
674 | if (td->bit_rate > max_bitrate) { | |
675 | dev_dbg(dev, | |
676 | "%s bitrate (%d) larger than level and profile allow, clip to %d\n", | |
677 | pctx->name, td->bit_rate, max_bitrate); | |
678 | td->bit_rate = max_bitrate; | |
679 | } | |
680 | ||
681 | /* convert cpb_buffer_size in bits */ | |
682 | td->cpb_buffer_size = ctrls->cpb_size * 8000; | |
683 | ||
684 | /* compute maximum cpb buffer size depending on profile */ | |
685 | if (ctrls->profile >= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) | |
686 | max_cpb_buffer_size = | |
687 | h264_infos_list[level].max_cpb_size * H264_FACTOR_HIGH; | |
688 | else | |
689 | max_cpb_buffer_size = | |
690 | h264_infos_list[level].max_cpb_size * H264_FACTOR_BASELINE; | |
691 | ||
692 | /* check if cpb buffer size doesn't exceed max size */ | |
693 | if (td->cpb_buffer_size > max_cpb_buffer_size) { | |
694 | dev_dbg(dev, | |
695 | "%s cpb size larger than level %d allows, clip to %d\n", | |
696 | pctx->name, td->cpb_buffer_size, max_cpb_buffer_size); | |
697 | td->cpb_buffer_size = max_cpb_buffer_size; | |
698 | } | |
699 | ||
700 | /* enable skipping in the Bitrate Controller */ | |
701 | td->brc_no_skip = 0; | |
702 | ||
703 | /* initial delay */ | |
704 | if ((ctrls->bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) && | |
705 | td->bit_rate) | |
706 | td->delay = 1000 * (td->cpb_buffer_size / td->bit_rate); | |
707 | else | |
708 | td->delay = 0; | |
709 | ||
710 | switch (frame->info.pixelformat) { | |
711 | case V4L2_PIX_FMT_NV12: | |
712 | td->sampling_mode = SAMPLING_MODE_NV12; | |
713 | break; | |
714 | case V4L2_PIX_FMT_NV21: | |
715 | td->sampling_mode = SAMPLING_MODE_NV21; | |
716 | break; | |
717 | default: | |
718 | dev_err(dev, "%s invalid source pixel format\n", | |
719 | pctx->name); | |
720 | return -EINVAL; | |
721 | } | |
722 | ||
723 | /* | |
724 | * fill matrix color converter (RGB to YUV) | |
725 | * Y = 0,299 R + 0,587 G + 0,114 B | |
726 | * Cb = -0,1687 R -0,3313 G + 0,5 B + 128 | |
727 | * Cr = 0,5 R - 0,4187 G - 0,0813 B + 128 | |
728 | */ | |
729 | td->rgb2_yuv_y_coeff = 0x12031008; | |
730 | td->rgb2_yuv_u_coeff = 0x800EF7FB; | |
731 | td->rgb2_yuv_v_coeff = 0x80FEF40E; | |
732 | ||
733 | /* enable/disable transform mode */ | |
734 | td->transform_mode = ctrls->dct8x8; | |
735 | ||
736 | /* encoder complexity fix to 2, ENCODE_I_16x16_I_NxN_P_16x16_P_WxH */ | |
737 | td->encoder_complexity = 2; | |
738 | ||
739 | /* quant fix to 28, default VBR value */ | |
740 | td->quant = 28; | |
741 | ||
742 | if (td->framerate_den == 0) { | |
743 | dev_err(dev, "%s invalid framerate\n", pctx->name); | |
744 | return -EINVAL; | |
745 | } | |
746 | ||
747 | /* if automatic framerate, deactivate bitrate controller */ | |
748 | if (td->framerate_num == 0) | |
749 | td->brc_type = 0; | |
750 | ||
751 | /* compliancy fix to true */ | |
752 | td->strict_hrd_compliancy = 1; | |
753 | ||
754 | /* set minimum & maximum quantizers */ | |
755 | td->qp_min = clamp_val(ctrls->qpmin, 0, 51); | |
756 | td->qp_max = clamp_val(ctrls->qpmax, 0, 51); | |
757 | ||
758 | td->addr_source_buffer = frame->paddr; | |
759 | td->addr_fwd_ref_buffer = fwd_ref_frame->paddr; | |
760 | td->addr_rec_buffer = loc_rec_frame->paddr; | |
761 | ||
762 | td->addr_output_bitstream_end = (u32)stream->paddr + stream->size; | |
763 | ||
764 | td->addr_output_bitstream_start = (u32)stream->paddr; | |
765 | td->bitstream_offset = (((u32)stream->paddr & 0xF) << 3) & | |
766 | BITSTREAM_OFFSET_MASK; | |
767 | ||
768 | td->addr_param_out = (u32)ctx->task->paddr + | |
769 | offsetof(struct hva_h264_task, po); | |
770 | ||
771 | /* swap spatial and temporal context */ | |
772 | if (frame_num % 2) { | |
773 | paddr = seq_info->paddr; | |
774 | td->addr_spatial_context = ALIGN(paddr, 0x100); | |
775 | paddr = seq_info->paddr + DATA_SIZE(frame_width, | |
776 | frame_height); | |
777 | td->addr_temporal_context = ALIGN(paddr, 0x100); | |
778 | } else { | |
779 | paddr = seq_info->paddr; | |
780 | td->addr_temporal_context = ALIGN(paddr, 0x100); | |
781 | paddr = seq_info->paddr + DATA_SIZE(frame_width, | |
782 | frame_height); | |
783 | td->addr_spatial_context = ALIGN(paddr, 0x100); | |
784 | } | |
785 | ||
786 | paddr = seq_info->paddr + 2 * DATA_SIZE(frame_width, frame_height); | |
787 | ||
788 | td->addr_brc_in_out_parameter = ALIGN(paddr, 0x100); | |
789 | ||
790 | paddr = td->addr_brc_in_out_parameter + BRC_DATA_SIZE; | |
791 | td->addr_slice_header = ALIGN(paddr, 0x100); | |
792 | td->addr_external_sw = ALIGN(addr_esram, 0x100); | |
793 | ||
794 | addr_esram += SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width); | |
795 | td->addr_local_rec_buffer = ALIGN(addr_esram, 0x100); | |
796 | ||
797 | addr_esram += LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width); | |
798 | td->addr_lctx = ALIGN(addr_esram, 0x100); | |
799 | ||
800 | addr_esram += CTX_MB_BUFFER_MAX_SIZE(max(frame_width, frame_height)); | |
801 | td->addr_cabac_context_buffer = ALIGN(addr_esram, 0x100); | |
802 | ||
803 | if (!(frame_num % ctrls->gop_size)) { | |
804 | td->picture_coding_type = PICTURE_CODING_TYPE_I; | |
805 | stream->vbuf.flags |= V4L2_BUF_FLAG_KEYFRAME; | |
806 | } else { | |
807 | td->picture_coding_type = PICTURE_CODING_TYPE_P; | |
808 | stream->vbuf.flags &= ~V4L2_BUF_FLAG_KEYFRAME; | |
809 | } | |
810 | ||
811 | /* fill the slice header part */ | |
812 | slice_header_vaddr = seq_info->vaddr + (td->addr_slice_header - | |
813 | seq_info->paddr); | |
814 | ||
815 | hva_h264_fill_slice_header(pctx, slice_header_vaddr, ctrls, frame_num, | |
816 | &td->slice_header_size_in_bits, | |
817 | &td->slice_header_offset0, | |
818 | &td->slice_header_offset1, | |
819 | &td->slice_header_offset2); | |
820 | ||
821 | td->chroma_qp_index_offset = 2; | |
822 | td->slice_synchro_enable = 0; | |
823 | td->max_slice_number = 1; | |
824 | ||
825 | /* | |
826 | * check the sps/pps header size for key frame only | |
827 | * sps/pps header was previously fill by libv4l | |
828 | * during qbuf of stream buffer | |
829 | */ | |
830 | if ((stream->vbuf.flags == V4L2_BUF_FLAG_KEYFRAME) && | |
831 | (payload > MAX_SPS_PPS_SIZE)) { | |
832 | dev_err(dev, "%s invalid sps/pps size %d\n", pctx->name, | |
833 | payload); | |
834 | return -EINVAL; | |
835 | } | |
836 | ||
837 | if (stream->vbuf.flags != V4L2_BUF_FLAG_KEYFRAME) | |
838 | payload = 0; | |
839 | ||
840 | /* add SEI nal (video stereo info) */ | |
841 | if (ctrls->sei_fp && hva_h264_fill_sei_nal(pctx, SEI_STEREO_VIDEO_INFO, | |
842 | (u8 *)stream->vaddr, | |
843 | &payload)) { | |
844 | dev_err(dev, "%s fail to get SEI nal\n", pctx->name); | |
845 | return -EINVAL; | |
846 | } | |
847 | ||
848 | /* fill size of non-VCL NAL units (SPS, PPS, filler and SEI) */ | |
849 | td->non_vcl_nalu_size = payload * 8; | |
850 | ||
851 | /* compute bitstream offset & new start address of bitstream */ | |
852 | td->addr_output_bitstream_start += ((payload >> 4) << 4); | |
853 | td->bitstream_offset += (payload - ((payload >> 4) << 4)) * 8; | |
854 | ||
855 | stream->bytesused = payload; | |
856 | ||
857 | return 0; | |
858 | } | |
859 | ||
860 | static unsigned int hva_h264_get_stream_size(struct hva_h264_task *task) | |
861 | { | |
862 | struct hva_h264_po *po = &task->po; | |
863 | ||
864 | return po->bitstream_size; | |
865 | } | |
866 | ||
867 | static u32 hva_h264_get_stuffing_bytes(struct hva_h264_task *task) | |
868 | { | |
869 | struct hva_h264_po *po = &task->po; | |
870 | ||
871 | return po->stuffing_bits >> 3; | |
872 | } | |
873 | ||
874 | static int hva_h264_open(struct hva_ctx *pctx) | |
875 | { | |
876 | struct device *dev = ctx_to_dev(pctx); | |
877 | struct hva_h264_ctx *ctx; | |
878 | struct hva_dev *hva = ctx_to_hdev(pctx); | |
879 | u32 frame_width = pctx->frameinfo.aligned_width; | |
880 | u32 frame_height = pctx->frameinfo.aligned_height; | |
881 | u32 size; | |
882 | int ret; | |
883 | ||
884 | /* check esram size necessary to encode a frame */ | |
885 | size = SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width) + | |
886 | LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width) + | |
887 | CTX_MB_BUFFER_MAX_SIZE(max(frame_width, frame_height)) + | |
888 | CABAC_CONTEXT_BUFFER_MAX_SIZE(frame_width); | |
889 | ||
890 | if (hva->esram_size < size) { | |
891 | dev_err(dev, "%s not enough esram (max:%d request:%d)\n", | |
892 | pctx->name, hva->esram_size, size); | |
893 | ret = -EINVAL; | |
894 | goto err; | |
895 | } | |
896 | ||
897 | /* allocate context for codec */ | |
898 | ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); | |
899 | if (!ctx) { | |
900 | ret = -ENOMEM; | |
901 | goto err; | |
902 | } | |
903 | ||
904 | /* allocate sequence info buffer */ | |
905 | ret = hva_mem_alloc(pctx, | |
906 | 2 * DATA_SIZE(frame_width, frame_height) + | |
907 | SLICE_HEADER_SIZE + | |
908 | BRC_DATA_SIZE, | |
909 | "hva sequence info", | |
910 | &ctx->seq_info); | |
911 | if (ret) { | |
912 | dev_err(dev, | |
913 | "%s failed to allocate sequence info buffer\n", | |
914 | pctx->name); | |
915 | goto err_ctx; | |
916 | } | |
917 | ||
918 | /* allocate reference frame buffer */ | |
919 | ret = hva_mem_alloc(pctx, | |
920 | frame_width * frame_height * 3 / 2, | |
921 | "hva reference frame", | |
922 | &ctx->ref_frame); | |
923 | if (ret) { | |
924 | dev_err(dev, "%s failed to allocate reference frame buffer\n", | |
925 | pctx->name); | |
926 | goto err_seq_info; | |
927 | } | |
928 | ||
929 | /* allocate reconstructed frame buffer */ | |
930 | ret = hva_mem_alloc(pctx, | |
931 | frame_width * frame_height * 3 / 2, | |
932 | "hva reconstructed frame", | |
933 | &ctx->rec_frame); | |
934 | if (ret) { | |
935 | dev_err(dev, | |
936 | "%s failed to allocate reconstructed frame buffer\n", | |
937 | pctx->name); | |
938 | goto err_ref_frame; | |
939 | } | |
940 | ||
941 | /* allocate task descriptor */ | |
942 | ret = hva_mem_alloc(pctx, | |
943 | sizeof(struct hva_h264_task), | |
944 | "hva task descriptor", | |
945 | &ctx->task); | |
946 | if (ret) { | |
947 | dev_err(dev, | |
948 | "%s failed to allocate task descriptor\n", | |
949 | pctx->name); | |
950 | goto err_rec_frame; | |
951 | } | |
952 | ||
953 | pctx->priv = (void *)ctx; | |
954 | ||
955 | return 0; | |
956 | ||
957 | err_rec_frame: | |
958 | hva_mem_free(pctx, ctx->rec_frame); | |
959 | err_ref_frame: | |
960 | hva_mem_free(pctx, ctx->ref_frame); | |
961 | err_seq_info: | |
962 | hva_mem_free(pctx, ctx->seq_info); | |
963 | err_ctx: | |
964 | devm_kfree(dev, ctx); | |
965 | err: | |
966 | return ret; | |
967 | } | |
968 | ||
969 | static int hva_h264_close(struct hva_ctx *pctx) | |
970 | { | |
971 | struct hva_h264_ctx *ctx = (struct hva_h264_ctx *)pctx->priv; | |
972 | struct device *dev = ctx_to_dev(pctx); | |
973 | ||
974 | if (ctx->seq_info) | |
975 | hva_mem_free(pctx, ctx->seq_info); | |
976 | ||
977 | if (ctx->ref_frame) | |
978 | hva_mem_free(pctx, ctx->ref_frame); | |
979 | ||
980 | if (ctx->rec_frame) | |
981 | hva_mem_free(pctx, ctx->rec_frame); | |
982 | ||
983 | if (ctx->task) | |
984 | hva_mem_free(pctx, ctx->task); | |
985 | ||
986 | devm_kfree(dev, ctx); | |
987 | ||
988 | return 0; | |
989 | } | |
990 | ||
991 | static int hva_h264_encode(struct hva_ctx *pctx, struct hva_frame *frame, | |
992 | struct hva_stream *stream) | |
993 | { | |
994 | struct hva_h264_ctx *ctx = (struct hva_h264_ctx *)pctx->priv; | |
995 | struct hva_h264_task *task = (struct hva_h264_task *)ctx->task->vaddr; | |
996 | struct hva_buffer *tmp_frame; | |
997 | u32 stuffing_bytes = 0; | |
998 | int ret = 0; | |
999 | ||
1000 | ret = hva_h264_prepare_task(pctx, task, frame, stream); | |
1001 | if (ret) | |
1002 | goto err; | |
1003 | ||
1004 | ret = hva_hw_execute_task(pctx, H264_ENC, ctx->task); | |
1005 | if (ret) | |
1006 | goto err; | |
1007 | ||
1008 | pctx->stream_num++; | |
1009 | stream->bytesused += hva_h264_get_stream_size(task); | |
1010 | ||
1011 | stuffing_bytes = hva_h264_get_stuffing_bytes(task); | |
1012 | ||
1013 | if (stuffing_bytes) | |
1014 | hva_h264_fill_data_nal(pctx, stuffing_bytes, | |
1015 | (u8 *)stream->vaddr, | |
1016 | stream->size, | |
1017 | &stream->bytesused); | |
1018 | ||
1019 | /* switch reference & reconstructed frame */ | |
1020 | tmp_frame = ctx->ref_frame; | |
1021 | ctx->ref_frame = ctx->rec_frame; | |
1022 | ctx->rec_frame = tmp_frame; | |
1023 | ||
1024 | return 0; | |
1025 | err: | |
1026 | stream->bytesused = 0; | |
1027 | return ret; | |
1028 | } | |
1029 | ||
1030 | const struct hva_enc nv12h264enc = { | |
1031 | .name = "H264(NV12)", | |
1032 | .pixelformat = V4L2_PIX_FMT_NV12, | |
1033 | .streamformat = V4L2_PIX_FMT_H264, | |
1034 | .max_width = H264_MAX_SIZE_W, | |
1035 | .max_height = H264_MAX_SIZE_H, | |
1036 | .open = hva_h264_open, | |
1037 | .close = hva_h264_close, | |
1038 | .encode = hva_h264_encode, | |
1039 | }; | |
1040 | ||
1041 | const struct hva_enc nv21h264enc = { | |
1042 | .name = "H264(NV21)", | |
1043 | .pixelformat = V4L2_PIX_FMT_NV21, | |
1044 | .streamformat = V4L2_PIX_FMT_H264, | |
1045 | .max_width = H264_MAX_SIZE_W, | |
1046 | .max_height = H264_MAX_SIZE_H, | |
1047 | .open = hva_h264_open, | |
1048 | .close = hva_h264_close, | |
1049 | .encode = hva_h264_encode, | |
1050 | }; |