1
2
3
4
5
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
16#define H264_MAX_SIZE_W 1920
17#define H264_MAX_SIZE_H 1920
18
19
20#define MB_W(w) ((w + 0xF) / 0x10)
21#define MB_H(h) ((h + 0xF) / 0x10)
22
23
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
33#define CURRENT_WINDOW_BUFFER_MAX_SIZE (16 * 256 * 3 / 2)
34
35
36
37
38
39#define LOCAL_RECONSTRUCTED_BUFFER_MAX_SIZE(w) (4 * 16 * MB_W(w) * 2)
40
41
42#define H264_FACTOR_HIGH 1200
43
44
45#define H264_FACTOR_BASELINE 1000
46
47
48#define H264_FILLER_DATA_SIZE 6
49
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 = 3
83};
84
85enum hva_entropy_coding_mode {
86 CAVLC = 0,
87 CABAC = 1
88};
89
90enum hva_picture_coding_type {
91 PICTURE_CODING_TYPE_I = 0,
92 PICTURE_CODING_TYPE_P = 1,
93 PICTURE_CODING_TYPE_B = 2
94};
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 = 28
107};
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 = 20
128};
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 = 45
135};
136
137
138
139
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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
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
359
360
361
362
363
364
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
374
375
376
377
378
379
380
381
382
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
402
403
404
405
406
407
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
426
427
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, 0x00
434 };
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 else
442 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
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
476
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
505 memcpy(addr + *size, start, sizeof(start));
506 *size += sizeof(start);
507
508
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
532 memcpy(addr + *size, start, sizeof(start));
533 *size += sizeof(start);
534
535
536 addr[*size] = NALU_TYPE_SEI;
537 *size += 1;
538
539
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
548 info.field_views_flag = 1;
549 info.top_field_is_left_view_flag = 1;
550
551
552 addr[*size] = 1;
553 *size += 1;
554
555
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 = (struct hva_h264_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
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
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
640 td->pic_order_cnt_type = 2;
641
642
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
653 if (time_per_frame->numerator >= 536) {
654
655
656
657
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
665
666
667
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
677 if (ctrls->profile >= V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)
678 max_bitrate = h264_infos_list[level].max_bitrate *
679 H264_FACTOR_HIGH;
680 else
681 max_bitrate = h264_infos_list[level].max_bitrate *
682 H264_FACTOR_BASELINE;
683
684
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
693 td->cpb_buffer_size = ctrls->cpb_size * 8000;
694
695
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 else
700 max_cpb_buffer_size =
701 h264_infos_list[level].max_cpb_size * H264_FACTOR_BASELINE;
702
703
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
712 td->brc_no_skip = 0;
713
714
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 else
719 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
737
738
739
740
741 td->rgb2_yuv_y_coeff = 0x12031008;
742 td->rgb2_yuv_u_coeff = 0x800EF7FB;
743 td->rgb2_yuv_v_coeff = 0x80FEF40E;
744
745
746 td->transform_mode = ctrls->dct8x8;
747
748
749 td->encoder_complexity = 2;
750
751
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
761 if (td->framerate_num == 0)
762 td->brc_type = 0;
763
764
765 td->strict_hrd_compliancy = 1;
766
767
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
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
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
840
841
842
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
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
864 td->non_vcl_nalu_size = payload * 8;
865
866
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
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
913 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
914 if (!ctx) {
915 ret = -ENOMEM;
916 goto err;
917 }
918
919
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
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
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
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 = (struct hva_h264_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 = (struct hva_h264_ctx *)pctx->priv;
1011 struct hva_h264_task *task = (struct hva_h264_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
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