gst-libs/gst/vaapi/gstvaapiencoder_h264.c

   1 /*
   2  *  gstvaapiencoder_h264.c -  H.264 encoder
   3  *
   4  *  Copyright (C) 2011 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 "gstvaapiencoder_h264.h"
  23
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <va/va.h>
  27 #include <va/va_x11.h>
  28 #include <va/va_enc_h264.h>
  29 #include <X11/Xlib.h>
  30 #include <glib.h>
  31
  32 #include "gst/gstclock.h"
  33 #include "gst/gstvalue.h"
  34
  35 #include "gstvaapiobject.h"
  36 #include "gstvaapiobject_priv.h"
  37 #include "gstvaapicontext.h"
  38 #include "gstvaapisurface.h"
  39 #include "gstvaapivideobuffer.h"
  40 #include "gstvaapidisplay_priv.h"
  41
  42 GST_DEBUG_CATEGORY_STATIC (gst_vaapi_h264_encoder_debug);
  43
  44 #define GST_CAT_DEFAULT gst_vaapi_h264_encoder_debug
  45
  46 #define GST_VAAPI_ENCODER_H264_CAST(encoder)    ((GstVaapiEncoderH264 *)(encoder))
  47
  48 #define SHARE_CODED_BUF         0
  49
  50 #define DEFAULT_SURFACE_NUMBER  3
  51 #define DEFAULT_CODEDBUF_NUM    5
  52 #define DEFAULT_SID_INPUT       0 // suface_ids[0]
  53
  54 #define REF_RECON_SURFACE_NUM   2
  55
  56 #define ENTROPY_MODE_CAVLC      0
  57 #define ENTROPY_MODE_CABAC      1
  58
  59 #define BR_CBR          0
  60 #define BR_VBR          1
  61 #define BR_CQP          2
  62
  63 #define NAL_REF_IDC_NONE        0
  64 #define NAL_REF_IDC_LOW         1
  65 #define NAL_REF_IDC_MEDIUM      2
  66 #define NAL_REF_IDC_HIGH        3
  67
  68
  69 typedef enum {
  70   NAL_UNKNOWN     = 0,
  71   NAL_NON_IDR     = 1,
  72   NAL_IDR         = 5,    /* ref_idc != 0 */
  73   NAL_SEI         = 6,    /* ref_idc == 0 */
  74   NAL_SPS         = 7,
  75   NAL_PPS         = 8,
  76   NAL_AUD         = 9,
  77   NAL_FILLER      = 12,
  78 }H264_NAL_TYPE;
  79
  80
  81 typedef enum {
  82   SLICE_TYPE_P  = 0,
  83   SLICE_TYPE_B  = 1,
  84   SLICE_TYPE_I  = 2
  85 } H264_SLICE_TYPE;
  86
  87 struct _GstVaapiEncoderH264Private {
  88   GstVaapiEncoderH264   *public;
  89   guint32           format;   /*NV12, I420,*/
  90   gboolean          avc_flag;  /*elementary flag*/
  91
  92   /* private data*/
  93   GQueue           *video_buffer_caches; /*not used for baseline*/
  94
  95   GstVaapiSurface  *ref_surface1;  /* reference buffer*/
  96   GstVaapiSurface  *ref_surface2;  /* for B frames */
  97   GstVaapiSurface  *recon_surface; /* reconstruct buffer*/
  98
  99   VABufferID        seq_param_id;
 100   VABufferID        pic_param_id;
 101   VABufferID        slice_param_id;
 102   VABufferID        packed_seq_param_id;
 103   VABufferID        packed_seq_data_id;
 104   VABufferID        packed_pic_param_id;
 105   VABufferID        packed_pic_data_id;
 106 #ifdef _SIMPLE_LIB_VA_
 107   VAEncSliceParameterBuffer     *slice_param_buffers;
 108 #else
 109   VAEncSliceParameterBufferH264 *slice_param_buffers;
 110 #endif
 111   guint32           default_slice_height;
 112   guint32           slice_mod_mb_num;
 113   guint32           default_cts_offset;
 114
 115   GstBuffer        *sps_data;
 116   GstBuffer        *pps_data;
 117
 118   GQueue           *queued_buffers;  /* GstVaapiVideoBuffers with surface*/
 119
 120   guint32           gop_count;
 121   guint32           cur_display_num;
 122   guint32           cur_decode_num;
 123   H264_SLICE_TYPE   cur_slice_type;
 124   guint64           last_decode_time;
 125   guint32           max_frame_num;
 126   guint32           max_pic_order_cnt;
 127   guint16           idr_num;
 128 };
 129
 130 G_DEFINE_TYPE(GstVaapiEncoderH264, gst_vaapi_encoder_h264, GST_TYPE_VAAPI_BASE_ENCODER)
 131
 132 // 4096-1
 133 #define H264_BITSTREAM_ALLOC_ALIGN_MASK 0x0FFF
 134
 135 #define BIT_STREAM_BUFFER(stream)    ((stream)->buffer)
 136 #define BIT_STREAM_BIT_SIZE(stream)  ((stream)->bit_size)
 137
 138 struct _H264Bitstream {
 139   guint8   *buffer;
 140   guint32   bit_size;
 141   guint32   max_bit_capability;
 142 };
 143
 144 typedef struct _H264Bitstream H264Bitstream;
 145
 146 static const guint8 h264_bit_mask[9] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};
 147
 148 /* h264 bitstream functions */
 149 static void
 150 h264_bitstream_init(H264Bitstream *bitstream, guint32 bit_capability);
 151
 152 static gboolean
 153 h264_bitstream_write_uint(
 154     H264Bitstream *bitstream,
 155     guint32 value,
 156     guint32 bit_size
 157 );
 158
 159 static gboolean
 160 h264_bitstream_align(H264Bitstream *bitstream, guint32 value);
 161
 162 static gboolean
 163 h264_bitstream_write_ue(H264Bitstream *bitstream, guint32 value);
 164
 165 static gboolean
 166 h264_bitstream_write_se(H264Bitstream *bitstream, gint32 value);
 167
 168 static gboolean
 169 h264_bitstream_write_trailing_bits(H264Bitstream *bitstream);
 170
 171 static gboolean
 172 h264_bitstream_write_byte_array(
 173     H264Bitstream *bitstream,
 174     const guint8 *buf,
 175     guint32 byte_size
 176 );
 177
 178 static void
 179 h264_bitstream_destroy(H264Bitstream *bitstream, gboolean free_flag);
 180
 181 static gboolean
 182 h264_bitstream_auto_grow(H264Bitstream *bitstream, guint32 extra_bit_size);
 183
 184 static gboolean
 185 h264_bitstream_write_sps(
 186     H264Bitstream *bitstream,
 187     VAEncSequenceParameterBufferH264 *seq,
 188     H264_Profile profile
 189 );
 190 static gboolean
 191 h264_bitstream_write_pps(
 192     H264Bitstream *bitstream,
 193     VAEncPictureParameterBufferH264 *pic
 194 );
 195
 196 static gboolean
 197 h264_bitstream_write_nal_header(
 198     H264Bitstream *bitstream,
 199     guint nal_ref_idc,
 200     guint nal_unit_type
 201 );
 202
 203 static VAProfile
 204 h264_get_va_profile(guint32 profile)
 205 {
 206   switch (profile) {
 207     case H264_PROFILE_BASELINE:
 208       return VAProfileH264Baseline;
 209
 210     case H264_PROFILE_MAIN:
 211       return VAProfileH264Main;
 212
 213     case H264_PROFILE_HIGH:
 214       return VAProfileH264High;
 215
 216     default:
 217       break;
 218   }
 219   return (-1);
 220 }
 221
 222 GstVaapiEncoderH264 *
 223 gst_vaapi_encoder_h264_new(void)
 224 {
 225   return GST_VAAPI_ENCODER_H264_CAST(
 226              g_object_new(GST_TYPE_VAAPI_ENCODER_H264, NULL));
 227 }
 228
 229 static void
 230 gst_vaapi_encoder_h264_init_public_values(GstVaapiEncoderH264* encoder)
 231 {
 232   encoder->profile = 0;
 233   encoder->level = 0;
 234   encoder->bitrate = 0;
 235   encoder->intra_period = 0;
 236   encoder->init_qp = -1;
 237   encoder->min_qp = -1;
 238   encoder->slice_num = 0;
 239   encoder->b_frame_num = 0;
 240 }
 241
 242 void
 243 gst_vaapi_encoder_h264_set_avc_flag(GstVaapiEncoderH264* encoder, gboolean avc)
 244 {
 245   GstVaapiEncoderH264Private *priv = encoder->priv;
 246   priv->avc_flag = avc;
 247 }
 248
 249 gboolean
 250 gst_vaapi_encoder_h264_get_avc_flag(GstVaapiEncoderH264* encoder)
 251 {
 252   GstVaapiEncoderH264Private *priv = encoder->priv;
 253   return priv->avc_flag;
 254 }
 255
 256 gboolean
 257 gst_vaapi_encoder_h264_validate_attributes(GstVaapiBaseEncoder *base)
 258 {
 259   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 260   GstVaapiEncoderH264Private *priv = encoder->priv;
 261   if (!ENCODER_WIDTH(encoder) ||
 262       !ENCODER_HEIGHT(encoder) ||
 263       !ENCODER_FPS(encoder)) {
 264     return FALSE;
 265   }
 266   if (!encoder->profile) {
 267     encoder->profile = H264_DEFAULT_PROFILE;
 268   }
 269   gst_vaapi_base_encoder_set_va_profile(base, h264_get_va_profile(encoder->profile));
 270   if (!encoder->level) {
 271     if (encoder->profile <= H264_PROFILE_BASELINE)
 272       encoder->level = H264_LEVEL_30;
 273     else
 274       encoder->level = H264_LEVEL_41;
 275   }
 276   if (!encoder->intra_period) {
 277     encoder->intra_period = H264_DEFAULT_INTRA_PERIOD;
 278   }
 279   if (-1 == encoder->init_qp) {
 280     encoder->init_qp = H264_DEFAULT_INIT_QP;
 281   }
 282   if (-1 == encoder->min_qp) {
 283     encoder->min_qp = H264_DEFAULT_MIN_QP;
 284   }
 285
 286   if (encoder->min_qp > encoder->init_qp) {
 287     encoder->min_qp = encoder->init_qp;
 288   }
 289
 290   /* default compress ratio 1: (4*8*1.5) */
 291   if (!encoder->bitrate) {
 292     encoder->bitrate = 0; //ENCODER_WIDTH(encoder)*ENCODER_HEIGHT(encoder)*ENCODER_FPS(encoder)/4;
 293   }
 294
 295   if (!encoder->slice_num) {
 296     encoder->slice_num = H264_DEFAULT_SLICE_NUM;
 297   }
 298
 299   /* need  calculate slice-num and each slice-height
 300         suppose:  ((encoder->height+15)/16) = 13, slice_num = 8
 301         then: slice_1_height = 2
 302                  slice_2_height = 2
 303                  slice_3_height = 2
 304                  slice_4_height = 2
 305                  slice_5_height = 2
 306                  slice_6_height = 1
 307                  slice_7_height = 1
 308                  slice_8_height = 1
 309    */
 310   priv->default_slice_height = (ENCODER_HEIGHT(encoder)+15)/16/encoder->slice_num;
 311   if (0 == priv->default_slice_height) { /* special value */
 312     priv->default_slice_height = 1;
 313     priv->slice_mod_mb_num = 0;
 314     encoder->slice_num = (ENCODER_HEIGHT(encoder)+15)/16;
 315   } else {
 316     priv->slice_mod_mb_num = ((ENCODER_HEIGHT(encoder)+15)/16)%encoder->slice_num;
 317   }
 318
 319   if (encoder->b_frame_num) {
 320     priv->default_cts_offset = GST_SECOND/ENCODER_FPS(encoder);
 321   } else {
 322     priv->default_cts_offset = 0;
 323   }
 324   return TRUE;
 325 }
 326
 327
 328 static gboolean
 329 h264_encoder_release_parameters(GstVaapiEncoderH264 *encoder)
 330 {
 331   VAStatus va_status = VA_STATUS_SUCCESS;
 332   GstVaapiEncoderH264Private *priv = encoder->priv;
 333   GstVaapiDisplay *display = ENCODER_DISPLAY(encoder);
 334   GstVaapiContext *context = ENCODER_CONTEXT(encoder);
 335
 336   gboolean is_locked = FALSE;
 337
 338   ENCODER_ASSERT(display);
 339   ENCODER_ASSERT(context);
 340   VAAPI_UNUSED_ARG(va_status);
 341   VADisplay va_dpy = gst_vaapi_display_get_display(display);
 342
 343   ENCODER_ACQUIRE_DISPLAY_LOCK(display);
 344   if (VA_INVALID_ID != priv->seq_param_id) {
 345     va_status = vaDestroyBuffer(va_dpy, priv->seq_param_id);
 346     priv->seq_param_id = VA_INVALID_ID;
 347   }
 348   if (VA_INVALID_ID != priv->pic_param_id) {
 349     va_status = vaDestroyBuffer(va_dpy, priv->pic_param_id);
 350     priv->pic_param_id = VA_INVALID_ID;
 351   }
 352   if (VA_INVALID_ID != priv->slice_param_id) {
 353     va_status = vaDestroyBuffer(va_dpy, priv->slice_param_id);
 354     priv->slice_param_id = VA_INVALID_ID;
 355   }
 356
 357   if (VA_INVALID_ID != priv->packed_seq_param_id) {
 358     va_status = vaDestroyBuffer(va_dpy, priv->packed_seq_param_id);
 359     priv->packed_seq_param_id = VA_INVALID_ID;
 360   }
 361   if (VA_INVALID_ID != priv->packed_seq_data_id) {
 362     va_status = vaDestroyBuffer(va_dpy, priv->packed_seq_data_id);
 363     priv->packed_seq_data_id = VA_INVALID_ID;
 364   }
 365   if (VA_INVALID_ID != priv->packed_pic_param_id) {
 366     va_status = vaDestroyBuffer(va_dpy, priv->packed_pic_param_id);
 367     priv->packed_pic_param_id = VA_INVALID_ID;
 368   }
 369   if (VA_INVALID_ID != priv->packed_pic_data_id) {
 370     va_status = vaDestroyBuffer(va_dpy, priv->packed_pic_data_id);
 371     priv->packed_pic_data_id = VA_INVALID_ID;
 372   }
 373
 374   ENCODER_RELEASE_DISPLAY_LOCK(display);
 375
 376   if (priv->slice_param_buffers) {
 377     g_free(priv->slice_param_buffers);
 378     priv->slice_param_buffers = NULL;
 379   }
 380
 381   if (priv->sps_data) {
 382     gst_buffer_unref(priv->sps_data);
 383     priv->sps_data = NULL;
 384   }
 385   if (priv->pps_data) {
 386     gst_buffer_unref(priv->pps_data);
 387     priv->pps_data = NULL;
 388   }
 389
 390   return TRUE;
 391 }
 392
 393 static void
 394 h264_release_queued_buffers(GstVaapiEncoderH264Private *priv)
 395 {
 396     while (!g_queue_is_empty(priv->queued_buffers)) {
 397     GstBuffer* tmp = g_queue_pop_head(priv->queued_buffers);
 398     if (tmp)
 399       gst_buffer_unref(tmp);
 400   }
 401 }
 402
 403
 404 static gboolean
 405 gst_vaapi_encoder_h264_release_resource(
 406     GstVaapiBaseEncoder* base
 407 )
 408 {
 409   GstVaapiEncoderH264* encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 410   gboolean ret = TRUE;
 411   GstVaapiEncoderH264Private *priv = encoder->priv;
 412   GstVaapiContext *context = ENCODER_CONTEXT(base);
 413
 414   /* release buffers first */
 415   h264_encoder_release_parameters(encoder);
 416   h264_release_queued_buffers(priv);
 417   priv->cur_display_num = 0;
 418   priv->cur_decode_num = 0;
 419   priv->cur_slice_type = SLICE_TYPE_I;
 420   priv->gop_count = 0;
 421   priv->last_decode_time = 0LL;
 422   priv->default_cts_offset = 0;
 423
 424   /*remove ref_surface1*/
 425   if (priv->ref_surface1) {
 426     if (context) {
 427       gst_vaapi_context_put_surface(context, priv->ref_surface1);
 428     } else {
 429       g_object_unref(priv->ref_surface1);
 430     }
 431     priv->ref_surface1 = NULL;
 432   }
 433
 434   if (priv->ref_surface2) {
 435     if (context) {
 436       gst_vaapi_context_put_surface(context, priv->ref_surface2);
 437     } else {
 438       g_object_unref(priv->ref_surface2);
 439     }
 440     priv->ref_surface2 = NULL;
 441   }
 442
 443   /*remove recon_surface*/
 444   if (priv->recon_surface) {
 445     if (context) {
 446       gst_vaapi_context_put_surface(context, priv->recon_surface);
 447     } else {
 448       g_object_unref(priv->recon_surface);
 449     }
 450     priv->recon_surface = NULL;
 451   }
 452
 453   return ret;
 454 }
 455
 456 static gboolean
 457 gst_vaapi_encoder_h264_alloc_slices(
 458     GstVaapiBaseEncoder *base,
 459     GstVaapiContext *context
 460 )
 461 {
 462   gboolean ret = TRUE;
 463   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 464   GstVaapiEncoderH264Private *priv = encoder->priv;
 465
 466   priv->slice_param_buffers =
 467 #ifdef _SIMPLE_LIB_VA_
 468   (VAEncSliceParameterBuffer*)
 469 #else
 470   (VAEncSliceParameterBufferH264*)
 471 #endif
 472           g_malloc0_n(encoder->slice_num,
 473               sizeof(priv->slice_param_buffers[0]));
 474
 475   return ret;
 476 }
 477
 478 static void
 479 gst_vaapi_encoder_h264_frame_failed(
 480     GstVaapiBaseEncoder *base,
 481     GstVaapiVideoBuffer* buffer
 482 )
 483 {
 484   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 485   GstVaapiEncoderH264Private *priv = encoder->priv;
 486
 487   h264_release_queued_buffers(priv);
 488   priv->cur_display_num = 0;
 489   priv->cur_decode_num = 0;
 490   priv->cur_slice_type = SLICE_TYPE_I;
 491   priv->gop_count = 0;
 492   priv->last_decode_time = 0LL;
 493 }
 494
 495 static EncoderStatus
 496 gst_vaapi_encoder_h264_prepare_next_buffer(
 497     GstVaapiBaseEncoder* base,
 498     GstVaapiVideoBuffer *display_buf,
 499     gboolean need_flush,
 500     GstVaapiVideoBuffer **out_buf
 501 )
 502 {
 503   EncoderStatus ret = ENCODER_NO_ERROR;
 504   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 505   GstVaapiEncoderH264Private *priv = encoder->priv;
 506   GstVaapiVideoBuffer  *return_buf = NULL;
 507   //guint64 pts = 0;
 508
 509   if (NULL == display_buf && g_queue_is_empty(priv->queued_buffers)) {
 510     ret = ENCODER_BUFFER_EMPTY;
 511     if (priv->gop_count >= encoder->intra_period || need_flush)
 512       priv->gop_count = 0;
 513     goto end;
 514   }
 515
 516   if (display_buf) {
 517     ++priv->gop_count;
 518     gst_buffer_ref(GST_BUFFER_CAST(display_buf));
 519     priv->last_decode_time = GST_BUFFER_TIMESTAMP(display_buf);
 520   }
 521
 522   /* first frame */
 523   if (priv->gop_count == 1) {
 524     ENCODER_ASSERT(display_buf);
 525     priv->cur_display_num = 0;
 526     priv->cur_decode_num = 0;
 527     priv->cur_slice_type = SLICE_TYPE_I;
 528     ++priv->idr_num;
 529     return_buf = display_buf;
 530     goto end;
 531   }
 532
 533   if (display_buf) {
 534     if (encoder->b_frame_num &&
 535         priv->gop_count < encoder->intra_period &&
 536         g_queue_get_length(priv->queued_buffers) < encoder->b_frame_num
 537         )
 538     {
 539       g_queue_push_tail(priv->queued_buffers, display_buf);
 540       ret = ENCODER_BUFFER_WAITING;
 541       goto end;
 542     }
 543     priv->cur_slice_type = SLICE_TYPE_P;
 544     priv->cur_display_num = priv->gop_count-1;
 545     ++priv->cur_decode_num;
 546     return_buf = display_buf;
 547   } else {
 548     if (need_flush) {
 549       return_buf = (GstVaapiVideoBuffer*)g_queue_pop_tail(priv->queued_buffers);
 550       priv->cur_slice_type = SLICE_TYPE_P;
 551       priv->cur_display_num = priv->gop_count - 1;
 552       ++priv->cur_decode_num;
 553     } else {
 554       return_buf = (GstVaapiVideoBuffer*)g_queue_pop_head(priv->queued_buffers);
 555       priv->cur_slice_type = SLICE_TYPE_B;
 556       priv->cur_display_num =
 557         priv->gop_count - 2 - g_queue_get_length(priv->queued_buffers);
 558     }
 559   }
 560
 561 end:
 562   *out_buf = return_buf;
 563
 564   return ret;
 565 }
 566
 567 static inline void
 568 h264_swap_surface(GstVaapiSurface **s1, GstVaapiSurface **s2)
 569 {
 570   GstVaapiSurface *tmp;
 571
 572   g_return_if_fail(s1 && s2);
 573   tmp = *s1;
 574   *s1 = *s2;
 575   *s2 = tmp;
 576 }
 577
 578 #ifdef _SIMPLE_LIB_VA_
 579
 580 static EncoderStatus
 581 gst_vaapi_encoder_h264_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *display,
 582                              GstVaapiContext *context, GstVaapiSurface *surface,
 583                              guint frame_index, VABufferID coded_buf, gboolean *is_key)
 584 {
 585   EncoderStatus ret = ENCODER_NO_ERROR;
 586   VAStatus va_status = VA_STATUS_SUCCESS;
 587   GstVaapiEncoderH264 *h264_encoder = GST_VAAPI_ENCODER_H264_CAST(encoder);
 588   GstVaapiEncoderH264Private *priv = h264_encoder->priv;
 589   VAEncPictureParameterBufferH264 pic_param;
 590   VAEncSliceParameterBuffer *slice_param = NULL;
 591
 592   gboolean is_locked = FALSE;
 593
 594   ENCODER_ASSERT(display && context);
 595   VADisplay va_dpy = gst_vaapi_display_get_display(display);
 596   VAContextID context_id = GST_VAAPI_OBJECT_ID(context);
 597
 598   *is_key = (priv->cur_slice_type == SLICE_TYPE_I);
 599
 600   /* lock display */
 601   ENCODER_ACQUIRE_DISPLAY_LOCK(display);
 602   /*handle first surface_index*/
 603   /*only need first frame*/
 604   if (VA_INVALID_ID == priv->seq_param_id) { /*first time*/
 605     VAEncSequenceParameterBufferH264 seq = { 0 };
 606     seq.level_idc = h264_encoder->level; /* 3.0 */
 607     seq.max_num_ref_frames = 1; /*Only I, P frames*/
 608     seq.picture_width_in_mbs = (ENCODER_WIDTH(h264_encoder)+15)/16;
 609     seq.picture_height_in_mbs = (ENCODER_HEIGHT(h264_encoder)+15)/16;
 610
 611     seq.bits_per_second = h264_encoder->bitrate;
 612     seq.frame_rate = ENCODER_FPS(h264_encoder);
 613     seq.initial_qp = h264_encoder->init_qp; /*qp_value; 15, 24, 26?*/
 614     seq.min_qp = h264_encoder->min_qp;     /*1, 6, 10*/
 615     seq.basic_unit_size = 0;
 616     seq.intra_period = h264_encoder->intra_period;
 617     seq.intra_idr_period = h264_encoder->intra_period;
 618
 619     va_status = vaCreateBuffer(va_dpy, context_id,
 620                                VAEncSequenceParameterBufferType,
 621                                sizeof(seq), 1, &seq, &priv->seq_param_id);
 622     ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 623                          ENCODER_ENC_RES_ERR, "alloc seq-buffer failed.");
 624     va_status = vaRenderPicture(va_dpy, context_id, &priv->seq_param_id, 1);
 625     ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 626                          ENCODER_PICTURE_ERR, "vaRenderPicture seq-parameters failed.");
 627   }
 628
 629   /* set pic_parameters*/
 630   if (!priv->ref_surface1) {
 631     priv->ref_surface1 = gst_vaapi_context_get_surface(context);
 632     ENCODER_CHECK_STATUS(priv->ref_surface1,
 633                          ENCODER_SURFACE_ERR,
 634                          "reference surface, h264_pop_free_surface failed.");
 635   }
 636   if (!priv->recon_surface) {
 637     priv->recon_surface = gst_vaapi_context_get_surface(context);
 638     ENCODER_CHECK_STATUS(priv->recon_surface,
 639                          ENCODER_SURFACE_ERR,
 640                          "reconstructed surface, h264_pop_free_surface failed.");
 641   }
 642
 643   pic_param.reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
 644   pic_param.reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
 645   pic_param.coded_buf = coded_buf;
 646   pic_param.picture_width = ENCODER_WIDTH(h264_encoder);
 647   pic_param.picture_height = ENCODER_HEIGHT(h264_encoder);
 648   pic_param.last_picture = 0; // last pic or not
 649
 650   if (VA_INVALID_ID != priv->pic_param_id) { /* share the same pic_param_id*/
 651     vaDestroyBuffer(va_dpy, priv->pic_param_id);
 652     priv->pic_param_id = VA_INVALID_ID;
 653   }
 654   va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
 655                                sizeof(pic_param), 1, &pic_param, &priv->pic_param_id);
 656
 657   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 658                        ENCODER_PICTURE_ERR,
 659                        "creating pic-param buffer failed.");
 660
 661   va_status = vaRenderPicture(va_dpy, context_id, &priv->pic_param_id, 1);
 662   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 663                        ENCODER_PICTURE_ERR,
 664                        "rendering pic-param buffer failed.");
 665
 666   /* set slice parameters, support multiple slices */
 667   int i = 0;
 668   guint32 last_row_num = 0;
 669   guint32 slice_mod_num = priv->slice_mod_mb_num;
 670
 671   memset(priv->slice_param_buffers, 0, h264_encoder->slice_num*sizeof(priv->slice_param_buffers[0]));
 672   for (i = 0; i < h264_encoder->slice_num; ++i) {
 673     slice_param = &priv->slice_param_buffers[i];
 674     slice_param->start_row_number = last_row_num;               /* unit MB*/
 675     slice_param->slice_height = priv->default_slice_height; /* unit MB */
 676     if (slice_mod_num) {
 677       ++slice_param->slice_height;
 678       --slice_mod_num;
 679     }
 680     last_row_num += slice_param->slice_height;
 681     slice_param->slice_flags.bits.is_intra = *is_key;
 682     slice_param->slice_flags.bits.disable_deblocking_filter_idc = 0;
 683
 684   }
 685   ENCODER_ASSERT(last_row_num == (ENCODER_HEIGHT(h264_encoder)+15)/16);
 686
 687   if (VA_INVALID_ID != priv->slice_param_id) {
 688     vaDestroyBuffer(va_dpy, priv->slice_param_id);
 689     priv->slice_param_id = VA_INVALID_ID;
 690   }
 691   va_status = vaCreateBuffer(va_dpy,
 692                              context_id,
 693                              VAEncSliceParameterBufferType,
 694                              sizeof(priv->slice_param_buffers[0]),
 695                              h264_encoder->slice_num,
 696                              priv->slice_param_buffers,
 697                              &priv->slice_param_id);
 698   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
 699                        ENCODER_PICTURE_ERR,
 700                        "creating slice-parameters buffer failed.");
 701
 702   va_status = vaRenderPicture(va_dpy, context_id, &priv->slice_param_id, 1);
 703   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 704                        ENCODER_PICTURE_ERR,
 705                        "rendering slice-parameters buffer failed.");
 706
 707   /*after finished, set ref_surface1_index, recon_surface_index */
 708   GstVaapiSurface *swap = priv->ref_surface1;
 709   priv->ref_surface1 = priv->recon_surface;
 710   priv->recon_surface = swap;
 711
 712   end:
 713   ENCODER_RELEASE_DISPLAY_LOCK(display);
 714   return ret;
 715 }
 716
 717 #else  /* extended libva, new parameter structures*/
 718
 719 static gboolean
 720 set_sequence_parameters(
 721     GstVaapiEncoderH264 *encoder,
 722     VAEncSequenceParameterBufferH264 *seq_param
 723 )
 724 {
 725   GstVaapiEncoderH264Private *priv = encoder->priv;
 726   guint width_in_mbs, height_in_mbs;
 727
 728   width_in_mbs = (ENCODER_WIDTH(encoder)+15)/16;
 729   height_in_mbs = (ENCODER_HEIGHT(encoder)+15)/16;
 730
 731   seq_param->seq_parameter_set_id = 0;
 732   seq_param->level_idc = encoder->level; /* 3.0 */
 733   seq_param->intra_period = encoder->intra_period;
 734   seq_param->ip_period = 0;           // ?
 735   if (encoder->bitrate> 0)
 736       seq_param->bits_per_second = encoder->bitrate; /* use kbps as input */
 737   else
 738       seq_param->bits_per_second = 0;
 739
 740   seq_param->max_num_ref_frames =
 741       (encoder->b_frame_num < 2 ? 3 : encoder->b_frame_num+1);  // ?, why 4
 742   seq_param->picture_width_in_mbs = width_in_mbs;
 743   seq_param->picture_height_in_mbs = height_in_mbs;
 744
 745   /*sequence field values*/
 746   seq_param->seq_fields.value = 0;
 747   seq_param->seq_fields.bits.chroma_format_idc = 1;
 748   seq_param->seq_fields.bits.frame_mbs_only_flag = 1;
 749   seq_param->seq_fields.bits.mb_adaptive_frame_field_flag = FALSE;
 750   seq_param->seq_fields.bits.seq_scaling_matrix_present_flag = FALSE;
 751   /* direct_8x8_inference_flag default false */
 752   seq_param->seq_fields.bits.direct_8x8_inference_flag = FALSE;
 753   seq_param->seq_fields.bits.log2_max_frame_num_minus4 = 4; // log2(seq.intra_period)-3 : 0
 754   /* picture order count */
 755   seq_param->seq_fields.bits.pic_order_cnt_type = 0;
 756   seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 =
 757         seq_param->seq_fields.bits.log2_max_frame_num_minus4 + 2;
 758   seq_param->seq_fields.bits.delta_pic_order_always_zero_flag = TRUE;
 759
 760   priv->max_frame_num =
 761       1<<(seq_param->seq_fields.bits.log2_max_frame_num_minus4 + 4);
 762   priv->max_pic_order_cnt =
 763       1 <<(seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4);
 764
 765   seq_param->bit_depth_luma_minus8 = 0;
 766   seq_param->bit_depth_chroma_minus8 = 0;
 767
 768   /* not used if pic_order_cnt_type == 0 */
 769   seq_param->num_ref_frames_in_pic_order_cnt_cycle = 0;
 770   seq_param->offset_for_non_ref_pic = 0;
 771   seq_param->offset_for_top_to_bottom_field = 0;
 772   memset(seq_param->offset_for_ref_frame,
 773          0,
 774          sizeof(seq_param->offset_for_ref_frame));
 775
 776   if (height_in_mbs*16 - ENCODER_HEIGHT(encoder)) {
 777     seq_param->frame_cropping_flag = 1;
 778     seq_param->frame_crop_left_offset = 0;
 779     seq_param->frame_crop_right_offset = 0;
 780     seq_param->frame_crop_top_offset = 0;
 781     seq_param->frame_crop_bottom_offset =
 782         ((height_in_mbs * 16 - ENCODER_HEIGHT(encoder))/
 783          (2 * (!seq_param->seq_fields.bits.frame_mbs_only_flag + 1)));
 784   }
 785 #if 0
 786   if (h264_encoder->init_qp == -1)
 787       seq.rate_control_method = BR_CBR;
 788   else if (h264_encoder->init_qp == -2)
 789       seq.rate_control_method = BR_VBR;
 790   else {
 791       ENCODER_ASSERT(h264_encoder->init_qp >= 0 && h264_encoder->init_qp <= 51);
 792       seq.rate_control_method = BR_CQP;
 793   }
 794 #endif
 795
 796   /*vui not set*/
 797   seq_param->vui_parameters_present_flag = FALSE;
 798   return TRUE;
 799 }
 800
 801 static gboolean
 802 h264_fill_sequence_buffer(GstVaapiEncoderH264 *encoder)
 803 {
 804   GstVaapiEncoderH264Private *priv = encoder->priv;
 805   VAEncSequenceParameterBufferH264 seq_param = { 0 };
 806   VADisplay va_dpy       = ENCODER_VA_DISPLAY(encoder);
 807   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
 808   gboolean ret = TRUE;
 809   VAStatus va_status = VA_STATUS_SUCCESS;
 810
 811   /* only once */
 812   if (VA_INVALID_ID != priv->seq_param_id)
 813     return TRUE;
 814
 815   set_sequence_parameters(encoder, &seq_param);
 816   va_status = vaCreateBuffer(va_dpy, context_id,
 817                              VAEncSequenceParameterBufferType,
 818                              sizeof(seq_param), 1,
 819                              &seq_param, &priv->seq_param_id);
 820   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 821                        FALSE,
 822                        "alloc seq-buffer failed.");
 823
 824   /*pack sps header buffer/data */
 825   if (NULL == priv->sps_data) {
 826     VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 };
 827     guint32 length_in_bits;
 828     guint8 *packed_seq_buffer = NULL;
 829     H264Bitstream bitstream;
 830     h264_bitstream_init(&bitstream, 128*8);
 831     h264_bitstream_write_uint(&bitstream, 0x00000001, 32); /* start code*/
 832     h264_bitstream_write_nal_header(&bitstream, NAL_REF_IDC_HIGH, NAL_SPS);
 833     h264_bitstream_write_sps(&bitstream, &seq_param, encoder->profile);
 834     ENCODER_ASSERT(BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
 835     length_in_bits = BIT_STREAM_BIT_SIZE(&bitstream);
 836     packed_seq_buffer = BIT_STREAM_BUFFER(&bitstream);
 837
 838     /* set codec data sps */
 839     priv->sps_data = gst_buffer_new_and_alloc((length_in_bits+7)/8);
 840     GST_BUFFER_SIZE(priv->sps_data) = (length_in_bits+7)/8-4; /* start code size == 4*/
 841     memcpy(GST_BUFFER_DATA(priv->sps_data),
 842            packed_seq_buffer+4,
 843            GST_BUFFER_SIZE(priv->sps_data));
 844
 845     packed_header_param_buffer.type = VAEncPackedHeaderSequence;
 846     packed_header_param_buffer.bit_length = length_in_bits;
 847     packed_header_param_buffer.has_emulation_bytes = 0;
 848     va_status = vaCreateBuffer(va_dpy,
 849                                context_id,
 850                                VAEncPackedHeaderParameterBufferType,
 851                                sizeof(packed_header_param_buffer), 1,
 852                                &packed_header_param_buffer,
 853                                &priv->packed_seq_param_id);
 854     ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 855                          FALSE,
 856                          "EncPackedSeqHeaderParameterBuffer failed");
 857     va_status = vaCreateBuffer(va_dpy,
 858                                context_id,
 859                                VAEncPackedHeaderDataBufferType,
 860                                (length_in_bits + 7) / 8, 1,
 861                                packed_seq_buffer,
 862                                &priv->packed_seq_data_id);
 863     h264_bitstream_destroy(&bitstream, TRUE);
 864     ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 865                          FALSE,
 866                          "EncPackedSeqHeaderDataBuffer failed");
 867   }
 868 end:
 869
 870   return ret;
 871 }
 872
 873 static gboolean
 874 set_picture_parameters(
 875     GstVaapiEncoderH264 *encoder,
 876     VAEncPictureParameterBufferH264 *pic_param
 877 )
 878 {
 879   GstVaapiEncoderH264Private *priv = encoder->priv;
 880
 881   pic_param->pic_parameter_set_id = 0;
 882   pic_param->seq_parameter_set_id = 0;
 883   pic_param->last_picture = 0; /* means last encoding picture */
 884   pic_param->frame_num = (priv->cur_slice_type == SLICE_TYPE_B ?
 885                        (priv->cur_decode_num + 1) : priv->cur_decode_num);
 886   //pic_param.coding_type = 0;
 887   pic_param->pic_init_qp = (encoder->init_qp >= 0 ? encoder->init_qp : 26);
 888   pic_param->num_ref_idx_l0_active_minus1 = 0; /* only 1 reference */
 889   pic_param->num_ref_idx_l1_active_minus1 = 0; /* B frames only have 1 backward and 1 forward reference*/
 890   pic_param->chroma_qp_index_offset = 0;
 891   pic_param->second_chroma_qp_index_offset = 0;
 892
 893   /* set picture fields */
 894   pic_param->pic_fields.value = 0;
 895   pic_param->pic_fields.bits.idr_pic_flag = (priv->cur_slice_type == SLICE_TYPE_I);
 896   pic_param->pic_fields.bits.reference_pic_flag = (priv->cur_slice_type != SLICE_TYPE_B);
 897   pic_param->pic_fields.bits.entropy_coding_mode_flag = ENTROPY_MODE_CABAC;
 898   pic_param->pic_fields.bits.weighted_pred_flag = FALSE;
 899   pic_param->pic_fields.bits.weighted_bipred_idc = 0;
 900   pic_param->pic_fields.bits.constrained_intra_pred_flag = 0;
 901   pic_param->pic_fields.bits.transform_8x8_mode_flag = TRUE; /* enable 8x8 */
 902   pic_param->pic_fields.bits.deblocking_filter_control_present_flag = TRUE; /* enable debloking */
 903   pic_param->pic_fields.bits.redundant_pic_cnt_present_flag = FALSE;
 904   /* bottom_field_pic_order_in_frame_present_flag */
 905   pic_param->pic_fields.bits.pic_order_present_flag = FALSE;
 906   pic_param->pic_fields.bits.pic_scaling_matrix_present_flag = FALSE;
 907
 908   return TRUE;
 909 }
 910
 911 static inline const char *
 912 get_slice_type(H264_SLICE_TYPE type)
 913 {
 914     switch (type) {
 915     case SLICE_TYPE_I:
 916         return "I";
 917     case SLICE_TYPE_P:
 918         return "P";
 919     case SLICE_TYPE_B:
 920         return "B";
 921     default:
 922         return "Unknown";
 923     }
 924 }
 925
 926 static gboolean
 927 h264_fill_picture_buffer(
 928     GstVaapiEncoderH264 *encoder,
 929     VABufferID coded_buf
 930 )
 931 {
 932   GstVaapiEncoderH264Private *priv = encoder->priv;
 933   VAEncPictureParameterBufferH264 pic_param;
 934   VADisplay va_dpy       = ENCODER_VA_DISPLAY(encoder);
 935   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
 936   gboolean ret = TRUE;
 937   VAStatus va_status = VA_STATUS_SUCCESS;
 938
 939   VAAPI_UNUSED_ARG(va_status);
 940   memset(&pic_param, 0, sizeof(pic_param));
 941   set_picture_parameters(encoder, &pic_param);
 942   pic_param.CurrPic.picture_id = GST_VAAPI_OBJECT_ID(priv->recon_surface);
 943   pic_param.CurrPic.TopFieldOrderCnt = priv->cur_display_num * 2;   // ??? /**/
 944   pic_param.ReferenceFrames[0].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
 945   pic_param.ReferenceFrames[1].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface2);
 946   pic_param.ReferenceFrames[2].picture_id = VA_INVALID_ID;
 947   pic_param.coded_buf = coded_buf;
 948
 949   ENCODER_LOG_INFO("type:%s, frame_num:%d, display_num:%d",
 950     get_slice_type(priv->cur_slice_type),
 951     pic_param.frame_num,
 952     pic_param.CurrPic.TopFieldOrderCnt);
 953
 954   if (VA_INVALID_ID != priv->pic_param_id) { /* share the same pic_param_id*/
 955     vaDestroyBuffer(va_dpy, priv->pic_param_id);
 956     priv->pic_param_id = VA_INVALID_ID;
 957   }
 958   va_status = vaCreateBuffer(va_dpy,
 959                              context_id,
 960                              VAEncPictureParameterBufferType,
 961                              sizeof(pic_param), 1,
 962                              &pic_param,
 963                              &priv->pic_param_id);
 964
 965   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 966                        FALSE,
 967                        "creating pic-param buffer failed.");
 968
 969   if (VA_INVALID_ID == priv->packed_pic_data_id) {
 970     VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 };
 971     guint32 length_in_bits;
 972     guint8 *packed_pic_buffer = NULL;
 973     H264Bitstream bitstream;
 974     h264_bitstream_init(&bitstream, 128*8);
 975     h264_bitstream_write_uint(&bitstream, 0x00000001, 32); /* start code*/
 976     h264_bitstream_write_nal_header(&bitstream, NAL_REF_IDC_HIGH, NAL_PPS);
 977     h264_bitstream_write_pps(&bitstream, &pic_param);
 978     ENCODER_ASSERT(BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
 979     length_in_bits = BIT_STREAM_BIT_SIZE(&bitstream);
 980     packed_pic_buffer = BIT_STREAM_BUFFER(&bitstream);
 981
 982     /*set codec data pps*/
 983     priv->pps_data = gst_buffer_new_and_alloc((length_in_bits+7)/8);
 984     GST_BUFFER_SIZE(priv->pps_data) = (length_in_bits+7)/8-4;
 985     memcpy(GST_BUFFER_DATA(priv->pps_data), packed_pic_buffer+4, GST_BUFFER_SIZE(priv->pps_data));
 986
 987     packed_header_param_buffer.type = VAEncPackedHeaderPicture;
 988     packed_header_param_buffer.bit_length = length_in_bits;
 989     packed_header_param_buffer.has_emulation_bytes = 0;
 990
 991     va_status = vaCreateBuffer(va_dpy,
 992                                context_id,
 993                                VAEncPackedHeaderParameterBufferType,
 994                                sizeof(packed_header_param_buffer), 1,
 995                                &packed_header_param_buffer,
 996                                &priv->packed_pic_param_id);
 997     ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 998                          FALSE,
 999                          "EncPackedPicHeaderParameterBuffer failed");
