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
11 #define MAX_SPS_PPS_SIZE 128
13 #define BITSTREAM_OFFSET_MASK 0x7F
16 #define H264_MAX_SIZE_W 1920
17 #define H264_MAX_SIZE_H 1920
19 /* macroBlocs number (width & height) */
20 #define MB_W(w) ((w + 0xF) / 0x10)
21 #define MB_H(h) ((h + 0xF) / 0x10)
23 /* formula to get temporal or spatial data size */
24 #define DATA_SIZE(w, h) (MB_W(w) * MB_H(h) * 16)
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)
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)
36 * 4 lines of pixels (in Luma, Chroma blue and Chroma red) of top MB
37 * for deblocking with size=4*16*MBx*2
39 #define LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(w) (4 * 16 * MB_W(w) * 2)
41 /* factor for bitrate and cpb buffer size max values if profile >= high */
42 #define H264_FACTOR_HIGH 1200
44 /* factor for bitrate and cpb buffer size max values if profile < high */
45 #define H264_FACTOR_BASELINE 1000
47 /* number of bytes for NALU_TYPE_FILLER_DATA header and footer */
48 #define H264_FILLER_DATA_SIZE 6
51 enum v4l2_mpeg_video_h264_level level
;
52 u32 max_mb_per_seconds
;
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}
82 BRC_TYPE_VBR_LOW_DELAY
= 3
85 enum hva_entropy_coding_mode
{
90 enum hva_picture_coding_type
{
91 PICTURE_CODING_TYPE_I
= 0,
92 PICTURE_CODING_TYPE_P
= 1,
93 PICTURE_CODING_TYPE_B
= 2
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
109 enum hva_h264_nalu_type
{
110 NALU_TYPE_UNKNOWN
= 0,
112 NALU_TYPE_SLICE_DPA
= 2,
113 NALU_TYPE_SLICE_DPB
= 3,
114 NALU_TYPE_SLICE_DPC
= 4,
115 NALU_TYPE_SLICE_IDR
= 5,
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
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
138 * stereo Video Info struct
140 struct hva_h264_stereo_video_sei
{
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
;
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.
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
161 * 2= a slice is closed as soon as the slice_byte_size limit
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
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.
198 * @brc_type: selects the bit-rate control algorithm
199 * 0 = constant Qp, (no BRC)
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),
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
241 * @window_height: width in pixels of the window to be encoded inside
243 * @window_horizontal_offset: horizontal offset in pels for input window
245 * @window_vertical_offset: vertical offset in pels for input window
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
255 * @slice_header_offset1: Slice header offset where to insert
257 * @slice_header_offset2: Slice header offset where to insert
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
282 u16 picture_coding_type
;
284 u16 pic_order_cnt_type
;
285 u16 first_picture_in_sequence
;
290 u16 intra_refresh_type
;
291 u16 use_constrained_intra_flag
;
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
;
301 u32 non_vcl_nalu_size
;
309 u16 strict_hrd_compliancy
;
310 u32 addr_source_buffer
;
311 u32 addr_fwd_ref_buffer
;
313 u32 addr_output_bitstream_start
;
314 u32 addr_output_bitstream_end
;
315 u32 addr_external_sw
;
317 u32 addr_local_rec_buffer
;
318 u32 addr_spatial_context
;
319 u16 bitstream_offset
;
322 u32 addr_scaling_matrix
;
323 u32 addr_scaling_matrix_dir
;
324 u32 addr_cabac_context_buffer
;
331 u16 window_horizontal_offset
;
332 u16 window_vertical_offset
;
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
;
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
;
349 u16 max_air_intra_mb_nb
;
351 u32 addr_temporal_context
;
352 u32 addr_brc_in_out_parameter
;
356 * @ slice_size: slice size
357 * @ slice_start_time: start time
358 * @ slice_stop_time: stop time
359 * @ slice_num: slice number
361 struct hva_h264_slice_po
{
363 u32 slice_start_time
;
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
379 u32 dct_bitstream_size
;
386 struct hva_h264_slice_po slice_params
[16];
389 struct hva_h264_task
{
390 struct hva_h264_td td
;
391 struct hva_h264_po po
;
395 * @seq_info: sequence information buffer
396 * @ref_frame: reference frame buffer
397 * @rec_frame: reconstructed frame buffer
398 * @task: task descriptor
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
;
407 static int hva_h264_fill_slice_header(struct hva_ctx
*pctx
,
408 u8
*slice_header_addr
,
409 struct hva_controls
*ctrls
,
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.
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
;
429 if (!(frame_num
% ctrls
->gop_size
))
430 type
= PICTURE_CODING_TYPE_I
;
432 type
= PICTURE_CODING_TYPE_P
;
434 memcpy(slice_header_addr
, slice_header
, sizeof(slice_header
));
437 *header_offset0
= 40;
438 *header_offset1
= 13;
441 if (type
== PICTURE_CODING_TYPE_I
) {
442 slice_header_addr
[4] = 0x65;
443 slice_header_addr
[5] = 0x11;
445 /* toggle the I frame */
446 if ((frame_num
/ ctrls
->gop_size
) % 2) {
448 *header_offset1
+= 4;
449 slice_header_addr
[6] = 0x04;
450 slice_header_addr
[7] = 0x70;
454 *header_offset1
+= 2;
455 slice_header_addr
[6] = 0x09;
456 slice_header_addr
[7] = 0xC0;
459 if (ctrls
->entropy_mode
== cabac
) {
461 *header_offset1
+= 1;
462 slice_header_addr
[7] = 0x80;
465 * update slice header with P frame order
466 * frame order is limited to 16 (coded on 4bits only)
468 slice_header_addr
[5] += ((frame_order
& 0x0C) >> 2);
469 slice_header_addr
[6] += ((frame_order
& 0x03) << 6);
473 "%s %s slice header order %d idrPicId %d header size %d\n",
474 pctx
->name
, __func__
, frame_order
, idr_pic_id
, *header_size
);
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
)
482 struct device
*dev
= ctx_to_dev(pctx
);
483 const u8 start
[] = { 0x00, 0x00, 0x00, 0x01 };
485 dev_dbg(dev
, "%s %s stuffing bytes %d\n", pctx
->name
, __func__
,
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
);
495 memcpy(addr
+ *size
, start
, sizeof(start
));
496 *size
+= sizeof(start
);
499 addr
[*size
] = NALU_TYPE_FILLER_DATA
;
502 memset(addr
+ *size
, 0xff, stuffing_bytes
);
503 *size
+= stuffing_bytes
;
511 static int hva_h264_fill_sei_nal(struct hva_ctx
*pctx
,
512 enum hva_h264_sei_payload_type type
,
515 struct device
*dev
= ctx_to_dev(pctx
);
516 const u8 start
[] = { 0x00, 0x00, 0x00, 0x01 };
517 struct hva_h264_stereo_video_sei info
;
522 memcpy(addr
+ *size
, start
, sizeof(start
));
523 *size
+= sizeof(start
);
526 addr
[*size
] = NALU_TYPE_SEI
;
534 case SEI_STEREO_VIDEO_INFO
:
535 memset(&info
, 0, sizeof(info
));
537 /* set to top/bottom frame packing arrangement */
538 info
.field_views_flag
= 1;
539 info
.top_field_is_left_view_flag
= 1;
546 msg
= info
.field_views_flag
<< offset
--;
548 if (info
.field_views_flag
) {
549 msg
|= info
.top_field_is_left_view_flag
<<
552 msg
|= info
.current_frame_is_left_view_flag
<<
554 msg
|= info
.next_frame_is_second_view_flag
<<
557 msg
|= info
.left_view_self_contained_flag
<< offset
--;
558 msg
|= info
.right_view_self_contained_flag
<< offset
--;
567 case SEI_BUFFERING_PERIOD
:
568 case SEI_PICTURE_TIMING
:
569 case SEI_FRAME_PACKING_ARRANGEMENT
:
571 dev_err(dev
, "%s sei nal type not supported %d\n",
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
)
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
;
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
))) {
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 pctx
->frame_errors
++;
614 level
= ctrls
->level
;
616 memset(td
, 0, sizeof(struct hva_h264_td
));
618 td
->frame_width
= frame_width
;
619 td
->frame_height
= frame_height
;
621 /* set frame alignement */
622 td
->window_width
= frame_width
;
623 td
->window_height
= frame_height
;
624 td
->window_horizontal_offset
= 0;
625 td
->window_vertical_offset
= 0;
627 td
->first_picture_in_sequence
= (!frame_num
) ? 1 : 0;
629 /* pic_order_cnt_type hard coded to '2' as only I & P frames */
630 td
->pic_order_cnt_type
= 2;
632 /* useConstrainedIntraFlag set to false for better coding efficiency */
633 td
->use_constrained_intra_flag
= false;
634 td
->brc_type
= (ctrls
->bitrate_mode
== V4L2_MPEG_VIDEO_BITRATE_MODE_CBR
)
635 ? BRC_TYPE_CBR
: BRC_TYPE_VBR
;
637 td
->entropy_coding_mode
= (ctrls
->entropy_mode
== cavlc
) ? CAVLC
:
640 td
->bit_rate
= ctrls
->bitrate
;
642 /* set framerate, framerate = 1 n/ time per frame */
643 if (time_per_frame
->numerator
>= 536) {
645 * due to a hardware bug, framerate denominator can't exceed
646 * 536 (BRC overflow). Compute nearest framerate
648 td
->framerate_den
= 1;
649 td
->framerate_num
= (time_per_frame
->denominator
+
650 (time_per_frame
->numerator
>> 1) - 1) /
651 time_per_frame
->numerator
;
654 * update bitrate to introduce a correction due to
656 * new bitrate = (old bitrate * new framerate) / old framerate
658 td
->bit_rate
/= time_per_frame
->numerator
;
659 td
->bit_rate
*= time_per_frame
->denominator
;
660 td
->bit_rate
/= td
->framerate_num
;
662 td
->framerate_den
= time_per_frame
->numerator
;
663 td
->framerate_num
= time_per_frame
->denominator
;
666 /* compute maximum bitrate depending on profile */
667 if (ctrls
->profile
>= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH
)
668 max_bitrate
= h264_infos_list
[level
].max_bitrate
*
671 max_bitrate
= h264_infos_list
[level
].max_bitrate
*
672 H264_FACTOR_BASELINE
;
674 /* check if bitrate doesn't exceed max size */
675 if (td
->bit_rate
> max_bitrate
) {
677 "%s bitrate (%d) larger than level and profile allow, clip to %d\n",
678 pctx
->name
, td
->bit_rate
, max_bitrate
);
679 td
->bit_rate
= max_bitrate
;
682 /* convert cpb_buffer_size in bits */
683 td
->cpb_buffer_size
= ctrls
->cpb_size
* 8000;
685 /* compute maximum cpb buffer size depending on profile */
686 if (ctrls
->profile
>= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH
)
687 max_cpb_buffer_size
=
688 h264_infos_list
[level
].max_cpb_size
* H264_FACTOR_HIGH
;
690 max_cpb_buffer_size
=
691 h264_infos_list
[level
].max_cpb_size
* H264_FACTOR_BASELINE
;
693 /* check if cpb buffer size doesn't exceed max size */
694 if (td
->cpb_buffer_size
> max_cpb_buffer_size
) {
696 "%s cpb size larger than level %d allows, clip to %d\n",
697 pctx
->name
, td
->cpb_buffer_size
, max_cpb_buffer_size
);
698 td
->cpb_buffer_size
= max_cpb_buffer_size
;
701 /* enable skipping in the Bitrate Controller */
705 if ((ctrls
->bitrate_mode
== V4L2_MPEG_VIDEO_BITRATE_MODE_CBR
) &&
707 td
->delay
= 1000 * (td
->cpb_buffer_size
/ td
->bit_rate
);
711 switch (frame
->info
.pixelformat
) {
712 case V4L2_PIX_FMT_NV12
:
713 td
->sampling_mode
= SAMPLING_MODE_NV12
;
715 case V4L2_PIX_FMT_NV21
:
716 td
->sampling_mode
= SAMPLING_MODE_NV21
;
719 dev_err(dev
, "%s invalid source pixel format\n",
721 pctx
->frame_errors
++;
726 * fill matrix color converter (RGB to YUV)
727 * Y = 0,299 R + 0,587 G + 0,114 B
728 * Cb = -0,1687 R -0,3313 G + 0,5 B + 128
729 * Cr = 0,5 R - 0,4187 G - 0,0813 B + 128
731 td
->rgb2_yuv_y_coeff
= 0x12031008;
732 td
->rgb2_yuv_u_coeff
= 0x800EF7FB;
733 td
->rgb2_yuv_v_coeff
= 0x80FEF40E;
735 /* enable/disable transform mode */
736 td
->transform_mode
= ctrls
->dct8x8
;
738 /* encoder complexity fix to 2, ENCODE_I_16x16_I_NxN_P_16x16_P_WxH */
739 td
->encoder_complexity
= 2;
741 /* quant fix to 28, default VBR value */
744 if (td
->framerate_den
== 0) {
745 dev_err(dev
, "%s invalid framerate\n", pctx
->name
);
746 pctx
->frame_errors
++;
750 /* if automatic framerate, deactivate bitrate controller */
751 if (td
->framerate_num
== 0)
754 /* compliancy fix to true */
755 td
->strict_hrd_compliancy
= 1;
757 /* set minimum & maximum quantizers */
758 td
->qp_min
= clamp_val(ctrls
->qpmin
, 0, 51);
759 td
->qp_max
= clamp_val(ctrls
->qpmax
, 0, 51);
761 td
->addr_source_buffer
= frame
->paddr
;
762 td
->addr_fwd_ref_buffer
= fwd_ref_frame
->paddr
;
763 td
->addr_rec_buffer
= loc_rec_frame
->paddr
;
765 td
->addr_output_bitstream_end
= (u32
)stream
->paddr
+ stream
->size
;
767 td
->addr_output_bitstream_start
= (u32
)stream
->paddr
;
768 td
->bitstream_offset
= (((u32
)stream
->paddr
& 0xF) << 3) &
769 BITSTREAM_OFFSET_MASK
;
771 td
->addr_param_out
= (u32
)ctx
->task
->paddr
+
772 offsetof(struct hva_h264_task
, po
);
774 /* swap spatial and temporal context */
776 paddr
= seq_info
->paddr
;
777 td
->addr_spatial_context
= ALIGN(paddr
, 0x100);
778 paddr
= seq_info
->paddr
+ DATA_SIZE(frame_width
,
780 td
->addr_temporal_context
= ALIGN(paddr
, 0x100);
782 paddr
= seq_info
->paddr
;
783 td
->addr_temporal_context
= ALIGN(paddr
, 0x100);
784 paddr
= seq_info
->paddr
+ DATA_SIZE(frame_width
,
786 td
->addr_spatial_context
= ALIGN(paddr
, 0x100);
789 paddr
= seq_info
->paddr
+ 2 * DATA_SIZE(frame_width
, frame_height
);
791 td
->addr_brc_in_out_parameter
= ALIGN(paddr
, 0x100);
793 paddr
= td
->addr_brc_in_out_parameter
+ BRC_DATA_SIZE
;
794 td
->addr_slice_header
= ALIGN(paddr
, 0x100);
795 td
->addr_external_sw
= ALIGN(addr_esram
, 0x100);
797 addr_esram
+= SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width
);
798 td
->addr_local_rec_buffer
= ALIGN(addr_esram
, 0x100);
800 addr_esram
+= LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width
);
801 td
->addr_lctx
= ALIGN(addr_esram
, 0x100);
803 addr_esram
+= CTX_MB_BUFFER_MAX_SIZE(max(frame_width
, frame_height
));
804 td
->addr_cabac_context_buffer
= ALIGN(addr_esram
, 0x100);
806 if (!(frame_num
% ctrls
->gop_size
)) {
807 td
->picture_coding_type
= PICTURE_CODING_TYPE_I
;
808 stream
->vbuf
.flags
|= V4L2_BUF_FLAG_KEYFRAME
;
810 td
->picture_coding_type
= PICTURE_CODING_TYPE_P
;
811 stream
->vbuf
.flags
&= ~V4L2_BUF_FLAG_KEYFRAME
;
814 /* fill the slice header part */
815 slice_header_vaddr
= seq_info
->vaddr
+ (td
->addr_slice_header
-
818 hva_h264_fill_slice_header(pctx
, slice_header_vaddr
, ctrls
, frame_num
,
819 &td
->slice_header_size_in_bits
,
820 &td
->slice_header_offset0
,
821 &td
->slice_header_offset1
,
822 &td
->slice_header_offset2
);
824 td
->chroma_qp_index_offset
= 2;
825 td
->slice_synchro_enable
= 0;
826 td
->max_slice_number
= 1;
829 * check the sps/pps header size for key frame only
830 * sps/pps header was previously fill by libv4l
831 * during qbuf of stream buffer
833 if ((stream
->vbuf
.flags
== V4L2_BUF_FLAG_KEYFRAME
) &&
834 (payload
> MAX_SPS_PPS_SIZE
)) {
835 dev_err(dev
, "%s invalid sps/pps size %d\n", pctx
->name
,
837 pctx
->frame_errors
++;
841 if (stream
->vbuf
.flags
!= V4L2_BUF_FLAG_KEYFRAME
)
844 /* add SEI nal (video stereo info) */
845 if (ctrls
->sei_fp
&& hva_h264_fill_sei_nal(pctx
, SEI_STEREO_VIDEO_INFO
,
848 dev_err(dev
, "%s fail to get SEI nal\n", pctx
->name
);
849 pctx
->frame_errors
++;
853 /* fill size of non-VCL NAL units (SPS, PPS, filler and SEI) */
854 td
->non_vcl_nalu_size
= payload
* 8;
856 /* compute bitstream offset & new start address of bitstream */
857 td
->addr_output_bitstream_start
+= ((payload
>> 4) << 4);
858 td
->bitstream_offset
+= (payload
- ((payload
>> 4) << 4)) * 8;
860 stream
->bytesused
= payload
;
865 static unsigned int hva_h264_get_stream_size(struct hva_h264_task
*task
)
867 struct hva_h264_po
*po
= &task
->po
;
869 return po
->bitstream_size
;
872 static u32
hva_h264_get_stuffing_bytes(struct hva_h264_task
*task
)
874 struct hva_h264_po
*po
= &task
->po
;
876 return po
->stuffing_bits
>> 3;
879 static int hva_h264_open(struct hva_ctx
*pctx
)
881 struct device
*dev
= ctx_to_dev(pctx
);
882 struct hva_h264_ctx
*ctx
;
883 struct hva_dev
*hva
= ctx_to_hdev(pctx
);
884 u32 frame_width
= pctx
->frameinfo
.aligned_width
;
885 u32 frame_height
= pctx
->frameinfo
.aligned_height
;
889 /* check esram size necessary to encode a frame */
890 size
= SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width
) +
891 LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width
) +
892 CTX_MB_BUFFER_MAX_SIZE(max(frame_width
, frame_height
)) +
893 CABAC_CONTEXT_BUFFER_MAX_SIZE(frame_width
);
895 if (hva
->esram_size
< size
) {
896 dev_err(dev
, "%s not enough esram (max:%d request:%d)\n",
897 pctx
->name
, hva
->esram_size
, size
);
902 /* allocate context for codec */
903 ctx
= devm_kzalloc(dev
, sizeof(*ctx
), GFP_KERNEL
);
909 /* allocate sequence info buffer */
910 ret
= hva_mem_alloc(pctx
,
911 2 * DATA_SIZE(frame_width
, frame_height
) +
918 "%s failed to allocate sequence info buffer\n",
923 /* allocate reference frame buffer */
924 ret
= hva_mem_alloc(pctx
,
925 frame_width
* frame_height
* 3 / 2,
926 "hva reference frame",
929 dev_err(dev
, "%s failed to allocate reference frame buffer\n",
934 /* allocate reconstructed frame buffer */
935 ret
= hva_mem_alloc(pctx
,
936 frame_width
* frame_height
* 3 / 2,
937 "hva reconstructed frame",
941 "%s failed to allocate reconstructed frame buffer\n",
946 /* allocate task descriptor */
947 ret
= hva_mem_alloc(pctx
,
948 sizeof(struct hva_h264_task
),
949 "hva task descriptor",
953 "%s failed to allocate task descriptor\n",
958 pctx
->priv
= (void *)ctx
;
963 hva_mem_free(pctx
, ctx
->rec_frame
);
965 hva_mem_free(pctx
, ctx
->ref_frame
);
967 hva_mem_free(pctx
, ctx
->seq_info
);
969 devm_kfree(dev
, ctx
);
975 static int hva_h264_close(struct hva_ctx
*pctx
)
977 struct hva_h264_ctx
*ctx
= (struct hva_h264_ctx
*)pctx
->priv
;
978 struct device
*dev
= ctx_to_dev(pctx
);
981 hva_mem_free(pctx
, ctx
->seq_info
);
984 hva_mem_free(pctx
, ctx
->ref_frame
);
987 hva_mem_free(pctx
, ctx
->rec_frame
);
990 hva_mem_free(pctx
, ctx
->task
);
992 devm_kfree(dev
, ctx
);
997 static int hva_h264_encode(struct hva_ctx
*pctx
, struct hva_frame
*frame
,
998 struct hva_stream
*stream
)
1000 struct hva_h264_ctx
*ctx
= (struct hva_h264_ctx
*)pctx
->priv
;
1001 struct hva_h264_task
*task
= (struct hva_h264_task
*)ctx
->task
->vaddr
;
1002 u32 stuffing_bytes
= 0;
1005 ret
= hva_h264_prepare_task(pctx
, task
, frame
, stream
);
1009 ret
= hva_hw_execute_task(pctx
, H264_ENC
, ctx
->task
);
1014 stream
->bytesused
+= hva_h264_get_stream_size(task
);
1016 stuffing_bytes
= hva_h264_get_stuffing_bytes(task
);
1019 hva_h264_fill_data_nal(pctx
, stuffing_bytes
,
1020 (u8
*)stream
->vaddr
,
1022 &stream
->bytesused
);
1024 /* switch reference & reconstructed frame */
1025 swap(ctx
->ref_frame
, ctx
->rec_frame
);
1029 stream
->bytesused
= 0;
1033 const struct hva_enc nv12h264enc
= {
1034 .name
= "H264(NV12)",
1035 .pixelformat
= V4L2_PIX_FMT_NV12
,
1036 .streamformat
= V4L2_PIX_FMT_H264
,
1037 .max_width
= H264_MAX_SIZE_W
,
1038 .max_height
= H264_MAX_SIZE_H
,
1039 .open
= hva_h264_open
,
1040 .close
= hva_h264_close
,
1041 .encode
= hva_h264_encode
,
1044 const struct hva_enc nv21h264enc
= {
1045 .name
= "H264(NV21)",
1046 .pixelformat
= V4L2_PIX_FMT_NV21
,
1047 .streamformat
= V4L2_PIX_FMT_H264
,
1048 .max_width
= H264_MAX_SIZE_W
,
1049 .max_height
= H264_MAX_SIZE_H
,
1050 .open
= hva_h264_open
,
1051 .close
= hva_h264_close
,
1052 .encode
= hva_h264_encode
,