encoder: fix subclassing process.
[vaapi:gstreamer-vaapi.git] / gst-libs / gst / vaapi / gstvaapiencoder_h264.c
1 /*
2  *  gstvaapiencoder_h264.c - H.264 encoder
3  *
4  *  Copyright (C) 2012 -2013 Intel Corporation
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public License
8  *  as published by the Free Software Foundation; either version 2.1
9  *  of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free
18  *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301 USA
20  */
21
22 #include "sysdeps.h"
23 #include "gstvaapicompat.h"
24 #include "gstvaapiencoder_h264.h"
25 #include "gstvaapiencoder_h264_priv.h"
26 #include "gstvaapiencoder_priv.h"
27 #include "gstvaapicodedbufferproxy_priv.h"
28
29 #include <va/va.h>
30 #include <va/va_enc_h264.h>
31
32 #include "gstvaapicontext.h"
33 #include "gstvaapisurface.h"
34 #include "gstvaapidisplay_priv.h"
35
36 #define DEBUG 1
37 #include "gstvaapidebug.h"
38
39 #define GST_VAAPI_ENCODER_H264_NAL_REF_IDC_NONE        0
40 #define GST_VAAPI_ENCODER_H264_NAL_REF_IDC_LOW         1
41 #define GST_VAAPI_ENCODER_H264_NAL_REF_IDC_MEDIUM      2
42 #define GST_VAAPI_ENCODER_H264_NAL_REF_IDC_HIGH        3
43
44 typedef enum
45 {
46   GST_VAAPI_ENCODER_H264_ENTROPY_MODE_CAVLC = 0,
47   GST_VAAPI_ENCODER_H264_ENTROPY_MODE_CABAC = 1
48 } GstVaapiEncoderH264EntropyMode;
49
50 typedef enum
51 {
52   GST_VAAPI_ENCODER_H264_NAL_UNKNOWN = 0,
53   GST_VAAPI_ENCODER_H264_NAL_NON_IDR = 1,
54   GST_VAAPI_ENCODER_H264_NAL_IDR = 5,   /* ref_idc != 0 */
55   GST_VAAPI_ENCODER_H264_NAL_SEI = 6,   /* ref_idc == 0 */
56   GST_VAAPI_ENCODER_H264_NAL_SPS = 7,
57   GST_VAAPI_ENCODER_H264_NAL_PPS = 8
58 } GstVaapiEncoderH264NalType;
59
60 typedef enum
61 {
62   SLICE_TYPE_P = 0,
63   SLICE_TYPE_B = 1,
64   SLICE_TYPE_I = 2
65 } H264_SLICE_TYPE;
66
67 typedef struct
68 {
69   GstVaapiSurfaceProxy *pic;
70   guint poc;
71   guint frame_num;
72 } GstVaapiEncoderH264Ref;
73
74 #define GST_VAAPI_H264_CAPS                                \
75         "video/x-h264, "                                   \
76         "framerate = (fraction) [0/1, MAX], "              \
77         "width = (int) [ 1, MAX ], "                       \
78         "height = (int) [ 1, MAX ], "                      \
79         "stream-format = (string) { avc, byte-stream }, "  \
80         "alignment = (string) { au } "
81
82 typedef enum
83 {
84   GST_VAAPI_ENC_H264_REORD_NONE = 0,
85   GST_VAAPI_ENC_H264_REORD_DUMP_FRAMES = 1,
86   GST_VAAPI_ENC_H264_REORD_WAIT_FRAMES = 2
87 } GstVaapiEncH264ReorderState;
88
89 static inline gboolean
90 _poc_greater_than (guint poc1, guint poc2, guint max_poc)
91 {
92   return (((poc1 - poc2) & (max_poc - 1)) < max_poc / 2);
93 }
94
95 static inline guint8
96 _get_va_slice_type (GstVaapiPictureType type)
97 {
98   switch (type) {
99     case GST_VAAPI_PICTURE_TYPE_I:
100       return 2;
101     case GST_VAAPI_PICTURE_TYPE_P:
102       return 0;
103     case GST_VAAPI_PICTURE_TYPE_B:
104       return 1;
105     default:
106       return -1;
107   }
108   return -1;
109 }
110
111 static inline gboolean
112 _read_sps_attributes (const guint8 * sps_data,
113     guint32 sps_size,
114     guint32 * profile_idc, guint32 * profile_comp, guint32 * level_idc)
115 {
116   g_assert (profile_idc && profile_comp && level_idc);
117   g_assert (sps_size >= 4);
118   if (sps_size < 4) {
119     return FALSE;
120   }
121   /* skip sps_data[0], nal_type */
122   *profile_idc = sps_data[1];
123   *profile_comp = sps_data[2];
124   *level_idc = sps_data[3];
125   return TRUE;
126 }
127
128 static inline guint
129 _get_log2_max_frame_num (guint num)
130 {
131   guint ret = 0;
132
133   while (num) {
134     ++ret;
135     num >>= 1;
136   }
137   if (ret <= 4)
138     ret = 4;
139   else if (ret > 10)
140     ret = 10;
141   /* must greater than 4 */
142   return ret;
143 }
144
145 static inline guint
146 _profile_to_value (GstVaapiProfile profile)
147 {
148   switch (profile) {
149     case GST_VAAPI_PROFILE_H264_BASELINE:
150       return 66;
151     case GST_VAAPI_PROFILE_H264_MAIN:
152       return 77;
153     case GST_VAAPI_PROFILE_H264_HIGH:
154       return 100;
155     default:
156       break;
157   }
158   return 0;
159 }
160
161 static inline void
162 _check_sps_pps_status (GstVaapiEncoderH264 * encoder,
163     const guint8 * nal, guint32 size)
164 {
165   guint8 nal_type;
166   gsize ret;
167
168   g_assert (size);
169
170   if (encoder->sps_data && encoder->pps_data)
171     return;
172
173   nal_type = nal[0] & 0x1F;
174   switch (nal_type) {
175     case GST_VAAPI_ENCODER_H264_NAL_SPS:
176       encoder->sps_data = gst_buffer_new_allocate (NULL, size, NULL);
177       ret = gst_buffer_fill (encoder->sps_data, 0, nal, size);
178       g_assert (ret == size);
179       break;
180     case GST_VAAPI_ENCODER_H264_NAL_PPS:
181       encoder->pps_data = gst_buffer_new_allocate (NULL, size, NULL);
182       ret = gst_buffer_fill (encoder->pps_data, 0, nal, size);
183       g_assert (ret == size);
184       break;
185     default:
186       break;
187   }
188 }
189
190 static void
191 _set_level (GstVaapiEncoderH264 * encoder)
192 {
193   guint pic_mb_size;
194   guint MaxDpbMbs, MaxMBPS;
195   guint dbp_level, mbps_level, profile_level;
196
197   if (encoder->level) {
198     if (encoder->level < GST_VAAPI_ENCODER_H264_LEVEL_10)
199       encoder->level = GST_VAAPI_ENCODER_H264_LEVEL_10;
200     else if (encoder->level > GST_VAAPI_ENCODER_H264_LEVEL_51)
201       encoder->level = GST_VAAPI_ENCODER_H264_LEVEL_51;
202     return;
203   }
204
205   /* calculate level */
206   pic_mb_size = ((GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16) *
207       ((GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16);
208   MaxDpbMbs = pic_mb_size * ((encoder->b_frame_num) ? 2 : 1);
209   MaxMBPS = pic_mb_size * GST_VAAPI_ENCODER_FPS_N (encoder) /
210       GST_VAAPI_ENCODER_FPS_D (encoder);
211
212   /* calculate from MaxDbpMbs */
213   if (MaxDpbMbs > 110400)
214     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_51;
215   else if (MaxDpbMbs > 34816)
216     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_50;
217   else if (MaxDpbMbs > 32768)
218     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_42;
219   else if (MaxDpbMbs > 20480)   /* 41 or 40 */
220     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_41;
221   else if (MaxDpbMbs > 18000)
222     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_32;
223   else if (MaxDpbMbs > 8100)
224     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_31;
225   else if (MaxDpbMbs > 4752)    /* 30 or 22 */
226     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_30;
227   else if (MaxDpbMbs > 2376)
228     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_21;
229   else if (MaxDpbMbs > 900)     /* 20, 13, 12 */
230     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_20;
231   else if (MaxDpbMbs > 396)
232     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_11;
233   else
234     dbp_level = GST_VAAPI_ENCODER_H264_LEVEL_10;
235
236   /* calculate from Max Mb processing rate */
237   if (MaxMBPS > 589824)
238     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_51;
239   else if (MaxMBPS > 522240)
240     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_50;
241   else if (MaxMBPS > 245760)
242     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_42;
243   else if (MaxMBPS > 216000)    /* 40 or 41 */
244     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_41;
245   else if (MaxMBPS > 108000)
246     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_32;
247   else if (MaxMBPS > 40500)
248     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_31;
249   else if (MaxMBPS > 20250)
250     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_30;
251   else if (MaxMBPS > 19800)
252     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_22;
253   else if (MaxMBPS > 11800)
254     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_21;
255   else if (MaxMBPS > 6000)      /*13 or 20 */
256     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_20;
257   else if (MaxMBPS > 3000)
258     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_12;
259   else if (MaxMBPS > 1485)
260     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_11;
261   else
262     mbps_level = GST_VAAPI_ENCODER_H264_LEVEL_10;
263
264   if (encoder->profile == GST_VAAPI_PROFILE_H264_HIGH)
265     profile_level = GST_VAAPI_ENCODER_H264_LEVEL_41;
266   else if (encoder->profile == GST_VAAPI_PROFILE_H264_MAIN)
267     profile_level = GST_VAAPI_ENCODER_H264_LEVEL_30;
268   else
269     profile_level = GST_VAAPI_ENCODER_H264_LEVEL_20;
270
271   encoder->level = (dbp_level > mbps_level ? dbp_level : mbps_level);
272   if (encoder->level < profile_level)
273     encoder->level = profile_level;
274 }
275
276 static inline void
277 _reset_gop_start (GstVaapiEncoderH264 * encoder)
278 {
279   ++encoder->idr_num;
280   encoder->frame_index = 1;
281   encoder->cur_frame_num = 0;
282   encoder->cur_present_index = 0;
283 }
284
285 static void
286 _set_b_frame (GstVaapiEncPicture * pic, GstVaapiEncoderH264 * encoder)
287 {
288   g_assert (pic && encoder);
289   g_return_if_fail (pic->type == GST_VAAPI_PICTURE_TYPE_NONE);
290   pic->type = GST_VAAPI_PICTURE_TYPE_B;
291   pic->frame_num = (encoder->cur_frame_num % encoder->max_frame_num);
292 }
293
294 static inline void
295 _set_p_frame (GstVaapiEncPicture * pic, GstVaapiEncoderH264 * encoder)
296 {
297   g_return_if_fail (pic->type == GST_VAAPI_PICTURE_TYPE_NONE);
298   pic->type = GST_VAAPI_PICTURE_TYPE_P;
299   pic->frame_num = (encoder->cur_frame_num % encoder->max_frame_num);
300 }
301
302 static inline void
303 _set_i_frame (GstVaapiEncPicture * pic, GstVaapiEncoderH264 * encoder)
304 {
305   g_return_if_fail (pic->type == GST_VAAPI_PICTURE_TYPE_NONE);
306   pic->type = GST_VAAPI_PICTURE_TYPE_I;
307   pic->frame_num = (encoder->cur_frame_num % encoder->max_frame_num);
308   g_assert (GST_VAAPI_ENC_PICTURE_GET_FRAME (pic));
309   GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (GST_VAAPI_ENC_PICTURE_GET_FRAME (pic));
310 }
311
312 static inline void
313 _set_idr_frame (GstVaapiEncPicture * pic, GstVaapiEncoderH264 * encoder)
314 {
315   g_return_if_fail (pic->type == GST_VAAPI_PICTURE_TYPE_NONE);
316   pic->type = GST_VAAPI_PICTURE_TYPE_I;
317   pic->frame_num = 0;
318   pic->poc = 0;
319   GST_VAAPI_ENC_PICTURE_FLAG_SET (pic, GST_VAAPI_ENC_PICTURE_FLAG_IDR);
320
321   g_assert (GST_VAAPI_ENC_PICTURE_GET_FRAME (pic));
322   GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (GST_VAAPI_ENC_PICTURE_GET_FRAME (pic));
323 }
324
325 static inline void
326 _set_key_frame (GstVaapiEncPicture * picture,
327     GstVaapiEncoderH264 * encoder, gboolean is_idr)
328 {
329   if (is_idr) {
330     _reset_gop_start (encoder);
331     _set_idr_frame (picture, encoder);
332   } else
333     _set_i_frame (picture, encoder);
334
335 }
336
337 gboolean
338 gst_bit_writer_put_ue (GstBitWriter * bitwriter, guint32 value)
339 {
340   guint32 size_in_bits = 0;
341   guint32 tmp_value = ++value;
342
343   while (tmp_value) {
344     ++size_in_bits;
345     tmp_value >>= 1;
346   }
347   if (size_in_bits > 1
348       && !gst_bit_writer_put_bits_uint32 (bitwriter, 0, size_in_bits - 1))
349     return FALSE;
350   if (!gst_bit_writer_put_bits_uint32 (bitwriter, value, size_in_bits))
351     return FALSE;
352   return TRUE;
353 }
354
355 gboolean
356 gst_bit_writer_put_se (GstBitWriter * bitwriter, gint32 value)
357 {
358   guint32 new_val;
359
360   if (value <= 0)
361     new_val = -(value << 1);
362   else
363     new_val = (value << 1) - 1;
364
365   if (!gst_bit_writer_put_ue (bitwriter, new_val))
366     return FALSE;
367   return TRUE;
368 }
369
370
371 static gboolean
372 gst_bit_writer_write_nal_header (GstBitWriter * bitwriter,
373     guint32 nal_ref_idc, guint32 nal_unit_type)
374 {
375   gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
376   gst_bit_writer_put_bits_uint32 (bitwriter, nal_ref_idc, 2);
377   gst_bit_writer_put_bits_uint32 (bitwriter, nal_unit_type, 5);
378   return TRUE;
379 }
380
381 static gboolean
382 gst_bit_writer_write_trailing_bits (GstBitWriter * bitwriter)
383 {
384   gst_bit_writer_put_bits_uint32 (bitwriter, 1, 1);
385   gst_bit_writer_align_bytes_unchecked (bitwriter, 0);
386   return TRUE;
387 }
388
389 static gboolean
390 gst_bit_writer_write_sps (GstBitWriter * bitwriter,
391     VAEncSequenceParameterBufferH264 * seq, GstVaapiProfile profile)
392 {
393   guint32 constraint_set0_flag, constraint_set1_flag;
394   guint32 constraint_set2_flag, constraint_set3_flag;
395   guint32 gaps_in_frame_num_value_allowed_flag = 0;     // ??
396   gboolean nal_hrd_parameters_present_flag;
397
398   guint32 b_qpprime_y_zero_transform_bypass = 0;
399   guint32 residual_color_transform_flag = 0;
400   guint32 pic_height_in_map_units =
401       (seq->seq_fields.bits.frame_mbs_only_flag ?
402       seq->picture_height_in_mbs : seq->picture_height_in_mbs / 2);
403   guint32 mb_adaptive_frame_field = !seq->seq_fields.bits.frame_mbs_only_flag;
404   guint32 i = 0;
405
406   constraint_set0_flag = profile == GST_VAAPI_PROFILE_H264_BASELINE;
407   constraint_set1_flag = profile <= GST_VAAPI_PROFILE_H264_MAIN;
408   constraint_set2_flag = 0;
409   constraint_set3_flag = 0;
410
411   /* profile_idc */
412   gst_bit_writer_put_bits_uint32 (bitwriter, _profile_to_value (profile), 8);
413   /* constraint_set0_flag */
414   gst_bit_writer_put_bits_uint32 (bitwriter, constraint_set0_flag, 1);
415   /* constraint_set1_flag */
416   gst_bit_writer_put_bits_uint32 (bitwriter, constraint_set1_flag, 1);
417   /* constraint_set2_flag */
418   gst_bit_writer_put_bits_uint32 (bitwriter, constraint_set2_flag, 1);
419   /* constraint_set3_flag */
420   gst_bit_writer_put_bits_uint32 (bitwriter, constraint_set3_flag, 1);
421   /* reserved_zero_4bits */
422   gst_bit_writer_put_bits_uint32 (bitwriter, 0, 4);
423   /* level_idc */
424   gst_bit_writer_put_bits_uint32 (bitwriter, seq->level_idc, 8);
425   /* seq_parameter_set_id */
426   gst_bit_writer_put_ue (bitwriter, seq->seq_parameter_set_id);
427
428   if (profile == GST_VAAPI_PROFILE_H264_HIGH) {
429     /* for high profile */
430     /* chroma_format_idc  = 1, 4:2:0 */
431     gst_bit_writer_put_ue (bitwriter, seq->seq_fields.bits.chroma_format_idc);
432     if (3 == seq->seq_fields.bits.chroma_format_idc) {
433       gst_bit_writer_put_bits_uint32 (bitwriter, residual_color_transform_flag,
434           1);
435     }
436     /* bit_depth_luma_minus8 */
437     gst_bit_writer_put_ue (bitwriter, seq->bit_depth_luma_minus8);
438     /* bit_depth_chroma_minus8 */
439     gst_bit_writer_put_ue (bitwriter, seq->bit_depth_chroma_minus8);
440     /* b_qpprime_y_zero_transform_bypass */
441     gst_bit_writer_put_bits_uint32 (bitwriter,
442         b_qpprime_y_zero_transform_bypass, 1);
443     g_assert (seq->seq_fields.bits.seq_scaling_matrix_present_flag == 0);
444     /*seq_scaling_matrix_present_flag  */
445     gst_bit_writer_put_bits_uint32 (bitwriter,
446         seq->seq_fields.bits.seq_scaling_matrix_present_flag, 1);
447
448 #if 0
449     if (seq->seq_fields.bits.seq_scaling_matrix_present_flag) {
450       for (i = 0; i < (seq->seq_fields.bits.chroma_format_idc != 3 ? 8 : 12);
451           i++) {
452         gst_bit_writer_put_bits_uint8 (bitwriter,
453             seq->seq_fields.bits.seq_scaling_list_present_flag, 1);
454         if (seq->seq_fields.bits.seq_scaling_list_present_flag) {
455           g_assert (0);
456           /* FIXME, need write scaling list if seq_scaling_matrix_present_flag ==1 */
457         }
458       }
459     }
460 #endif
461   }
462
463   /* log2_max_frame_num_minus4 */
464   gst_bit_writer_put_ue (bitwriter,
465       seq->seq_fields.bits.log2_max_frame_num_minus4);
466   /* pic_order_cnt_type */
467   gst_bit_writer_put_ue (bitwriter, seq->seq_fields.bits.pic_order_cnt_type);
468
469   if (seq->seq_fields.bits.pic_order_cnt_type == 0) {
470     /* log2_max_pic_order_cnt_lsb_minus4 */
471     gst_bit_writer_put_ue (bitwriter,
472         seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);
473   } else if (seq->seq_fields.bits.pic_order_cnt_type == 1) {
474     g_assert (0);
475     gst_bit_writer_put_bits_uint32 (bitwriter,
476         seq->seq_fields.bits.delta_pic_order_always_zero_flag, 1);
477     gst_bit_writer_put_se (bitwriter, seq->offset_for_non_ref_pic);
478     gst_bit_writer_put_se (bitwriter, seq->offset_for_top_to_bottom_field);
479     gst_bit_writer_put_ue (bitwriter,
480         seq->num_ref_frames_in_pic_order_cnt_cycle);
481     for (i = 0; i < seq->num_ref_frames_in_pic_order_cnt_cycle; i++) {
482       gst_bit_writer_put_se (bitwriter, seq->offset_for_ref_frame[i]);
483     }
484   }
485
486   /* num_ref_frames */
487   gst_bit_writer_put_ue (bitwriter, seq->max_num_ref_frames);
488   /* gaps_in_frame_num_value_allowed_flag */
489   gst_bit_writer_put_bits_uint32 (bitwriter,
490       gaps_in_frame_num_value_allowed_flag, 1);
491
492   /* pic_width_in_mbs_minus1 */
493   gst_bit_writer_put_ue (bitwriter, seq->picture_width_in_mbs - 1);
494   /* pic_height_in_map_units_minus1 */
495   gst_bit_writer_put_ue (bitwriter, pic_height_in_map_units - 1);
496   /* frame_mbs_only_flag */
497   gst_bit_writer_put_bits_uint32 (bitwriter,
498       seq->seq_fields.bits.frame_mbs_only_flag, 1);
499
500   if (!seq->seq_fields.bits.frame_mbs_only_flag) {      //ONLY mbs
501     g_assert (0);
502     gst_bit_writer_put_bits_uint32 (bitwriter, mb_adaptive_frame_field, 1);
503   }
504
505   /* direct_8x8_inference_flag */
506   gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
507   /* frame_cropping_flag */
508   gst_bit_writer_put_bits_uint32 (bitwriter, seq->frame_cropping_flag, 1);
509
510   if (seq->frame_cropping_flag) {
511     /* frame_crop_left_offset */
512     gst_bit_writer_put_ue (bitwriter, seq->frame_crop_left_offset);
513     /* frame_crop_right_offset */
514     gst_bit_writer_put_ue (bitwriter, seq->frame_crop_right_offset);
515     /* frame_crop_top_offset */
516     gst_bit_writer_put_ue (bitwriter, seq->frame_crop_top_offset);
517     /* frame_crop_bottom_offset */
518     gst_bit_writer_put_ue (bitwriter, seq->frame_crop_bottom_offset);
519   }
520
521   /* vui_parameters_present_flag */
522   gst_bit_writer_put_bits_uint32 (bitwriter, seq->vui_parameters_present_flag,
523       1);
524   if (seq->vui_parameters_present_flag) {
525     /* aspect_ratio_info_present_flag */
526     gst_bit_writer_put_bits_uint32 (bitwriter,
527         seq->vui_fields.bits.aspect_ratio_info_present_flag, 1);
528     if (seq->vui_fields.bits.aspect_ratio_info_present_flag) {
529       gst_bit_writer_put_bits_uint32 (bitwriter, seq->aspect_ratio_idc, 8);
530       if (seq->aspect_ratio_idc == 0xFF) {
531         gst_bit_writer_put_bits_uint32 (bitwriter, seq->sar_width, 16);
532         gst_bit_writer_put_bits_uint32 (bitwriter, seq->sar_height, 16);
533       }
534     }
535
536     /* overscan_info_present_flag */
537     gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
538     /* video_signal_type_present_flag */
539     gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
540     /* chroma_loc_info_present_flag */
541     gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
542
543     /* timing_info_present_flag */
544     gst_bit_writer_put_bits_uint32 (bitwriter,
545         seq->vui_fields.bits.timing_info_present_flag, 1);
546     if (seq->vui_fields.bits.timing_info_present_flag) {
547       gst_bit_writer_put_bits_uint32 (bitwriter, seq->num_units_in_tick, 32);
548       gst_bit_writer_put_bits_uint32 (bitwriter, seq->time_scale, 32);
549       gst_bit_writer_put_bits_uint32 (bitwriter, 1, 1); /* fixed_frame_rate_flag */
550     }
551
552     nal_hrd_parameters_present_flag = (seq->bits_per_second > 0 ? TRUE : FALSE);
553     /* nal_hrd_parameters_present_flag */
554     gst_bit_writer_put_bits_uint32 (bitwriter, nal_hrd_parameters_present_flag,
555         1);
556     if (nal_hrd_parameters_present_flag) {
557       /* hrd_parameters */
558       /* cpb_cnt_minus1 */
559       gst_bit_writer_put_ue (bitwriter, 0);
560       gst_bit_writer_put_bits_uint32 (bitwriter, 4, 4); /* bit_rate_scale */
561       gst_bit_writer_put_bits_uint32 (bitwriter, 6, 4); /* cpb_size_scale */
562
563       for (i = 0; i < 1; ++i) {
564         /* bit_rate_value_minus1[0] */
565         gst_bit_writer_put_ue (bitwriter, seq->bits_per_second / 1024 - 1);
566         /* cpb_size_value_minus1[0] */
567         gst_bit_writer_put_ue (bitwriter, seq->bits_per_second / 1024 * 8 - 1);
568         /* cbr_flag[0] */
569         gst_bit_writer_put_bits_uint32 (bitwriter, 1, 1);
570       }
571       /* initial_cpb_removal_delay_length_minus1 */
572       gst_bit_writer_put_bits_uint32 (bitwriter, 23, 5);
573       /* cpb_removal_delay_length_minus1 */
574       gst_bit_writer_put_bits_uint32 (bitwriter, 23, 5);
575       /* dpb_output_delay_length_minus1 */
576       gst_bit_writer_put_bits_uint32 (bitwriter, 23, 5);
577       /* time_offset_length  */
578       gst_bit_writer_put_bits_uint32 (bitwriter, 23, 5);
579     }
580     /* vcl_hrd_parameters_present_flag */
581     gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
582     if (nal_hrd_parameters_present_flag
583         || 0 /*vcl_hrd_parameters_present_flag */ ) {
584       /* low_delay_hrd_flag */
585       gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
586     }
587     /* pic_struct_present_flag */
588     gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
589     /* bitwriter_restriction_flag */
590     gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1);
591   }
592
593   /* rbsp_trailing_bits */
594   gst_bit_writer_write_trailing_bits (bitwriter);
595   return TRUE;
596 }
597
598 static gboolean
599 gst_bit_writer_write_pps (GstBitWriter * bitwriter,
600     VAEncPictureParameterBufferH264 * pic)
601 {
602   guint32 num_slice_groups_minus1 = 0;
603   guint32 pic_init_qs_minus26 = 0;
604   guint32 redundant_pic_cnt_present_flag = 0;
605
606   /* pic_parameter_set_id */
607   gst_bit_writer_put_ue (bitwriter, pic->pic_parameter_set_id);
608   /* seq_parameter_set_id */
609   gst_bit_writer_put_ue (bitwriter, pic->seq_parameter_set_id);
610   /* entropy_coding_mode_flag */
611   gst_bit_writer_put_bits_uint32 (bitwriter,
612       pic->pic_fields.bits.entropy_coding_mode_flag, 1);
613   /* pic_order_present_flag */
614   gst_bit_writer_put_bits_uint32 (bitwriter,
615       pic->pic_fields.bits.pic_order_present_flag, 1);
616   /*slice_groups-1 */
617   gst_bit_writer_put_ue (bitwriter, num_slice_groups_minus1);
618
619   if (num_slice_groups_minus1 > 0) {
620      /*FIXME*/ g_assert (0);
621   }
622   gst_bit_writer_put_ue (bitwriter, pic->num_ref_idx_l0_active_minus1);
623   gst_bit_writer_put_ue (bitwriter, pic->num_ref_idx_l1_active_minus1);
624   gst_bit_writer_put_bits_uint32 (bitwriter,
625       pic->pic_fields.bits.weighted_pred_flag, 1);
626   gst_bit_writer_put_bits_uint32 (bitwriter,
627       pic->pic_fields.bits.weighted_bipred_idc, 2);
628   /* pic_init_qp_minus26 */
629   gst_bit_writer_put_se (bitwriter, pic->pic_init_qp - 26);
630   /* pic_init_qs_minus26 */
631   gst_bit_writer_put_se (bitwriter, pic_init_qs_minus26);
632   /*chroma_qp_index_offset */
633   gst_bit_writer_put_se (bitwriter, pic->chroma_qp_index_offset);
634
635   gst_bit_writer_put_bits_uint32 (bitwriter,
636       pic->pic_fields.bits.deblocking_filter_control_present_flag, 1);
637   gst_bit_writer_put_bits_uint32 (bitwriter,
638       pic->pic_fields.bits.constrained_intra_pred_flag, 1);
639   gst_bit_writer_put_bits_uint32 (bitwriter, redundant_pic_cnt_present_flag, 1);
640
641   /*more_rbsp_data */
642   gst_bit_writer_put_bits_uint32 (bitwriter,
643       pic->pic_fields.bits.transform_8x8_mode_flag, 1);
644   gst_bit_writer_put_bits_uint32 (bitwriter,
645       pic->pic_fields.bits.pic_scaling_matrix_present_flag, 1);
646   if (pic->pic_fields.bits.pic_scaling_matrix_present_flag) {
647     g_assert (0);
648     /* FIXME */
649     /*
650        for (i = 0; i <
651        (6+(-( (chroma_format_idc ! = 3) ? 2 : 6) * -pic->pic_fields.bits.transform_8x8_mode_flag));
652        i++) {
653        gst_bit_writer_put_bits_uint8(bitwriter, pic->pic_fields.bits.pic_scaling_list_present_flag, 1);
654        }
655      */
656   }
657
658   gst_bit_writer_put_se (bitwriter, pic->second_chroma_qp_index_offset);
659   gst_bit_writer_write_trailing_bits (bitwriter);
660
661   return TRUE;
662 }
663
664 static gboolean
665 add_sequence_packed_header (GstVaapiEncoderH264 * encoder,
666     GstVaapiEncPicture * picture, GstVaapiEncSequence * sequence)
667 {
668   GstVaapiEncPackedHeader *packed_seq;
669   GstBitWriter writer;
670   VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 };
671   VAEncSequenceParameterBufferH264 *seq_param = sequence->param;
672   guint32 data_bit_size;
673   guint8 *data;
674
675   gst_bit_writer_init (&writer, 128 * 8);
676   gst_bit_writer_put_bits_uint32 (&writer, 0x00000001, 32);     /* start code */
677   gst_bit_writer_write_nal_header (&writer,
678       GST_VAAPI_ENCODER_H264_NAL_REF_IDC_HIGH, GST_VAAPI_ENCODER_H264_NAL_SPS);
679   gst_bit_writer_write_sps (&writer, seq_param, encoder->profile);
680   g_assert (GST_BIT_WRITER_BIT_SIZE (&writer) % 8 == 0);
681   data_bit_size = GST_BIT_WRITER_BIT_SIZE (&writer);
682   data = GST_BIT_WRITER_DATA (&writer);
683
684   packed_header_param_buffer.type = VAEncPackedHeaderSequence;
685   packed_header_param_buffer.bit_length = data_bit_size;
686   packed_header_param_buffer.has_emulation_bytes = 0;
687
688   packed_seq = gst_vaapi_enc_packed_header_new (GST_VAAPI_ENCODER (encoder),
689       &packed_header_param_buffer, sizeof (packed_header_param_buffer),
690       data, (data_bit_size + 7) / 8);
691   g_assert (packed_seq);
692
693   gst_vaapi_enc_picture_add_packed_header (picture, packed_seq);
694   gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & packed_seq, NULL);
695
696   /* store sps data */
697   _check_sps_pps_status (encoder, data + 4, data_bit_size / 8 - 4);
698
699   gst_bit_writer_clear (&writer, TRUE);
700
701   return TRUE;
702 }
703
704 static gboolean
705 add_picture_packed_header (GstVaapiEncoderH264 * encoder,
706     GstVaapiEncPicture * picture)
707 {
708   GstVaapiEncPackedHeader *packed_pic;
709   GstBitWriter writer;
710   VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 };
711   VAEncPictureParameterBufferH264 *pic_param = picture->param;
712   guint32 data_bit_size;
713   guint8 *data;
714
715   gst_bit_writer_init (&writer, 128 * 8);
716   gst_bit_writer_put_bits_uint32 (&writer, 0x00000001, 32);     /* start code */
717   gst_bit_writer_write_nal_header (&writer,
718       GST_VAAPI_ENCODER_H264_NAL_REF_IDC_HIGH, GST_VAAPI_ENCODER_H264_NAL_PPS);
719   gst_bit_writer_write_pps (&writer, pic_param);
720   g_assert (GST_BIT_WRITER_BIT_SIZE (&writer) % 8 == 0);
721   data_bit_size = GST_BIT_WRITER_BIT_SIZE (&writer);
722   data = GST_BIT_WRITER_DATA (&writer);
723
724   packed_header_param_buffer.type = VAEncPackedHeaderPicture;
725   packed_header_param_buffer.bit_length = data_bit_size;
726   packed_header_param_buffer.has_emulation_bytes = 0;
727
728   packed_pic = gst_vaapi_enc_packed_header_new (GST_VAAPI_ENCODER (encoder),
729       &packed_header_param_buffer, sizeof (packed_header_param_buffer),
730       data, (data_bit_size + 7) / 8);
731   g_assert (packed_pic);
732
733   gst_vaapi_enc_picture_add_packed_header (picture, packed_pic);
734   gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & packed_pic, NULL);
735
736   /* store pps data */
737   _check_sps_pps_status (encoder, data + 4, data_bit_size / 8 - 4);
738   gst_bit_writer_clear (&writer, TRUE);
739
740   return TRUE;
741 }
742
743 /*  reference picture management */
744 static void
745 reference_pic_free (GstVaapiEncoderH264 * encoder, GstVaapiEncoderH264Ref * ref)
746 {
747   if (!ref)
748     return;
749   if (ref->pic)
750     gst_vaapi_encoder_release_surface (GST_VAAPI_ENCODER (encoder), ref->pic);
751   g_slice_free (GstVaapiEncoderH264Ref, ref);
752 }
753
754 static inline GstVaapiEncoderH264Ref *
755 reference_pic_create (GstVaapiEncoderH264 * encoder,
756     GstVaapiEncPicture * picture, GstVaapiSurfaceProxy * surface)
757 {
758   GstVaapiEncoderH264Ref *ref = g_slice_new0 (GstVaapiEncoderH264Ref);
759
760   ref->pic = surface;
761   ref->frame_num = picture->frame_num;
762   ref->poc = picture->poc;
763   return ref;
764 }
765
766 static gboolean
767 reference_list_update (GstVaapiEncoderH264 * encoder,
768     GstVaapiEncPicture * picture, GstVaapiSurfaceProxy * surface)
769 {
770   GstVaapiEncoderH264Ref *ref;
771
772   if (GST_VAAPI_PICTURE_TYPE_B == picture->type) {
773     gst_vaapi_encoder_release_surface (GST_VAAPI_ENCODER (encoder), surface);
774     return TRUE;
775   }
776   if (GST_VAAPI_ENC_PICTURE_IS_IDR (picture)) {
777     while (!g_queue_is_empty (&encoder->ref_list))
778       reference_pic_free (encoder, g_queue_pop_head (&encoder->ref_list));
779   } else if (g_queue_get_length (&encoder->ref_list) >= encoder->max_ref_num) {
780     reference_pic_free (encoder, g_queue_pop_head (&encoder->ref_list));
781   }
782   ref = reference_pic_create (encoder, picture, surface);
783   g_queue_push_tail (&encoder->ref_list, ref);
784   g_assert (g_queue_get_length (&encoder->ref_list) <= encoder->max_ref_num);
785   return TRUE;
786 }
787
788 static gboolean
789 reference_list_init (GstVaapiEncoderH264 * encoder,
790     GstVaapiEncPicture * picture,
791     GstVaapiEncoderH264Ref ** reflist_0,
792     guint * reflist_0_count,
793     GstVaapiEncoderH264Ref ** reflist_1, guint * reflist_1_count)
794 {
795   GstVaapiEncoderH264Ref *tmp;
796   GList *iter, *list_0_start = NULL, *list_1_start = NULL;
797   guint max_pic_order_cnt = (1 << encoder->log2_max_pic_order_cnt);
798   guint count;
799
800   *reflist_0_count = 0;
801   *reflist_1_count = 0;
802   if (picture->type == GST_VAAPI_PICTURE_TYPE_I)
803     return TRUE;
804
805   iter = g_queue_peek_tail_link (&encoder->ref_list);
806   for (; iter; iter = g_list_previous (iter)) {
807     tmp = (GstVaapiEncoderH264Ref *) iter->data;
808     g_assert (tmp && tmp->poc != picture->poc);
809     if (_poc_greater_than (picture->poc, tmp->poc, max_pic_order_cnt)) {
810       list_0_start = iter;
811       list_1_start = g_list_next (iter);
812       break;
813     }
814   }
815
816   /* order reflist_0 */
817   g_assert (list_0_start);
818   iter = list_0_start;
819   count = 0;
820   for (; iter; iter = g_list_previous (iter)) {
821     reflist_0[count] = (GstVaapiEncoderH264Ref *) iter->data;
822     ++count;
823   }
824   *reflist_0_count = count;
825
826   if (picture->type != GST_VAAPI_PICTURE_TYPE_B)
827     return TRUE;
828
829   /* order reflist_1 */
830   count = 0;
831   iter = list_1_start;
832   for (; iter; iter = g_list_next (iter)) {
833     reflist_1[count] = (GstVaapiEncoderH264Ref *) iter->data;
834     ++count;
835   }
836   *reflist_1_count = count;
837   return TRUE;
838 }
839
840 /* fill the  H264 VA encoding parameters */
841 static gboolean
842 fill_va_sequence_param (GstVaapiEncoderH264 * encoder,
843     GstVaapiEncSequence * sequence)
844 {
845   VAEncSequenceParameterBufferH264 *seq = sequence->param;
846   guint width_in_mbs, height_in_mbs;
847
848   width_in_mbs = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16;
849   height_in_mbs = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16;
850
851   memset (seq, 0, sizeof (VAEncSequenceParameterBufferH264));
852   seq->seq_parameter_set_id = 0;
853   seq->level_idc = encoder->level;
854   seq->intra_period = encoder->intra_period;
855   seq->ip_period = 0;           // ?
856   if (encoder->bitrate > 0)
857     seq->bits_per_second = encoder->bitrate * 1024;
858   else
859     seq->bits_per_second = 0;
860
861   seq->max_num_ref_frames = encoder->max_ref_num;
862   seq->picture_width_in_mbs = width_in_mbs;
863   seq->picture_height_in_mbs = height_in_mbs;
864
865   /*sequence field values */
866   seq->seq_fields.value = 0;
867   seq->seq_fields.bits.chroma_format_idc = 1;
868   seq->seq_fields.bits.frame_mbs_only_flag = 1;
869   seq->seq_fields.bits.mb_adaptive_frame_field_flag = FALSE;
870   seq->seq_fields.bits.seq_scaling_matrix_present_flag = FALSE;
871   /* direct_8x8_inference_flag default false */
872   seq->seq_fields.bits.direct_8x8_inference_flag = FALSE;
873   g_assert (encoder->log2_max_frame_num >= 4);
874   seq->seq_fields.bits.log2_max_frame_num_minus4 =
875       encoder->log2_max_frame_num - 4;
876   /* picture order count */
877   seq->seq_fields.bits.pic_order_cnt_type = 0;
878   g_assert (encoder->log2_max_pic_order_cnt >= 4);
879   seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 =
880       encoder->log2_max_pic_order_cnt - 4;
881
882   seq->bit_depth_luma_minus8 = 0;
883   seq->bit_depth_chroma_minus8 = 0;
884
885   /* not used if pic_order_cnt_type == 0 */
886   if (seq->seq_fields.bits.pic_order_cnt_type == 1) {
887     seq->seq_fields.bits.delta_pic_order_always_zero_flag = TRUE;
888     seq->num_ref_frames_in_pic_order_cnt_cycle = 0;
889     seq->offset_for_non_ref_pic = 0;
890     seq->offset_for_top_to_bottom_field = 0;
891     memset (seq->offset_for_ref_frame, 0, sizeof (seq->offset_for_ref_frame));
892   }
893
894   if (height_in_mbs * 16 - GST_VAAPI_ENCODER_HEIGHT (encoder)) {
895     seq->frame_cropping_flag = 1;
896     seq->frame_crop_left_offset = 0;
897     seq->frame_crop_right_offset = 0;
898     seq->frame_crop_top_offset = 0;
899     seq->frame_crop_bottom_offset =
900         ((height_in_mbs * 16 - GST_VAAPI_ENCODER_HEIGHT (encoder)) /
901         (2 * (!seq->seq_fields.bits.frame_mbs_only_flag + 1)));
902   }
903
904   /*vui not set */
905   seq->vui_parameters_present_flag = (encoder->bitrate > 0 ? TRUE : FALSE);
906   if (seq->vui_parameters_present_flag) {
907     seq->vui_fields.bits.aspect_ratio_info_present_flag = FALSE;
908     seq->vui_fields.bits.bitstream_restriction_flag = FALSE;
909     seq->vui_fields.bits.timing_info_present_flag =
910         (encoder->bitrate > 0 ? TRUE : FALSE);
911     if (seq->vui_fields.bits.timing_info_present_flag) {
912       seq->num_units_in_tick = GST_VAAPI_ENCODER_FPS_D (encoder);
913       seq->time_scale = GST_VAAPI_ENCODER_FPS_N (encoder) * 2;
914     }
915   }
916
917   return TRUE;
918 }
919
920 static gboolean
921 fill_va_picture_param (GstVaapiEncoderH264 * encoder,
922     GstVaapiEncPicture * picture,
923     GstVaapiCodedBuffer * codedbuf, GstVaapiSurfaceProxy * surface)
924 {
925   VAEncPictureParameterBufferH264 *pic = picture->param;
926   GstVaapiEncoderH264Ref *ref_pic;
927   GList *reflist;
928   guint i;
929
930   memset (pic, 0, sizeof (VAEncPictureParameterBufferH264));
931
932   /* reference list,  */
933   pic->CurrPic.picture_id = GST_VAAPI_SURFACE_PROXY_SURFACE_ID (surface);
934   pic->CurrPic.TopFieldOrderCnt = picture->poc;
935   i = 0;
936   if (picture->type != GST_VAAPI_PICTURE_TYPE_I) {
937     for (reflist = g_queue_peek_head_link (&encoder->ref_list);
938         reflist; reflist = g_list_next (reflist)) {
939       ref_pic = reflist->data;
940       g_assert (ref_pic && ref_pic->pic &&
941           GST_VAAPI_SURFACE_PROXY_SURFACE_ID (ref_pic->pic) != VA_INVALID_ID);
942
943       pic->ReferenceFrames[i].picture_id =
944           GST_VAAPI_SURFACE_PROXY_SURFACE_ID (ref_pic->pic);
945       ++i;
946     }
947     g_assert (i <= 16 && i <= encoder->max_ref_num);
948   }
949   for (; i < 16; ++i) {
950     pic->ReferenceFrames[i].picture_id = VA_INVALID_ID;
951   }
952   pic->coded_buf = GST_VAAPI_OBJECT_ID (codedbuf);
953
954   pic->pic_parameter_set_id = 0;
955   pic->seq_parameter_set_id = 0;
956   pic->last_picture = 0;        /* means last encoding picture */
957   pic->frame_num = picture->frame_num;
958   pic->pic_init_qp = encoder->init_qp;
959   pic->num_ref_idx_l0_active_minus1 =
960       (encoder->max_reflist0_count ? (encoder->max_reflist0_count - 1) : 0);
961   pic->num_ref_idx_l1_active_minus1 =
962       (encoder->max_reflist1_count ? (encoder->max_reflist1_count - 1) : 0);
963   pic->chroma_qp_index_offset = 0;
964   pic->second_chroma_qp_index_offset = 0;
965
966   /* set picture fields */
967   pic->pic_fields.value = 0;
968   pic->pic_fields.bits.idr_pic_flag = GST_VAAPI_ENC_PICTURE_IS_IDR (picture);
969   pic->pic_fields.bits.reference_pic_flag =
970       (picture->type != GST_VAAPI_PICTURE_TYPE_B);
971   pic->pic_fields.bits.entropy_coding_mode_flag =
972       GST_VAAPI_ENCODER_H264_ENTROPY_MODE_CABAC;
973   pic->pic_fields.bits.weighted_pred_flag = FALSE;
974   pic->pic_fields.bits.weighted_bipred_idc = 0;
975   pic->pic_fields.bits.constrained_intra_pred_flag = 0;
976   pic->pic_fields.bits.transform_8x8_mode_flag = (encoder->profile >= GST_VAAPI_PROFILE_H264_HIGH);     /* enable 8x8 */
977   /* enable debloking */
978   pic->pic_fields.bits.deblocking_filter_control_present_flag = TRUE;
979   pic->pic_fields.bits.redundant_pic_cnt_present_flag = FALSE;
980   /* bottom_field_pic_order_in_frame_present_flag */
981   pic->pic_fields.bits.pic_order_present_flag = FALSE;
982   pic->pic_fields.bits.pic_scaling_matrix_present_flag = FALSE;
983
984   return TRUE;
985 }
986
987 static gboolean
988 fill_va_slices_param (GstVaapiEncoderH264 * encoder,
989     GstVaapiEncPicture * picture,
990     GstVaapiEncoderH264Ref ** reflist_0,
991     guint reflist_0_count,
992     GstVaapiEncoderH264Ref ** reflist_1, guint reflist_1_count)
993 {
994   VAEncSliceParameterBufferH264 *slice_param;
995   GstVaapiEncSlice *slice;
996   guint width_in_mbs, height_in_mbs;
997   guint slice_of_mbs, slice_mod_mbs, cur_slice_mbs;
998   guint total_mbs;
999   guint last_mb_index;
1000   guint i_slice, i_ref;
1001
1002   g_assert (picture);
1003
1004   width_in_mbs = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16;
1005   height_in_mbs = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16;
1006   total_mbs = width_in_mbs * height_in_mbs;
1007
1008   g_assert (encoder->slice_num && encoder->slice_num < total_mbs);
1009   slice_of_mbs = total_mbs / encoder->slice_num;
1010   slice_mod_mbs = total_mbs % encoder->slice_num;
1011   last_mb_index = 0;
1012   for (i_slice = 0; i_slice < encoder->slice_num; ++i_slice) {
1013     cur_slice_mbs = slice_of_mbs;
1014     if (slice_mod_mbs) {
1015       ++cur_slice_mbs;
1016       --slice_mod_mbs;
1017     }
1018     slice = GST_VAAPI_ENC_SLICE_NEW (H264, encoder);
1019     g_assert (slice && slice->param_id != VA_INVALID_ID);
1020     slice_param = slice->param;
1021
1022     memset (slice_param, 0, sizeof (VAEncSliceParameterBufferH264));
1023     slice_param->macroblock_address = last_mb_index;
1024     slice_param->num_macroblocks = cur_slice_mbs;
1025     slice_param->macroblock_info = VA_INVALID_ID;
1026     slice_param->slice_type = _get_va_slice_type (picture->type);
1027     g_assert (slice_param->slice_type != -1);
1028     slice_param->pic_parameter_set_id = 0;
1029     slice_param->idr_pic_id = encoder->idr_num;
1030     slice_param->pic_order_cnt_lsb = picture->poc;
1031
1032     /* not used if pic_order_cnt_type = 0 */
1033     slice_param->delta_pic_order_cnt_bottom = 0;
1034     memset (slice_param->delta_pic_order_cnt,
1035         0, sizeof (slice_param->delta_pic_order_cnt));
1036
1037     /*only works for B frames */
1038     slice_param->direct_spatial_mv_pred_flag = FALSE;
1039     /* default equal to picture parameters */
1040     slice_param->num_ref_idx_active_override_flag = FALSE;
1041     if (picture->type != GST_VAAPI_PICTURE_TYPE_I && reflist_0_count > 0)
1042       slice_param->num_ref_idx_l0_active_minus1 = reflist_0_count - 1;
1043     else
1044       slice_param->num_ref_idx_l0_active_minus1 = 0;
1045     if (picture->type == GST_VAAPI_PICTURE_TYPE_B && reflist_1_count > 0)
1046       slice_param->num_ref_idx_l1_active_minus1 = reflist_1_count - 1;
1047     else
1048       slice_param->num_ref_idx_l1_active_minus1 = 0;
1049     g_assert (slice_param->num_ref_idx_l0_active_minus1 == 0);
1050     g_assert (slice_param->num_ref_idx_l1_active_minus1 == 0);
1051
1052     i_ref = 0;
1053     if (picture->type != GST_VAAPI_PICTURE_TYPE_I) {
1054       for (; i_ref < reflist_0_count; ++i_ref) {
1055         slice_param->RefPicList0[i_ref].picture_id =
1056             GST_VAAPI_SURFACE_PROXY_SURFACE_ID (reflist_0[i_ref]->pic);
1057       }
1058       g_assert (i_ref == 1);
1059     }
1060     for (;
1061         i_ref <
1062         sizeof (slice_param->RefPicList0) /
1063         sizeof (slice_param->RefPicList0[0]); ++i_ref) {
1064       slice_param->RefPicList0[i_ref].picture_id = VA_INVALID_SURFACE;
1065     }
1066
1067     i_ref = 0;
1068     if (picture->type == GST_VAAPI_PICTURE_TYPE_B) {
1069       for (; i_ref < reflist_1_count; ++i_ref) {
1070         slice_param->RefPicList1[i_ref].picture_id =
1071             GST_VAAPI_SURFACE_PROXY_SURFACE_ID (reflist_1[i_ref]->pic);
1072       }
1073       g_assert (i_ref == 1);
1074     }
1075     for (;
1076         i_ref <
1077         sizeof (slice_param->RefPicList1) /
1078         sizeof (slice_param->RefPicList1[0]); ++i_ref) {
1079       slice_param->RefPicList1[i_ref].picture_id = VA_INVALID_SURFACE;
1080     }
1081
1082     /* not used if  pic_param.pic_fields.bits.weighted_pred_flag == FALSE */
1083     slice_param->luma_log2_weight_denom = 0;
1084     slice_param->chroma_log2_weight_denom = 0;
1085     slice_param->luma_weight_l0_flag = FALSE;
1086     memset (slice_param->luma_weight_l0, 0,
1087         sizeof (slice_param->luma_weight_l0));
1088     memset (slice_param->luma_offset_l0, 0,
1089         sizeof (slice_param->luma_offset_l0));
1090     slice_param->chroma_weight_l0_flag = FALSE;
1091     memset (slice_param->chroma_weight_l0, 0,
1092         sizeof (slice_param->chroma_weight_l0));
1093     memset (slice_param->chroma_offset_l0, 0,
1094         sizeof (slice_param->chroma_offset_l0));
1095     slice_param->luma_weight_l1_flag = FALSE;
1096     memset (slice_param->luma_weight_l1, 0,
1097         sizeof (slice_param->luma_weight_l1));
1098     memset (slice_param->luma_offset_l1, 0,
1099         sizeof (slice_param->luma_offset_l1));
1100     slice_param->chroma_weight_l1_flag = FALSE;
1101     memset (slice_param->chroma_weight_l1, 0,
1102         sizeof (slice_param->chroma_weight_l1));
1103     memset (slice_param->chroma_offset_l1, 0,
1104         sizeof (slice_param->chroma_offset_l1));
1105
1106     slice_param->cabac_init_idc = 0;
1107     slice_param->slice_qp_delta = encoder->init_qp - encoder->min_qp;
1108     if (slice_param->slice_qp_delta > 4)
1109       slice_param->slice_qp_delta = 4;
1110     slice_param->disable_deblocking_filter_idc = 0;
1111     slice_param->slice_alpha_c0_offset_div2 = 2;
1112     slice_param->slice_beta_offset_div2 = 2;
1113
1114     /* set calculation for next slice */
1115     last_mb_index += cur_slice_mbs;
1116
1117     gst_vaapi_enc_picture_add_slice (picture, slice);
1118     gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & slice, NULL);
1119
1120   }
1121   g_assert (last_mb_index == total_mbs);
1122   return TRUE;
1123 }
1124
1125 static gboolean
1126 ensure_sequence (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture)
1127 {
1128   GstVaapiEncSequence *sequence;
1129
1130   g_assert (picture);
1131   sequence = GST_VAAPI_ENC_SEQUENCE_NEW (H264, encoder);
1132   g_assert (sequence);
1133   if (!sequence)
1134     goto error;
1135
1136   if (!fill_va_sequence_param (encoder, sequence))
1137     goto error;
1138
1139   if (picture->type == GST_VAAPI_PICTURE_TYPE_I &&
1140       !add_sequence_packed_header (encoder, picture, sequence))
1141     goto error;
1142   gst_vaapi_enc_picture_set_sequence (picture, sequence);
1143   gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) (&sequence), NULL);
1144   return TRUE;
1145
1146 error:
1147   gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) (&sequence), NULL);
1148   return FALSE;
1149 }
1150
1151 static gboolean
1152 ensure_picture (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture,
1153     GstVaapiCodedBufferProxy * codedbuf_proxy, GstVaapiSurfaceProxy * surface)
1154 {
1155   GstVaapiCodedBuffer *const codedbuf =
1156     GST_VAAPI_CODED_BUFFER_PROXY_BUFFER (codedbuf_proxy);
1157
1158   if (!fill_va_picture_param (encoder, picture, codedbuf, surface))
1159     return FALSE;
1160
1161   if (picture->type == GST_VAAPI_PICTURE_TYPE_I &&
1162       !add_picture_packed_header (encoder, picture)) {
1163     GST_ERROR ("set picture packed header failed");
1164     return FALSE;
1165   }
1166
1167   return TRUE;
1168 }
1169
1170 static gboolean
1171 ensure_slices (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture)
1172 {
1173   GstVaapiEncoderH264Ref *reflist_0[16];
1174   GstVaapiEncoderH264Ref *reflist_1[16];
1175   guint reflist_0_count = 0, reflist_1_count = 0;
1176
1177   g_assert (picture);
1178
1179   if (picture->type != GST_VAAPI_PICTURE_TYPE_I &&
1180       !reference_list_init (encoder, picture,
1181           reflist_0, &reflist_0_count, reflist_1, &reflist_1_count)) {
1182     GST_ERROR ("reference list reorder failed");
1183     return FALSE;
1184   }
1185
1186   g_assert (reflist_0_count + reflist_1_count <= encoder->max_ref_num);
1187   if (reflist_0_count > encoder->max_reflist0_count)
1188     reflist_0_count = encoder->max_reflist0_count;
1189   if (reflist_1_count > encoder->max_reflist1_count)
1190     reflist_1_count = encoder->max_reflist1_count;
1191
1192   if (!fill_va_slices_param (encoder, picture,
1193           reflist_0, reflist_0_count, reflist_1, reflist_1_count))
1194     return FALSE;
1195
1196   return TRUE;
1197 }
1198
1199 static gboolean
1200 ensure_misc (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture)
1201 {
1202   GstVaapiEncMiscParam *misc = NULL;
1203   VAEncMiscParameterHRD *hrd;
1204   VAEncMiscParameterRateControl *rate_control;
1205
1206   /* add hrd */
1207   misc = GST_VAAPI_ENC_MISC_PARAM_NEW (HRD, encoder);
1208   g_assert (misc);
1209   if (!misc)
1210     return FALSE;
1211   gst_vaapi_enc_picture_add_misc_buffer (picture, misc);
1212   hrd = misc->impl;
1213   if (encoder->bitrate > 0) {
1214     hrd->initial_buffer_fullness = encoder->bitrate * 1024 * 4;
1215     hrd->buffer_size = encoder->bitrate * 1024 * 8;
1216   } else {
1217     hrd->initial_buffer_fullness = 0;
1218     hrd->buffer_size = 0;
1219   }
1220   gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & misc, NULL);
1221
1222   /* add ratecontrol */
1223   if (GST_VAAPI_ENCODER_RATE_CONTROL (encoder) == GST_VAAPI_RATECONTROL_CBR ||
1224       GST_VAAPI_ENCODER_RATE_CONTROL (encoder) == GST_VAAPI_RATECONTROL_VBR) {
1225     misc = GST_VAAPI_ENC_MISC_PARAM_NEW (RateControl, encoder);
1226     g_assert (misc);
1227     if (!misc)
1228       return FALSE;
1229     gst_vaapi_enc_picture_add_misc_buffer (picture, misc);
1230     rate_control = misc->impl;
1231     memset (rate_control, 0, sizeof (VAEncMiscParameterRateControl));
1232     if (encoder->bitrate)
1233       rate_control->bits_per_second = encoder->bitrate * 1024;
1234     else
1235       rate_control->bits_per_second = 0;
1236     rate_control->target_percentage = 70;
1237     rate_control->window_size = 500;
1238     rate_control->initial_qp = encoder->init_qp;
1239     rate_control->min_qp = encoder->min_qp;
1240     rate_control->basic_unit_size = 0;
1241     gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & misc, NULL);
1242   }
1243
1244   return TRUE;
1245 }
1246
1247 gboolean
1248 init_encoder_public_attributes (GstVaapiEncoderH264 * encoder)
1249 {
1250   guint width_mbs, height_mbs, total_mbs;
1251
1252   if (!GST_VAAPI_ENCODER_WIDTH (encoder) ||
1253       !GST_VAAPI_ENCODER_HEIGHT (encoder) ||
1254       !GST_VAAPI_ENCODER_FPS_N (encoder) ||
1255       !GST_VAAPI_ENCODER_FPS_D (encoder)) {
1256     return FALSE;
1257   }
1258   if (!encoder->profile)
1259     encoder->profile = GST_VAAPI_ENCODER_H264_DEFAULT_PROFILE;
1260
1261   _set_level (encoder);
1262
1263   if (!encoder->intra_period)
1264     encoder->intra_period = GST_VAAPI_ENCODER_H264_DEFAULT_INTRA_PERIOD;
1265   else if (encoder->intra_period > GST_VAAPI_ENCODER_H264_MAX_INTRA_PERIOD)
1266     encoder->intra_period = GST_VAAPI_ENCODER_H264_MAX_INTRA_PERIOD;
1267
1268   if (encoder->idr_period < encoder->intra_period)
1269     encoder->idr_period = encoder->intra_period;
1270   if (encoder->idr_period > GST_VAAPI_ENCODER_H264_MAX_IDR_PERIOD)
1271     encoder->idr_period = GST_VAAPI_ENCODER_H264_MAX_IDR_PERIOD;
1272
1273   if (-1 == encoder->init_qp)
1274     encoder->init_qp = GST_VAAPI_ENCODER_H264_DEFAULT_INIT_QP;
1275
1276   if (-1 == encoder->min_qp) {
1277     if (GST_VAAPI_RATECONTROL_CQP == GST_VAAPI_ENCODER_RATE_CONTROL (encoder))
1278       encoder->min_qp = encoder->init_qp;
1279     else
1280       encoder->min_qp = GST_VAAPI_ENCODER_H264_DEFAULT_MIN_QP;
1281   }
1282
1283   if (encoder->min_qp > encoder->init_qp)
1284     encoder->min_qp = encoder->init_qp;
1285
1286   /* default compress ratio 1: (4*8*1.5) */
1287   if (GST_VAAPI_RATECONTROL_CBR == GST_VAAPI_ENCODER_RATE_CONTROL (encoder) ||
1288       GST_VAAPI_RATECONTROL_VBR == GST_VAAPI_ENCODER_RATE_CONTROL (encoder) ||
1289       GST_VAAPI_RATECONTROL_VBR_CONSTRAINED ==
1290       GST_VAAPI_ENCODER_RATE_CONTROL (encoder)) {
1291     if (!encoder->bitrate)
1292       encoder->bitrate = GST_VAAPI_ENCODER_WIDTH (encoder) *
1293           GST_VAAPI_ENCODER_HEIGHT (encoder) *
1294           GST_VAAPI_ENCODER_FPS_N (encoder) /
1295           GST_VAAPI_ENCODER_FPS_D (encoder) / 4 / 1024;
1296   } else
1297     encoder->bitrate = 0;
1298
1299   if (!encoder->slice_num)
1300     encoder->slice_num = GST_VAAPI_ENCODER_H264_DEFAULT_SLICE_NUM;
1301
1302   width_mbs = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16;
1303   height_mbs = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16;
1304   total_mbs = width_mbs * height_mbs;
1305
1306   if (encoder->slice_num > (total_mbs + 1) / 2)
1307     encoder->slice_num = (total_mbs + 1) / 2;
1308   g_assert (encoder->slice_num);
1309
1310   if (encoder->b_frame_num > (encoder->intra_period + 1) / 2)
1311     encoder->b_frame_num = (encoder->intra_period + 1) / 2;
1312
1313   if (encoder->b_frame_num > 50)
1314     encoder->b_frame_num = 50;
1315
1316   return TRUE;
1317 }
1318
1319 static gboolean
1320 init_encoder_private_attributes (GstVaapiEncoderH264 * encoder, GstCaps * caps)
1321 {
1322   if (encoder->b_frame_num)
1323     encoder->cts_offset = GST_SECOND * GST_VAAPI_ENCODER_FPS_D (encoder) /
1324         GST_VAAPI_ENCODER_FPS_N (encoder);
1325   else
1326     encoder->cts_offset = 0;
1327
1328   /* init max_frame_num, max_poc */
1329   encoder->log2_max_frame_num = _get_log2_max_frame_num (encoder->idr_period);
1330   g_assert (encoder->log2_max_frame_num >= 4);
1331   encoder->max_frame_num = (1 << encoder->log2_max_frame_num);
1332   encoder->log2_max_pic_order_cnt = encoder->log2_max_frame_num + 1;
1333   encoder->max_pic_order_cnt = (1 << encoder->log2_max_pic_order_cnt);
1334
1335   encoder->frame_index = 0;
1336   encoder->idr_num = 0;
1337   encoder->max_reflist0_count = 1;
1338   if (encoder->b_frame_num)
1339     encoder->max_reflist1_count = 1;
1340   else
1341     encoder->max_reflist1_count = 0;
1342   encoder->max_ref_num =
1343       encoder->max_reflist0_count + encoder->max_reflist1_count;
1344   return TRUE;
1345 }
1346
1347
1348 static GstVaapiEncoderStatus
1349 gst_vaapi_encoder_h264_encode (GstVaapiEncoder * base,
1350     GstVaapiEncPicture * picture, GstVaapiCodedBufferProxy * codedbuf)
1351 {
1352   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST (base);
1353   GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_UNKNOWN_ERR;
1354   GstVaapiSurfaceProxy *reconstruct = NULL;
1355
1356   reconstruct = gst_vaapi_encoder_create_surface (base);
1357
1358   g_assert (GST_VAAPI_SURFACE_PROXY_SURFACE (reconstruct));
1359
1360   if (!ensure_sequence (encoder, picture))
1361     goto error;
1362   if (!ensure_picture (encoder, picture, codedbuf, reconstruct))
1363     goto error;
1364   if (!ensure_misc (encoder, picture))
1365     goto error;
1366   if (!ensure_slices (encoder, picture))
1367     goto error;
1368   if (!gst_vaapi_enc_picture_encode (picture))
1369     goto error;
1370
1371   if (!reference_list_update (encoder, picture, reconstruct))
1372     goto error;
1373
1374   return GST_VAAPI_ENCODER_STATUS_SUCCESS;
1375 error:
1376   if (reconstruct)
1377     gst_vaapi_encoder_release_surface (GST_VAAPI_ENCODER (encoder),
1378         reconstruct);
1379   return ret;
1380 }
1381
1382 static GstVaapiEncoderStatus
1383 gst_vaapi_encoder_h264_flush (GstVaapiEncoder * base)
1384 {
1385   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST (base);
1386   GstVaapiEncPicture *pic;
1387
1388   encoder->frame_index = 0;
1389   encoder->cur_frame_num = 0;
1390   encoder->cur_present_index = 0;
1391   while (!g_queue_is_empty (&encoder->reorder_frame_list)) {
1392     pic =
1393         (GstVaapiEncPicture *) g_queue_pop_head (&encoder->reorder_frame_list);
1394     gst_vaapi_enc_picture_unref (pic);
1395   }
1396   g_queue_clear (&encoder->reorder_frame_list);
1397
1398   return GST_VAAPI_ENCODER_STATUS_SUCCESS;
1399 }
1400
1401 static GstVaapiEncoderStatus
1402 gst_vaapi_encoder_h264_get_avcC_codec_data (GstVaapiEncoderH264 * encoder,
1403     GstBuffer ** buffer)
1404 {
1405   GstBuffer *avc_codec;
1406   const guint32 configuration_version = 0x01;
1407   const guint32 length_size_minus_one = 0x03;
1408   guint32 profile, profile_comp, level_idc;
1409   GstMapInfo sps_info, pps_info;
1410   GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_SUCCESS;
1411   GstBitWriter writer;
1412
1413   g_assert (buffer);
1414   if (!encoder->sps_data || !encoder->pps_data)
1415     return GST_VAAPI_ENCODER_STATUS_NOT_READY;
1416
1417   if (!gst_buffer_map (encoder->sps_data, &sps_info, GST_MAP_READ))
1418     return GST_VAAPI_ENCODER_STATUS_MEM_ERROR;
1419
1420   if (FALSE == _read_sps_attributes (sps_info.data, sps_info.size,
1421           &profile, &profile_comp, &level_idc)) {
1422     ret = GST_VAAPI_ENCODER_STATUS_UNKNOWN_ERR;
1423     goto end;
1424   }
1425
1426   if (!gst_buffer_map (encoder->pps_data, &pps_info, GST_MAP_READ)) {
1427     ret = GST_VAAPI_ENCODER_STATUS_MEM_ERROR;
1428     goto end;
1429   }
1430
1431   gst_bit_writer_init (&writer, (sps_info.size + pps_info.size + 64) * 8);
1432   /* codec_data */
1433   gst_bit_writer_put_bits_uint32 (&writer, configuration_version, 8);
1434   gst_bit_writer_put_bits_uint32 (&writer, profile, 8);
1435   gst_bit_writer_put_bits_uint32 (&writer, profile_comp, 8);
1436   gst_bit_writer_put_bits_uint32 (&writer, level_idc, 8);
1437   gst_bit_writer_put_bits_uint32 (&writer, 0x3F, 6);    /*111111 */
1438   gst_bit_writer_put_bits_uint32 (&writer, length_size_minus_one, 2);
1439   gst_bit_writer_put_bits_uint32 (&writer, 0x07, 3);    /*111 */
1440
1441   /* write sps */
1442   gst_bit_writer_put_bits_uint32 (&writer, 1, 5);       /* sps count = 1 */
1443   g_assert (GST_BIT_WRITER_BIT_SIZE (&writer) % 8 == 0);
1444   gst_bit_writer_put_bits_uint32 (&writer, sps_info.size, 16);
1445   gst_bit_writer_put_bytes (&writer, sps_info.data, sps_info.size);
1446
1447   /* write pps */
1448   gst_bit_writer_put_bits_uint32 (&writer, 1, 8);       /*pps count = 1 */
1449   gst_bit_writer_put_bits_uint32 (&writer, pps_info.size, 16);
1450   gst_bit_writer_put_bytes (&writer, pps_info.data, pps_info.size);
1451
1452   avc_codec = gst_buffer_new_wrapped (GST_BIT_WRITER_DATA (&writer),
1453       GST_BIT_WRITER_BIT_SIZE (&writer) / 8);
1454   g_assert (avc_codec);
1455   if (!avc_codec) {
1456     ret = GST_VAAPI_ENCODER_STATUS_MEM_ERROR;
1457     goto clear_writer;
1458   }
1459   *buffer = avc_codec;
1460
1461   gst_buffer_unmap (encoder->pps_data, &pps_info);
1462   gst_bit_writer_clear (&writer, FALSE);
1463   ret = GST_VAAPI_ENCODER_STATUS_SUCCESS;
1464   goto end;
1465
1466 clear_writer:
1467   gst_bit_writer_clear (&writer, TRUE);
1468
1469 end:
1470   gst_buffer_unmap (encoder->sps_data, &sps_info);
1471
1472   return ret;
1473 }
1474
1475 static GstVaapiEncoderStatus
1476 gst_vaapi_encoder_h264_get_codec_data (GstVaapiEncoder * base,
1477     GstBuffer ** buffer)
1478 {
1479   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST (base);
1480
1481   *buffer = NULL;
1482
1483   if (!encoder->is_avc)
1484     return GST_VAAPI_ENCODER_STATUS_SUCCESS;
1485
1486   return gst_vaapi_encoder_h264_get_avcC_codec_data (encoder, buffer);
1487 }
1488
1489 static GstVaapiEncoderStatus
1490 gst_vaapi_encoder_h264_reordering (GstVaapiEncoder * base,
1491     GstVideoCodecFrame * frame, gboolean flush, GstVaapiEncPicture ** output)
1492 {
1493   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264 (base);
1494   GstVaapiEncPicture *picture;
1495   gboolean is_idr = FALSE;
1496
1497   *output = NULL;
1498
1499   if (!frame) {
1500     if (encoder->reorder_state != GST_VAAPI_ENC_H264_REORD_DUMP_FRAMES)
1501       return GST_VAAPI_ENCODER_STATUS_FRAME_NOT_READY;
1502
1503     /* reorder_state = GST_VAAPI_ENC_H264_REORD_DUMP_FRAMES
1504        dump B frames from queue, sometime, there may also have P frame or I frame */
1505     g_assert (encoder->b_frame_num > 0);
1506     g_return_val_if_fail (!g_queue_is_empty (&encoder->reorder_frame_list),
1507         GST_VAAPI_ENCODER_STATUS_UNKNOWN_ERR);
1508     picture = g_queue_pop_head (&encoder->reorder_frame_list);
1509     g_assert (picture);
1510     if (g_queue_is_empty (&encoder->reorder_frame_list)) {
1511       encoder->reorder_state = GST_VAAPI_ENC_H264_REORD_WAIT_FRAMES;
1512     }
1513     goto end;
1514   }
1515
1516   /* new frame coming */
1517   picture = GST_VAAPI_ENC_PICTURE_NEW (H264, encoder, frame);
1518   if (!picture) {
1519     GST_WARNING ("create H264 picture failed, frame timestamp:%"
1520         GST_TIME_FORMAT, GST_TIME_ARGS (frame->pts));
1521     return GST_VAAPI_ENCODER_STATUS_OBJECT_ERR;
1522   }
1523   ++encoder->cur_present_index;
1524   picture->poc = ((encoder->cur_present_index * 2) %
1525       encoder->max_pic_order_cnt);
1526
1527   is_idr = (encoder->frame_index == 0 ||
1528       encoder->frame_index >= encoder->idr_period);
1529
1530   /* check key frames */
1531   if (is_idr || GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME (frame) ||
1532       (encoder->frame_index % encoder->intra_period) == 0) {
1533     ++encoder->cur_frame_num;
1534     ++encoder->frame_index;
1535
1536     /* b frame enabled,  check queue of reorder_frame_list */
1537     if (encoder->b_frame_num
1538         && !g_queue_is_empty (&encoder->reorder_frame_list)) {
1539       GstVaapiEncPicture *p_pic;
1540
1541       p_pic = g_queue_pop_tail (&encoder->reorder_frame_list);
1542       _set_p_frame (p_pic, encoder);
1543       g_queue_foreach (&encoder->reorder_frame_list,
1544           (GFunc) _set_b_frame, encoder);
1545       ++encoder->cur_frame_num;
1546       _set_key_frame (picture, encoder, is_idr);
1547       g_queue_push_tail (&encoder->reorder_frame_list, picture);
1548       picture = p_pic;
1549       encoder->reorder_state = GST_VAAPI_ENC_H264_REORD_DUMP_FRAMES;
1550     } else {                    /* no b frames in queue */
1551       _set_key_frame (picture, encoder, is_idr);
1552       g_assert (g_queue_is_empty (&encoder->reorder_frame_list));
1553       if (encoder->b_frame_num)
1554         encoder->reorder_state = GST_VAAPI_ENC_H264_REORD_WAIT_FRAMES;
1555     }
1556     goto end;
1557   }
1558
1559   /* new p/b frames coming */
1560   ++encoder->frame_index;
1561   if (encoder->reorder_state == GST_VAAPI_ENC_H264_REORD_WAIT_FRAMES &&
1562       g_queue_get_length (&encoder->reorder_frame_list) <
1563       encoder->b_frame_num) {
1564     g_queue_push_tail (&encoder->reorder_frame_list, picture);
1565     return GST_VAAPI_ENCODER_STATUS_FRAME_NOT_READY;
1566   }
1567
1568   ++encoder->cur_frame_num;
1569   _set_p_frame (picture, encoder);
1570
1571   if (encoder->reorder_state == GST_VAAPI_ENC_H264_REORD_WAIT_FRAMES) {
1572     g_queue_foreach (&encoder->reorder_frame_list, (GFunc) _set_b_frame,
1573         encoder);
1574     encoder->reorder_state = GST_VAAPI_ENC_H264_REORD_DUMP_FRAMES;
1575     g_assert (!g_queue_is_empty (&encoder->reorder_frame_list));
1576   }
1577
1578 end:
1579   g_assert (picture);
1580   frame = GST_VAAPI_ENC_PICTURE_GET_FRAME (picture);
1581   if (GST_CLOCK_TIME_IS_VALID (frame->pts))
1582     frame->pts += encoder->cts_offset;
1583   *output = picture;
1584
1585   return GST_VAAPI_ENCODER_STATUS_SUCCESS;
1586 }
1587
1588 static gboolean
1589 gst_vaapi_encoder_h264_get_context_info (GstVaapiEncoder * base,
1590     GstVaapiContextInfo * info)
1591 {
1592   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264 (base);
1593   const static guint default_surface_num = 3;
1594
1595   g_return_val_if_fail (info, FALSE);
1596
1597   info->profile = encoder->profile;
1598   info->entrypoint = GST_VAAPI_ENTRYPOINT_SLICE_ENCODE;
1599   info->width = GST_VAAPI_ENCODER_WIDTH (encoder);
1600   info->height = GST_VAAPI_ENCODER_HEIGHT (encoder);
1601   info->ref_frames = (encoder->b_frame_num ? 2 : 1) + default_surface_num;
1602   info->rc_mode = GST_VAAPI_ENCODER_RATE_CONTROL (encoder);
1603
1604   return TRUE;
1605 }
1606
1607 static GstCaps *
1608 gst_vaapi_encoder_h264_set_format (GstVaapiEncoder * base,
1609     GstVideoCodecState * in_state, GstCaps * ref_caps)
1610 {
1611   GstVaapiEncoderH264 *encoder;
1612   GstCaps *result = NULL, *tmp;
1613   GstStructure *structure;
1614   const GValue *value;
1615   const gchar *stream_format;
1616
1617   encoder = GST_VAAPI_ENCODER_H264 (base);
1618
1619   tmp = gst_caps_from_string ("video/x-h264");
1620   gst_caps_set_simple (tmp,
1621       "width", G_TYPE_INT, GST_VAAPI_ENCODER_WIDTH (encoder),
1622       "height", G_TYPE_INT, GST_VAAPI_ENCODER_HEIGHT (encoder),
1623       "framerate", GST_TYPE_FRACTION,
1624       GST_VAAPI_ENCODER_FPS_N (encoder), GST_VAAPI_ENCODER_FPS_D (encoder),
1625       NULL);
1626   result = gst_caps_intersect (tmp, ref_caps);
1627   gst_caps_unref (tmp);
1628
1629   /* fixed stream-format and choose byte-stream first */
1630   structure = gst_caps_get_structure (result, 0);
1631   value = gst_structure_get_value (structure, "stream-format");
1632   if (value) {
1633     gst_structure_fixate_field_string (structure, "stream-format",
1634         "byte-stream");
1635     stream_format = gst_structure_get_string (structure, "stream-format");
1636   } else {
1637     stream_format = "byte-stream";
1638     gst_structure_set (structure, "stream-format", G_TYPE_STRING, stream_format,
1639         NULL);
1640   }
1641
1642   if (strcmp (stream_format, "byte-stream") == 0)
1643     encoder->is_avc = FALSE;
1644   else                          /* need codec data later */
1645     encoder->is_avc = TRUE;
1646
1647 #if GST_CHECK_VERSION(1,0,0)
1648   result = gst_caps_fixate (result);
1649 #endif
1650
1651   if (!init_encoder_public_attributes (encoder)) {
1652     GST_WARNING ("encoder ensure public attributes failed ");
1653     goto error;
1654   }
1655
1656   if (!init_encoder_private_attributes (encoder, result)) {
1657     GST_WARNING ("prepare encoding failed ");
1658     goto error;
1659   }
1660
1661   return result;
1662
1663 error:
1664   gst_caps_unref (result);
1665   return NULL;
1666 }
1667
1668 static gboolean
1669 gst_vaapi_encoder_h264_init (GstVaapiEncoder * base)
1670 {
1671   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264 (base);
1672
1673   /* init attributes */
1674   encoder->profile = 0;
1675   encoder->level = 0;
1676   encoder->bitrate = 0;
1677   encoder->idr_period = 0;
1678   encoder->intra_period = 0;
1679   encoder->init_qp = -1;
1680   encoder->min_qp = -1;
1681   encoder->slice_num = 0;
1682   encoder->b_frame_num = 0;
1683   //gst_vaapi_base_encoder_set_frame_notify(GST_VAAPI_BASE_ENCODER(encoder), TRUE);
1684
1685   /* init private values */
1686   encoder->is_avc = FALSE;
1687   /* re-ordering */
1688   g_queue_init (&encoder->reorder_frame_list);
1689   encoder->reorder_state = GST_VAAPI_ENC_H264_REORD_NONE;
1690   encoder->frame_index = 0;
1691   encoder->cur_frame_num = 0;
1692   encoder->cur_present_index = 0;
1693
1694   g_queue_init (&encoder->ref_list);
1695   encoder->max_ref_num = 0;
1696   encoder->max_reflist0_count = 1;
1697   encoder->max_reflist1_count = 1;
1698
1699   encoder->sps_data = NULL;
1700   encoder->pps_data = NULL;
1701
1702   encoder->cts_offset = 0;
1703
1704   encoder->max_frame_num = 0;
1705   encoder->log2_max_frame_num = 0;
1706   encoder->max_pic_order_cnt = 0;
1707   encoder->log2_max_pic_order_cnt = 0;
1708   encoder->idr_num = 0;
1709
1710   return TRUE;
1711 }
1712
1713 static void
1714 gst_vaapi_encoder_h264_finalize (GstVaapiEncoder * base)
1715 {
1716   /*free private buffers */
1717   GstVaapiEncoderH264 *const encoder = GST_VAAPI_ENCODER_H264 (base);
1718   GstVaapiEncPicture *pic;
1719   GstVaapiEncoderH264Ref *ref;
1720
1721   gst_buffer_replace (&encoder->sps_data, NULL);
1722   gst_buffer_replace (&encoder->pps_data, NULL);
1723
1724   while (!g_queue_is_empty (&encoder->ref_list)) {
1725     ref = (GstVaapiEncoderH264Ref *) g_queue_pop_head (&encoder->ref_list);
1726     reference_pic_free (encoder, ref);
1727   }
1728   g_queue_clear (&encoder->ref_list);
1729
1730   while (!g_queue_is_empty (&encoder->reorder_frame_list)) {
1731     pic =
1732         (GstVaapiEncPicture *) g_queue_pop_head (&encoder->reorder_frame_list);
1733     gst_vaapi_enc_picture_unref (pic);
1734   }
1735   g_queue_clear (&encoder->reorder_frame_list);
1736
1737 }
1738
1739 static inline const GstVaapiEncoderClass *
1740 gst_vaapi_encoder_h264_class ()
1741 {
1742   static const GstVaapiEncoderClass GstVaapiEncoderH264Class = {
1743     GST_VAAPI_ENCODER_CLASS_INIT (H264, h264),
1744     .get_codec_data = gst_vaapi_encoder_h264_get_codec_data
1745   };
1746   return &GstVaapiEncoderH264Class;
1747 }
1748
1749 GstVaapiEncoder *
1750 gst_vaapi_encoder_h264_new (GstVaapiDisplay * display)
1751 {
1752   return gst_vaapi_encoder_new (gst_vaapi_encoder_h264_class (), display);
1753 }
1754
1755 void
1756 gst_vaapi_encoder_h264_set_avc (GstVaapiEncoderH264 * encoder, gboolean is_avc)
1757 {
1758   encoder->is_avc = is_avc;
1759 }
1760
1761 gboolean
1762 gst_vaapi_encoder_h264_is_avc (GstVaapiEncoderH264 * encoder)
1763 {
1764   return encoder->is_avc;
1765 }