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 #define HAVE_OLD_H264_ENCODER 0
  22
  23 #include "gstvaapiencoder_h264.h"
  24 #include "config.h"
  25
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <va/va.h>
  29 #include <va/va_x11.h>
  30 #if !HAVE_OLD_H264_ENCODER
  31 #include <va/va_enc_h264.h>
  32 #endif
  33 #include <X11/Xlib.h>
  34 #include <glib.h>
  35
  36 #include "gst/gstclock.h"
  37 #include "gst/gstvalue.h"
  38
  39 #include "gstvaapiobject.h"
  40 #include "gstvaapiobject_priv.h"
  41 #include "gstvaapicontext.h"
  42 #include "gstvaapisurface.h"
  43 #include "gstvaapivideobuffer.h"
  44 #include "gstvaapidisplay_priv.h"
  45
  46 GST_DEBUG_CATEGORY_STATIC (gst_vaapi_h264_encoder_debug);
  47
  48 #define GST_CAT_DEFAULT gst_vaapi_h264_encoder_debug
  49
  50 #define GST_VAAPI_ENCODER_H264_CAST(encoder)    ((GstVaapiEncoderH264 *)(encoder))
  51
  52 #define SHARE_CODED_BUF         0
  53
  54 #define DEFAULT_SURFACE_NUMBER  3
  55 #define DEFAULT_CODEDBUF_NUM    5
  56 #define DEFAULT_SID_INPUT       0 // suface_ids[0]
  57
  58 #define REF_RECON_SURFACE_NUM   2
  59
  60 #define ENTROPY_MODE_CAVLC      0
  61 #define ENTROPY_MODE_CABAC      1
  62
  63 #define BR_CBR          0
  64 #define BR_VBR          1
  65 #define BR_CQP          2
  66
  67 #define NAL_REF_IDC_NONE        0
  68 #define NAL_REF_IDC_LOW         1
  69 #define NAL_REF_IDC_MEDIUM      2
  70 #define NAL_REF_IDC_HIGH        3
  71
  72
  73 typedef enum {
  74   NAL_UNKNOWN     = 0,
  75   NAL_NON_IDR     = 1,
  76   NAL_IDR         = 5,    /* ref_idc != 0 */
  77   NAL_SEI         = 6,    /* ref_idc == 0 */
  78   NAL_SPS         = 7,
  79   NAL_PPS         = 8,
  80   NAL_AUD         = 9,
  81   NAL_FILLER      = 12,
  82 }H264_NAL_TYPE;
  83
  84
  85 typedef enum {
  86   SLICE_TYPE_P  = 0,
  87   SLICE_TYPE_B  = 1,
  88   SLICE_TYPE_I  = 2
  89 } H264_SLICE_TYPE;
  90
  91 struct _GstVaapiEncoderH264Private {
  92   GstVaapiEncoderH264   *public;
  93   guint32           format;   /*NV12, I420,*/
  94   gboolean          avc_flag;  /*elementary flag*/
  95
  96   /* private data*/
  97   GQueue           *video_buffer_caches; /*not used for baseline*/
  98
  99   GstVaapiSurface  *ref_surface1;  /* reference buffer*/
 100   GstVaapiSurface  *ref_surface2;  /* for B frames */
 101   GstVaapiSurface  *recon_surface; /* reconstruct buffer*/
 102
 103   VABufferID        seq_param_id;
 104   VABufferID        pic_param_id;
 105   VABufferID        slice_param_id;
 106   VABufferID        packed_seq_param_id;
 107   VABufferID        packed_seq_data_id;
 108   VABufferID        packed_pic_param_id;
 109   VABufferID        packed_pic_data_id;
 110 #if HAVE_OLD_H264_ENCODER
 111   VAEncSliceParameterBuffer     *slice_param_buffers;
 112 #else
 113   VAEncSliceParameterBufferH264 *slice_param_buffers;
 114 #endif
 115   guint32           default_slice_height;
 116   guint32           slice_mod_mb_num;
 117   guint32           default_cts_offset;
 118
 119   GstBuffer        *sps_data;
 120   GstBuffer        *pps_data;
 121
 122   GQueue           *queued_buffers;  /* GstVaapiVideoBuffers with surface*/
 123
 124   guint32           gop_count;
 125   guint32           cur_display_num;
 126   guint32           cur_decode_num;
 127   H264_SLICE_TYPE   cur_slice_type;
 128   guint64           last_decode_time;
 129   guint32           max_frame_num;
 130   guint32           max_pic_order_cnt;
 131   guint16           idr_num;
 132 };
 133
 134 G_DEFINE_TYPE(GstVaapiEncoderH264, gst_vaapi_encoder_h264, GST_TYPE_VAAPI_BASE_ENCODER)
 135
 136 // 4096-1
 137 #define H264_BITSTREAM_ALLOC_ALIGN_MASK 0x0FFF
 138
 139 #define BIT_STREAM_BUFFER(stream)    ((stream)->buffer)
 140 #define BIT_STREAM_BIT_SIZE(stream)  ((stream)->bit_size)
 141
 142 struct _H264Bitstream {
 143   guint8   *buffer;
 144   guint32   bit_size;
 145   guint32   max_bit_capability;
 146 };
 147
 148 typedef struct _H264Bitstream H264Bitstream;
 149
 150 static const guint8 h264_bit_mask[9] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};
 151
 152 /* h264 bitstream functions */
 153 static void
 154 h264_bitstream_init(H264Bitstream *bitstream, guint32 bit_capability);
 155
 156 static gboolean
 157 h264_bitstream_write_uint(
 158     H264Bitstream *bitstream,
 159     guint32 value,
 160     guint32 bit_size
 161 );
 162
 163 static gboolean
 164 h264_bitstream_align(H264Bitstream *bitstream, guint32 value);
 165
 166 static gboolean
 167 h264_bitstream_write_ue(H264Bitstream *bitstream, guint32 value);
 168
 169 static gboolean
 170 h264_bitstream_write_se(H264Bitstream *bitstream, gint32 value);
 171
 172 static gboolean
 173 h264_bitstream_write_trailing_bits(H264Bitstream *bitstream);
 174
 175 static gboolean
 176 h264_bitstream_write_byte_array(
 177     H264Bitstream *bitstream,
 178     const guint8 *buf,
 179     guint32 byte_size
 180 );
 181
 182 static void
 183 h264_bitstream_destroy(H264Bitstream *bitstream, gboolean free_flag);
 184
 185 static gboolean
 186 h264_bitstream_auto_grow(H264Bitstream *bitstream, guint32 extra_bit_size);
 187
 188 static gboolean
 189 h264_bitstream_write_sps(
 190     H264Bitstream *bitstream,
 191     VAEncSequenceParameterBufferH264 *seq,
 192     H264_Profile profile
 193 );
 194 static gboolean
 195 h264_bitstream_write_pps(
 196     H264Bitstream *bitstream,
 197     VAEncPictureParameterBufferH264 *pic
 198 );
 199
 200 static gboolean
 201 h264_bitstream_write_nal_header(
 202     H264Bitstream *bitstream,
 203     guint nal_ref_idc,
 204     guint nal_unit_type
 205 );
 206
 207 static VAProfile
 208 h264_get_va_profile(guint32 profile)
 209 {
 210   switch (profile) {
 211     case H264_PROFILE_BASELINE:
 212       return VAProfileH264Baseline;
 213
 214     case H264_PROFILE_MAIN:
 215       return VAProfileH264Main;
 216
 217     case H264_PROFILE_HIGH:
 218       return VAProfileH264High;
 219
 220     default:
 221       break;
 222   }
 223   return (-1);
 224 }
 225
 226 GstVaapiEncoderH264 *
 227 gst_vaapi_encoder_h264_new(void)
 228 {
 229   return GST_VAAPI_ENCODER_H264_CAST(
 230              g_object_new(GST_TYPE_VAAPI_ENCODER_H264, NULL));
 231 }
 232
 233 static void
 234 gst_vaapi_encoder_h264_init_public_values(GstVaapiEncoderH264* encoder)
 235 {
 236   encoder->profile = 0;
 237   encoder->level = 0;
 238   encoder->bitrate = 0;
 239   encoder->intra_period = 0;
 240   encoder->init_qp = -1;
 241   encoder->min_qp = -1;
 242   encoder->slice_num = 0;
 243   encoder->b_frame_num = 0;
 244 }
 245
 246 void
 247 gst_vaapi_encoder_h264_set_avc_flag(GstVaapiEncoderH264* encoder, gboolean avc)
 248 {
 249   GstVaapiEncoderH264Private *priv = encoder->priv;
 250   priv->avc_flag = avc;
 251 }
 252
 253 gboolean
 254 gst_vaapi_encoder_h264_get_avc_flag(GstVaapiEncoderH264* encoder)
 255 {
 256   GstVaapiEncoderH264Private *priv = encoder->priv;
 257   return priv->avc_flag;
 258 }
 259
 260 gboolean
 261 gst_vaapi_encoder_h264_validate_attributes(GstVaapiBaseEncoder *base)
 262 {
 263   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 264   GstVaapiEncoderH264Private *priv = encoder->priv;
 265   if (!ENCODER_WIDTH(encoder) ||
 266       !ENCODER_HEIGHT(encoder) ||
 267       !ENCODER_FPS(encoder)) {
 268     return FALSE;
 269   }
 270   if (!encoder->profile) {
 271     encoder->profile = H264_DEFAULT_PROFILE;
 272   }
 273   gst_vaapi_base_encoder_set_va_profile(base, h264_get_va_profile(encoder->profile));
 274   if (!encoder->level) {
 275     if (encoder->profile <= H264_PROFILE_BASELINE)
 276       encoder->level = H264_LEVEL_30;
 277     else
 278       encoder->level = H264_LEVEL_41;
 279   }
 280   if (!encoder->intra_period) {
 281     encoder->intra_period = H264_DEFAULT_INTRA_PERIOD;
 282   }
 283   if (-1 == encoder->init_qp) {
 284     encoder->init_qp = H264_DEFAULT_INIT_QP;
 285   }
 286   if (-1 == encoder->min_qp) {
 287     encoder->min_qp = H264_DEFAULT_MIN_QP;
 288   }
 289
 290   if (encoder->min_qp > encoder->init_qp) {
 291     encoder->min_qp = encoder->init_qp;
 292   }
 293
 294   /* default compress ratio 1: (4*8*1.5) */
 295   if (!encoder->bitrate) {
 296     encoder->bitrate = 0; //ENCODER_WIDTH(encoder)*ENCODER_HEIGHT(encoder)*ENCODER_FPS(encoder)/4;
 297   }
 298
 299   if (!encoder->slice_num) {
 300     encoder->slice_num = H264_DEFAULT_SLICE_NUM;
 301   }
 302
 303   /* need  calculate slice-num and each slice-height
 304         suppose:  ((encoder->height+15)/16) = 13, slice_num = 8
 305         then: slice_1_height = 2
 306                  slice_2_height = 2
 307                  slice_3_height = 2
 308                  slice_4_height = 2
 309                  slice_5_height = 2
 310                  slice_6_height = 1
 311                  slice_7_height = 1
 312                  slice_8_height = 1
 313    */
 314   priv->default_slice_height = (ENCODER_HEIGHT(encoder)+15)/16/encoder->slice_num;
 315   if (0 == priv->default_slice_height) { /* special value */
 316     priv->default_slice_height = 1;
 317     priv->slice_mod_mb_num = 0;
 318     encoder->slice_num = (ENCODER_HEIGHT(encoder)+15)/16;
 319   } else {
 320     priv->slice_mod_mb_num = ((ENCODER_HEIGHT(encoder)+15)/16)%encoder->slice_num;
 321   }
 322
 323   if (encoder->b_frame_num) {
 324     priv->default_cts_offset = GST_SECOND/ENCODER_FPS(encoder);
 325   } else {
 326     priv->default_cts_offset = 0;
 327   }
 328   return TRUE;
 329 }
 330
 331
 332 static gboolean
 333 h264_encoder_release_parameters(GstVaapiEncoderH264 *encoder)
 334 {
 335   VAStatus va_status = VA_STATUS_SUCCESS;
 336   GstVaapiEncoderH264Private *priv = encoder->priv;
 337   GstVaapiDisplay *display = ENCODER_DISPLAY(encoder);
 338   GstVaapiContext *context = ENCODER_CONTEXT(encoder);
 339
 340   gboolean is_locked = FALSE;
 341
 342   ENCODER_ASSERT(display);
 343   ENCODER_ASSERT(context);
 344   VAAPI_UNUSED_ARG(va_status);
 345   VADisplay va_dpy = gst_vaapi_display_get_display(display);
 346
 347   ENCODER_ACQUIRE_DISPLAY_LOCK(display);
 348   if (VA_INVALID_ID != priv->seq_param_id) {
 349     va_status = vaDestroyBuffer(va_dpy, priv->seq_param_id);
 350     priv->seq_param_id = VA_INVALID_ID;
 351   }
 352   if (VA_INVALID_ID != priv->pic_param_id) {
 353     va_status = vaDestroyBuffer(va_dpy, priv->pic_param_id);
 354     priv->pic_param_id = VA_INVALID_ID;
 355   }
 356   if (VA_INVALID_ID != priv->slice_param_id) {
 357     va_status = vaDestroyBuffer(va_dpy, priv->slice_param_id);
 358     priv->slice_param_id = VA_INVALID_ID;
 359   }
 360
 361   if (VA_INVALID_ID != priv->packed_seq_param_id) {
 362     va_status = vaDestroyBuffer(va_dpy, priv->packed_seq_param_id);
 363     priv->packed_seq_param_id = VA_INVALID_ID;
 364   }
 365   if (VA_INVALID_ID != priv->packed_seq_data_id) {
 366     va_status = vaDestroyBuffer(va_dpy, priv->packed_seq_data_id);
 367     priv->packed_seq_data_id = VA_INVALID_ID;
 368   }
 369   if (VA_INVALID_ID != priv->packed_pic_param_id) {
 370     va_status = vaDestroyBuffer(va_dpy, priv->packed_pic_param_id);
 371     priv->packed_pic_param_id = VA_INVALID_ID;
 372   }
 373   if (VA_INVALID_ID != priv->packed_pic_data_id) {
 374     va_status = vaDestroyBuffer(va_dpy, priv->packed_pic_data_id);
 375     priv->packed_pic_data_id = VA_INVALID_ID;
 376   }
 377
 378   ENCODER_RELEASE_DISPLAY_LOCK(display);
 379
 380   if (priv->slice_param_buffers) {
 381     g_free(priv->slice_param_buffers);
 382     priv->slice_param_buffers = NULL;
 383   }
 384
 385   if (priv->sps_data) {
 386     gst_buffer_unref(priv->sps_data);
 387     priv->sps_data = NULL;
 388   }
 389   if (priv->pps_data) {
 390     gst_buffer_unref(priv->pps_data);
 391     priv->pps_data = NULL;
 392   }
 393
 394   return TRUE;
 395 }
 396
 397 static void
 398 h264_release_queued_buffers(GstVaapiEncoderH264Private *priv)
 399 {
 400     while (!g_queue_is_empty(priv->queued_buffers)) {
 401     GstBuffer* tmp = g_queue_pop_head(priv->queued_buffers);
 402     if (tmp)
 403       gst_buffer_unref(tmp);
 404   }
 405 }
 406
 407
 408 static gboolean
 409 gst_vaapi_encoder_h264_release_resource(
 410     GstVaapiBaseEncoder* base
 411 )
 412 {
 413   GstVaapiEncoderH264* encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 414   gboolean ret = TRUE;
 415   GstVaapiEncoderH264Private *priv = encoder->priv;
 416   GstVaapiContext *context = ENCODER_CONTEXT(base);
 417
 418   /* release buffers first */
 419   h264_encoder_release_parameters(encoder);
 420   h264_release_queued_buffers(priv);
 421   priv->cur_display_num = 0;
 422   priv->cur_decode_num = 0;
 423   priv->cur_slice_type = SLICE_TYPE_I;
 424   priv->gop_count = 0;
 425   priv->last_decode_time = 0LL;
 426   priv->default_cts_offset = 0;
 427
 428   /*remove ref_surface1*/
 429   if (priv->ref_surface1) {
 430     if (context) {
 431       gst_vaapi_context_put_surface(context, priv->ref_surface1);
 432     } else {
 433       g_object_unref(priv->ref_surface1);
 434     }
 435     priv->ref_surface1 = NULL;
 436   }
 437
 438   if (priv->ref_surface2) {
 439     if (context) {
 440       gst_vaapi_context_put_surface(context, priv->ref_surface2);
 441     } else {
 442       g_object_unref(priv->ref_surface2);
 443     }
 444     priv->ref_surface2 = NULL;
 445   }
 446
 447   /*remove recon_surface*/
 448   if (priv->recon_surface) {
 449     if (context) {
 450       gst_vaapi_context_put_surface(context, priv->recon_surface);
 451     } else {
 452       g_object_unref(priv->recon_surface);
 453     }
 454     priv->recon_surface = NULL;
 455   }
 456
 457   return ret;
 458 }
 459
 460 static gboolean
 461 gst_vaapi_encoder_h264_alloc_slices(
 462     GstVaapiBaseEncoder *base,
 463     GstVaapiContext *context
 464 )
 465 {
 466   gboolean ret = TRUE;
 467   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 468   GstVaapiEncoderH264Private *priv = encoder->priv;
 469
 470   priv->slice_param_buffers =
 471 #if HAVE_OLD_H264_ENCODER
 472   (VAEncSliceParameterBuffer*)
 473 #else
 474   (VAEncSliceParameterBufferH264*)
 475 #endif
 476           g_malloc0_n(encoder->slice_num,
 477               sizeof(priv->slice_param_buffers[0]));
 478
 479   return ret;
 480 }
 481
 482 static void
 483 gst_vaapi_encoder_h264_frame_failed(
 484     GstVaapiBaseEncoder *base,
 485     GstVaapiVideoBuffer* buffer
 486 )
 487 {
 488   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 489   GstVaapiEncoderH264Private *priv = encoder->priv;
 490
 491   h264_release_queued_buffers(priv);
 492   priv->cur_display_num = 0;
 493   priv->cur_decode_num = 0;
 494   priv->cur_slice_type = SLICE_TYPE_I;
 495   priv->gop_count = 0;
 496   priv->last_decode_time = 0LL;
 497 }
 498
 499 static EncoderStatus
 500 gst_vaapi_encoder_h264_prepare_next_buffer(
 501     GstVaapiBaseEncoder* base,
 502     GstVaapiVideoBuffer *display_buf,
 503     gboolean need_flush,
 504     GstVaapiVideoBuffer **out_buf
 505 )
 506 {
 507   EncoderStatus ret = ENCODER_NO_ERROR;
 508   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
 509   GstVaapiEncoderH264Private *priv = encoder->priv;
 510   GstVaapiVideoBuffer  *return_buf = NULL;
 511   //guint64 pts = 0;
 512
 513   if (NULL == display_buf && g_queue_is_empty(priv->queued_buffers)) {
 514     ret = ENCODER_BUFFER_EMPTY;
 515     if (priv->gop_count >= encoder->intra_period || need_flush)
 516       priv->gop_count = 0;
 517     goto end;
 518   }
 519
 520   if (display_buf) {
 521     ++priv->gop_count;
 522     gst_buffer_ref(GST_BUFFER_CAST(display_buf));
 523     priv->last_decode_time = GST_BUFFER_TIMESTAMP(display_buf);
 524   }
 525
 526   /* first frame */
 527   if (priv->gop_count == 1) {
 528     ENCODER_ASSERT(display_buf);
 529     priv->cur_display_num = 0;
 530     priv->cur_decode_num = 0;
 531     priv->cur_slice_type = SLICE_TYPE_I;
 532     ++priv->idr_num;
 533     return_buf = display_buf;
 534     goto end;
 535   }
 536
 537   if (display_buf) {
 538     if (encoder->b_frame_num &&
 539         priv->gop_count < encoder->intra_period &&
 540         g_queue_get_length(priv->queued_buffers) < encoder->b_frame_num
 541         )
 542     {
 543       g_queue_push_tail(priv->queued_buffers, display_buf);
 544       ret = ENCODER_BUFFER_WAITING;
 545       goto end;
 546     }
 547     priv->cur_slice_type = SLICE_TYPE_P;
 548     priv->cur_display_num = priv->gop_count-1;
 549     ++priv->cur_decode_num;
 550     return_buf = display_buf;
 551   } else {
 552     if (need_flush) {
 553       return_buf = (GstVaapiVideoBuffer*)g_queue_pop_tail(priv->queued_buffers);
 554       priv->cur_slice_type = SLICE_TYPE_P;
 555       priv->cur_display_num = priv->gop_count - 1;
 556       ++priv->cur_decode_num;
 557     } else {
 558       return_buf = (GstVaapiVideoBuffer*)g_queue_pop_head(priv->queued_buffers);
 559       priv->cur_slice_type = SLICE_TYPE_B;
 560       priv->cur_display_num =
 561         priv->gop_count - 2 - g_queue_get_length(priv->queued_buffers);
 562     }
 563   }
 564
 565 end:
 566   *out_buf = return_buf;
 567
 568   return ret;
 569 }
 570
 571 static inline void
 572 h264_swap_surface(GstVaapiSurface **s1, GstVaapiSurface **s2)
 573 {
 574   GstVaapiSurface *tmp;
 575
 576   g_return_if_fail(s1 && s2);
 577   tmp = *s1;
 578   *s1 = *s2;
 579   *s2 = tmp;
 580 }
 581
 582 static inline const char *
 583 get_slice_type(H264_SLICE_TYPE type)
 584 {
 585     switch (type) {
 586     case SLICE_TYPE_I:
 587         return "I";
 588     case SLICE_TYPE_P:
 589         return "P";
 590     case SLICE_TYPE_B:
 591         return "B";
 592     default:
 593         return "Unknown";
 594     }
 595 }
 596
 597 #if HAVE_OLD_H264_ENCODER
 598
 599 static gboolean
 600 set_sequence_parameters(
 601     GstVaapiEncoderH264 *encoder,
 602     VAEncSequenceParameterBufferH264 *seq_param
 603 )
 604 {
 605   seq_param->seq_parameter_set_id = 0;
 606   seq_param->level_idc = encoder->level; /* 3.0 */
 607   seq_param->intra_period = encoder->intra_period;
 608   seq_param->intra_idr_period = encoder->intra_period;
 609   seq_param->max_num_ref_frames = 1; /*Only I, P frames*/
 610   seq_param->picture_width_in_mbs = (ENCODER_WIDTH(encoder)+15)/16;
 611   seq_param->picture_height_in_mbs = (ENCODER_HEIGHT(encoder)+15)/16;
 612
 613   seq_param->bits_per_second = encoder->bitrate;
 614   seq_param->frame_rate = ENCODER_FPS(encoder);
 615   seq_param->initial_qp = encoder->init_qp; /*qp_value; 15, 24, 26?*/
 616   seq_param->min_qp = encoder->min_qp;     /*1, 6, 10*/
 617   seq_param->basic_unit_size = 0;
 618   seq_param->vui_flag = FALSE;
 619
 620   return TRUE;
 621 }
 622
 623 static gboolean
 624 set_picture_parameters(
 625     GstVaapiEncoderH264 *encoder,
 626     VAEncPictureParameterBufferH264 *pic_param,
 627     VABufferID coded_buf
 628 )
 629 {
 630   GstVaapiEncoderH264Private *priv = encoder->priv;
 631
 632   pic_param->reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
 633   pic_param->reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
 634   pic_param->coded_buf = coded_buf;
 635   pic_param->picture_width = ENCODER_WIDTH(encoder);
 636   pic_param->picture_height = ENCODER_HEIGHT(encoder);
 637   pic_param->last_picture = 0; // last pic or not
 638
 639   return TRUE;
 640 }
 641
 642 static gboolean
 643 set_slices_parameters(
 644     GstVaapiEncoderH264 *encoder,
 645     VAEncSliceParameterBuffer *slices,
 646     guint slice_num
 647 )
 648 {
 649   GstVaapiEncoderH264Private *priv = encoder->priv;
 650   VAEncSliceParameterBuffer *slice_param;
 651
 652   int i = 0;
 653   guint32 last_row_num = 0;
 654   guint32 slice_mod_num = priv->slice_mod_mb_num;
 655
 656   for (i = 0; i < slice_num; ++i) {
 657     slice_param = &slices[i];
 658     slice_param->start_row_number = last_row_num;               /* unit MB*/
 659     slice_param->slice_height = priv->default_slice_height; /* unit MB */
 660     if (slice_mod_num) {
 661       ++slice_param->slice_height;
 662       --slice_mod_num;
 663     }
 664     last_row_num += slice_param->slice_height;
 665     slice_param->slice_flags.bits.is_intra =
 666         (priv->cur_slice_type == SLICE_TYPE_I);
 667     slice_param->slice_flags.bits.disable_deblocking_filter_idc = FALSE;
 668     slice_param->slice_flags.bits.uses_long_term_ref = FALSE;
 669     slice_param->slice_flags.bits.is_long_term_ref = FALSE;
 670   }
 671
 672   ENCODER_ASSERT(last_row_num == (ENCODER_HEIGHT(encoder)+15)/16);
 673   return TRUE;
 674 }
 675
 676 #else  /* extended libva, new parameter structures*/
 677
 678 static gboolean
 679 set_sequence_parameters(
 680     GstVaapiEncoderH264 *encoder,
 681     VAEncSequenceParameterBufferH264 *seq_param
 682 )
 683 {
 684   GstVaapiEncoderH264Private *priv = encoder->priv;
 685   guint width_in_mbs, height_in_mbs;
 686
 687   width_in_mbs = (ENCODER_WIDTH(encoder)+15)/16;
 688   height_in_mbs = (ENCODER_HEIGHT(encoder)+15)/16;
 689
 690   seq_param->seq_parameter_set_id = 0;
 691   seq_param->level_idc = encoder->level; /* 3.0 */
 692   seq_param->intra_period = encoder->intra_period;
 693   seq_param->ip_period = 0;           // ?
 694   if (encoder->bitrate> 0)
 695       seq_param->bits_per_second = encoder->bitrate; /* use kbps as input */
 696   else
 697       seq_param->bits_per_second = 0;
 698
 699   seq_param->max_num_ref_frames =
 700       (encoder->b_frame_num < 2 ? 3 : encoder->b_frame_num+1);  // ?, why 4
 701   seq_param->picture_width_in_mbs = width_in_mbs;
 702   seq_param->picture_height_in_mbs = height_in_mbs;
 703
 704   /*sequence field values*/
 705   seq_param->seq_fields.value = 0;
 706   seq_param->seq_fields.bits.chroma_format_idc = 1;
 707   seq_param->seq_fields.bits.frame_mbs_only_flag = 1;
 708   seq_param->seq_fields.bits.mb_adaptive_frame_field_flag = FALSE;
 709   seq_param->seq_fields.bits.seq_scaling_matrix_present_flag = FALSE;
 710   /* direct_8x8_inference_flag default false */
 711   seq_param->seq_fields.bits.direct_8x8_inference_flag = FALSE;
 712   seq_param->seq_fields.bits.log2_max_frame_num_minus4 = 4; // log2(seq.intra_period)-3 : 0
 713   /* picture order count */
 714   seq_param->seq_fields.bits.pic_order_cnt_type = 0;
 715   seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 =
 716         seq_param->seq_fields.bits.log2_max_frame_num_minus4 + 2;
 717   seq_param->seq_fields.bits.delta_pic_order_always_zero_flag = TRUE;
 718
 719   priv->max_frame_num =
 720       1<<(seq_param->seq_fields.bits.log2_max_frame_num_minus4 + 4);
 721   priv->max_pic_order_cnt =
 722       1 <<(seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4);
 723
 724   seq_param->bit_depth_luma_minus8 = 0;
 725   seq_param->bit_depth_chroma_minus8 = 0;
 726
 727   /* not used if pic_order_cnt_type == 0 */
 728   seq_param->num_ref_frames_in_pic_order_cnt_cycle = 0;
 729   seq_param->offset_for_non_ref_pic = 0;
 730   seq_param->offset_for_top_to_bottom_field = 0;
 731   memset(seq_param->offset_for_ref_frame,
 732          0,
 733          sizeof(seq_param->offset_for_ref_frame));
 734
 735   if (height_in_mbs*16 - ENCODER_HEIGHT(encoder)) {
 736     seq_param->frame_cropping_flag = 1;
 737     seq_param->frame_crop_left_offset = 0;
 738     seq_param->frame_crop_right_offset = 0;
 739     seq_param->frame_crop_top_offset = 0;
 740     seq_param->frame_crop_bottom_offset =
 741         ((height_in_mbs * 16 - ENCODER_HEIGHT(encoder))/
 742          (2 * (!seq_param->seq_fields.bits.frame_mbs_only_flag + 1)));
 743   }
 744 #if 0
 745   if (h264_encoder->init_qp == -1)
 746       seq.rate_control_method = BR_CBR;
 747   else if (h264_encoder->init_qp == -2)
 748       seq.rate_control_method = BR_VBR;
 749   else {
 750       ENCODER_ASSERT(h264_encoder->init_qp >= 0 && h264_encoder->init_qp <= 51);
 751       seq.rate_control_method = BR_CQP;
 752   }
 753 #endif
 754
 755   /*vui not set*/
 756   seq_param->vui_parameters_present_flag = FALSE;
 757   return TRUE;
 758 }
 759
 760 static gboolean
 761 ensure_packed_sps_data(
 762     GstVaapiEncoderH264 *encoder,
 763     VAEncSequenceParameterBufferH264 *seq_param
 764 )
 765 {
 766   GstVaapiEncoderH264Private *priv = encoder->priv;
 767   VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 };
 768   VADisplay va_dpy = ENCODER_VA_DISPLAY(encoder);
 769   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
 770   guint32 length_in_bits;
 771   guint8 *packed_seq_buffer = NULL;
 772   H264Bitstream bitstream;
 773   gboolean ret = TRUE;
 774   VAStatus va_status = VA_STATUS_SUCCESS;
 775
 776   if (priv->sps_data)
 777     return TRUE;
 778
 779   h264_bitstream_init(&bitstream, 128*8);
 780   h264_bitstream_write_uint(&bitstream, 0x00000001, 32); /* start code*/
 781   h264_bitstream_write_nal_header(&bitstream, NAL_REF_IDC_HIGH, NAL_SPS);
 782   h264_bitstream_write_sps(&bitstream, seq_param, encoder->profile);
 783   ENCODER_ASSERT(BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
 784   length_in_bits = BIT_STREAM_BIT_SIZE(&bitstream);
 785   packed_seq_buffer = BIT_STREAM_BUFFER(&bitstream);
 786
 787   /* set codec data sps */
 788   priv->sps_data = gst_buffer_new_and_alloc((length_in_bits+7)/8);
 789   GST_BUFFER_SIZE(priv->sps_data) = (length_in_bits+7)/8-4; /* start code size == 4*/
 790   memcpy(GST_BUFFER_DATA(priv->sps_data),
 791          packed_seq_buffer+4,
 792          GST_BUFFER_SIZE(priv->sps_data));
 793
 794   packed_header_param_buffer.type = VAEncPackedHeaderSequence;
 795   packed_header_param_buffer.bit_length = length_in_bits;
 796   packed_header_param_buffer.has_emulation_bytes = 0;
 797   va_status = vaCreateBuffer(va_dpy,
 798                              context_id,
 799                              VAEncPackedHeaderParameterBufferType,
 800                              sizeof(packed_header_param_buffer), 1,
 801                              &packed_header_param_buffer,
 802                              &priv->packed_seq_param_id);
 803   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 804                        FALSE,
 805                        "EncPackedSeqHeaderParameterBuffer failed");
 806   va_status = vaCreateBuffer(va_dpy,
 807                              context_id,
 808                              VAEncPackedHeaderDataBufferType,
 809                              (length_in_bits + 7) / 8, 1,
 810                              packed_seq_buffer,
 811                              &priv->packed_seq_data_id);
 812   h264_bitstream_destroy(&bitstream, TRUE);
 813   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 814                        FALSE,
 815                        "EncPackedSeqHeaderDataBuffer failed");
 816 end:
 817     return ret;
 818
 819 }
 820
 821 static gboolean
 822 set_picture_parameters(
 823     GstVaapiEncoderH264 *encoder,
 824     VAEncPictureParameterBufferH264 *pic_param,
 825     VABufferID coded_buf
 826 )
 827 {
 828   GstVaapiEncoderH264Private *priv = encoder->priv;
 829
 830   pic_param->pic_parameter_set_id = 0;
 831   pic_param->seq_parameter_set_id = 0;
 832   pic_param->last_picture = 0; /* means last encoding picture */
 833   pic_param->frame_num = (priv->cur_slice_type == SLICE_TYPE_B ?
 834                        (priv->cur_decode_num + 1) : priv->cur_decode_num);
 835   //pic_param.coding_type = 0;
 836   pic_param->pic_init_qp = (encoder->init_qp >= 0 ? encoder->init_qp : 26);
 837   pic_param->num_ref_idx_l0_active_minus1 = 0; /* only 1 reference */
 838   pic_param->num_ref_idx_l1_active_minus1 = 0; /* B frames only have 1 backward and 1 forward reference*/
 839   pic_param->chroma_qp_index_offset = 0;
 840   pic_param->second_chroma_qp_index_offset = 0;
 841
 842   /* set picture fields */
 843   pic_param->pic_fields.value = 0;
 844   pic_param->pic_fields.bits.idr_pic_flag = (priv->cur_slice_type == SLICE_TYPE_I);
 845   pic_param->pic_fields.bits.reference_pic_flag = (priv->cur_slice_type != SLICE_TYPE_B);
 846   pic_param->pic_fields.bits.entropy_coding_mode_flag = ENTROPY_MODE_CABAC;
 847   pic_param->pic_fields.bits.weighted_pred_flag = FALSE;
 848   pic_param->pic_fields.bits.weighted_bipred_idc = 0;
 849   pic_param->pic_fields.bits.constrained_intra_pred_flag = 0;
 850   pic_param->pic_fields.bits.transform_8x8_mode_flag = TRUE; /* enable 8x8 */
 851   pic_param->pic_fields.bits.deblocking_filter_control_present_flag = TRUE; /* enable debloking */
 852   pic_param->pic_fields.bits.redundant_pic_cnt_present_flag = FALSE;
 853   /* bottom_field_pic_order_in_frame_present_flag */
 854   pic_param->pic_fields.bits.pic_order_present_flag = FALSE;
 855   pic_param->pic_fields.bits.pic_scaling_matrix_present_flag = FALSE;
 856
 857   /* reference list,  */
 858   pic_param->CurrPic.picture_id = GST_VAAPI_OBJECT_ID(priv->recon_surface);
 859   pic_param->CurrPic.TopFieldOrderCnt = priv->cur_display_num * 2;   // ??? /**/
 860   pic_param->ReferenceFrames[0].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
 861   pic_param->ReferenceFrames[1].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface2);
 862   pic_param->ReferenceFrames[2].picture_id = VA_INVALID_ID;
 863   pic_param->coded_buf = coded_buf;
 864
 865   ENCODER_LOG_INFO("type:%s, frame_num:%d, display_num:%d",
 866     get_slice_type(priv->cur_slice_type),
 867     pic_param->frame_num,
 868     pic_param->CurrPic.TopFieldOrderCnt);
 869   return TRUE;
 870 }
 871
 872 static gboolean
 873 ensure_packed_pps_data(
 874     GstVaapiEncoderH264 *encoder,
 875     VAEncPictureParameterBufferH264 *pic_param
 876 )
 877 {
 878   GstVaapiEncoderH264Private *priv = encoder->priv;
 879   VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 };
 880   H264Bitstream bitstream;
 881   VADisplay va_dpy = ENCODER_VA_DISPLAY(encoder);
 882   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
 883   guint32 length_in_bits;
 884   guint8 *packed_pic_buffer = NULL;
 885   gboolean ret = TRUE;
 886   VAStatus va_status = VA_STATUS_SUCCESS;
 887
 888   if (VA_INVALID_ID != priv->packed_pic_data_id)
 889       return TRUE;
 890
 891   h264_bitstream_init(&bitstream, 128*8);
 892   h264_bitstream_write_uint(&bitstream, 0x00000001, 32); /* start code*/
 893   h264_bitstream_write_nal_header(&bitstream, NAL_REF_IDC_HIGH, NAL_PPS);
 894   h264_bitstream_write_pps(&bitstream, pic_param);
 895   ENCODER_ASSERT(BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
 896   length_in_bits = BIT_STREAM_BIT_SIZE(&bitstream);
 897   packed_pic_buffer = BIT_STREAM_BUFFER(&bitstream);
 898
 899   /*set codec data pps*/
 900   priv->pps_data = gst_buffer_new_and_alloc((length_in_bits+7)/8);
 901   GST_BUFFER_SIZE(priv->pps_data) = (length_in_bits+7)/8-4;
 902   memcpy(GST_BUFFER_DATA(priv->pps_data),
 903          packed_pic_buffer+4,
 904          GST_BUFFER_SIZE(priv->pps_data));
 905
 906   packed_header_param_buffer.type = VAEncPackedHeaderPicture;
 907   packed_header_param_buffer.bit_length = length_in_bits;
 908   packed_header_param_buffer.has_emulation_bytes = 0;
 909
 910   va_status = vaCreateBuffer(va_dpy,
 911                              context_id,
 912                              VAEncPackedHeaderParameterBufferType,
 913                              sizeof(packed_header_param_buffer), 1,
 914                              &packed_header_param_buffer,
 915                              &priv->packed_pic_param_id);
 916   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 917                        FALSE,
 918                        "EncPackedPicHeaderParameterBuffer failed");
 919
 920   va_status = vaCreateBuffer(va_dpy,
 921                              context_id,
 922                              VAEncPackedHeaderDataBufferType,
 923                              (length_in_bits + 7) / 8, 1,
 924                              packed_pic_buffer,
 925                              &priv->packed_pic_data_id);
 926   h264_bitstream_destroy(&bitstream, TRUE);
 927   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
 928                        FALSE,
 929                        "EncPackedPicHeaderDataBuffer failed");
 930 end:
 931   return ret;
 932 }
 933
 934 static gboolean
 935 set_slices_parameters(
 936     GstVaapiEncoderH264 *encoder,
 937     VAEncSliceParameterBufferH264 *slices,
 938     guint slice_num
 939 )
 940 {
 941   GstVaapiEncoderH264Private *priv = encoder->priv;
 942   VAEncSliceParameterBufferH264 *slice_param;
 943
 944   guint width_in_mbs = (ENCODER_WIDTH(encoder)+15)/16;
 945   int i = 0;
 946   guint32 last_row_num = 0;
 947   guint32 slice_mod_num = priv->slice_mod_mb_num;
 948
 949   for (i = 0; i < slice_num; ++i) {
 950     int i_pic = 0;
 951     slice_param = slices + i;
 952
 953     slice_param->macroblock_address = last_row_num*width_in_mbs;
 954     slice_param->num_macroblocks = width_in_mbs*priv->default_slice_height;
 955     last_row_num += priv->default_slice_height;
 956     if (slice_mod_num) {
 957       slice_param->num_macroblocks += width_in_mbs;
 958       ++last_row_num;
 959       --slice_mod_num;
 960     }
 961     slice_param->macroblock_info = VA_INVALID_ID;
 962     slice_param->slice_type = priv->cur_slice_type;
 963     slice_param->pic_parameter_set_id = 0;
 964     slice_param->idr_pic_id = priv->idr_num;
 965     slice_param->pic_order_cnt_lsb =
 966         (priv->cur_display_num*2) % priv->max_pic_order_cnt;
 967
 968     /* not used if pic_order_cnt_type = 0 */
 969     slice_param->delta_pic_order_cnt_bottom = 0;
 970     memset(slice_param->delta_pic_order_cnt,
 971            0,
 972            sizeof(slice_param->delta_pic_order_cnt));
 973
 974     /*only works for B frames*/
 975     slice_param->direct_spatial_mv_pred_flag = FALSE;
 976     /* default equal to picture parameters */
 977     slice_param->num_ref_idx_active_override_flag = FALSE;
 978     slice_param->num_ref_idx_l0_active_minus1 = 0;
 979     slice_param->num_ref_idx_l1_active_minus1 = 0;
 980
 981     slice_param->RefPicList0[0].picture_id =
 982         GST_VAAPI_OBJECT_ID(priv->ref_surface1);
 983     for (i_pic = 1;
 984          i_pic < sizeof(slice_param->RefPicList0)/sizeof(slice_param->RefPicList0[0]);
 985          i_pic++) {
 986       slice_param->RefPicList0[i_pic].picture_id = VA_INVALID_ID;
 987     }
 988
 989     if (SLICE_TYPE_B == priv->cur_slice_type) {
 990       slice_param->RefPicList1[0].picture_id =
 991           GST_VAAPI_OBJECT_ID(priv->ref_surface2);
 992       i_pic = 1;
 993     } else
 994       i_pic = 0;
 995     for (;
 996          i_pic < sizeof(slice_param->RefPicList1)/sizeof(slice_param->RefPicList1[0]);
 997          i_pic++)
 998       slice_param->RefPicList1[i_pic].picture_id = VA_INVALID_ID;
 999
1000     /* not used if  pic_param.pic_fields.bits.weighted_pred_flag == FALSE */
1001     slice_param->luma_log2_weight_denom = 0;
1002     slice_param->chroma_log2_weight_denom = 0;
1003     slice_param->luma_weight_l0_flag = FALSE;
1004     memset(slice_param->luma_weight_l0, 0, sizeof(slice_param->luma_weight_l0));
1005     memset(slice_param->luma_offset_l0, 0, sizeof(slice_param->luma_offset_l0));
1006     slice_param->chroma_weight_l0_flag = FALSE;
1007     memset(slice_param->chroma_weight_l0, 0, sizeof(slice_param->chroma_weight_l0));
1008     memset(slice_param->chroma_offset_l0, 0, sizeof(slice_param->chroma_offset_l0));
1009     slice_param->luma_weight_l1_flag = FALSE;
1010     memset(slice_param->luma_weight_l1, 0, sizeof(slice_param->luma_weight_l1));
1011     memset(slice_param->luma_offset_l1, 0, sizeof(slice_param->luma_offset_l1));
1012     slice_param->chroma_weight_l1_flag = FALSE;
1013     memset(slice_param->chroma_weight_l1, 0, sizeof(slice_param->chroma_weight_l1));
1014     memset(slice_param->chroma_offset_l1, 0, sizeof(slice_param->chroma_offset_l1));
1015
1016     slice_param->cabac_init_idc = 0;
1017     slice_param->slice_qp_delta = 0;
1018     slice_param->disable_deblocking_filter_idc = 0;
1019     slice_param->slice_alpha_c0_offset_div2 = 2;
1020     slice_param->slice_beta_offset_div2 = 2;
1021
1022   }
1023   ENCODER_ASSERT(last_row_num == (ENCODER_HEIGHT(encoder)+15)/16);
1024   return TRUE;
1025 }
1026
1027 #endif
1028
1029 static gboolean
1030 h264_fill_sequence_buffer(GstVaapiEncoderH264 *encoder)
1031 {
1032   GstVaapiEncoderH264Private *priv = encoder->priv;
1033   VAEncSequenceParameterBufferH264 seq_param = { 0 };
1034   VADisplay va_dpy       = ENCODER_VA_DISPLAY(encoder);
1035   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
1036   gboolean ret = TRUE;
1037   VAStatus va_status = VA_STATUS_SUCCESS;
1038
1039   /* only once */
1040   if (VA_INVALID_ID != priv->seq_param_id)
1041     return TRUE;
1042
1043   set_sequence_parameters(encoder, &seq_param);
1044   va_status = vaCreateBuffer(va_dpy, context_id,
1045                              VAEncSequenceParameterBufferType,
1046                              sizeof(seq_param), 1,
1047                              &seq_param, &priv->seq_param_id);
1048   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
1049                        FALSE,
1050                        "alloc seq-buffer failed.");
1051
1052 #if !HAVE_OLD_H264_ENCODER
1053   ensure_packed_sps_data(encoder, &seq_param);
1054 #endif
1055
1056 end:
1057   return ret;
1058 }
1059
1060 static gboolean
1061 h264_fill_picture_buffer(
1062     GstVaapiEncoderH264 *encoder,
1063     VABufferID coded_buf
1064 )
1065 {
1066   GstVaapiEncoderH264Private *priv = encoder->priv;
1067   VAEncPictureParameterBufferH264 pic_param;
1068   VADisplay va_dpy = ENCODER_VA_DISPLAY(encoder);
1069   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
1070   gboolean ret = TRUE;
1071   VAStatus va_status = VA_STATUS_SUCCESS;
1072
1073   VAAPI_UNUSED_ARG(va_status);
1074   memset(&pic_param, 0, sizeof(pic_param));
1075   set_picture_parameters(encoder, &pic_param, coded_buf);
1076
1077   if (VA_INVALID_ID != priv->pic_param_id) { /* share the same pic_param_id*/
1078     vaDestroyBuffer(va_dpy, priv->pic_param_id);
1079     priv->pic_param_id = VA_INVALID_ID;
1080   }
1081   va_status = vaCreateBuffer(va_dpy,
1082                              context_id,
1083                              VAEncPictureParameterBufferType,
1084                              sizeof(pic_param), 1,
1085                              &pic_param,
1086                              &priv->pic_param_id);
1087
1088   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
1089                        FALSE,
1090                        "creating pic-param buffer failed.");
1091 #if !HAVE_OLD_H264_ENCODER
1092   ensure_packed_pps_data(encoder, &pic_param);
1093 #endif
1094
1095 end:
1096   return ret;
1097 }
1098
1099 static gboolean
1100 h264_fill_slice_buffers(
1101     GstVaapiEncoderH264 *encoder
1102 )
1103 {
1104   GstVaapiEncoderH264Private *priv = encoder->priv;
1105   VADisplay va_dpy       = ENCODER_VA_DISPLAY(encoder);
1106   VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
1107   gboolean ret = TRUE;
1108   VAStatus va_status = VA_STATUS_SUCCESS;
1109
1110   memset(priv->slice_param_buffers,
1111          0,
1112          encoder->slice_num * sizeof(priv->slice_param_buffers[0]));
1113   set_slices_parameters(encoder,
1114                         priv->slice_param_buffers,
1115                         encoder->slice_num);
1116
1117   if (VA_INVALID_ID != priv->slice_param_id) {
1118     vaDestroyBuffer(va_dpy, priv->slice_param_id);
1119     priv->slice_param_id = VA_INVALID_ID;
1120   }
1121   va_status = vaCreateBuffer(va_dpy,
1122                              context_id,
1123                              VAEncSliceParameterBufferType,
1124                              sizeof(priv->slice_param_buffers[0]),
1125                              encoder->slice_num,
1126                              priv->slice_param_buffers,
1127                              &priv->slice_param_id);
1128   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
1129                        FALSE,
1130                        "creating slice-parameters buffer failed.");
1131
1132 end:
1133   return ret;
1134 }
1135
1136 static EncoderStatus
1137 gst_vaapi_encoder_h264_rendering(
1138     GstVaapiBaseEncoder *base,
1139     GstVaapiSurface *surface,
1140     guint frame_index,
1141     VABufferID coded_buf,
1142     gboolean *is_key
1143 )
1144 {
1145   EncoderStatus ret = ENCODER_NO_ERROR;
1146   VAStatus va_status = VA_STATUS_SUCCESS;
1147   GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
1148   GstVaapiEncoderH264Private *priv = encoder->priv;
1149   GstVaapiDisplay *display = ENCODER_DISPLAY(base);
1150   GstVaapiContext *context = ENCODER_CONTEXT(base);
1151   VADisplay va_dpy;
1152   VAContextID context_id;
1153   VABufferID va_buffers[64];
1154   guint32    va_buffers_count = 0;
1155   gboolean is_params_ok = TRUE;
1156   gboolean is_locked = FALSE;
1157
1158   ENCODER_ASSERT(context);
1159
1160   va_dpy = ENCODER_VA_DISPLAY(base);
1161   context_id = ENCODER_VA_CONTEXT(base);
1162
1163   *is_key = (priv->cur_slice_type == SLICE_TYPE_I);
1164
1165   if (!priv->ref_surface1) {
1166     priv->ref_surface1 = gst_vaapi_context_get_surface(context);
1167     ENCODER_CHECK_STATUS(priv->ref_surface1,
1168                          ENCODER_SURFACE_ERR,
1169                          "reference surface, h264_pop_free_surface failed.");
1170   }
1171   if (!priv->ref_surface2) {
1172     priv->ref_surface2 = gst_vaapi_context_get_surface(context);
1173     ENCODER_CHECK_STATUS(priv->ref_surface2,
1174                          ENCODER_SURFACE_ERR,
1175                          "reference surface, h264_pop_free_surface failed.");
1176   }
1177   if (!priv->recon_surface) {
1178     priv->recon_surface = gst_vaapi_context_get_surface(context);
1179     ENCODER_CHECK_STATUS(priv->recon_surface,
1180                          ENCODER_SURFACE_ERR,
1181                          "reconstructed surface, h264_pop_free_surface failed.");
1182   }
1183
1184   if (SLICE_TYPE_P == priv->cur_slice_type) {
1185     h264_swap_surface(&priv->ref_surface1, &priv->ref_surface2);
1186   }
1187
1188   /* fill sequence parameters, need set every time */
1189   is_params_ok = h264_fill_sequence_buffer(encoder);
1190   ENCODER_CHECK_STATUS(is_params_ok,
1191                        ENCODER_PARAMETER_ERR,
1192                        "h264_recreate_seq_param failed");
1193   /* set pic_parameters*/
1194   is_params_ok = h264_fill_picture_buffer(encoder, coded_buf);
1195   ENCODER_CHECK_STATUS(is_params_ok,
1196                        ENCODER_PARAMETER_ERR,
1197                        "h264_recreate_pic_param failed");
1198   /* set slice parameters, support multiple slices */
1199   is_params_ok = h264_fill_slice_buffers(encoder);
1200   ENCODER_CHECK_STATUS(is_params_ok,
1201                        ENCODER_PARAMETER_ERR,
1202                        "h264_recreate_slice_param failed");
1203
1204   /* lock display */
1205   ENCODER_ACQUIRE_DISPLAY_LOCK(display);
1206
1207   /*render all buffers*/
1208   if (VA_INVALID_ID != priv->seq_param_id) {
1209     va_buffers[va_buffers_count++] = priv->seq_param_id;
1210   }
1211   if (VA_INVALID_ID != priv->pic_param_id) {
1212     va_buffers[va_buffers_count++] = priv->pic_param_id;
1213   }
1214   if (VA_INVALID_ID != priv->slice_param_id) {
1215     va_buffers[va_buffers_count++] = priv->slice_param_id;
1216   }
1217   if (SLICE_TYPE_I == priv->cur_slice_type) {
1218     if (VA_INVALID_ID != priv->packed_seq_param_id) {
1219       va_buffers[va_buffers_count++] = priv->packed_seq_param_id;
1220     }
1221     if (VA_INVALID_ID != priv->packed_seq_data_id) {
1222       va_buffers[va_buffers_count++] = priv->packed_seq_data_id;
1223     }
1224     if (VA_INVALID_ID != priv->packed_pic_param_id) {
1225       va_buffers[va_buffers_count++] = priv->packed_pic_param_id;
1226     }
1227     if (VA_INVALID_ID != priv->packed_pic_data_id) {
1228       va_buffers[va_buffers_count++] = priv->packed_pic_data_id;
1229     }
1230   }
1231
1232   va_status = vaRenderPicture(va_dpy,
1233                               context_id,
1234                               va_buffers,
1235                               va_buffers_count);
1236   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
1237                        ENCODER_PICTURE_ERR,
1238                        "vaRenderH264Picture failed.");
1239
1240   /*after finished,  swap  recon and surface2*/
1241   if (SLICE_TYPE_P == priv->cur_slice_type ||
1242       SLICE_TYPE_I == priv->cur_slice_type) {
1243     h264_swap_surface(&priv->recon_surface, &priv->ref_surface2);
1244   }
1245
1246   end:
1247   ENCODER_RELEASE_DISPLAY_LOCK(display);
1248   return ret;
1249 }
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 #if !HAVE_OLD_H264_ENCODER
1841
1842 static gboolean
1843 h264_bitstream_write_sps(
1844     H264Bitstream *bitstream,
1845     VAEncSequenceParameterBufferH264 *seq,
1846     H264_Profile profile
1847 )
1848 {
1849   guint32 constraint_set0_flag, constraint_set1_flag;
1850   guint32 constraint_set2_flag, constraint_set3_flag;
1851   guint32 gaps_in_frame_num_value_allowed_flag = 0; // ??
1852
1853   guint32 b_qpprime_y_zero_transform_bypass = 0;
1854   guint32 residual_color_transform_flag = 0;
1855   guint32 pic_height_in_map_units =
1856     (seq->seq_fields.bits.frame_mbs_only_flag ?
1857      seq->picture_height_in_mbs :
1858      seq->picture_height_in_mbs/2);
1859   guint32 mb_adaptive_frame_field = !seq->seq_fields.bits.frame_mbs_only_flag;
1860   guint32 i = 0;
1861
1862   constraint_set0_flag = profile == H264_PROFILE_BASELINE;
1863   constraint_set1_flag = profile <= H264_PROFILE_MAIN;
1864   constraint_set2_flag = 0;
1865   constraint_set3_flag = 0;
1866
1867   /* profile_idc */
1868   h264_bitstream_write_uint(bitstream, profile, 8);
1869   /* constraint_set0_flag */
1870   h264_bitstream_write_uint(bitstream, constraint_set0_flag, 1);
1871   /* constraint_set1_flag */
1872   h264_bitstream_write_uint(bitstream, constraint_set1_flag, 1);
1873   /* constraint_set2_flag */
1874   h264_bitstream_write_uint(bitstream, constraint_set2_flag, 1);
1875   /* constraint_set3_flag */
1876   h264_bitstream_write_uint(bitstream, constraint_set3_flag, 1);
1877   /* reserved_zero_4bits */
1878   h264_bitstream_write_uint(bitstream, 0, 4);
1879   /* level_idc */
1880   h264_bitstream_write_uint(bitstream, seq->level_idc, 8);
1881   /* seq_parameter_set_id */
1882   h264_bitstream_write_ue(bitstream, seq->seq_parameter_set_id);
1883
1884   if (profile >= H264_PROFILE_HIGH) {
1885     /* for high profile */
1886     ENCODER_ASSERT(0);
1887     /* chroma_format_idc  = 1, 4:2:0*/
1888     h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.chroma_format_idc);
1889     if (3 == seq->seq_fields.bits.chroma_format_idc) {
1890       h264_bitstream_write_uint(bitstream, residual_color_transform_flag, 1);
1891     }
1892     /* bit_depth_luma_minus8 */
1893     h264_bitstream_write_ue(bitstream, seq->bit_depth_luma_minus8);
1894     /* bit_depth_chroma_minus8 */
1895     h264_bitstream_write_ue(bitstream, seq->bit_depth_chroma_minus8);
1896     /* b_qpprime_y_zero_transform_bypass */
1897     h264_bitstream_write_uint(bitstream, b_qpprime_y_zero_transform_bypass, 1);
1898     ENCODER_ASSERT(seq->seq_fields.bits.seq_scaling_matrix_present_flag == 0);
1899     /*seq_scaling_matrix_present_flag  */
1900     h264_bitstream_write_uint(bitstream,
1901                               seq->seq_fields.bits.seq_scaling_matrix_present_flag,
1902                               1);
1903
1904     #if 0
1905     if (seq->seq_fields.bits.seq_scaling_matrix_present_flag) {
1906       for (i = 0; i < (seq->seq_fields.bits.chroma_format_idc != 3 ? 8 : 12); i++) {
1907         h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.seq_scaling_list_present_flag, 1);
1908         if (seq->seq_fields.bits.seq_scaling_list_present_flag) {
1909           ENCODER_ASSERT(0);
1910           /* FIXME, need write scaling list if seq_scaling_matrix_present_flag ==1*/
1911         }
1912       }
1913     }
1914     #endif
1915   }
1916
1917   /* log2_max_frame_num_minus4 */
1918   h264_bitstream_write_ue(bitstream,
1919                           seq->seq_fields.bits.log2_max_frame_num_minus4);
1920   /* pic_order_cnt_type */
1921   h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.pic_order_cnt_type);
1922
1923   if (seq->seq_fields.bits.pic_order_cnt_type == 0) {
1924     /* log2_max_pic_order_cnt_lsb_minus4 */
1925     h264_bitstream_write_ue(bitstream,
1926                             seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);
1927   } else if (seq->seq_fields.bits.pic_order_cnt_type == 1) {
1928     ENCODER_ASSERT(0);
1929     h264_bitstream_write_uint(bitstream,
1930                               seq->seq_fields.bits.delta_pic_order_always_zero_flag,
1931                               1);
1932     h264_bitstream_write_se(bitstream, seq->offset_for_non_ref_pic);
1933     h264_bitstream_write_se(bitstream,
1934                             seq->offset_for_top_to_bottom_field);
1935     h264_bitstream_write_ue(bitstream,
1936                             seq->num_ref_frames_in_pic_order_cnt_cycle);
1937     for ( i = 0; i < seq->num_ref_frames_in_pic_order_cnt_cycle; i++) {
1938       h264_bitstream_write_se(bitstream, seq->offset_for_ref_frame[i]);
1939     }
1940   }
1941
1942   /* num_ref_frames */
1943   h264_bitstream_write_ue(bitstream, seq->max_num_ref_frames);
1944   /* gaps_in_frame_num_value_allowed_flag */
1945   h264_bitstream_write_uint(bitstream,
1946                             gaps_in_frame_num_value_allowed_flag,
1947                             1);
1948
1949   /* pic_width_in_mbs_minus1 */
1950   h264_bitstream_write_ue(bitstream, seq->picture_width_in_mbs - 1);
1951   /* pic_height_in_map_units_minus1 */
1952   h264_bitstream_write_ue(bitstream, pic_height_in_map_units - 1);
1953   /* frame_mbs_only_flag */
1954   h264_bitstream_write_uint(bitstream,
1955                             seq->seq_fields.bits.frame_mbs_only_flag,
1956                             1);
1957
1958   if (!seq->seq_fields.bits.frame_mbs_only_flag) { //ONLY mbs
1959       ENCODER_ASSERT(0);
1960       h264_bitstream_write_uint(bitstream, mb_adaptive_frame_field, 1);
1961   }
1962
1963   /* direct_8x8_inference_flag */
1964   h264_bitstream_write_uint(bitstream, 0, 1);
1965   /* frame_cropping_flag */
1966   h264_bitstream_write_uint(bitstream, seq->frame_cropping_flag, 1);
1967
1968   if (seq->frame_cropping_flag) {
1969       /* frame_crop_left_offset */
1970       h264_bitstream_write_ue(bitstream, seq->frame_crop_left_offset);
1971       /* frame_crop_right_offset */
1972       h264_bitstream_write_ue(bitstream, seq->frame_crop_right_offset);
1973       /* frame_crop_top_offset */
1974       h264_bitstream_write_ue(bitstream, seq->frame_crop_top_offset);
1975       /* frame_crop_bottom_offset */
1976       h264_bitstream_write_ue(bitstream, seq->frame_crop_bottom_offset);
1977   }
1978   ENCODER_ASSERT(seq->vui_parameters_present_flag == FALSE);
1979
1980   /* vui_parameters_present_flag */
1981   h264_bitstream_write_uint(bitstream, seq->vui_parameters_present_flag, 1);
1982   if (seq->vui_parameters_present_flag) {
1983     /*FIXME, to write vui parameters*/
1984   }
1985   /* rbsp_trailing_bits */
1986   h264_bitstream_write_trailing_bits(bitstream);
1987   return TRUE;
1988 }
1989
1990 static gboolean
1991 h264_bitstream_write_pps(
1992     H264Bitstream *bitstream,
1993     VAEncPictureParameterBufferH264 *pic
1994 )
1995 {
1996   guint32 num_slice_groups_minus1 = 0;
1997   guint32 pic_init_qs_minus26 = 0;
1998   guint32 redundant_pic_cnt_present_flag = 0;
1999
2000   /* pic_parameter_set_id */
2001   h264_bitstream_write_ue(bitstream, pic->pic_parameter_set_id);
2002   /* seq_parameter_set_id */
2003   h264_bitstream_write_ue(bitstream, pic->seq_parameter_set_id);
2004   /* entropy_coding_mode_flag */
2005   h264_bitstream_write_uint(bitstream,
2006                             pic->pic_fields.bits.entropy_coding_mode_flag,
2007                             1);
2008   /* pic_order_present_flag */
2009   h264_bitstream_write_uint(bitstream,
2010                             pic->pic_fields.bits.pic_order_present_flag,
2011                             1);
2012   /*slice_groups-1*/
2013   h264_bitstream_write_ue(bitstream, num_slice_groups_minus1);
2014
2015   if (num_slice_groups_minus1 > 0) {
2016     /*FIXME*/
2017     ENCODER_ASSERT(0);
2018   }
2019   h264_bitstream_write_ue(bitstream, pic->num_ref_idx_l0_active_minus1);
2020   h264_bitstream_write_ue(bitstream, pic->num_ref_idx_l1_active_minus1);
2021   h264_bitstream_write_uint(bitstream,
2022                             pic->pic_fields.bits.weighted_pred_flag,
2023                             1);
2024   h264_bitstream_write_uint(bitstream,
2025                             pic->pic_fields.bits.weighted_bipred_idc,
2026                             2);
2027   /* pic_init_qp_minus26 */
2028   h264_bitstream_write_se(bitstream, pic->pic_init_qp-26);
2029   /* pic_init_qs_minus26 */
2030   h264_bitstream_write_se(bitstream, pic_init_qs_minus26);
2031   /*chroma_qp_index_offset*/
2032   h264_bitstream_write_se(bitstream, pic->chroma_qp_index_offset);
2033
2034   h264_bitstream_write_uint(bitstream,
2035                             pic->pic_fields.bits.deblocking_filter_control_present_flag,
2036                             1);
2037   h264_bitstream_write_uint(bitstream,
2038                             pic->pic_fields.bits.constrained_intra_pred_flag,
2039                             1);
2040   h264_bitstream_write_uint(bitstream, redundant_pic_cnt_present_flag, 1);
2041
2042   /*more_rbsp_data*/
2043   h264_bitstream_write_uint(bitstream,
2044                             pic->pic_fields.bits.transform_8x8_mode_flag,
2045                             1);
2046   h264_bitstream_write_uint(bitstream,
2047                             pic->pic_fields.bits.pic_scaling_matrix_present_flag,
2048                             1);
2049   if (pic->pic_fields.bits.pic_scaling_matrix_present_flag) {
2050     ENCODER_ASSERT(0);
2051     /* FIXME */
2052     /*
2053     for (i = 0; i <
2054       (6+(-( (chroma_format_idc ! = 3) ? 2 : 6) * -pic->pic_fields.bits.transform_8x8_mode_flag));
2055       i++) {
2056       h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.pic_scaling_list_present_flag, 1);
2057     }
2058     */
2059   }
2060
2061   h264_bitstream_write_se(bitstream, pic->second_chroma_qp_index_offset);
2062   h264_bitstream_write_trailing_bits(bitstream);
2063   return TRUE;
2064 }
2065 #endif