1000
1001     va_status = vaCreateBuffer(va_dpy,
1002                                context_id,
1003                                VAEncPackedHeaderDataBufferType,
1004                                (length_in_bits + 7) / 8, 1,
1005                                packed_pic_buffer,
1006                                &priv->packed_pic_data_id);
1007     h264_bitstream_destroy(&bitstream, TRUE);
1008     ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
1009                          FALSE,
1010                          "EncPackedPicHeaderDataBuffer failed");
1011   }
1012 end:
1013   return ret;
1014 }
1015
1016
1017 static gboolean
1018 h264_fill_slice_buffers(
1019     GstVaapiEncoderH264 *encoder
1020 )
1021 {
1022   GstVaapiEncoderH264Private *priv = encoder->priv;
1023   VAEncSliceParameterBufferH264 *slice_param = NULL;
1024   VADisplay va_dpy       = ENCODER_VA_DISPLAY(encoder);
1025   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
1026   guint width_in_mbs;
1027   gboolean ret = TRUE;
1028   VAStatus va_status = VA_STATUS_SUCCESS;
1029
1030   width_in_mbs = (ENCODER_WIDTH(encoder)+15)/16;
1031
1032   int i = 0;
1033   guint32 last_row_num = 0;
1034   guint32 slice_mod_num = priv->slice_mod_mb_num;
1035
1036   memset(priv->slice_param_buffers,
1037          0,
1038          encoder->slice_num*sizeof(priv->slice_param_buffers[0]));
1039   for (i = 0; i < encoder->slice_num; ++i) {
1040     int i_pic = 0;
1041     slice_param = &priv->slice_param_buffers[i];
1042
1043     slice_param->macroblock_address = last_row_num*width_in_mbs;
1044     slice_param->num_macroblocks = width_in_mbs*priv->default_slice_height;
1045     last_row_num += priv->default_slice_height;
1046     if (slice_mod_num) {
1047       slice_param->num_macroblocks += width_in_mbs;
1048       ++last_row_num;
1049       --slice_mod_num;
1050     }
1051     slice_param->macroblock_info = VA_INVALID_ID;
1052     slice_param->slice_type = priv->cur_slice_type;
1053     slice_param->pic_parameter_set_id = 0;
1054     slice_param->idr_pic_id = priv->idr_num;
1055     slice_param->pic_order_cnt_lsb =
1056         (priv->cur_display_num*2) % priv->max_pic_order_cnt;
1057
1058     /* not used if pic_order_cnt_type = 0 */
1059     slice_param->delta_pic_order_cnt_bottom = 0;
1060     memset(slice_param->delta_pic_order_cnt,
1061            0,
1062            sizeof(slice_param->delta_pic_order_cnt));
1063
1064     /*only works for B frames*/
1065     slice_param->direct_spatial_mv_pred_flag = FALSE;
1066     /* default equal to picture parameters */
1067     slice_param->num_ref_idx_active_override_flag = FALSE;
1068     slice_param->num_ref_idx_l0_active_minus1 = 0;
1069     slice_param->num_ref_idx_l1_active_minus1 = 0;
1070
1071     slice_param->RefPicList0[0].picture_id =
1072         GST_VAAPI_OBJECT_ID(priv->ref_surface1);
1073     for (i_pic = 1;
1074          i_pic < sizeof(slice_param->RefPicList0)/sizeof(slice_param->RefPicList0[0]);
1075          i_pic++) {
1076       slice_param->RefPicList0[i_pic].picture_id = VA_INVALID_ID;
1077     }
1078
1079     if (SLICE_TYPE_B == priv->cur_slice_type) {
1080       slice_param->RefPicList1[0].picture_id =
1081           GST_VAAPI_OBJECT_ID(priv->ref_surface2);
1082       i_pic = 1;
1083     } else
1084       i_pic = 0;
1085     for (;
1086          i_pic < sizeof(slice_param->RefPicList1)/sizeof(slice_param->RefPicList1[0]);
1087          i_pic++)
1088       slice_param->RefPicList1[i_pic].picture_id = VA_INVALID_ID;
1089
1090     /* not used if  pic_param.pic_fields.bits.weighted_pred_flag == FALSE */
1091     slice_param->luma_log2_weight_denom = 0;
1092     slice_param->chroma_log2_weight_denom = 0;
1093     slice_param->luma_weight_l0_flag = FALSE;
1094     memset(slice_param->luma_weight_l0, 0, sizeof(slice_param->luma_weight_l0));
1095     memset(slice_param->luma_offset_l0, 0, sizeof(slice_param->luma_offset_l0));
1096     slice_param->chroma_weight_l0_flag = FALSE;
1097     memset(slice_param->chroma_weight_l0, 0, sizeof(slice_param->chroma_weight_l0));
1098     memset(slice_param->chroma_offset_l0, 0, sizeof(slice_param->chroma_offset_l0));
1099     slice_param->luma_weight_l1_flag = FALSE;
1100     memset(slice_param->luma_weight_l1, 0, sizeof(slice_param->luma_weight_l1));
1101     memset(slice_param->luma_offset_l1, 0, sizeof(slice_param->luma_offset_l1));
1102     slice_param->chroma_weight_l1_flag = FALSE;
1103     memset(slice_param->chroma_weight_l1, 0, sizeof(slice_param->chroma_weight_l1));
1104     memset(slice_param->chroma_offset_l1, 0, sizeof(slice_param->chroma_offset_l1));
1105
1106     slice_param->cabac_init_idc = 0;
1107     slice_param->slice_qp_delta = 0;
1108     slice_param->disable_deblocking_filter_idc = 0;
1109     slice_param->slice_alpha_c0_offset_div2 = 2;
1110     slice_param->slice_beta_offset_div2 = 2;
1111
1112   }
1113   ENCODER_ASSERT(last_row_num == (ENCODER_HEIGHT(encoder)+15)/16);
1114
1115   if (VA_INVALID_ID != priv->slice_param_id) {
1116     vaDestroyBuffer(va_dpy, priv->slice_param_id);
1117     priv->slice_param_id = VA_INVALID_ID;
1118   }
1119   va_status = vaCreateBuffer(va_dpy,
1120                              context_id,
1121                              VAEncSliceParameterBufferType,
1122                              sizeof(priv->slice_param_buffers[0]),
1123                              encoder->slice_num,
1124                              priv->slice_param_buffers,
1125                              &priv->slice_param_id);
1126   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
1127                        FALSE,
1128                        "creating slice-parameters buffer failed.");
1129
1130 end:
1131   return ret;
1132 }
1133
1134 static EncoderStatus
1135 gst_vaapi_encoder_h264_rendering(
1136     GstVaapiBaseEncoder *base,
1137     GstVaapiSurface *surface,
1138     guint frame_index,
1139     VABufferID coded_buf,
1140     gboolean *is_key
1141 )
1142 {
1143   EncoderStatus ret = ENCODER_NO_ERROR;
1144   VAStatus va_status = VA_STATUS_SUCCESS;
1145   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
1146   GstVaapiEncoderH264Private *priv = encoder->priv;
1147   GstVaapiDisplay *display = ENCODER_DISPLAY(base);
1148   GstVaapiContext *context = ENCODER_CONTEXT(base);
1149   VADisplay va_dpy;
1150   VAContextID context_id;
1151   VABufferID va_buffers[64];
1152   guint32    va_buffers_count = 0;
1153   gboolean is_params_ok = TRUE;
1154   gboolean is_locked = FALSE;
1155
1156   ENCODER_ASSERT(context);
1157
1158   va_dpy = ENCODER_VA_DISPLAY(base);
1159   context_id = ENCODER_VA_CONTEXT(base);
1160
1161   *is_key = (priv->cur_slice_type == SLICE_TYPE_I);
1162
1163   if (!priv->ref_surface1) {
1164     priv->ref_surface1 = gst_vaapi_context_get_surface(context);
1165     ENCODER_CHECK_STATUS(priv->ref_surface1,
1166                          ENCODER_SURFACE_ERR,
1167                          "reference surface, h264_pop_free_surface failed.");
1168   }
1169   if (!priv->ref_surface2) {
1170     priv->ref_surface2 = gst_vaapi_context_get_surface(context);
1171     ENCODER_CHECK_STATUS(priv->ref_surface2,
1172                          ENCODER_SURFACE_ERR,
1173                          "reference surface, h264_pop_free_surface failed.");
1174   }
1175   if (!priv->recon_surface) {
1176     priv->recon_surface = gst_vaapi_context_get_surface(context);
1177     ENCODER_CHECK_STATUS(priv->recon_surface,
1178                          ENCODER_SURFACE_ERR,
1179                          "reconstructed surface, h264_pop_free_surface failed.");
1180   }
1181
1182   if (SLICE_TYPE_P == priv->cur_slice_type) {
1183     h264_swap_surface(&priv->ref_surface1, &priv->ref_surface2);
1184   }
1185
1186   /* fill sequence parameters, need set every time */
1187   is_params_ok = h264_fill_sequence_buffer(encoder);
1188   ENCODER_CHECK_STATUS(is_params_ok,
1189                        ENCODER_PARAMETER_ERR,
1190                        "h264_recreate_seq_param failed");
1191   /* set pic_parameters*/
1192   is_params_ok = h264_fill_picture_buffer(encoder, coded_buf);
1193   ENCODER_CHECK_STATUS(is_params_ok,
1194                        ENCODER_PARAMETER_ERR,
1195                        "h264_recreate_pic_param failed");
1196   /* set slice parameters, support multiple slices */
1197   is_params_ok = h264_fill_slice_buffers(encoder);
1198   ENCODER_CHECK_STATUS(is_params_ok,
1199                        ENCODER_PARAMETER_ERR,
1200                        "h264_recreate_slice_param failed");
1201
1202   /* lock display */
1203   ENCODER_ACQUIRE_DISPLAY_LOCK(display);
1204
1205   /*render all buffers*/
1206   if (VA_INVALID_ID != priv->seq_param_id) {
1207     va_buffers[va_buffers_count++] = priv->seq_param_id;
1208   }
1209   if (VA_INVALID_ID != priv->pic_param_id) {
1210     va_buffers[va_buffers_count++] = priv->pic_param_id;
1211   }
1212   if (VA_INVALID_ID != priv->slice_param_id) {
1213     va_buffers[va_buffers_count++] = priv->slice_param_id;
1214   }
1215   if (SLICE_TYPE_I == priv->cur_slice_type) {
1216     if (VA_INVALID_ID != priv->packed_seq_param_id) {
1217       va_buffers[va_buffers_count++] = priv->packed_seq_param_id;
1218     }
1219     if (VA_INVALID_ID != priv->packed_seq_data_id) {
1220       va_buffers[va_buffers_count++] = priv->packed_seq_data_id;
1221     }
1222     if (VA_INVALID_ID != priv->packed_pic_param_id) {
1223       va_buffers[va_buffers_count++] = priv->packed_pic_param_id;
1224     }
1225     if (VA_INVALID_ID != priv->packed_pic_data_id) {
1226       va_buffers[va_buffers_count++] = priv->packed_pic_data_id;
1227     }
1228   }
1229
1230   va_status = vaRenderPicture(va_dpy,
1231                               context_id,
1232                               va_buffers,
1233                               va_buffers_count);
1234   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
1235                        ENCODER_PICTURE_ERR,
1236                        "vaRenderH264Picture failed.");
1237
1238   /*after finished,  swap  recon and surface2*/
1239   if (SLICE_TYPE_P == priv->cur_slice_type ||
1240       SLICE_TYPE_I == priv->cur_slice_type) {
1241     h264_swap_surface(&priv->recon_surface, &priv->ref_surface2);
1242   }
1243
1244   end:
1245   ENCODER_RELEASE_DISPLAY_LOCK(display);
1246   return ret;
1247 }
1248
1249 #endif
1250
1251 static const guint8 *
1252 h264_next_nal(const guint8 *buffer, guint32 len, guint32 *nal_size)
1253 {
1254     const guint8 *cur = buffer;
1255     const guint8 *end = buffer + len;
1256     const guint8 *nal_start = NULL;
1257     guint32 flag = 0xFFFFFFFF;
1258     guint32 nal_start_len = 0;
1259
1260     ENCODER_ASSERT(len >= 0 && buffer && nal_size);
1261     if (len < 3) {
1262         *nal_size = len;
1263         nal_start = (len ? buffer : NULL);
1264         return nal_start;
1265     }
1266
1267     /*locate head postion*/
1268     if (!buffer[0] && !buffer[1]) {
1269         if (buffer[2] == 1) { // 0x000001
1270             nal_start_len = 3;
1271         } else if (!buffer[2] && len >=4 && buffer[3] == 1) { //0x00000001
1272             nal_start_len = 4;
1273         }
1274     }
1275     nal_start = buffer + nal_start_len;
1276     cur = nal_start;
1277
1278     /*find next nal start position*/
1279     while (cur < end) {
1280         flag = ((flag<<8) | ((*cur++)&0xFF));
1281         if (flag == 0x00000001) {
1282             *nal_size = cur - 4 - nal_start;
1283             break;
1284         } else if ((flag&0x00FFFFFF) == 0x00000001) {
1285             *nal_size = cur - 3 - nal_start;
1286             break;
1287         }
1288     }
1289     if (cur >= end) {
1290       *nal_size = end - nal_start;
1291       if (nal_start >= end) {
1292         nal_start = NULL;
1293       }
1294     }
1295     return nal_start;
1296 }
1297
1298 static GstBuffer *
1299 gst_vaapi_encoder_h264_copy_coded_buffer(
1300     GstVaapiBaseEncoder *base,
1301     guint8 *frame,
1302     guint32 frame_size,
1303     VABufferID *coded_buf
1304 )
1305 {
1306   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
1307   GstVaapiEncoderH264Private *priv = encoder->priv;
1308   GstBuffer *ret_buffer;
1309   guint32   nal_size;
1310   const guint8   *nal_start;
1311   guint8  *frame_end;
1312
1313   ret_buffer = gst_buffer_new();
1314   ENCODER_ASSERT(ret_buffer);
1315   H264Bitstream bitstream;
1316   h264_bitstream_init(&bitstream, (frame_size+32)*8);
1317   h264_bitstream_align(&bitstream, 0);
1318   ENCODER_ASSERT(bitstream.bit_size == 0);
1319
1320   if (!priv->avc_flag) { /*nal format*/
1321     h264_bitstream_write_byte_array(&bitstream, frame, frame_size);
1322     ENCODER_ASSERT(bitstream.bit_size == frame_size*8);
1323   } else { /* elementary format */
1324     frame_end = frame + frame_size;
1325     nal_start = frame;
1326     nal_size = 0;
1327     while(NULL !=
1328           (nal_start = h264_next_nal(nal_start, frame_end-nal_start, &nal_size))
1329          ) {
1330       ENCODER_ASSERT(nal_size);
1331       if (!nal_size) {
1332         nal_start += nal_size;
1333         continue;
1334       }
1335       h264_bitstream_write_uint(&bitstream, nal_size, 32);
1336       h264_bitstream_write_byte_array(&bitstream, nal_start, nal_size);
1337       nal_start += nal_size;
1338     }
1339   }
1340   h264_bitstream_align(&bitstream, 0);
1341
1342   GST_BUFFER_MALLOCDATA(ret_buffer) =
1343         GST_BUFFER_DATA(ret_buffer) = BIT_STREAM_BUFFER(&bitstream);
1344   GST_BUFFER_SIZE(ret_buffer) = BIT_STREAM_BIT_SIZE(&bitstream)/8;
1345   h264_bitstream_destroy(&bitstream, FALSE);
1346
1347   return ret_buffer;
1348 }
1349
1350 static EncoderStatus
1351 read_sps_pps(GstVaapiEncoderH264Private *priv, const guint8 *buf, guint32 size)
1352 {
1353   const guint8 *end = buf + size;
1354   const guint8 *nal_start = buf;
1355   guint32 nal_size = 0;
1356   guint8 nal_type;
1357   GstBuffer *sps = NULL, *pps = NULL;
1358
1359   while((!sps || !pps) &&
1360         (nal_start = h264_next_nal(nal_start, end-nal_start, &nal_size)) != NULL
1361        ) {
1362     if (!nal_size) {
1363       nal_start += nal_size;
1364       continue;
1365     }
1366
1367     nal_type = (*nal_start)&0x1F;
1368     switch (nal_type) {
1369       case NAL_SPS: {
1370         sps = gst_buffer_new_and_alloc(nal_size);
1371         memcpy(GST_BUFFER_DATA(sps), nal_start, nal_size);
1372         gst_buffer_replace(&priv->sps_data, sps);
1373         gst_buffer_unref(sps); /*don't set to NULL*/
1374         break;
1375       }
1376
1377       case NAL_PPS: {
1378         pps = gst_buffer_new_and_alloc(nal_size);
1379         memcpy(GST_BUFFER_DATA(pps), nal_start, nal_size);
1380         gst_buffer_replace(&priv->pps_data, pps);
1381         gst_buffer_unref(pps);
1382         break;
1383       }
1384
1385       default:
1386         break;
1387     }
1388     nal_start += nal_size;
1389   }
1390
1391   if (!sps || !pps) {
1392     return ENCODER_DATA_NOT_READY;
1393   }
1394
1395   return ENCODER_NO_ERROR;
1396 }
1397
1398 static void
1399 gst_vaapi_encoder_h264_notify_frame(
1400     GstVaapiBaseEncoder *base,
1401     guint8 *buf,
1402     guint32 size
1403 )
1404 {
1405   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
1406   GstVaapiEncoderH264Private *priv = encoder->priv;
1407   if (!priv->sps_data || !priv->pps_data) {
1408     read_sps_pps(priv, buf, size);
1409   }
1410   if (priv->sps_data && priv->pps_data) {
1411     gst_vaapi_base_encoder_set_frame_notify(base, FALSE);
1412   }
1413 }
1414
1415 static gboolean
1416 read_sps_attributes(
1417     const guint8 *sps_data,
1418     guint32 sps_size,
1419     guint32 *profile_idc,
1420     guint32 *profile_comp,
1421     guint32 *level_idc
1422 )
1423 {
1424   ENCODER_ASSERT(profile_idc && profile_comp && level_idc);
1425   ENCODER_ASSERT(sps_size >= 4);
1426   if (sps_size < 4) {
1427     return FALSE;
1428   }
1429   /*skip sps_data[0], nal_type*/
1430   *profile_idc = sps_data[1];
1431   *profile_comp = sps_data[2];
1432   *level_idc = sps_data[3];
1433   return TRUE;
1434 }
1435
1436 static EncoderStatus
1437 gst_vaapi_encoder_h264_flush(
1438     GstVaapiEncoder* base,
1439     GList **coded_pics
1440 )
1441 {
1442   GstVaapiEncoderH264* encoder = GST_VAAPI_ENCODER_H264_CAST(base);
1443   EncoderStatus ret = ENCODER_NO_ERROR;
1444   GstVaapiEncoderH264Private *priv = encoder->priv;
1445
1446   //priv->frame_count = 0;
1447   priv->cur_display_num = 0;
1448   priv->cur_decode_num = 0;
1449   priv->cur_slice_type = SLICE_TYPE_I;
1450   priv->gop_count = g_queue_get_length(priv->queued_buffers);
1451   //gst_vaapi_base_encoder_set_frame_notify((GST_VAAPI_BASE_ENCODER)encoder, TRUE);
1452
1453   //end:
1454   return ret;
1455 }
1456
1457 static EncoderStatus
1458 gst_vaapi_encoder_h264_get_avcC_codec_data(
1459     GstVaapiEncoderH264 *encoder,
1460     GstBuffer **buffer
1461 )
1462 {
1463   GstVaapiEncoderH264Private *priv = encoder->priv;
1464   GstBuffer *avc_codec;
1465   const guint32 configuration_version = 0x01;
1466   const guint32 length_size_minus_one = 0x03;
1467   guint32 profile, profile_comp, level_idc;
1468
1469   ENCODER_ASSERT(buffer);
1470   if (!priv->sps_data || !priv->pps_data) {
1471     return ENCODER_DATA_NOT_READY;
1472   }
1473
1474   if (FALSE == read_sps_attributes(GST_BUFFER_DATA(priv->sps_data),
1475                                    GST_BUFFER_SIZE(priv->sps_data),
1476                                    &profile, &profile_comp, &level_idc))
1477   {
1478     ENCODER_ASSERT(0);
1479     return ENCODER_DATA_ERR;
1480   }
1481
1482   H264Bitstream bitstream;
1483   h264_bitstream_init(&bitstream,
1484                       (GST_BUFFER_SIZE(priv->sps_data) +
1485                        GST_BUFFER_SIZE(priv->pps_data) + 32)*8);
1486
1487   /*codec_data*/
1488   h264_bitstream_write_uint(&bitstream, configuration_version, 8);
1489   h264_bitstream_write_uint(&bitstream, profile, 8);
1490   h264_bitstream_write_uint(&bitstream, profile_comp, 8);
1491   h264_bitstream_write_uint(&bitstream, level_idc, 8);
1492   h264_bitstream_write_uint(&bitstream, h264_bit_mask[6], 6); /*111111*/
1493   h264_bitstream_write_uint(&bitstream, length_size_minus_one, 2);
1494   h264_bitstream_write_uint(&bitstream, h264_bit_mask[3], 3); /*111*/
1495
1496   /*write sps*/
1497   h264_bitstream_write_uint(&bitstream, 1, 5);   /* sps count = 1*/
1498   ENCODER_ASSERT( BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
1499   h264_bitstream_write_uint(&bitstream, GST_BUFFER_SIZE(priv->sps_data), 16);
1500   h264_bitstream_write_byte_array(&bitstream,
1501                                   GST_BUFFER_DATA(priv->sps_data),
1502                                   GST_BUFFER_SIZE(priv->sps_data));
1503
1504   /*write pps*/
1505   h264_bitstream_write_uint(&bitstream, 1, 8); /*pps count = 1*/
1506   h264_bitstream_write_uint(&bitstream, GST_BUFFER_SIZE(priv->pps_data), 16);
1507   h264_bitstream_write_byte_array(&bitstream,
1508                                   GST_BUFFER_DATA(priv->pps_data),
1509                                   GST_BUFFER_SIZE(priv->pps_data));
1510
1511   avc_codec = gst_buffer_new();
1512   GST_BUFFER_MALLOCDATA(avc_codec) =
1513          GST_BUFFER_DATA(avc_codec) =
1514          BIT_STREAM_BUFFER(&bitstream);
1515   GST_BUFFER_SIZE(avc_codec) = BIT_STREAM_BIT_SIZE(&bitstream)/8;
1516   h264_bitstream_destroy(&bitstream, FALSE);
1517   *buffer = avc_codec;
1518
1519   return ENCODER_NO_ERROR;
1520 }
1521
1522 static EncoderStatus
1523 gst_vaapi_encoder_h264_get_codec_data(
1524     GstVaapiEncoder* base,
1525     GstBuffer **buffer)
1526 {
1527   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
1528   GstVaapiEncoderH264Private *priv = encoder->priv;
1529
1530   if (priv->avc_flag)
1531     return gst_vaapi_encoder_h264_get_avcC_codec_data(encoder, buffer);
1532   return ENCODER_NO_DATA;
1533 }
1534
1535 static void
1536 gst_vaapi_encoder_h264_init(GstVaapiEncoderH264 *encoder)
1537 {
1538   GstVaapiEncoderH264Private *priv = GST_VAAPI_ENCODER_H264_GET_PRIVATE(encoder);
1539   ENCODER_ASSERT(priv);
1540   priv->public = encoder;
1541   encoder->priv = priv;
1542
1543   /* init public attributes */
1544   gst_vaapi_encoder_h264_init_public_values(encoder);
1545   gst_vaapi_base_encoder_set_frame_notify(GST_VAAPI_BASE_ENCODER(encoder), TRUE);
1546
1547   /* init private values*/
1548   priv->format = GST_MAKE_FOURCC('N','V','1','2');
1549   priv->avc_flag = FALSE;
1550
1551   priv->ref_surface1 = NULL;
1552   priv->ref_surface2 = NULL;
1553   priv->recon_surface = NULL;
1554
1555   priv->seq_param_id = VA_INVALID_ID;
1556   priv->pic_param_id = VA_INVALID_ID;
1557   priv->slice_param_id = VA_INVALID_ID;
1558   priv->packed_seq_param_id = VA_INVALID_ID;
1559   priv->packed_seq_data_id = VA_INVALID_ID;
1560   priv->packed_pic_param_id = VA_INVALID_ID;
1561   priv->packed_pic_data_id = VA_INVALID_ID;
1562   priv->slice_param_buffers = NULL;
1563   priv->default_slice_height = 0;
1564   priv->slice_mod_mb_num = 0;
1565
1566   priv->sps_data = NULL;
1567   priv->pps_data = NULL;
1568
1569   priv->queued_buffers = g_queue_new();
1570   priv->gop_count = 0;
1571   priv->cur_display_num = 0;
1572   priv->cur_decode_num = 0;
1573   priv->cur_slice_type = SLICE_TYPE_I;
1574   priv->last_decode_time = 0LL;
1575   priv->default_cts_offset = 0;
1576
1577   priv->max_frame_num = 0;
1578   priv->max_pic_order_cnt = 0;
1579   priv->idr_num = 0;
1580 }
1581
1582 static void
1583 gst_vaapi_encoder_h264_finalize(GObject *object)
1584 {
1585   /*free private buffers*/
1586   GstVaapiEncoder *encoder = GST_VAAPI_ENCODER(object);
1587   GstVaapiEncoderH264Private *priv = GST_VAAPI_ENCODER_H264_GET_PRIVATE(object);
1588
1589   if (gst_vaapi_encoder_get_state(encoder) != VAAPI_ENC_NULL) {
1590     gst_vaapi_encoder_uninitialize(encoder);
1591   }
1592
1593   if (priv->sps_data) {
1594     gst_buffer_unref(priv->sps_data);
1595     priv->sps_data = NULL;
1596   }
1597   if (priv->pps_data) {
1598     gst_buffer_unref(priv->pps_data);
1599     priv->pps_data = NULL;
1600   }
1601   if (priv->slice_param_buffers) {
1602     g_free(priv->slice_param_buffers);
1603     priv->slice_param_buffers = NULL;
1604   }
1605
1606   if (priv->queued_buffers) {
1607     ENCODER_ASSERT(g_queue_is_empty(priv->queued_buffers));
1608     g_queue_free(priv->queued_buffers);
1609     priv->queued_buffers = NULL;
1610   }
1611
1612   G_OBJECT_CLASS(gst_vaapi_encoder_h264_parent_class)->finalize(object);
1613 }
1614
1615 static void
1616 gst_vaapi_encoder_h264_class_init(GstVaapiEncoderH264Class *klass)
1617 {
1618   GObjectClass * const object_class = G_OBJECT_CLASS(klass);
1619   GstVaapiEncoderClass * const encoder_class = GST_VAAPI_ENCODER_CLASS(klass);
1620   GstVaapiBaseEncoderClass * const base_class = GST_VAAPI_BASE_ENCODER_CLASS(klass);
1621
1622   g_type_class_add_private(klass, sizeof(GstVaapiEncoderH264Private));
1623
1624   GST_DEBUG_CATEGORY_INIT (gst_vaapi_h264_encoder_debug,
1625                            "gst_va_h264_encoder",
1626                            0,
1627                            "gst_va_h264_encoder element");
1628
1629   object_class->finalize = gst_vaapi_encoder_h264_finalize;
1630
1631   base_class->validate_attributes = gst_vaapi_encoder_h264_validate_attributes;
1632   base_class->pre_alloc_resource  = gst_vaapi_encoder_h264_alloc_slices;
1633   base_class->release_resource    = gst_vaapi_encoder_h264_release_resource;
1634   base_class->prepare_next_input_buffer =
1635       gst_vaapi_encoder_h264_prepare_next_buffer;
1636   base_class->render_frame = gst_vaapi_encoder_h264_rendering;
1637   base_class->notify_frame = gst_vaapi_encoder_h264_notify_frame;
1638   base_class->copy_coded_frame = gst_vaapi_encoder_h264_copy_coded_buffer;
1639   base_class->encode_frame_failed = gst_vaapi_encoder_h264_frame_failed;
1640
1641   encoder_class->flush = gst_vaapi_encoder_h264_flush;
1642   encoder_class->get_codec_data = gst_vaapi_encoder_h264_get_codec_data;
1643 }
1644
1645 static void
1646 h264_bitstream_init(H264Bitstream *bitstream, guint32 bit_capability)
1647 {
1648   bitstream->bit_size = 0;
1649   bitstream->buffer = NULL;
1650   bitstream->max_bit_capability = 0;
1651   if (bit_capability) {
1652     h264_bitstream_auto_grow(bitstream, bit_capability);
1653   }
1654 }
1655
1656 static gboolean
1657 h264_bitstream_write_uint(
1658     H264Bitstream *bitstream,
1659     guint32 value,
1660     guint32 bit_size
1661 )
1662 {
1663   gboolean ret = TRUE;
1664   guint32 byte_pos, bit_offset;
1665   guint8  *cur_byte;
1666   guint32 fill_bits;
1667
1668   if(!bit_size) {
1669     return TRUE;
1670   }
1671
1672   VAAPI_UNUSED_ARG(ret);
1673   ENCODER_CHECK_STATUS(h264_bitstream_auto_grow(bitstream, bit_size),
1674                        FALSE,
1675                        "h264_bitstream_auto_grow failed.");
1676   byte_pos = (bitstream->bit_size>>3);
1677   bit_offset = (bitstream->bit_size&0x07);
1678   cur_byte = bitstream->buffer + byte_pos;
1679   ENCODER_ASSERT(bit_offset < 8 &&
1680                  bitstream->bit_size <= bitstream->max_bit_capability);
1681
1682   while (bit_size) {
1683     fill_bits = ((8-bit_offset) < bit_size ? (8-bit_offset) : bit_size);
1684     bit_size -= fill_bits;
1685     bitstream->bit_size += fill_bits;
1686
1687     *cur_byte |=
1688         ((value>>bit_size) & h264_bit_mask[fill_bits])<<(8-bit_offset-fill_bits);
1689     ++cur_byte;
1690     bit_offset = 0;
1691   }
1692   ENCODER_ASSERT(cur_byte <=
1693                  (bitstream->buffer + bitstream->max_bit_capability/8));
1694
1695   end:
1696   return ret;
1697 }
1698
1699 static gboolean
1700 h264_bitstream_align(H264Bitstream *bitstream, guint32 value)
1701 {
1702   guint32 bit_offset, bit_left;
1703
1704   bit_offset = (bitstream->bit_size&0x07);
1705   if (!bit_offset) {
1706     return TRUE;
1707   }
1708   bit_left = 8 - bit_offset;
1709   if (value) value = h264_bit_mask[bit_left];
1710   return h264_bitstream_write_uint(bitstream, value, bit_left);
1711 }
1712
1713
1714 static gboolean
1715 h264_bitstream_write_byte_array(
1716     H264Bitstream *bitstream,
1717     const guint8 *buf,
1718     guint32 byte_size
1719 )
1720 {
1721   gboolean ret = TRUE;
1722   if (!byte_size) {
1723     return 0;
1724   }
1725
1726   VAAPI_UNUSED_ARG(ret);
1727   ENCODER_CHECK_STATUS(h264_bitstream_auto_grow(bitstream, byte_size<<3),
1728                        FALSE,
1729                        "h264_bitstream_auto_grow failed.");
1730   if (0 == (bitstream->bit_size&0x07)) {
1731     memcpy(&bitstream->buffer[bitstream->bit_size>>3], buf, byte_size);
1732     bitstream->bit_size += (byte_size<<3);
1733   } else {
1734     ENCODER_ASSERT(0);
1735     while(byte_size) {
1736       h264_bitstream_write_uint(bitstream, *buf, 8);
1737       --byte_size;
1738       ++buf;
1739     }
1740   }
1741
1742 end:
1743   return ret;
1744 }
1745
1746 static gboolean
1747 h264_bitstream_write_ue(H264Bitstream *bitstream, guint32 value)
1748 {
1749   gboolean ret = TRUE;
1750   guint32  size_in_bits = 0;
1751   guint32  tmp_value = ++value;
1752   while (tmp_value) {
1753     ++size_in_bits;
1754     tmp_value >>= 1;
1755   }
1756   ENCODER_CHECK_STATUS(h264_bitstream_write_uint(bitstream, 0, size_in_bits-1),
1757                        FALSE,
1758                        "h264_bitstream_write_ue failed.");
1759   ENCODER_CHECK_STATUS(h264_bitstream_write_uint(bitstream, value, size_in_bits),
1760                        FALSE,
1761                        "h264_bitstream_write_ue failed.");
1762
1763 end:
1764   return ret;
1765 }
1766
1767 static gboolean
1768 h264_bitstream_write_se(H264Bitstream *bitstream, gint32 value)
1769 {
1770   gboolean ret = TRUE;
1771   guint32 new_val;
1772
1773   if (value <= 0) {
1774     new_val = -(value<<1);
1775   } else {
1776     new_val = (value<<1) - 1;
1777   }
1778
1779   ENCODER_CHECK_STATUS(h264_bitstream_write_ue(bitstream, new_val),
1780                        FALSE,
1781                        "h264_bitstream_write_se failed.");
1782
1783 end:
1784   return ret;
1785 }
1786
1787 static gboolean
1788 h264_bitstream_write_trailing_bits(H264Bitstream *bitstream)
1789 {
1790     h264_bitstream_write_uint(bitstream, 1, 1);
1791     h264_bitstream_align(bitstream, 0);
1792     return TRUE;
1793 }
1794
1795 static void
1796 h264_bitstream_destroy(H264Bitstream *bitstream, gboolean free_flag)
1797 {
1798   if (bitstream->buffer && free_flag) {
1799     free (bitstream->buffer);
1800   }
1801   bitstream->buffer = NULL;
1802   bitstream->bit_size = 0;
1803   bitstream->max_bit_capability = 0;
1804 }
1805
1806 static gboolean
1807 h264_bitstream_auto_grow(H264Bitstream *bitstream, guint32 extra_bit_size)
1808 {
1809   guint32 new_bit_size = extra_bit_size + bitstream->bit_size;
1810   guint32 clear_pos;
1811
1812   ENCODER_ASSERT(bitstream->bit_size <= bitstream->max_bit_capability);
1813   if (new_bit_size <= bitstream->max_bit_capability) {
1814     return TRUE;
1815   }
1816
1817   new_bit_size = ((new_bit_size + H264_BITSTREAM_ALLOC_ALIGN_MASK)
1818                 &(~H264_BITSTREAM_ALLOC_ALIGN_MASK));
1819   ENCODER_ASSERT(new_bit_size%(H264_BITSTREAM_ALLOC_ALIGN_MASK+1) == 0);
1820   clear_pos = ((bitstream->bit_size+7)>>3);
1821   bitstream->buffer = realloc(bitstream->buffer, new_bit_size>>3);
1822   memset(bitstream->buffer+clear_pos, 0, (new_bit_size>>3)-clear_pos);
1823   bitstream->max_bit_capability = new_bit_size;
1824   return TRUE;
1825 }
1826
1827 static gboolean
1828 h264_bitstream_write_nal_header(
1829     H264Bitstream *bitstream,
1830     guint nal_ref_idc,
1831     guint nal_unit_type
1832 )
1833 {
1834   h264_bitstream_write_uint(bitstream, 0, 1);
1835   h264_bitstream_write_uint(bitstream, nal_ref_idc, 2);
1836   h264_bitstream_write_uint(bitstream, nal_unit_type, 5);
1837   return TRUE;
1838 }
1839
1840 static gboolean
1841 h264_bitstream_write_sps(
1842     H264Bitstream *bitstream,
1843     VAEncSequenceParameterBufferH264 *seq,
1844     H264_Profile profile
1845 )
1846 {
1847   guint32 constraint_set0_flag, constraint_set1_flag;
1848   guint32 constraint_set2_flag, constraint_set3_flag;
1849   guint32 gaps_in_frame_num_value_allowed_flag = 0; // ??
1850
1851   guint32 b_qpprime_y_zero_transform_bypass = 0;
1852   guint32 residual_color_transform_flag = 0;
1853   guint32 pic_height_in_map_units =
1854     (seq->seq_fields.bits.frame_mbs_only_flag ?
1855      seq->picture_height_in_mbs :
1856      seq->picture_height_in_mbs/2);
1857   guint32 mb_adaptive_frame_field = !seq->seq_fields.bits.frame_mbs_only_flag;
1858   guint32 i = 0;
1859
1860   constraint_set0_flag = profile == H264_PROFILE_BASELINE;
1861   constraint_set1_flag = profile <= H264_PROFILE_MAIN;
1862   constraint_set2_flag = 0;
1863   constraint_set3_flag = 0;
1864
1865   /* profile_idc */
1866   h264_bitstream_write_uint(bitstream, profile, 8);
1867   /* constraint_set0_flag */
1868   h264_bitstream_write_uint(bitstream, constraint_set0_flag, 1);
1869   /* constraint_set1_flag */
1870   h264_bitstream_write_uint(bitstream, constraint_set1_flag, 1);
1871   /* constraint_set2_flag */
1872   h264_bitstream_write_uint(bitstream, constraint_set2_flag, 1);
1873   /* constraint_set3_flag */
1874   h264_bitstream_write_uint(bitstream, constraint_set3_flag, 1);
1875   /* reserved_zero_4bits */
1876   h264_bitstream_write_uint(bitstream, 0, 4);
1877   /* level_idc */
1878   h264_bitstream_write_uint(bitstream, seq->level_idc, 8);
1879   /* seq_parameter_set_id */
1880   h264_bitstream_write_ue(bitstream, seq->seq_parameter_set_id);
1881
1882   if (profile >= H264_PROFILE_HIGH) {
1883     /* for high profile */
1884     ENCODER_ASSERT(0);
1885     /* chroma_format_idc  = 1, 4:2:0*/
1886     h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.chroma_format_idc);
1887     if (3 == seq->seq_fields.bits.chroma_format_idc) {
1888       h264_bitstream_write_uint(bitstream, residual_color_transform_flag, 1);
1889     }
1890     /* bit_depth_luma_minus8 */
1891     h264_bitstream_write_ue(bitstream, seq->bit_depth_luma_minus8);
1892     /* bit_depth_chroma_minus8 */
1893     h264_bitstream_write_ue(bitstream, seq->bit_depth_chroma_minus8);
1894     /* b_qpprime_y_zero_transform_bypass */
1895     h264_bitstream_write_uint(bitstream, b_qpprime_y_zero_transform_bypass, 1);
1896     ENCODER_ASSERT(seq->seq_fields.bits.seq_scaling_matrix_present_flag == 0);
1897     /*seq_scaling_matrix_present_flag  */
1898     h264_bitstream_write_uint(bitstream,
1899                               seq->seq_fields.bits.seq_scaling_matrix_present_flag,
1900                               1);
1901
1902     #if 0
1903     if (seq->seq_fields.bits.seq_scaling_matrix_present_flag) {
1904       for (i = 0; i < (seq->seq_fields.bits.chroma_format_idc != 3 ? 8 : 12); i++) {
1905         h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.seq_scaling_list_present_flag, 1);
1906         if (seq->seq_fields.bits.seq_scaling_list_present_flag) {
1907           ENCODER_ASSERT(0);
1908           /* FIXME, need write scaling list if seq_scaling_matrix_present_flag ==1*/
1909         }
1910       }
1911     }
1912     #endif
1913   }
1914
1915   /* log2_max_frame_num_minus4 */
1916   h264_bitstream_write_ue(bitstream,
1917                           seq->seq_fields.bits.log2_max_frame_num_minus4);
1918   /* pic_order_cnt_type */
1919   h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.pic_order_cnt_type);
1920
1921   if (seq->seq_fields.bits.pic_order_cnt_type == 0) {
1922     /* log2_max_pic_order_cnt_lsb_minus4 */
1923     h264_bitstream_write_ue(bitstream,
1924                             seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);
1925   } else if (seq->seq_fields.bits.pic_order_cnt_type == 1) {
1926     ENCODER_ASSERT(0);
1927     h264_bitstream_write_uint(bitstream,
1928                               seq->seq_fields.bits.delta_pic_order_always_zero_flag,
1929                               1);
1930     h264_bitstream_write_se(bitstream, seq->offset_for_non_ref_pic);
1931     h264_bitstream_write_se(bitstream,
1932                             seq->offset_for_top_to_bottom_field);
1933     h264_bitstream_write_ue(bitstream,
1934                             seq->num_ref_frames_in_pic_order_cnt_cycle);
1935     for ( i = 0; i < seq->num_ref_frames_in_pic_order_cnt_cycle; i++) {
1936       h264_bitstream_write_se(bitstream, seq->offset_for_ref_frame[i]);
1937     }
1938   }
1939
1940   /* num_ref_frames */
1941   h264_bitstream_write_ue(bitstream, seq->max_num_ref_frames);
1942   /* gaps_in_frame_num_value_allowed_flag */
1943   h264_bitstream_write_uint(bitstream,
1944                             gaps_in_frame_num_value_allowed_flag,
1945                             1);
1946
1947   /* pic_width_in_mbs_minus1 */
1948   h264_bitstream_write_ue(bitstream, seq->picture_width_in_mbs - 1);
1949   /* pic_height_in_map_units_minus1 */
1950   h264_bitstream_write_ue(bitstream, pic_height_in_map_units - 1);
1951   /* frame_mbs_only_flag */
1952   h264_bitstream_write_uint(bitstream,
1953                             seq->seq_fields.bits.frame_mbs_only_flag,
1954                             1);
1955
1956   if (!seq->seq_fields.bits.frame_mbs_only_flag) { //ONLY mbs
1957       ENCODER_ASSERT(0);
1958       h264_bitstream_write_uint(bitstream, mb_adaptive_frame_field, 1);
1959   }
1960
1961   /* direct_8x8_inference_flag */
1962   h264_bitstream_write_uint(bitstream, 0, 1);
1963   /* frame_cropping_flag */
1964   h264_bitstream_write_uint(bitstream, seq->frame_cropping_flag, 1);
1965
1966   if (seq->frame_cropping_flag) {
1967       /* frame_crop_left_offset */
1968       h264_bitstream_write_ue(bitstream, seq->frame_crop_left_offset);
1969       /* frame_crop_right_offset */
1970       h264_bitstream_write_ue(bitstream, seq->frame_crop_right_offset);
1971       /* frame_crop_top_offset */
1972       h264_bitstream_write_ue(bitstream, seq->frame_crop_top_offset);
1973       /* frame_crop_bottom_offset */
1974       h264_bitstream_write_ue(bitstream, seq->frame_crop_bottom_offset);
1975   }
1976   ENCODER_ASSERT(seq->vui_parameters_present_flag == FALSE);
1977
1978   /* vui_parameters_present_flag */
1979   h264_bitstream_write_uint(bitstream, seq->vui_parameters_present_flag, 1);
1980   if (seq->vui_parameters_present_flag) {
1981     /*FIXME, to write vui parameters*/
1982   }
1983   /* rbsp_trailing_bits */
1984   h264_bitstream_write_trailing_bits(bitstream);
1985   return TRUE;
1986 }
1987
1988 static gboolean
1989 h264_bitstream_write_pps(
1990     H264Bitstream *bitstream,
1991     VAEncPictureParameterBufferH264 *pic
1992 )
1993 {
1994   guint32 num_slice_groups_minus1 = 0;
1995   guint32 pic_init_qs_minus26 = 0;
1996   guint32 redundant_pic_cnt_present_flag = 0;
1997
1998   /* pic_parameter_set_id */
1999   h264_bitstream_write_ue(bitstream, pic->pic_parameter_set_id);
2000   /* seq_parameter_set_id */
2001   h264_bitstream_write_ue(bitstream, pic->seq_parameter_set_id);
2002   /* entropy_coding_mode_flag */
2003   h264_bitstream_write_uint(bitstream,
2004                             pic->pic_fields.bits.entropy_coding_mode_flag,
2005                             1);
2006   /* pic_order_present_flag */
2007   h264_bitstream_write_uint(bitstream,
2008                             pic->pic_fields.bits.pic_order_present_flag,
2009                             1);
2010   /*slice_groups-1*/
2011   h264_bitstream_write_ue(bitstream, num_slice_groups_minus1);
2012
2013   if (num_slice_groups_minus1 > 0) {
2014     /*FIXME*/
2015     ENCODER_ASSERT(0);
2016   }
2017   h264_bitstream_write_ue(bitstream, pic->num_ref_idx_l0_active_minus1);
2018   h264_bitstream_write_ue(bitstream, pic->num_ref_idx_l1_active_minus1);
2019   h264_bitstream_write_uint(bitstream,
2020                             pic->pic_fields.bits.weighted_pred_flag,
2021                             1);
2022   h264_bitstream_write_uint(bitstream,
2023                             pic->pic_fields.bits.weighted_bipred_idc,
2024                             2);
2025   /* pic_init_qp_minus26 */
2026   h264_bitstream_write_se(bitstream, pic->pic_init_qp-26);
2027   /* pic_init_qs_minus26 */
2028   h264_bitstream_write_se(bitstream, pic_init_qs_minus26);
2029   /*chroma_qp_index_offset*/
2030   h264_bitstream_write_se(bitstream, pic->chroma_qp_index_offset);
2031
2032   h264_bitstream_write_uint(bitstream,
2033                             pic->pic_fields.bits.deblocking_filter_control_present_flag,
2034                             1);
2035   h264_bitstream_write_uint(bitstream,
2036                             pic->pic_fields.bits.constrained_intra_pred_flag,
2037                             1);
2038   h264_bitstream_write_uint(bitstream, redundant_pic_cnt_present_flag, 1);
2039
2040   /*more_rbsp_data*/
2041   h264_bitstream_write_uint(bitstream,
2042                             pic->pic_fields.bits.transform_8x8_mode_flag,
2043                             1);
2044   h264_bitstream_write_uint(bitstream,
2045                             pic->pic_fields.bits.pic_scaling_matrix_present_flag,
2046                             1);
2047   if (pic->pic_fields.bits.pic_scaling_matrix_present_flag) {
2048     ENCODER_ASSERT(0);
2049     /* FIXME */
2050     /*
2051     for (i = 0; i <
2052       (6+(-( (chroma_format_idc ! = 3) ? 2 : 6) * -pic->pic_fields.bits.transform_8x8_mode_flag));
2053       i++) {
2054       h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.pic_scaling_list_present_flag, 1);
2055     }
2056     */
2057   }
2058
2059   h264_bitstream_write_se(bitstream, pic->second_chroma_qp_index_offset);
2060   h264_bitstream_write_trailing_bits(bitstream);
2061   return TRUE;
2062 }