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