drivers/media/platform/sti/hva/hva-h264.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
hva_h264_fill_slice_header
hva_h264_fill_data_nal
hva_h264_fill_sei_nal
hva_h264_prepare_task
hva_h264_get_stream_size
hva_h264_get_stuffing_bytes
hva_h264_open
hva_h264_close
hva_h264_encode
   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) STMicroelectronics SA 2015
   4  * 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 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  * struct hva_h264_td
 151  *
 152  * @frame_width: width in pixels of the buffer containing the input frame
 153  * @frame_height: height in pixels of the buffer containing the input frame
 154  * @frame_num: the parameter to be written in the slice header
 155  * @picture_coding_type: type I, P or B
 156  * @pic_order_cnt_type: POC mode, as defined in H264 std : can be 0,1,2
 157  * @first_picture_in_sequence: flag telling to encoder that this is the
 158  *                             first picture in a video sequence.
 159  *                             Used for VBR
 160  * @slice_size_type: 0 = no constraint to close the slice
 161  *                   1= a slice is closed as soon as the slice_mb_size limit
 162  *                      is reached
 163  *                   2= a slice is closed as soon as the slice_byte_size limit
 164  *                      is reached
 165  *                   3= a slice is closed as soon as either the slice_byte_size
 166  *                      limit or the slice_mb_size limit is reached
 167  * @slice_mb_size: defines the slice size in number of macroblocks
 168  *                 (used when slice_size_type=1 or slice_size_type=3)
 169  * @ir_param_option: defines the number of macroblocks per frame to be
 170  *                   refreshed by AIR algorithm OR the refresh period
 171  *                   by CIR algorithm
 172  * @intra_refresh_type: enables the adaptive intra refresh algorithm.
 173  *                      Disable=0 / Adaptative=1 and Cycle=2 as intra refresh
 174  * @use_constrained_intra_flag: constrained_intra_pred_flag from PPS
 175  * @transform_mode: controls the use of 4x4/8x8 transform mode
 176  * @disable_deblocking_filter_idc:
 177  *                   0: specifies that all luma and chroma block edges of
 178  *                      the slice are filtered.
 179  *                   1: specifies that deblocking is disabled for all block
 180  *                      edges of the slice.
 181  *                   2: specifies that all luma and chroma block edges of
 182  *                      the slice are filtered with exception of the block edges
 183  *                      that coincide with slice boundaries
 184  * @slice_alpha_c0_offset_div2: to be written in slice header,
 185  *                              controls deblocking
 186  * @slice_beta_offset_div2: to be written in slice header,
 187  *                          controls deblocking
 188  * @encoder_complexity: encoder complexity control (IME).
 189  *                   0 = I_16x16, P_16x16, Full ME Complexity
 190  *                   1 = I_16x16, I_NxN, P_16x16, Full ME Complexity
 191  *                   2 = I_16x16, I_NXN, P_16x16, P_WxH, Full ME Complexity
 192  *                   4 = I_16x16, P_16x16, Reduced ME Complexity
 193  *                   5 = I_16x16, I_NxN, P_16x16, Reduced ME Complexity
 194  *                   6 = I_16x16, I_NXN, P_16x16, P_WxH, Reduced ME Complexity
 195  *  @chroma_qp_index_offset: coming from picture parameter set
 196  *                           (PPS see [H.264 STD] 7.4.2.2)
 197  *  @entropy_coding_mode: entropy coding mode.
 198  *                        0 = CAVLC
 199  *                        1 = CABAC
 200  * @brc_type: selects the bit-rate control algorithm
 201  *                   0 = constant Qp, (no BRC)
 202  *                   1 = CBR
 203  *                   2 = VBR
 204  * @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 BRC
 207  * @cpb_buffer_size: size of Coded Picture Buffer, used by BRC
 208  * @bit_rate: target bitrate, for BRC
 209  * @qp_min: min QP threshold
 210  * @qp_max: max QP threshold
 211  * @framerate_num: target framerate numerator , used by BRC
 212  * @framerate_den: target framerate denomurator , used by BRC
 213  * @delay: End-to-End Initial Delay
 214  * @strict_HRD_compliancy: flag for HDR compliancy (1)
 215  *                         May impact quality encoding
 216  * @addr_source_buffer: address of input frame buffer for current frame
 217  * @addr_fwd_Ref_Buffer: address of reference frame buffer
 218  * @addr_rec_buffer: address of reconstructed frame buffer
 219  * @addr_output_bitstream_start: output bitstream start address
 220  * @addr_output_bitstream_end: output bitstream end address
 221  * @addr_external_sw : address of external search window
 222  * @addr_lctx : address of context picture buffer
 223  * @addr_local_rec_buffer: address of local reconstructed buffer
 224  * @addr_spatial_context: address of spatial context buffer
 225  * @bitstream_offset: offset in bits between aligned bitstream start
 226  *                    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 Interleaved
 230  *                   1: YUV422 raster Interleaved
 231  * @addr_param_out: address of output parameters structure
 232  * @addr_scaling_matrix: address to the coefficient of
 233  *                       the inverse scaling matrix
 234  * @addr_scaling_matrix_dir: address to the coefficient of
 235  *                           the direct scaling matrix
 236  * @addr_cabac_context_buffer: address of cabac context buffer
 237  * @GmvX: Input information about the horizontal global displacement of
 238  *        the encoded frame versus the previous one
 239  * @GmvY: Input information about the vertical global displacement of
 240  *        the encoded frame versus the previous one
 241  * @window_width: width in pixels of the window to be encoded inside
 242  *                the input frame
 243  * @window_height: width in pixels of the window to be encoded inside
 244  *                 the input frame
 245  * @window_horizontal_offset: horizontal offset in pels for input window
 246  *                            within input frame
 247  * @window_vertical_offset: vertical offset in pels for input window
 248  *                          within input frame
 249  * @addr_roi: Map of QP offset for the Region of Interest algorithm and
 250  *            also used for Error map.
 251  *            Bit 0-6 used for qp offset (value -64 to 63).
 252  *            Bit 7 used to force intra
 253  * @addr_slice_header: address to slice header
 254  * @slice_header_size_in_bits: size in bits of the Slice header
 255  * @slice_header_offset0: Slice header offset where to insert
 256  *                        first_Mb_in_slice
 257  * @slice_header_offset1: Slice header offset where to insert
 258  *                        slice_qp_delta
 259  * @slice_header_offset2: Slice header offset where to insert
 260  *                        num_MBs_in_slice
 261  * @slice_synchro_enable: enable "slice ready" interrupt after each slice
 262  * @max_slice_number: Maximum number of slice in a frame
 263  *                    (0 is strictly forbidden)
 264  * @rgb2_yuv_y_coeff: Four coefficients (C0C1C2C3) to convert from RGB to
 265  *                    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 to
 268  *                    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 to
 271  *                    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 bytes
 274  *                   (used when slice_size_type=2 or slice_size_type=3)
 275  * @max_air_intra_mb_nb: Maximum number of intra macroblock in a frame
 276  *                       for the AIR algorithm
 277  * @brc_no_skip: Disable skipping in the Bitrate Controller
 278  * @addr_brc_in_out_parameter: address of static buffer for BRC parameters
 279  */
 280 struct 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_po
 359  *
 360  * @ slice_size: slice size
 361  * @ slice_start_time: start time
 362  * @ slice_stop_time: stop time
 363  * @ slice_num: slice number
 364  */
 365 struct 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_po
 374  *
 375  * @ bitstream_size: bitstream size
 376  * @ dct_bitstream_size: dtc bitstream size
 377  * @ stuffing_bits: number of stuffing bits inserted by the encoder
 378  * @ removal_time: removal time of current frame (nb of ticks 1/framerate)
 379  * @ hvc_start_time: hvc start time
 380  * @ hvc_stop_time: hvc stop time
 381  * @ slice_count: slice count
 382  */
 383 struct 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 
 395 struct hva_h264_task {
 396         struct hva_h264_td td;
 397         struct hva_h264_po po;
 398 };
 399 
 400 /*
 401  * struct hva_h264_ctx
 402  *
 403  * @seq_info:  sequence information buffer
 404  * @ref_frame: reference frame buffer
 405  * @rec_frame: reconstructed frame buffer
 406  * @task:      task descriptor
 407  */
 408 struct 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 
 415 static 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 computed
 426          * 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         const unsigned char slice_header[] = { 0x00, 0x00, 0x00, 0x01,
 432                                                0x41, 0x34, 0x07, 0x00};
 433         int idr_pic_id = frame_num % 2;
 434         enum hva_picture_coding_type type;
 435         u32 frame_order = frame_num % ctrls->gop_size;
 436 
 437         if (!(frame_num % ctrls->gop_size))
 438                 type = PICTURE_CODING_TYPE_I;
 439         else
 440                 type = PICTURE_CODING_TYPE_P;
 441 
 442         memcpy(slice_header_addr, slice_header, sizeof(slice_header));
 443 
 444         *header_size = 56;
 445         *header_offset0 = 40;
 446         *header_offset1 = 13;
 447         *header_offset2 = 0;
 448 
 449         if (type == PICTURE_CODING_TYPE_I) {
 450                 slice_header_addr[4] = 0x65;
 451                 slice_header_addr[5] = 0x11;
 452 
 453                 /* toggle the I frame */
 454                 if ((frame_num / ctrls->gop_size) % 2) {
 455                         *header_size += 4;
 456                         *header_offset1 += 4;
 457                         slice_header_addr[6] = 0x04;
 458                         slice_header_addr[7] = 0x70;
 459 
 460                 } else {
 461                         *header_size += 2;
 462                         *header_offset1 += 2;
 463                         slice_header_addr[6] = 0x09;
 464                         slice_header_addr[7] = 0xC0;
 465                 }
 466         } else {
 467                 if (ctrls->entropy_mode == cabac) {
 468                         *header_size += 1;
 469                         *header_offset1 += 1;
 470                         slice_header_addr[7] = 0x80;
 471                 }
 472                 /*
 473                  * update slice header with P frame order
 474                  * frame order is limited to 16 (coded on 4bits only)
 475                  */
 476                 slice_header_addr[5] += ((frame_order & 0x0C) >> 2);
 477                 slice_header_addr[6] += ((frame_order & 0x03) << 6);
 478         }
 479 
 480         dev_dbg(dev,
 481                 "%s   %s slice header order %d idrPicId %d header size %d\n",
 482                 pctx->name, __func__, frame_order, idr_pic_id, *header_size);
 483         return 0;
 484 }
 485 
 486 static int hva_h264_fill_data_nal(struct hva_ctx *pctx,
 487                                   unsigned int stuffing_bytes, u8 *addr,
 488                                   unsigned int stream_size, unsigned int *size)
 489 {
 490         struct device *dev = ctx_to_dev(pctx);
 491         const u8 start[] = { 0x00, 0x00, 0x00, 0x01 };
 492 
 493         dev_dbg(dev, "%s   %s stuffing bytes %d\n", pctx->name, __func__,
 494                 stuffing_bytes);
 495 
 496         if ((*size + stuffing_bytes + H264_FILLER_DATA_SIZE) > stream_size) {
 497                 dev_dbg(dev, "%s   %s too many stuffing bytes %d\n",
 498                         pctx->name, __func__, stuffing_bytes);
 499                 return 0;
 500         }
 501 
 502         /* start code */
 503         memcpy(addr + *size, start, sizeof(start));
 504         *size += sizeof(start);
 505 
 506         /* nal_unit_type */
 507         addr[*size] = NALU_TYPE_FILLER_DATA;
 508         *size += 1;
 509 
 510         memset(addr + *size, 0xff, stuffing_bytes);
 511         *size += stuffing_bytes;
 512 
 513         addr[*size] = 0x80;
 514         *size += 1;
 515 
 516         return 0;
 517 }
 518 
 519 static int hva_h264_fill_sei_nal(struct hva_ctx *pctx,
 520                                  enum hva_h264_sei_payload_type type,
 521                                  u8 *addr, u32 *size)
 522 {
 523         struct device *dev = ctx_to_dev(pctx);
 524         const u8 start[] = { 0x00, 0x00, 0x00, 0x01 };
 525         struct hva_h264_stereo_video_sei info;
 526         u8 offset = 7;
 527         u8 msg = 0;
 528 
 529         /* start code */
 530         memcpy(addr + *size, start, sizeof(start));
 531         *size += sizeof(start);
 532 
 533         /* nal_unit_type */
 534         addr[*size] = NALU_TYPE_SEI;
 535         *size += 1;
 536 
 537         /* payload type */
 538         addr[*size] = type;
 539         *size += 1;
 540 
 541         switch (type) {
 542         case SEI_STEREO_VIDEO_INFO:
 543                 memset(&info, 0, sizeof(info));
 544 
 545                 /* set to top/bottom frame packing arrangement */
 546                 info.field_views_flag = 1;
 547                 info.top_field_is_left_view_flag = 1;
 548 
 549                 /* payload size */
 550                 addr[*size] = 1;
 551                 *size += 1;
 552 
 553                 /* payload */
 554                 msg = info.field_views_flag << offset--;
 555 
 556                 if (info.field_views_flag) {
 557                         msg |= info.top_field_is_left_view_flag <<
 558                                offset--;
 559                 } else {
 560                         msg |= info.current_frame_is_left_view_flag <<
 561                                offset--;
 562                         msg |= info.next_frame_is_second_view_flag <<
 563                                offset--;
 564                 }
 565                 msg |= info.left_view_self_contained_flag << offset--;
 566                 msg |= info.right_view_self_contained_flag << offset--;
 567 
 568                 addr[*size] = msg;
 569                 *size += 1;
 570 
 571                 addr[*size] = 0x80;
 572                 *size += 1;
 573 
 574                 return 0;
 575         case SEI_BUFFERING_PERIOD:
 576         case SEI_PICTURE_TIMING:
 577         case SEI_FRAME_PACKING_ARRANGEMENT:
 578         default:
 579                 dev_err(dev, "%s   sei nal type not supported %d\n",
 580                         pctx->name, type);
 581                 return -EINVAL;
 582         }
 583 }
 584 
 585 static int hva_h264_prepare_task(struct hva_ctx *pctx,
 586                                  struct hva_h264_task *task,
 587                                  struct hva_frame *frame,
 588                                  struct hva_stream *stream)
 589 {
 590         struct hva_dev *hva = ctx_to_hdev(pctx);
 591         struct device *dev = ctx_to_dev(pctx);
 592         struct hva_h264_ctx *ctx = (struct hva_h264_ctx *)pctx->priv;
 593         struct hva_buffer *seq_info = ctx->seq_info;
 594         struct hva_buffer *fwd_ref_frame = ctx->ref_frame;
 595         struct hva_buffer *loc_rec_frame = ctx->rec_frame;
 596         struct hva_h264_td *td = &task->td;
 597         struct hva_controls *ctrls = &pctx->ctrls;
 598         struct v4l2_fract *time_per_frame = &pctx->ctrls.time_per_frame;
 599         int cavlc =  V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC;
 600         u32 frame_num = pctx->stream_num;
 601         u32 addr_esram = hva->esram_addr;
 602         enum v4l2_mpeg_video_h264_level level;
 603         dma_addr_t paddr = 0;
 604         u8 *slice_header_vaddr;
 605         u32 frame_width = frame->info.aligned_width;
 606         u32 frame_height = frame->info.aligned_height;
 607         u32 max_cpb_buffer_size;
 608         unsigned int payload = stream->bytesused;
 609         u32 max_bitrate;
 610 
 611         /* check width and height parameters */
 612         if ((frame_width > max(H264_MAX_SIZE_W, H264_MAX_SIZE_H)) ||
 613             (frame_height > max(H264_MAX_SIZE_W, H264_MAX_SIZE_H))) {
 614                 dev_err(dev,
 615                         "%s   width(%d) or height(%d) exceeds limits (%dx%d)\n",
 616                         pctx->name, frame_width, frame_height,
 617                         H264_MAX_SIZE_W, H264_MAX_SIZE_H);
 618                 pctx->frame_errors++;
 619                 return -EINVAL;
 620         }
 621 
 622         level = ctrls->level;
 623 
 624         memset(td, 0, sizeof(struct hva_h264_td));
 625 
 626         td->frame_width = frame_width;
 627         td->frame_height = frame_height;
 628 
 629         /* set frame alignment */
 630         td->window_width =  frame_width;
 631         td->window_height = frame_height;
 632         td->window_horizontal_offset = 0;
 633         td->window_vertical_offset = 0;
 634 
 635         td->first_picture_in_sequence = (!frame_num) ? 1 : 0;
 636 
 637         /* pic_order_cnt_type hard coded to '2' as only I & P frames */
 638         td->pic_order_cnt_type = 2;
 639 
 640         /* useConstrainedIntraFlag set to false for better coding efficiency */
 641         td->use_constrained_intra_flag = false;
 642         td->brc_type = (ctrls->bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
 643                         ? BRC_TYPE_CBR : BRC_TYPE_VBR;
 644 
 645         td->entropy_coding_mode = (ctrls->entropy_mode == cavlc) ? CAVLC :
 646                                   CABAC;
 647 
 648         td->bit_rate = ctrls->bitrate;
 649 
 650         /* set framerate, framerate = 1 n/ time per frame */
 651         if (time_per_frame->numerator >= 536) {
 652                 /*
 653                  * due to a hardware bug, framerate denominator can't exceed
 654                  * 536 (BRC overflow). Compute nearest framerate
 655                  */
 656                 td->framerate_den = 1;
 657                 td->framerate_num = (time_per_frame->denominator +
 658                                     (time_per_frame->numerator >> 1) - 1) /
 659                                     time_per_frame->numerator;
 660 
 661                 /*
 662                  * update bitrate to introduce a correction due to
 663                  * the new framerate
 664                  * new bitrate = (old bitrate * new framerate) / old framerate
 665                  */
 666                 td->bit_rate /= time_per_frame->numerator;
 667                 td->bit_rate *= time_per_frame->denominator;
 668                 td->bit_rate /= td->framerate_num;
 669         } else {
 670                 td->framerate_den = time_per_frame->numerator;
 671                 td->framerate_num = time_per_frame->denominator;
 672         }
 673 
 674         /* compute maximum bitrate depending on profile */
 675         if (ctrls->profile >= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)
 676                 max_bitrate = h264_infos_list[level].max_bitrate *
 677                               H264_FACTOR_HIGH;
 678         else
 679                 max_bitrate = h264_infos_list[level].max_bitrate *
 680                               H264_FACTOR_BASELINE;
 681 
 682         /* check if bitrate doesn't exceed max size */
 683         if (td->bit_rate > max_bitrate) {
 684                 dev_dbg(dev,
 685                         "%s   bitrate (%d) larger than level and profile allow, clip to %d\n",
 686                         pctx->name, td->bit_rate, max_bitrate);
 687                 td->bit_rate = max_bitrate;
 688         }
 689 
 690         /* convert cpb_buffer_size in bits */
 691         td->cpb_buffer_size = ctrls->cpb_size * 8000;
 692 
 693         /* compute maximum cpb buffer size depending on profile */
 694         if (ctrls->profile >= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)
 695                 max_cpb_buffer_size =
 696                     h264_infos_list[level].max_cpb_size * H264_FACTOR_HIGH;
 697         else
 698                 max_cpb_buffer_size =
 699                     h264_infos_list[level].max_cpb_size * H264_FACTOR_BASELINE;
 700 
 701         /* check if cpb buffer size doesn't exceed max size */
 702         if (td->cpb_buffer_size > max_cpb_buffer_size) {
 703                 dev_dbg(dev,
 704                         "%s   cpb size larger than level %d allows, clip to %d\n",
 705                         pctx->name, td->cpb_buffer_size, max_cpb_buffer_size);
 706                 td->cpb_buffer_size = max_cpb_buffer_size;
 707         }
 708 
 709         /* enable skipping in the Bitrate Controller */
 710         td->brc_no_skip = 0;
 711 
 712         /* initial delay */
 713         if ((ctrls->bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) &&
 714             td->bit_rate)
 715                 td->delay = 1000 * (td->cpb_buffer_size / td->bit_rate);
 716         else
 717                 td->delay = 0;
 718 
 719         switch (frame->info.pixelformat) {
 720         case V4L2_PIX_FMT_NV12:
 721                 td->sampling_mode = SAMPLING_MODE_NV12;
 722                 break;
 723         case V4L2_PIX_FMT_NV21:
 724                 td->sampling_mode = SAMPLING_MODE_NV21;
 725                 break;
 726         default:
 727                 dev_err(dev, "%s   invalid source pixel format\n",
 728                         pctx->name);
 729                 pctx->frame_errors++;
 730                 return -EINVAL;
 731         }
 732 
 733         /*
 734          * fill matrix color converter (RGB to YUV)
 735          * Y = 0,299 R + 0,587 G + 0,114 B
 736          * Cb = -0,1687 R -0,3313 G + 0,5 B + 128
 737          * Cr = 0,5 R - 0,4187 G - 0,0813 B + 128
 738          */
 739         td->rgb2_yuv_y_coeff = 0x12031008;
 740         td->rgb2_yuv_u_coeff = 0x800EF7FB;
 741         td->rgb2_yuv_v_coeff = 0x80FEF40E;
 742 
 743         /* enable/disable transform mode */
 744         td->transform_mode = ctrls->dct8x8;
 745 
 746         /* encoder complexity fix to 2, ENCODE_I_16x16_I_NxN_P_16x16_P_WxH */
 747         td->encoder_complexity = 2;
 748 
 749         /* quant fix to 28, default VBR value */
 750         td->quant = 28;
 751 
 752         if (td->framerate_den == 0) {
 753                 dev_err(dev, "%s   invalid framerate\n", pctx->name);
 754                 pctx->frame_errors++;
 755                 return -EINVAL;
 756         }
 757 
 758         /* if automatic framerate, deactivate bitrate controller */
 759         if (td->framerate_num == 0)
 760                 td->brc_type = 0;
 761 
 762         /* compliancy fix to true */
 763         td->strict_hrd_compliancy = 1;
 764 
 765         /* set minimum & maximum quantizers */
 766         td->qp_min = clamp_val(ctrls->qpmin, 0, 51);
 767         td->qp_max = clamp_val(ctrls->qpmax, 0, 51);
 768 
 769         td->addr_source_buffer = frame->paddr;
 770         td->addr_fwd_ref_buffer = fwd_ref_frame->paddr;
 771         td->addr_rec_buffer = loc_rec_frame->paddr;
 772 
 773         td->addr_output_bitstream_end = (u32)stream->paddr + stream->size;
 774 
 775         td->addr_output_bitstream_start = (u32)stream->paddr;
 776         td->bitstream_offset = (((u32)stream->paddr & 0xF) << 3) &
 777                                BITSTREAM_OFFSET_MASK;
 778 
 779         td->addr_param_out = (u32)ctx->task->paddr +
 780                              offsetof(struct hva_h264_task, po);
 781 
 782         /* swap spatial and temporal context */
 783         if (frame_num % 2) {
 784                 paddr = seq_info->paddr;
 785                 td->addr_spatial_context =  ALIGN(paddr, 0x100);
 786                 paddr = seq_info->paddr + DATA_SIZE(frame_width,
 787                                                         frame_height);
 788                 td->addr_temporal_context = ALIGN(paddr, 0x100);
 789         } else {
 790                 paddr = seq_info->paddr;
 791                 td->addr_temporal_context = ALIGN(paddr, 0x100);
 792                 paddr = seq_info->paddr + DATA_SIZE(frame_width,
 793                                                         frame_height);
 794                 td->addr_spatial_context =  ALIGN(paddr, 0x100);
 795         }
 796 
 797         paddr = seq_info->paddr + 2 * DATA_SIZE(frame_width, frame_height);
 798 
 799         td->addr_brc_in_out_parameter =  ALIGN(paddr, 0x100);
 800 
 801         paddr = td->addr_brc_in_out_parameter + BRC_DATA_SIZE;
 802         td->addr_slice_header =  ALIGN(paddr, 0x100);
 803         td->addr_external_sw =  ALIGN(addr_esram, 0x100);
 804 
 805         addr_esram += SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width);
 806         td->addr_local_rec_buffer = ALIGN(addr_esram, 0x100);
 807 
 808         addr_esram += LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width);
 809         td->addr_lctx = ALIGN(addr_esram, 0x100);
 810 
 811         addr_esram += CTX_MB_BUFFER_MAX_SIZE(max(frame_width, frame_height));
 812         td->addr_cabac_context_buffer = ALIGN(addr_esram, 0x100);
 813 
 814         if (!(frame_num % ctrls->gop_size)) {
 815                 td->picture_coding_type = PICTURE_CODING_TYPE_I;
 816                 stream->vbuf.flags |= V4L2_BUF_FLAG_KEYFRAME;
 817         } else {
 818                 td->picture_coding_type = PICTURE_CODING_TYPE_P;
 819                 stream->vbuf.flags &= ~V4L2_BUF_FLAG_KEYFRAME;
 820         }
 821 
 822         /* fill the slice header part */
 823         slice_header_vaddr = seq_info->vaddr + (td->addr_slice_header -
 824                              seq_info->paddr);
 825 
 826         hva_h264_fill_slice_header(pctx, slice_header_vaddr, ctrls, frame_num,
 827                                    &td->slice_header_size_in_bits,
 828                                    &td->slice_header_offset0,
 829                                    &td->slice_header_offset1,
 830                                    &td->slice_header_offset2);
 831 
 832         td->chroma_qp_index_offset = 2;
 833         td->slice_synchro_enable = 0;
 834         td->max_slice_number = 1;
 835 
 836         /*
 837          * check the sps/pps header size for key frame only
 838          * sps/pps header was previously fill by libv4l
 839          * during qbuf of stream buffer
 840          */
 841         if ((stream->vbuf.flags == V4L2_BUF_FLAG_KEYFRAME) &&
 842             (payload > MAX_SPS_PPS_SIZE)) {
 843                 dev_err(dev, "%s   invalid sps/pps size %d\n", pctx->name,
 844                         payload);
 845                 pctx->frame_errors++;
 846                 return -EINVAL;
 847         }
 848 
 849         if (stream->vbuf.flags != V4L2_BUF_FLAG_KEYFRAME)
 850                 payload = 0;
 851 
 852         /* add SEI nal (video stereo info) */
 853         if (ctrls->sei_fp && hva_h264_fill_sei_nal(pctx, SEI_STEREO_VIDEO_INFO,
 854                                                    (u8 *)stream->vaddr,
 855                                                    &payload)) {
 856                 dev_err(dev, "%s   fail to get SEI nal\n", pctx->name);
 857                 pctx->frame_errors++;
 858                 return -EINVAL;
 859         }
 860 
 861         /* fill size of non-VCL NAL units (SPS, PPS, filler and SEI) */
 862         td->non_vcl_nalu_size = payload * 8;
 863 
 864         /* compute bitstream offset & new start address of bitstream */
 865         td->addr_output_bitstream_start += ((payload >> 4) << 4);
 866         td->bitstream_offset += (payload - ((payload >> 4) << 4)) * 8;
 867 
 868         stream->bytesused = payload;
 869 
 870         return 0;
 871 }
 872 
 873 static unsigned int hva_h264_get_stream_size(struct hva_h264_task *task)
 874 {
 875         struct hva_h264_po *po = &task->po;
 876 
 877         return po->bitstream_size;
 878 }
 879 
 880 static u32 hva_h264_get_stuffing_bytes(struct hva_h264_task *task)
 881 {
 882         struct hva_h264_po *po = &task->po;
 883 
 884         return po->stuffing_bits >> 3;
 885 }
 886 
 887 static int hva_h264_open(struct hva_ctx *pctx)
 888 {
 889         struct device *dev = ctx_to_dev(pctx);
 890         struct hva_h264_ctx *ctx;
 891         struct hva_dev *hva = ctx_to_hdev(pctx);
 892         u32 frame_width = pctx->frameinfo.aligned_width;
 893         u32 frame_height = pctx->frameinfo.aligned_height;
 894         u32 size;
 895         int ret;
 896 
 897         /* check esram size necessary to encode a frame */
 898         size = SEARCH_WINDOW_BUFFER_MAX_SIZE(frame_width) +
 899                LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(frame_width) +
 900                CTX_MB_BUFFER_MAX_SIZE(max(frame_width, frame_height)) +
 901                CABAC_CONTEXT_BUFFER_MAX_SIZE(frame_width);
 902 
 903         if (hva->esram_size < size) {
 904                 dev_err(dev, "%s   not enough esram (max:%d request:%d)\n",
 905                         pctx->name, hva->esram_size, size);
 906                 ret = -EINVAL;
 907                 goto err;
 908         }
 909 
 910         /* allocate context for codec */
 911         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
 912         if (!ctx) {
 913                 ret = -ENOMEM;
 914                 goto err;
 915         }
 916 
 917         /* allocate sequence info buffer */
 918         ret = hva_mem_alloc(pctx,
 919                             2 * DATA_SIZE(frame_width, frame_height) +
 920                             SLICE_HEADER_SIZE +
 921                             BRC_DATA_SIZE,
 922                             "hva sequence info",
 923                             &ctx->seq_info);
 924         if (ret) {
 925                 dev_err(dev,
 926                         "%s   failed to allocate sequence info buffer\n",
 927                         pctx->name);
 928                 goto err_ctx;
 929         }
 930 
 931         /* allocate reference frame buffer */
 932         ret = hva_mem_alloc(pctx,
 933                             frame_width * frame_height * 3 / 2,
 934                             "hva reference frame",
 935                             &ctx->ref_frame);
 936         if (ret) {
 937                 dev_err(dev, "%s   failed to allocate reference frame buffer\n",
 938                         pctx->name);
 939                 goto err_seq_info;
 940         }
 941 
 942         /* allocate reconstructed frame buffer */
 943         ret = hva_mem_alloc(pctx,
 944                             frame_width * frame_height * 3 / 2,
 945                             "hva reconstructed frame",
 946                             &ctx->rec_frame);
 947         if (ret) {
 948                 dev_err(dev,
 949                         "%s   failed to allocate reconstructed frame buffer\n",
 950                         pctx->name);
 951                 goto err_ref_frame;
 952         }
 953 
 954         /* allocate task descriptor */
 955         ret = hva_mem_alloc(pctx,
 956                             sizeof(struct hva_h264_task),
 957                             "hva task descriptor",
 958                             &ctx->task);
 959         if (ret) {
 960                 dev_err(dev,
 961                         "%s   failed to allocate task descriptor\n",
 962                         pctx->name);
 963                 goto err_rec_frame;
 964         }
 965 
 966         pctx->priv = (void *)ctx;
 967 
 968         return 0;
 969 
 970 err_rec_frame:
 971         hva_mem_free(pctx, ctx->rec_frame);
 972 err_ref_frame:
 973         hva_mem_free(pctx, ctx->ref_frame);
 974 err_seq_info:
 975         hva_mem_free(pctx, ctx->seq_info);
 976 err_ctx:
 977         devm_kfree(dev, ctx);
 978 err:
 979         pctx->sys_errors++;
 980         return ret;
 981 }
 982 
 983 static int hva_h264_close(struct hva_ctx *pctx)
 984 {
 985         struct hva_h264_ctx *ctx = (struct hva_h264_ctx *)pctx->priv;
 986         struct device *dev = ctx_to_dev(pctx);
 987 
 988         if (ctx->seq_info)
 989                 hva_mem_free(pctx, ctx->seq_info);
 990 
 991         if (ctx->ref_frame)
 992                 hva_mem_free(pctx, ctx->ref_frame);
 993 
 994         if (ctx->rec_frame)
 995                 hva_mem_free(pctx, ctx->rec_frame);
 996 
 997         if (ctx->task)
 998                 hva_mem_free(pctx, ctx->task);
 999 
1000         devm_kfree(dev, ctx);
1001 
1002         return 0;
1003 }
1004 
1005 static int hva_h264_encode(struct hva_ctx *pctx, struct hva_frame *frame,
1006                            struct hva_stream *stream)
1007 {
1008         struct hva_h264_ctx *ctx = (struct hva_h264_ctx *)pctx->priv;
1009         struct hva_h264_task *task = (struct hva_h264_task *)ctx->task->vaddr;
1010         u32 stuffing_bytes = 0;
1011         int ret = 0;
1012 
1013         ret = hva_h264_prepare_task(pctx, task, frame, stream);
1014         if (ret)
1015                 goto err;
1016 
1017         ret = hva_hw_execute_task(pctx, H264_ENC, ctx->task);
1018         if (ret)
1019                 goto err;
1020 
1021         pctx->stream_num++;
1022         stream->bytesused += hva_h264_get_stream_size(task);
1023 
1024         stuffing_bytes = hva_h264_get_stuffing_bytes(task);
1025 
1026         if (stuffing_bytes)
1027                 hva_h264_fill_data_nal(pctx, stuffing_bytes,
1028                                        (u8 *)stream->vaddr,
1029                                        stream->size,
1030                                        &stream->bytesused);
1031 
1032         /* switch reference & reconstructed frame */
1033         swap(ctx->ref_frame, ctx->rec_frame);
1034 
1035         return 0;
1036 err:
1037         stream->bytesused = 0;
1038         return ret;
1039 }
1040 
1041 const struct hva_enc nv12h264enc = {
1042         .name = "H264(NV12)",
1043         .pixelformat = V4L2_PIX_FMT_NV12,
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 };
1051 
1052 const struct hva_enc nv21h264enc = {
1053         .name = "H264(NV21)",
1054         .pixelformat = V4L2_PIX_FMT_NV21,
1055         .streamformat = V4L2_PIX_FMT_H264,
1056         .max_width = H264_MAX_SIZE_W,
1057         .max_height = H264_MAX_SIZE_H,
1058         .open = hva_h264_open,
1059         .close = hva_h264_close,
1060         .encode = hva_h264_encode,
1061 };
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/media/platform/sti/hva/hva-h264.c

DEFINITIONS
