1064 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (C) STMicroelectronics SA 20154 * Authors: Yannick Fertre <yannick.fertre@st.com>5 * Hugues Fruchet <hugues.fruchet@st.com>6 */7 8#include "hva.h"9#include "hva-hw.h"10 11#define MAX_SPS_PPS_SIZE 12812 13#define BITSTREAM_OFFSET_MASK 0x7F14 15/* video max size*/16#define H264_MAX_SIZE_W 192017#define H264_MAX_SIZE_H 192018 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 MB37 * for deblocking with size=4*16*MBx*238 */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 120043 44/* factor for bitrate and cpb buffer size max values if profile < high */45#define H264_FACTOR_BASELINE 100046 47/* number of bytes for NALU_TYPE_FILLER_DATA header and footer */48#define H264_FILLER_DATA_SIZE 649 50struct 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 59static 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 78enum hva_brc_type {79 BRC_TYPE_NONE = 0,80 BRC_TYPE_CBR = 1,81 BRC_TYPE_VBR = 2,82 BRC_TYPE_VBR_LOW_DELAY = 383};84 85enum hva_entropy_coding_mode {86 CAVLC = 0,87 CABAC = 188};89 90enum hva_picture_coding_type {91 PICTURE_CODING_TYPE_I = 0,92 PICTURE_CODING_TYPE_P = 1,93 PICTURE_CODING_TYPE_B = 294};95 96enum 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 = 28107};108 109enum 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 = 20128};129 130enum 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 = 45135};136 137/*138 * stereo Video Info struct139 */140struct 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 * struct hva_h264_td151 *152 * @frame_width: width in pixels of the buffer containing the input frame153 * @frame_height: height in pixels of the buffer containing the input frame154 * @frame_num: the parameter to be written in the slice header155 * @picture_coding_type: type I, P or B156 * @pic_order_cnt_type: POC mode, as defined in H264 std : can be 0,1,2157 * @first_picture_in_sequence: flag telling to encoder that this is the158 * first picture in a video sequence.159 * Used for VBR160 * @slice_size_type: 0 = no constraint to close the slice161 * 1= a slice is closed as soon as the slice_mb_size limit162 * is reached163 * 2= a slice is closed as soon as the slice_byte_size limit164 * is reached165 * 3= a slice is closed as soon as either the slice_byte_size166 * limit or the slice_mb_size limit is reached167 * @slice_mb_size: defines the slice size in number of macroblocks168 * (used when slice_size_type=1 or slice_size_type=3)169 * @ir_param_option: defines the number of macroblocks per frame to be170 * refreshed by AIR algorithm OR the refresh period171 * by CIR algorithm172 * @intra_refresh_type: enables the adaptive intra refresh algorithm.173 * Disable=0 / Adaptative=1 and Cycle=2 as intra refresh174 * @use_constrained_intra_flag: constrained_intra_pred_flag from PPS175 * @transform_mode: controls the use of 4x4/8x8 transform mode176 * @disable_deblocking_filter_idc:177 * 0: specifies that all luma and chroma block edges of178 * the slice are filtered.179 * 1: specifies that deblocking is disabled for all block180 * edges of the slice.181 * 2: specifies that all luma and chroma block edges of182 * the slice are filtered with exception of the block edges183 * that coincide with slice boundaries184 * @slice_alpha_c0_offset_div2: to be written in slice header,185 * controls deblocking186 * @slice_beta_offset_div2: to be written in slice header,187 * controls deblocking188 * @encoder_complexity: encoder complexity control (IME).189 * 0 = I_16x16, P_16x16, Full ME Complexity190 * 1 = I_16x16, I_NxN, P_16x16, Full ME Complexity191 * 2 = I_16x16, I_NXN, P_16x16, P_WxH, Full ME Complexity192 * 4 = I_16x16, P_16x16, Reduced ME Complexity193 * 5 = I_16x16, I_NxN, P_16x16, Reduced ME Complexity194 * 6 = I_16x16, I_NXN, P_16x16, P_WxH, Reduced ME Complexity195 * @chroma_qp_index_offset: coming from picture parameter set196 * (PPS see [H.264 STD] 7.4.2.2)197 * @entropy_coding_mode: entropy coding mode.198 * 0 = CAVLC199 * 1 = CABAC200 * @brc_type: selects the bit-rate control algorithm201 * 0 = constant Qp, (no BRC)202 * 1 = CBR203 * 2 = VBR204 * @quant: Quantization param used in case of fix QP encoding (no BRC)205 * @non_VCL_NALU_Size: size of non-VCL NALUs (SPS, PPS, filler),206 * used by BRC207 * @cpb_buffer_size: size of Coded Picture Buffer, used by BRC208 * @bit_rate: target bitrate, for BRC209 * @qp_min: min QP threshold210 * @qp_max: max QP threshold211 * @framerate_num: target framerate numerator , used by BRC212 * @framerate_den: target framerate denomurator , used by BRC213 * @delay: End-to-End Initial Delay214 * @strict_HRD_compliancy: flag for HDR compliancy (1)215 * May impact quality encoding216 * @addr_source_buffer: address of input frame buffer for current frame217 * @addr_fwd_Ref_Buffer: address of reference frame buffer218 * @addr_rec_buffer: address of reconstructed frame buffer219 * @addr_output_bitstream_start: output bitstream start address220 * @addr_output_bitstream_end: output bitstream end address221 * @addr_external_sw : address of external search window222 * @addr_lctx : address of context picture buffer223 * @addr_local_rec_buffer: address of local reconstructed buffer224 * @addr_spatial_context: address of spatial context buffer225 * @bitstream_offset: offset in bits between aligned bitstream start226 * address and first bit to be written by HVA.227 * Range value is [0..63]228 * @sampling_mode: Input picture format .229 * 0: YUV420 semi_planar Interleaved230 * 1: YUV422 raster Interleaved231 * @addr_param_out: address of output parameters structure232 * @addr_scaling_matrix: address to the coefficient of233 * the inverse scaling matrix234 * @addr_scaling_matrix_dir: address to the coefficient of235 * the direct scaling matrix236 * @addr_cabac_context_buffer: address of cabac context buffer237 * @GmvX: Input information about the horizontal global displacement of238 * the encoded frame versus the previous one239 * @GmvY: Input information about the vertical global displacement of240 * the encoded frame versus the previous one241 * @window_width: width in pixels of the window to be encoded inside242 * the input frame243 * @window_height: width in pixels of the window to be encoded inside244 * the input frame245 * @window_horizontal_offset: horizontal offset in pels for input window246 * within input frame247 * @window_vertical_offset: vertical offset in pels for input window248 * within input frame249 * @addr_roi: Map of QP offset for the Region of Interest algorithm and250 * also used for Error map.251 * Bit 0-6 used for qp offset (value -64 to 63).252 * Bit 7 used to force intra253 * @addr_slice_header: address to slice header254 * @slice_header_size_in_bits: size in bits of the Slice header255 * @slice_header_offset0: Slice header offset where to insert256 * first_Mb_in_slice257 * @slice_header_offset1: Slice header offset where to insert258 * slice_qp_delta259 * @slice_header_offset2: Slice header offset where to insert260 * num_MBs_in_slice261 * @slice_synchro_enable: enable "slice ready" interrupt after each slice262 * @max_slice_number: Maximum number of slice in a frame263 * (0 is strictly forbidden)264 * @rgb2_yuv_y_coeff: Four coefficients (C0C1C2C3) to convert from RGB to265 * YUV for the Y component.266 * Y = C0*R + C1*G + C2*B + C3 (C0 is on byte 0)267 * @rgb2_yuv_u_coeff: four coefficients (C0C1C2C3) to convert from RGB to268 * YUV for the Y component.269 * Y = C0*R + C1*G + C2*B + C3 (C0 is on byte 0)270 * @rgb2_yuv_v_coeff: Four coefficients (C0C1C2C3) to convert from RGB to271 * YUV for the U (Cb) component.272 * U = C0*R + C1*G + C2*B + C3 (C0 is on byte 0)273 * @slice_byte_size: maximum slice size in bytes274 * (used when slice_size_type=2 or slice_size_type=3)275 * @max_air_intra_mb_nb: Maximum number of intra macroblock in a frame276 * for the AIR algorithm277 * @brc_no_skip: Disable skipping in the Bitrate Controller278 * @addr_brc_in_out_parameter: address of static buffer for BRC parameters279 */280struct hva_h264_td {281 u16 frame_width;282 u16 frame_height;283 u32 frame_num;284 u16 picture_coding_type;285 u16 reserved1;286 u16 pic_order_cnt_type;287 u16 first_picture_in_sequence;288 u16 slice_size_type;289 u16 reserved2;290 u32 slice_mb_size;291 u16 ir_param_option;292 u16 intra_refresh_type;293 u16 use_constrained_intra_flag;294 u16 transform_mode;295 u16 disable_deblocking_filter_idc;296 s16 slice_alpha_c0_offset_div2;297 s16 slice_beta_offset_div2;298 u16 encoder_complexity;299 s16 chroma_qp_index_offset;300 u16 entropy_coding_mode;301 u16 brc_type;302 u16 quant;303 u32 non_vcl_nalu_size;304 u32 cpb_buffer_size;305 u32 bit_rate;306 u16 qp_min;307 u16 qp_max;308 u16 framerate_num;309 u16 framerate_den;310 u16 delay;311 u16 strict_hrd_compliancy;312 u32 addr_source_buffer;313 u32 addr_fwd_ref_buffer;314 u32 addr_rec_buffer;315 u32 addr_output_bitstream_start;316 u32 addr_output_bitstream_end;317 u32 addr_external_sw;318 u32 addr_lctx;319 u32 addr_local_rec_buffer;320 u32 addr_spatial_context;321 u16 bitstream_offset;322 u16 sampling_mode;323 u32 addr_param_out;324 u32 addr_scaling_matrix;325 u32 addr_scaling_matrix_dir;326 u32 addr_cabac_context_buffer;327 u32 reserved3;328 u32 reserved4;329 s16 gmv_x;330 s16 gmv_y;331 u16 window_width;332 u16 window_height;333 u16 window_horizontal_offset;334 u16 window_vertical_offset;335 u32 addr_roi;336 u32 addr_slice_header;337 u16 slice_header_size_in_bits;338 u16 slice_header_offset0;339 u16 slice_header_offset1;340 u16 slice_header_offset2;341 u32 reserved5;342 u32 reserved6;343 u16 reserved7;344 u16 reserved8;345 u16 slice_synchro_enable;346 u16 max_slice_number;347 u32 rgb2_yuv_y_coeff;348 u32 rgb2_yuv_u_coeff;349 u32 rgb2_yuv_v_coeff;350 u32 slice_byte_size;351 u16 max_air_intra_mb_nb;352 u16 brc_no_skip;353 u32 addr_temporal_context;354 u32 addr_brc_in_out_parameter;355};356 357/*358 * struct hva_h264_slice_po359 *360 * @ slice_size: slice size361 * @ slice_start_time: start time362 * @ slice_stop_time: stop time363 * @ slice_num: slice number364 */365struct hva_h264_slice_po {366 u32 slice_size;367 u32 slice_start_time;368 u32 slice_end_time;369 u32 slice_num;370};371 372/*373 * struct hva_h264_po374 *375 * @ bitstream_size: bitstream size376 * @ dct_bitstream_size: dtc bitstream size377 * @ stuffing_bits: number of stuffing bits inserted by the encoder378 * @ removal_time: removal time of current frame (nb of ticks 1/framerate)379 * @ hvc_start_time: hvc start time380 * @ hvc_stop_time: hvc stop time381 * @ slice_count: slice count382 */383struct hva_h264_po {384 u32 bitstream_size;385 u32 dct_bitstream_size;386 u32 stuffing_bits;387 u32 removal_time;388 u32 hvc_start_time;389 u32 hvc_stop_time;390 u32 slice_count;391 u32 reserved0;392 struct hva_h264_slice_po slice_params[16];393};394 395struct hva_h264_task {396 struct hva_h264_td td;397 struct hva_h264_po po;398};399 400/*401 * struct hva_h264_ctx402 *403 * @seq_info: sequence information buffer404 * @ref_frame: reference frame buffer405 * @rec_frame: reconstructed frame buffer406 * @task: task descriptor407 */408struct hva_h264_ctx {409 struct hva_buffer *seq_info;410 struct hva_buffer *ref_frame;411 struct hva_buffer *rec_frame;412 struct hva_buffer *task;413};414 415static int hva_h264_fill_slice_header(struct hva_ctx *pctx,416 u8 *slice_header_addr,417 struct hva_controls *ctrls,418 int frame_num,419 u16 *header_size,420 u16 *header_offset0,421 u16 *header_offset1,422 u16 *header_offset2)423{424 /*425 * with this HVA hardware version, part of the slice header is computed426 * on host and part by hardware.427 * The part of host is precomputed and available through this array.428 */429 struct device *dev = ctx_to_dev(pctx);430 int cabac = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC;431 static const unsigned char slice_header[] = {432 0x00, 0x00, 0x00, 0x01,433 0x41, 0x34, 0x07, 0x00434 };435 int idr_pic_id = frame_num % 2;436 enum hva_picture_coding_type type;437 u32 frame_order = frame_num % ctrls->gop_size;438 439 if (!(frame_num % ctrls->gop_size))440 type = PICTURE_CODING_TYPE_I;441 else442 type = PICTURE_CODING_TYPE_P;443 444 memcpy(slice_header_addr, slice_header, sizeof(slice_header));445 446 *header_size = 56;447 *header_offset0 = 40;448 *header_offset1 = 13;449 *header_offset2 = 0;450 451 if (type == PICTURE_CODING_TYPE_I) {452 slice_header_addr[4] = 0x65;453 slice_header_addr[5] = 0x11;454 455 /* toggle the I frame */456 if ((frame_num / ctrls->gop_size) % 2) {457 *header_size += 4;458 *header_offset1 += 4;459 slice_header_addr[6] = 0x04;460 slice_header_addr[7] = 0x70;461 462 } else {463 *header_size += 2;464 *header_offset1 += 2;465 slice_header_addr[6] = 0x09;466 slice_header_addr[7] = 0xC0;467 }468 } else {469 if (ctrls->entropy_mode == cabac) {470 *header_size += 1;471 *header_offset1 += 1;472 slice_header_addr[7] = 0x80;473 }474 /*475 * update slice header with P frame order476 * frame order is limited to 16 (coded on 4bits only)477 */478 slice_header_addr[5] += ((frame_order & 0x0C) >> 2);479 slice_header_addr[6] += ((frame_order & 0x03) << 6);480 }481 482 dev_dbg(dev,483 "%s %s slice header order %d idrPicId %d header size %d\n",484 pctx->name, __func__, frame_order, idr_pic_id, *header_size);485 return 0;486}487 488static int hva_h264_fill_data_nal(struct hva_ctx *pctx,489 unsigned int stuffing_bytes, u8 *addr,490 unsigned int stream_size, unsigned int *size)491{492 struct device *dev = ctx_to_dev(pctx);493 static const u8 start[] = { 0x00, 0x00, 0x00, 0x01 };494 495 dev_dbg(dev, "%s %s stuffing bytes %d\n", pctx->name, __func__,496 stuffing_bytes);497 498 if ((*size + stuffing_bytes + H264_FILLER_DATA_SIZE) > stream_size) {499 dev_dbg(dev, "%s %s too many stuffing bytes %d\n",500 pctx->name, __func__, stuffing_bytes);501 return 0;502 }503 504 /* start code */505 memcpy(addr + *size, start, sizeof(start));506 *size += sizeof(start);507 508 /* nal_unit_type */509 addr[*size] = NALU_TYPE_FILLER_DATA;510 *size += 1;511 512 memset(addr + *size, 0xff, stuffing_bytes);513 *size += stuffing_bytes;514 515 addr[*size] = 0x80;516 *size += 1;517 518 return 0;519}520 521static int hva_h264_fill_sei_nal(struct hva_ctx *pctx,522 enum hva_h264_sei_payload_type type,523 u8 *addr, u32 *size)524{525 struct device *dev = ctx_to_dev(pctx);526 static const u8 start[] = { 0x00, 0x00, 0x00, 0x01 };527 struct hva_h264_stereo_video_sei info;528 u8 offset = 7;529 u8 msg = 0;530 531 /* start code */532 memcpy(addr + *size, start, sizeof(start));533 *size += sizeof(start);534 535 /* nal_unit_type */536 addr[*size] = NALU_TYPE_SEI;537 *size += 1;538 539 /* payload type */540 addr[*size] = type;541 *size += 1;542 543 switch (type) {544 case SEI_STEREO_VIDEO_INFO:545 memset(&info, 0, sizeof(info));546 547 /* set to top/bottom frame packing arrangement */548 info.field_views_flag = 1;549 info.top_field_is_left_view_flag = 1;550 551 /* payload size */552 addr[*size] = 1;553 *size += 1;554 555 /* payload */556 msg = info.field_views_flag << offset--;557 558 if (info.field_views_flag) {559 msg |= info.top_field_is_left_view_flag <<560 offset--;561 } else {562 msg |= info.current_frame_is_left_view_flag <<563 offset--;564 msg |= info.next_frame_is_second_view_flag <<565 offset--;566 }567 msg |= info.left_view_self_contained_flag << offset--;568 msg |= info.right_view_self_contained_flag << offset--;569 570 addr[*size] = msg;571 *size += 1;572 573 addr[*size] = 0x80;574 *size += 1;575 576 return 0;577 case SEI_BUFFERING_PERIOD:578 case SEI_PICTURE_TIMING:579 case SEI_FRAME_PACKING_ARRANGEMENT:580 default:581 dev_err(dev, "%s sei nal type not supported %d\n",582 pctx->name, type);583 return -EINVAL;584 }585}586 587static int hva_h264_prepare_task(struct hva_ctx *pctx,588 struct hva_h264_task *task,589 struct hva_frame *frame,590 struct hva_stream *stream)591{592 struct hva_dev *hva = ctx_to_hdev(pctx);593 struct device *dev = ctx_to_dev(pctx);594 struct hva_h264_ctx *ctx = pctx->priv;595 struct hva_buffer *seq_info = ctx->seq_info;596 struct hva_buffer *fwd_ref_frame = ctx->ref_frame;597 struct hva_buffer *loc_rec_frame = ctx->rec_frame;598 struct hva_h264_td *td = &task->td;599 struct hva_controls *ctrls = &pctx->ctrls;600 struct v4l2_fract *time_per_frame = &pctx->ctrls.time_per_frame;601 int cavlc = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC;602 u32 frame_num = pctx->stream_num;603 u32 addr_esram = hva->esram_addr;604 enum v4l2_mpeg_video_h264_level level;605 dma_addr_t paddr = 0;606 u8 *slice_header_vaddr;607 u32 frame_width = frame->info.aligned_width;608 u32 frame_height = frame->info.aligned_height;609 u32 max_cpb_buffer_size;610 unsigned int payload = stream->bytesused;611 u32 max_bitrate;612 613 /* check width and height parameters */614 if ((frame_width > max(H264_MAX_SIZE_W, H264_MAX_SIZE_H)) ||615 (frame_height > max(H264_MAX_SIZE_W, H264_MAX_SIZE_H))) {616 dev_err(dev,617 "%s width(%d) or height(%d) exceeds limits (%dx%d)\n",618 pctx->name, frame_width, frame_height,619 H264_MAX_SIZE_W, H264_MAX_SIZE_H);620 pctx->frame_errors++;621 return -EINVAL;622 }623 624 level = ctrls->level;625 626 memset(td, 0, sizeof(struct hva_h264_td));627 628 td->frame_width = frame_width;629 td->frame_height = frame_height;630 631 /* set frame alignment */632 td->window_width = frame_width;633 td->window_height = frame_height;634 td->window_horizontal_offset = 0;635 td->window_vertical_offset = 0;636 637 td->first_picture_in_sequence = (!frame_num) ? 1 : 0;638 639 /* pic_order_cnt_type hard coded to '2' as only I & P frames */640 td->pic_order_cnt_type = 2;641 642 /* useConstrainedIntraFlag set to false for better coding efficiency */643 td->use_constrained_intra_flag = false;644 td->brc_type = (ctrls->bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)645 ? BRC_TYPE_CBR : BRC_TYPE_VBR;646 647 td->entropy_coding_mode = (ctrls->entropy_mode == cavlc) ? CAVLC :648 CABAC;649 650 td->bit_rate = ctrls->bitrate;651 652 /* set framerate, framerate = 1 n/ time per frame */653 if (time_per_frame->numerator >= 536) {654 /*655 * due to a hardware bug, framerate denominator can't exceed656 * 536 (BRC overflow). Compute nearest framerate657 */658 td->framerate_den = 1;659 td->framerate_num = (time_per_frame->denominator +660 (time_per_frame->numerator >> 1) - 1) /661 time_per_frame->numerator;662 663 /*664 * update bitrate to introduce a correction due to665 * the new framerate666 * new bitrate = (old bitrate * new framerate) / old framerate667 */668 td->bit_rate /= time_per_frame->numerator;669 td->bit_rate *= time_per_frame->denominator;670 td->bit_rate /= td->framerate_num;671 } else {672 td->framerate_den = time_per_frame->numerator;673 td->framerate_num = time_per_frame->denominator;674 }675 676 /* compute maximum bitrate depending on profile */677 if (ctrls->profile >= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)678 max_bitrate = h264_infos_list[level].max_bitrate *679 H264_FACTOR_HIGH;680 else681 max_bitrate = h264_infos_list[level].max_bitrate *682 H264_FACTOR_BASELINE;683 684 /* check if bitrate doesn't exceed max size */685 if (td->bit_rate > max_bitrate) {686 dev_dbg(dev,687 "%s bitrate (%d) larger than level and profile allow, clip to %d\n",688 pctx->name, td->bit_rate, max_bitrate);689 td->bit_rate = max_bitrate;690 }691 692 /* convert cpb_buffer_size in bits */693 td->cpb_buffer_size = ctrls->cpb_size * 8000;694 695 /* compute maximum cpb buffer size depending on profile */696 if (ctrls->profile >= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)697 max_cpb_buffer_size =698 h264_infos_list[level].max_cpb_size * H264_FACTOR_HIGH;699 else700 max_cpb_buffer_size =701 h264_infos_list[level].max_cpb_size * H264_FACTOR_BASELINE;702 703 /* check if cpb buffer size doesn't exceed max size */704 if (td->cpb_buffer_size > max_cpb_buffer_size) {705 dev_dbg(dev,706 "%s cpb size larger than level %d allows, clip to %d\n",707 pctx->name, td->cpb_buffer_size, max_cpb_buffer_size);708 td->cpb_buffer_size = max_cpb_buffer_size;709 }710 711 /* enable skipping in the Bitrate Controller */712 td->brc_no_skip = 0;713 714 /* initial delay */715 if ((ctrls->bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) &&716 td->bit_rate)717 td->delay = 1000 * (td->cpb_buffer_size / td->bit_rate);718 else719 td->delay = 0;720 721 switch (frame->info.pixelformat) {722 case V4L2_PIX_FMT_NV12:723 td->sampling_mode = SAMPLING_MODE_NV12;724 break;725 case V4L2_PIX_FMT_NV21:726 td->sampling_mode = SAMPLING_MODE_NV21;727 break;728 default:729 dev_err(dev, "%s invalid source pixel format\n",730 pctx->name);731 pctx->frame_errors++;732 return -EINVAL;733 }734 735 /*736 * fill matrix color converter (RGB to YUV)737 * Y = 0,299 R + 0,587 G + 0,114 B738 * Cb = -0,1687 R -0,3313 G + 0,5 B + 128739 * Cr = 0,5 R - 0,4187 G - 0,0813 B + 128740 */741 td->rgb2_yuv_y_coeff = 0x12031008;742 td->rgb2_yuv_u_coeff = 0x800EF7FB;743 td->rgb2_yuv_v_coeff = 0x80FEF40E;744 745 /* enable/disable transform mode */746 td->transform_mode = ctrls->dct8x8;747 748 /* encoder complexity fix to 2, ENCODE_I_16x16_I_NxN_P_16x16_P_WxH */749 td->encoder_complexity = 2;750 751 /* quant fix to 28, default VBR value */752 td->quant = 28;753 754 if (td->framerate_den == 0) {755 dev_err(dev, "%s invalid framerate\n", pctx->name);756 pctx->frame_errors++;757 return -EINVAL;758 }759 760 /* if automatic framerate, deactivate bitrate controller */761 if (td->framerate_num == 0)762 td->brc_type = 0;763 764 /* compliancy fix to true */765 td->strict_hrd_compliancy = 1;766 767 /* set minimum & maximum quantizers */768 td->qp_min = clamp_val(ctrls->qpmin, 0, 51);769 td->qp_max = clamp_val(ctrls->qpmax, 0, 51);770 771 td->addr_source_buffer = frame->paddr;772 td->addr_fwd_ref_buffer = fwd_ref_frame->paddr;773 td->addr_rec_buffer = loc_rec_frame->paddr;774 775 td->addr_output_bitstream_end = (u32)stream->paddr + stream->size;776 777 td->addr_output_bitstream_start = (u32)stream->paddr;778 td->bitstream_offset = (((u32)stream->paddr & 0xF) << 3) &779 BITSTREAM_OFFSET_MASK;780 781 td->addr_param_out = (u32)ctx->task->paddr +782 offsetof(struct hva_h264_task, po);783 784 /* swap spatial and temporal context */785 if (frame_num % 2) {786 paddr = seq_info->paddr;787 td->addr_spatial_context = ALIGN(paddr, 0x100);788 paddr = seq_info->paddr + DATA_SIZE(frame_width,789 frame_height);790 td->addr_temporal_context = ALIGN(paddr, 0x100);791 } else {792 paddr = seq_info->paddr;793 td->addr_temporal_context = ALIGN(paddr, 0x100);794 paddr = seq_info->paddr + DATA_SIZE(frame_width,795 frame_height);796 td->addr_spatial_context = ALIGN(paddr, 0x100);797 }798 799 paddr = seq_info->paddr + 2 * DATA_SIZE(frame_width, frame_height);800 801 td->addr_brc_in_out_parameter = ALIGN(paddr, 0x100);802 803 paddr = td->addr_brc_in_out_parameter + BRC_DATA_SIZE;804 td->addr_slice_header = ALIGN(paddr, 0x100);805 td->addr_external_sw = ALIGN(addr_esram, 0x100);806 807 addr_esram += SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width);808 td->addr_local_rec_buffer = ALIGN(addr_esram, 0x100);809 810 addr_esram += LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width);811 td->addr_lctx = ALIGN(addr_esram, 0x100);812 813 addr_esram += CTX_MB_BUFFER_MAX_SIZE(max(frame_width, frame_height));814 td->addr_cabac_context_buffer = ALIGN(addr_esram, 0x100);815 816 if (!(frame_num % ctrls->gop_size)) {817 td->picture_coding_type = PICTURE_CODING_TYPE_I;818 stream->vbuf.flags |= V4L2_BUF_FLAG_KEYFRAME;819 } else {820 td->picture_coding_type = PICTURE_CODING_TYPE_P;821 stream->vbuf.flags &= ~V4L2_BUF_FLAG_KEYFRAME;822 }823 824 /* fill the slice header part */825 slice_header_vaddr = seq_info->vaddr + (td->addr_slice_header -826 seq_info->paddr);827 828 hva_h264_fill_slice_header(pctx, slice_header_vaddr, ctrls, frame_num,829 &td->slice_header_size_in_bits,830 &td->slice_header_offset0,831 &td->slice_header_offset1,832 &td->slice_header_offset2);833 834 td->chroma_qp_index_offset = 2;835 td->slice_synchro_enable = 0;836 td->max_slice_number = 1;837 838 /*839 * check the sps/pps header size for key frame only840 * sps/pps header was previously fill by libv4l841 * during qbuf of stream buffer842 */843 if ((stream->vbuf.flags == V4L2_BUF_FLAG_KEYFRAME) &&844 (payload > MAX_SPS_PPS_SIZE)) {845 dev_err(dev, "%s invalid sps/pps size %d\n", pctx->name,846 payload);847 pctx->frame_errors++;848 return -EINVAL;849 }850 851 if (stream->vbuf.flags != V4L2_BUF_FLAG_KEYFRAME)852 payload = 0;853 854 /* add SEI nal (video stereo info) */855 if (ctrls->sei_fp && hva_h264_fill_sei_nal(pctx, SEI_STEREO_VIDEO_INFO,856 (u8 *)stream->vaddr,857 &payload)) {858 dev_err(dev, "%s fail to get SEI nal\n", pctx->name);859 pctx->frame_errors++;860 return -EINVAL;861 }862 863 /* fill size of non-VCL NAL units (SPS, PPS, filler and SEI) */864 td->non_vcl_nalu_size = payload * 8;865 866 /* compute bitstream offset & new start address of bitstream */867 td->addr_output_bitstream_start += ((payload >> 4) << 4);868 td->bitstream_offset += (payload - ((payload >> 4) << 4)) * 8;869 870 stream->bytesused = payload;871 872 return 0;873}874 875static unsigned int hva_h264_get_stream_size(struct hva_h264_task *task)876{877 struct hva_h264_po *po = &task->po;878 879 return po->bitstream_size;880}881 882static u32 hva_h264_get_stuffing_bytes(struct hva_h264_task *task)883{884 struct hva_h264_po *po = &task->po;885 886 return po->stuffing_bits >> 3;887}888 889static int hva_h264_open(struct hva_ctx *pctx)890{891 struct device *dev = ctx_to_dev(pctx);892 struct hva_h264_ctx *ctx;893 struct hva_dev *hva = ctx_to_hdev(pctx);894 u32 frame_width = pctx->frameinfo.aligned_width;895 u32 frame_height = pctx->frameinfo.aligned_height;896 u32 size;897 int ret;898 899 /* check esram size necessary to encode a frame */900 size = SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width) +901 LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width) +902 CTX_MB_BUFFER_MAX_SIZE(max(frame_width, frame_height)) +903 CABAC_CONTEXT_BUFFER_MAX_SIZE(frame_width);904 905 if (hva->esram_size < size) {906 dev_err(dev, "%s not enough esram (max:%d request:%d)\n",907 pctx->name, hva->esram_size, size);908 ret = -EINVAL;909 goto err;910 }911 912 /* allocate context for codec */913 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);914 if (!ctx) {915 ret = -ENOMEM;916 goto err;917 }918 919 /* allocate sequence info buffer */920 ret = hva_mem_alloc(pctx,921 2 * DATA_SIZE(frame_width, frame_height) +922 SLICE_HEADER_SIZE +923 BRC_DATA_SIZE,924 "hva sequence info",925 &ctx->seq_info);926 if (ret) {927 dev_err(dev,928 "%s failed to allocate sequence info buffer\n",929 pctx->name);930 goto err_ctx;931 }932 933 /* allocate reference frame buffer */934 ret = hva_mem_alloc(pctx,935 frame_width * frame_height * 3 / 2,936 "hva reference frame",937 &ctx->ref_frame);938 if (ret) {939 dev_err(dev, "%s failed to allocate reference frame buffer\n",940 pctx->name);941 goto err_seq_info;942 }943 944 /* allocate reconstructed frame buffer */945 ret = hva_mem_alloc(pctx,946 frame_width * frame_height * 3 / 2,947 "hva reconstructed frame",948 &ctx->rec_frame);949 if (ret) {950 dev_err(dev,951 "%s failed to allocate reconstructed frame buffer\n",952 pctx->name);953 goto err_ref_frame;954 }955 956 /* allocate task descriptor */957 ret = hva_mem_alloc(pctx,958 sizeof(struct hva_h264_task),959 "hva task descriptor",960 &ctx->task);961 if (ret) {962 dev_err(dev,963 "%s failed to allocate task descriptor\n",964 pctx->name);965 goto err_rec_frame;966 }967 968 pctx->priv = (void *)ctx;969 970 return 0;971 972err_rec_frame:973 hva_mem_free(pctx, ctx->rec_frame);974err_ref_frame:975 hva_mem_free(pctx, ctx->ref_frame);976err_seq_info:977 hva_mem_free(pctx, ctx->seq_info);978err_ctx:979 devm_kfree(dev, ctx);980err:981 pctx->sys_errors++;982 return ret;983}984 985static int hva_h264_close(struct hva_ctx *pctx)986{987 struct hva_h264_ctx *ctx = pctx->priv;988 struct device *dev = ctx_to_dev(pctx);989 990 if (ctx->seq_info)991 hva_mem_free(pctx, ctx->seq_info);992 993 if (ctx->ref_frame)994 hva_mem_free(pctx, ctx->ref_frame);995 996 if (ctx->rec_frame)997 hva_mem_free(pctx, ctx->rec_frame);998 999 if (ctx->task)1000 hva_mem_free(pctx, ctx->task);1001 1002 devm_kfree(dev, ctx);1003 1004 return 0;1005}1006 1007static int hva_h264_encode(struct hva_ctx *pctx, struct hva_frame *frame,1008 struct hva_stream *stream)1009{1010 struct hva_h264_ctx *ctx = pctx->priv;1011 struct hva_h264_task *task = ctx->task->vaddr;1012 u32 stuffing_bytes = 0;1013 int ret = 0;1014 1015 ret = hva_h264_prepare_task(pctx, task, frame, stream);1016 if (ret)1017 goto err;1018 1019 ret = hva_hw_execute_task(pctx, H264_ENC, ctx->task);1020 if (ret)1021 goto err;1022 1023 pctx->stream_num++;1024 stream->bytesused += hva_h264_get_stream_size(task);1025 1026 stuffing_bytes = hva_h264_get_stuffing_bytes(task);1027 1028 if (stuffing_bytes)1029 hva_h264_fill_data_nal(pctx, stuffing_bytes,1030 (u8 *)stream->vaddr,1031 stream->size,1032 &stream->bytesused);1033 1034 /* switch reference & reconstructed frame */1035 swap(ctx->ref_frame, ctx->rec_frame);1036 1037 return 0;1038err:1039 stream->bytesused = 0;1040 return ret;1041}1042 1043const struct hva_enc nv12h264enc = {1044 .name = "H264(NV12)",1045 .pixelformat = V4L2_PIX_FMT_NV12,1046 .streamformat = V4L2_PIX_FMT_H264,1047 .max_width = H264_MAX_SIZE_W,1048 .max_height = H264_MAX_SIZE_H,1049 .open = hva_h264_open,1050 .close = hva_h264_close,1051 .encode = hva_h264_encode,1052};1053 1054const struct hva_enc nv21h264enc = {1055 .name = "H264(NV21)",1056 .pixelformat = V4L2_PIX_FMT_NV21,1057 .streamformat = V4L2_PIX_FMT_H264,1058 .max_width = H264_MAX_SIZE_W,1059 .max_height = H264_MAX_SIZE_H,1060 .open = hva_h264_open,1061 .close = hva_h264_close,1062 .encode = hva_h264_encode,1063};1064