diff --git a/videoencoder/Android.mk b/videoencoder/Android.mk
index bf29710..af21f9f 100644
--- a/videoencoder/Android.mk
+++ b/videoencoder/Android.mk
@@ -46,6 +46,10 @@
 LOCAL_CPPFLAGS += -DVIDEO_ENC_STATISTICS_ENABLE
 endif
 
+ifeq ($(REF_PRODUCT_NAME),baylake)
+    LOCAL_C_FLAGS += -DBAYLAKE
+endif
+
 LOCAL_MODULE_TAGS := optional
 LOCAL_MODULE := libva_videoencoder
 
diff --git a/videoencoder/VideoEncoderAVC.cpp b/videoencoder/VideoEncoderAVC.cpp
index 0f4d84b..ea1d3f9 100644
--- a/videoencoder/VideoEncoderAVC.cpp
+++ b/videoencoder/VideoEncoderAVC.cpp
@@ -12,6 +12,7 @@
 #include "VideoEncoderAVC.h"
 #include <va/va_tpi.h>
 #include <va/va_enc_h264.h>
+#include <bitstream.h>
 
 VideoEncoderAVC::VideoEncoderAVC()
     :VideoEncoderBase() {
@@ -38,6 +39,13 @@
     mVideoParamsAVC.SAR.SarWidth = 0;
     mVideoParamsAVC.SAR.SarHeight = 0;
     mAutoReferenceSurfaceNum = 4;
+
+    packed_seq_header_param_buf_id = VA_INVALID_ID;
+    packed_seq_buf_id = VA_INVALID_ID;
+    packed_pic_header_param_buf_id = VA_INVALID_ID;
+    packed_pic_buf_id = VA_INVALID_ID;
+    packed_sei_header_param_buf_id = VA_INVALID_ID;   /* the SEI buffer */
+    packed_sei_buf_id = VA_INVALID_ID;
 }
 
 Encode_Status VideoEncoderAVC::start() {
@@ -627,7 +635,6 @@
     Encode_Status ret = ENCODE_SUCCESS;
 
     LOG_V( "Begin\n");
-
     if (mFrameNum == 0 || mNewHeader) {
 
         if (mRenderHrd) {
@@ -675,6 +682,14 @@
     ret = renderPictureParams(task);
     CHECK_ENCODE_STATUS_RETURN("renderPictureParams");
 
+    if (mFrameNum == 0 && (mEncPackedHeaders != VA_ATTRIB_NOT_SUPPORTED)) {
+        ret = renderPackedSequenceParams(task);
+        CHECK_ENCODE_STATUS_RETURN("renderPackedSequenceParams");
+
+        ret = renderPackedPictureParams(task);
+        CHECK_ENCODE_STATUS_RETURN("renderPackedPictureParams");
+    }
+
     ret = renderSliceParams(task);
     CHECK_ENCODE_STATUS_RETURN("renderSliceParams");
 
@@ -846,7 +861,7 @@
     avcSeqParams.intra_period = mComParams.intraPeriod;
     //avcSeqParams.vui_flag = 248;
     avcSeqParams.vui_parameters_present_flag = mVideoParamsAVC.VUIFlag;
-    avcSeqParams.seq_parameter_set_id = 8;
+    avcSeqParams.seq_parameter_set_id = 0;
     if (mVideoParamsAVC.crop.LeftOffset ||
             mVideoParamsAVC.crop.RightOffset ||
             mVideoParamsAVC.crop.TopOffset ||
@@ -880,7 +895,9 @@
     }
 
     // This is a temporary fix suggested by Binglin for bad encoding quality issue
-    avcSeqParams.max_num_ref_frames = 1; 
+    avcSeqParams.max_num_ref_frames = (mEncMaxRefFrames != VA_ATTRIB_NOT_SUPPORTED) ?
+        mEncMaxRefFrames : 1;
+
     if(avcSeqParams.ip_period > 1)
         avcSeqParams.max_num_ref_frames = 2; 
 
@@ -897,6 +914,17 @@
     LOG_I( "min_qp = %d\n", rcMiscParam->min_qp);
     LOG_I( "basic_unit_size = %d\n", rcMiscParam->basic_unit_size);
 
+    // Not sure whether these settings work for all drivers
+    avcSeqParams.seq_fields.bits.frame_mbs_only_flag = 1;
+    avcSeqParams.seq_fields.bits.pic_order_cnt_type = 0;
+    avcSeqParams.seq_fields.bits.direct_8x8_inference_flag = 0;
+
+    avcSeqParams.seq_fields.bits.log2_max_frame_num_minus4 = 0;
+    avcSeqParams.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = 2;
+    avcSeqParams.time_scale = 900;
+    avcSeqParams.num_units_in_tick = 15;			/* Tc = num_units_in_tick / time_sacle */
+    // Not sure whether these settings work for all drivers
+
     vaStatus = vaUnmapBuffer(mVADisplay, mRcParamBuf);
     CHECK_VA_STATUS_RETURN("vaUnmapBuffer");
     vaStatus = vaUnmapBuffer(mVADisplay, mFrameRateParamBuf);
@@ -917,21 +945,93 @@
     return ENCODE_SUCCESS;
 }
 
+Encode_Status VideoEncoderAVC::renderPackedSequenceParams(EncodeTask *task) {
+
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    VAEncSequenceParameterBufferH264 *avcSeqParams;
+    VAEncPackedHeaderParameterBuffer packed_header_param_buffer;
+    unsigned char *packed_seq_buffer = NULL;
+    unsigned int length_in_bits, offset_in_bytes;
+
+    vaStatus = vaMapBuffer(mVADisplay, mSeqParamBuf, (void **)&avcSeqParams);
+    CHECK_VA_STATUS_RETURN("vaMapBuffer");
+
+    length_in_bits = build_packed_seq_buffer(&packed_seq_buffer, mComParams.profile, avcSeqParams);
+    packed_header_param_buffer.type = VAEncPackedHeaderSequence;
+    packed_header_param_buffer.bit_length = length_in_bits;
+    packed_header_param_buffer.has_emulation_bytes = 0;
+    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
+            VAEncPackedHeaderParameterBufferType,
+            sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
+            &packed_seq_header_param_buf_id);
+    CHECK_VA_STATUS_RETURN("vaCreateBuffer");
+
+    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
+            VAEncPackedHeaderDataBufferType,
+            (length_in_bits + 7) / 8, 1, packed_seq_buffer,
+            &packed_seq_buf_id);
+    CHECK_VA_STATUS_RETURN("vaCreateBuffer");
+
+    vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_seq_header_param_buf_id, 1);
+    CHECK_VA_STATUS_RETURN("vaRenderPicture");
+
+    vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_seq_buf_id, 1);
+    CHECK_VA_STATUS_RETURN("vaRenderPicture");
+
+    vaStatus = vaUnmapBuffer(mVADisplay, mSeqParamBuf);
+    CHECK_VA_STATUS_RETURN("vaUnmapBuffer");
+
+    free(packed_seq_buffer);
+    return vaStatus;
+}
 
 Encode_Status VideoEncoderAVC::renderPictureParams(EncodeTask *task) {
 
     VAStatus vaStatus = VA_STATUS_SUCCESS;
     VAEncPictureParameterBufferH264 avcPicParams = {};
+    uint32_t RefFrmIdx;
 
     LOG_V( "Begin\n\n");
     // set picture params for HW
-    if(mAutoReference == false){
+    if (mAutoReference == false) {
+        for (RefFrmIdx = 0; RefFrmIdx < 16; RefFrmIdx++) {
+            avcPicParams.ReferenceFrames[RefFrmIdx].picture_id = VA_INVALID_ID;
+            avcPicParams.ReferenceFrames[RefFrmIdx].flags = VA_PICTURE_H264_INVALID;
+        }
         avcPicParams.ReferenceFrames[0].picture_id= task->ref_surface;
+        avcPicParams.ReferenceFrames[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
         avcPicParams.CurrPic.picture_id= task->rec_surface;
+        // Not sure whether these settings work for all drivers
+        avcPicParams.CurrPic.TopFieldOrderCnt = mFrameNum * 2;
+
+        avcPicParams.pic_fields.bits.transform_8x8_mode_flag = 0;
+        avcPicParams.seq_parameter_set_id = 0;
+        avcPicParams.pic_parameter_set_id = 0;
+
+        avcPicParams.last_picture = 0;
+        avcPicParams.frame_num = 0;
+
+        avcPicParams.pic_init_qp = 26;
+        avcPicParams.num_ref_idx_l0_active_minus1 = 0;
+        avcPicParams.num_ref_idx_l1_active_minus1 = 0;
+
+        avcPicParams.pic_fields.bits.idr_pic_flag = 0;
+        avcPicParams.pic_fields.bits.reference_pic_flag = 0;
+        avcPicParams.pic_fields.bits.entropy_coding_mode_flag = 1;
+        avcPicParams.pic_fields.bits.weighted_pred_flag = 0;
+        avcPicParams.pic_fields.bits.weighted_bipred_idc = 0;
+        avcPicParams.pic_fields.bits.transform_8x8_mode_flag = 0;
+        avcPicParams.pic_fields.bits.deblocking_filter_control_present_flag = 1;
+
+        avcPicParams.frame_num = mFrameNum;
+        avcPicParams.pic_fields.bits.idr_pic_flag = (mFrameNum == 0);
+        avcPicParams.pic_fields.bits.reference_pic_flag = 1;
+        // Not sure whether these settings work for all drivers
     }else {
         for(int i =0; i< mAutoReferenceSurfaceNum; i++)
             avcPicParams.ReferenceFrames[i].picture_id = mAutoRefSurfaces[i];
     }
+
     avcPicParams.coded_buf = task->coded_buffer;
     avcPicParams.last_picture = 0;
 
@@ -957,6 +1057,45 @@
     return ENCODE_SUCCESS;
 }
 
+Encode_Status VideoEncoderAVC::renderPackedPictureParams(EncodeTask *task) {
+
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    VAEncPictureParameterBufferH264 *avcPicParams;
+    VAEncPackedHeaderParameterBuffer packed_header_param_buffer;
+    unsigned char *packed_pic_buffer = NULL;
+    unsigned int length_in_bits, offset_in_bytes;
+
+    vaStatus = vaMapBuffer(mVADisplay, mPicParamBuf, (void **)&avcPicParams);
+    CHECK_VA_STATUS_RETURN("vaMapBuffer");
+
+    length_in_bits = build_packed_pic_buffer(&packed_pic_buffer, avcPicParams);
+    packed_header_param_buffer.type = VAEncPackedHeaderPicture;
+    packed_header_param_buffer.bit_length = length_in_bits;
+    packed_header_param_buffer.has_emulation_bytes = 0;
+    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
+            VAEncPackedHeaderParameterBufferType,
+            sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
+            &packed_pic_header_param_buf_id);
+    CHECK_VA_STATUS_RETURN("vaCreateBuffer");
+
+    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
+            VAEncPackedHeaderDataBufferType,
+            (length_in_bits + 7) / 8, 1, packed_pic_buffer,
+            &packed_pic_buf_id);
+    CHECK_VA_STATUS_RETURN("vaCreateBuffer");
+
+    vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_pic_header_param_buf_id, 1);
+    CHECK_VA_STATUS_RETURN("vaRenderPicture");
+
+    vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_pic_buf_id, 1);
+    CHECK_VA_STATUS_RETURN("vaRenderPicture");
+
+    vaStatus = vaUnmapBuffer(mVADisplay, mSeqParamBuf);
+    CHECK_VA_STATUS_RETURN("vaUnmapBuffer");
+
+    free(packed_pic_buffer);
+    return vaStatus;
+}
 
 Encode_Status VideoEncoderAVC::renderSliceParams(EncodeTask *task) {
 
@@ -970,6 +1109,7 @@
     uint32_t actualSliceHeightInMB = 0;
     uint32_t startRowInMB = 0;
     uint32_t modulus = 0;
+    uint32_t RefFrmIdx;
 
     LOG_V( "Begin\n\n");
 
@@ -1047,6 +1187,26 @@
         LOG_I( "slice.type = %d\n", (int) currentSlice->slice_type);
         LOG_I("disable_deblocking_filter_idc = %d\n\n", (int) currentSlice->disable_deblocking_filter_idc);
 
+        // Not sure whether these settings work for all drivers
+        currentSlice->pic_parameter_set_id = 0;
+        currentSlice->pic_order_cnt_lsb = mFrameNum * 2;
+        currentSlice->direct_spatial_mv_pred_flag = 0;
+        currentSlice->num_ref_idx_l0_active_minus1 = 0;      /* FIXME: ??? */
+        currentSlice->num_ref_idx_l1_active_minus1 = 0;
+        currentSlice->cabac_init_idc = 0;
+        currentSlice->slice_qp_delta = 0;
+        currentSlice->disable_deblocking_filter_idc = 0;
+        currentSlice->slice_alpha_c0_offset_div2 = 2;
+        currentSlice->slice_beta_offset_div2 = 2;
+        currentSlice->idr_pic_id = 0;
+        for (RefFrmIdx = 0; RefFrmIdx < 32; RefFrmIdx++) {
+            currentSlice->RefPicList0[RefFrmIdx].picture_id = VA_INVALID_ID;
+            currentSlice->RefPicList0[RefFrmIdx].flags = VA_PICTURE_H264_INVALID;
+        }
+        currentSlice->RefPicList0[0].picture_id = task->ref_surface;
+        currentSlice->RefPicList0[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
+        // Not sure whether these settings work for all drivers
+
         startRowInMB += actualSliceHeightInMB;
     }
 
diff --git a/videoencoder/VideoEncoderAVC.h b/videoencoder/VideoEncoderAVC.h
index 1248a3e..f33755b 100644
--- a/videoencoder/VideoEncoderAVC.h
+++ b/videoencoder/VideoEncoderAVC.h
@@ -44,11 +44,19 @@
     Encode_Status renderPictureParams(EncodeTask *task);
     Encode_Status renderSliceParams(EncodeTask *task);
     int calcLevel(int numMbs);
+    Encode_Status renderPackedSequenceParams(EncodeTask *task);
+    Encode_Status renderPackedPictureParams(EncodeTask *task);
 
 public:
 
     VideoParamsAVC mVideoParamsAVC;
     uint32_t mSliceNum;
+    VABufferID packed_seq_header_param_buf_id;
+    VABufferID packed_seq_buf_id;
+    VABufferID packed_pic_header_param_buf_id;
+    VABufferID packed_pic_buf_id;
+    VABufferID packed_sei_header_param_buf_id;   /* the SEI buffer */
+    VABufferID packed_sei_buf_id;
 
 };
 
diff --git a/videoencoder/VideoEncoderBase.cpp b/videoencoder/VideoEncoderBase.cpp
index 3442958..64f5a02 100644
--- a/videoencoder/VideoEncoderBase.cpp
+++ b/videoencoder/VideoEncoderBase.cpp
@@ -120,10 +120,20 @@
 
     queryAutoReferenceConfig(mComParams.profile);
 
-    VAConfigAttrib vaAttrib[3];
+    VAConfigAttrib vaAttrib[5];
     vaAttrib[0].type = VAConfigAttribRTFormat;
     vaAttrib[1].type = VAConfigAttribRateControl;
     vaAttrib[2].type = VAConfigAttribEncAutoReference;
+    vaAttrib[3].type = VAConfigAttribEncPackedHeaders;
+    vaAttrib[4].type = VAConfigAttribEncMaxRefFrames;
+
+    vaStatus = vaGetConfigAttributes(mVADisplay, mComParams.profile,
+            VAEntrypointEncSlice, &vaAttrib[0], 5);
+    CHECK_VA_STATUS_RETURN("vaGetConfigAttributes");
+
+    mEncPackedHeaders = vaAttrib[3].value;
+    mEncMaxRefFrames = vaAttrib[4].value;
+
     vaAttrib[0].value = VA_RT_FORMAT_YUV420;
     vaAttrib[1].value = mComParams.rcMode;
     vaAttrib[2].value = mAutoReference ? 1 : VA_ATTRIB_NOT_SUPPORTED;
@@ -220,13 +230,12 @@
     vaStatus = vaCreateContext(mVADisplay, mVAConfig,
             mComParams.resolution.width,
             mComParams.resolution.height,
-            0, contextSurfaces, contextSurfaceCnt,
+            VA_PROGRESSIVE, contextSurfaces, contextSurfaceCnt,
             &(mVAContext));
+    CHECK_VA_STATUS_RETURN("vaCreateContext");
 
     delete [] contextSurfaces;
 
-    CHECK_VA_STATUS_RETURN("vaCreateContext");
-
     LOG_I("Success to create libva context width %d, height %d\n",
           mComParams.resolution.width, mComParams.resolution.height);
 
@@ -1302,13 +1311,11 @@
     SurfaceMap *map = NULL;
 
     LOG_V( "Begin\n");
-
     // If encode session has been configured, we can not request surface creation anymore
     if (mStarted) {
         LOG_E( "Already Initialized, can not request VA surface anymore\n");
         return ENCODE_WRONG_STATE;
     }
-
     if (width<=0 || height<=0 ||outsize == NULL ||stride == NULL || usrptr == NULL) {
         LOG_E("width<=0 || height<=0 || outsize == NULL || stride == NULL ||usrptr == NULL\n");
         return ENCODE_NULL_PTR;
@@ -1333,7 +1340,7 @@
     attribute_tpi.pixel_format = VA_FOURCC_NV12;
     attribute_tpi.type = VAExternalMemoryNULL;
 
-    vaCreateSurfacesWithAttribute(mVADisplay, width, height, VA_RT_FORMAT_YUV420,
+    vaStatus = vaCreateSurfacesWithAttribute(mVADisplay, width, height, VA_RT_FORMAT_YUV420,
             1, &surface, &attribute_tpi);
     CHECK_VA_STATUS_RETURN("vaCreateSurfacesWithAttribute");
 
diff --git a/videoencoder/VideoEncoderBase.h b/videoencoder/VideoEncoderBase.h
index 764ccce..53b078b 100644
--- a/videoencoder/VideoEncoderBase.h
+++ b/videoencoder/VideoEncoderBase.h
@@ -140,6 +140,8 @@
     uint32_t mCodedBufSize;
     bool mAutoReference;
     uint32_t mAutoReferenceSurfaceNum;
+    uint32_t mEncPackedHeaders;
+    uint32_t mEncMaxRefFrames;
 
     bool mSliceSizeOverflow;
 
diff --git a/videoencoder/bitstream.h b/videoencoder/bitstream.h
new file mode 100644
index 0000000..2fe98fd
--- /dev/null
+++ b/videoencoder/bitstream.h
@@ -0,0 +1,386 @@
+#ifndef __BITSTREAM_H__
+#define __BITSTREAM_H__
+
+#include <VideoEncoderBase.h>
+#include <assert.h>
+
+struct bitstream {
+    unsigned int *buffer;
+    int bit_offset;
+    int max_size_in_dword;
+};
+
+#define BITSTREAM_ALLOCATE_STEPPING     4096
+
+static unsigned int va_swap32(unsigned int val)
+{
+    unsigned char *pval = (unsigned char *)&val;
+
+    return ((pval[0] << 24)     |
+            (pval[1] << 16)     |
+            (pval[2] << 8)      |
+            (pval[3] << 0));
+}
+
+static void bitstream_start(bitstream *bs)
+{
+    bs->max_size_in_dword = BITSTREAM_ALLOCATE_STEPPING;
+    bs->buffer = (unsigned int*)calloc(bs->max_size_in_dword * sizeof(int), 1);
+    bs->bit_offset = 0;
+}
+
+static void bitstream_end(bitstream *bs)
+{
+    int pos = (bs->bit_offset >> 5);
+    int bit_offset = (bs->bit_offset & 0x1f);
+    int bit_left = 32 - bit_offset;
+
+    if (bit_offset) {
+        bs->buffer[pos] = va_swap32((bs->buffer[pos] << bit_left));
+    }
+}
+
+static void bitstream_put_ui(bitstream *bs, unsigned int val, int size_in_bits)
+{
+    int pos = (bs->bit_offset >> 5);
+    int bit_offset = (bs->bit_offset & 0x1f);
+    int bit_left = 32 - bit_offset;
+
+    if (!size_in_bits)
+        return;
+
+    bs->bit_offset += size_in_bits;
+
+    if (bit_left > size_in_bits) {
+        bs->buffer[pos] = (bs->buffer[pos] << size_in_bits | val);
+    } else {
+        size_in_bits -= bit_left;
+        bs->buffer[pos] = (bs->buffer[pos] << bit_left) | (val >> size_in_bits);
+        bs->buffer[pos] = va_swap32(bs->buffer[pos]);
+
+        if (pos + 1 == bs->max_size_in_dword) {
+            bs->max_size_in_dword += BITSTREAM_ALLOCATE_STEPPING;
+            bs->buffer = (unsigned int*)realloc(bs->buffer, bs->max_size_in_dword * sizeof(unsigned int));
+        }
+
+        bs->buffer[pos + 1] = val;
+    }
+}
+
+static void bitstream_put_ue(bitstream *bs, unsigned int val)
+{
+    int size_in_bits = 0;
+    int tmp_val = ++val;
+
+    while (tmp_val) {
+        tmp_val >>= 1;
+        size_in_bits++;
+    }
+
+    bitstream_put_ui(bs, 0, size_in_bits - 1); // leading zero
+    bitstream_put_ui(bs, val, size_in_bits);
+}
+
+static void bitstream_put_se(bitstream *bs, int val)
+{
+    unsigned int new_val;
+
+    if (val <= 0)
+        new_val = -2 * val;
+    else
+        new_val = 2 * val - 1;
+
+    bitstream_put_ue(bs, new_val);
+}
+
+static void bitstream_byte_aligning(bitstream *bs, int bit)
+{
+    int bit_offset = (bs->bit_offset & 0x7);
+    int bit_left = 8 - bit_offset;
+    int new_val;
+
+    if (!bit_offset)
+        return;
+
+    assert(bit == 0 || bit == 1);
+
+    if (bit)
+        new_val = (1 << bit_left) - 1;
+    else
+        new_val = 0;
+
+    bitstream_put_ui(bs, new_val, bit_left);
+}
+
+static void rbsp_trailing_bits(bitstream *bs)
+{
+    bitstream_put_ui(bs, 1, 1);
+    bitstream_byte_aligning(bs, 0);
+}
+
+static void nal_start_code_prefix(bitstream *bs)
+{
+    bitstream_put_ui(bs, 0x00000001, 32);
+}
+
+static void nal_header(bitstream *bs, int nal_ref_idc, int nal_unit_type)
+{
+    bitstream_put_ui(bs, 0, 1);                /* forbidden_zero_bit: 0 */
+    bitstream_put_ui(bs, nal_ref_idc, 2);
+    bitstream_put_ui(bs, nal_unit_type, 5);
+}
+
+#define NAL_REF_IDC_NONE        0
+#define NAL_REF_IDC_LOW         1
+#define NAL_REF_IDC_MEDIUM      2
+#define NAL_REF_IDC_HIGH        3
+
+#define NAL_NON_IDR             1
+#define NAL_IDR                 5
+#define NAL_SPS                 7
+#define NAL_PPS                 8
+#define NAL_SEI			6
+
+#define SLICE_TYPE_P            0
+#define SLICE_TYPE_B            1
+#define SLICE_TYPE_I            2
+
+#define ENTROPY_MODE_CAVLC      0
+#define ENTROPY_MODE_CABAC      1
+
+#define PROFILE_IDC_BASELINE    66
+#define PROFILE_IDC_MAIN        77
+#define PROFILE_IDC_HIGH        100
+
+static void sps_rbsp(bitstream *bs, VAProfile profile, int frame_bit_rate, VAEncSequenceParameterBufferH264 *seq_param)
+{
+    int profile_idc;
+    int constraint_set_flag;
+
+    if (profile == VAProfileH264High) {
+        profile_idc = PROFILE_IDC_HIGH;
+        constraint_set_flag |= (1 << 3); /* Annex A.2.4 */
+    }
+    else if (profile == VAProfileH264Main) {
+        profile_idc = PROFILE_IDC_MAIN;
+        constraint_set_flag |= (1 << 1); /* Annex A.2.2 */
+    } else {
+        profile_idc = PROFILE_IDC_BASELINE;
+        constraint_set_flag |= (1 << 0); /* Annex A.2.1 */
+    }
+
+    bitstream_put_ui(bs, profile_idc, 8);               /* profile_idc */
+    bitstream_put_ui(bs, !!(constraint_set_flag & 1), 1);                         /* constraint_set0_flag */
+    bitstream_put_ui(bs, !!(constraint_set_flag & 2), 1);                         /* constraint_set1_flag */
+    bitstream_put_ui(bs, !!(constraint_set_flag & 4), 1);                         /* constraint_set2_flag */
+    bitstream_put_ui(bs, !!(constraint_set_flag & 8), 1);                         /* constraint_set3_flag */
+    bitstream_put_ui(bs, 0, 4);                         /* reserved_zero_4bits */
+    bitstream_put_ui(bs, seq_param->level_idc, 8);      /* level_idc */
+    bitstream_put_ue(bs, seq_param->seq_parameter_set_id);      /* seq_parameter_set_id */
+
+    if ( profile_idc == PROFILE_IDC_HIGH) {
+        bitstream_put_ue(bs, 1);        /* chroma_format_idc = 1, 4:2:0 */
+        bitstream_put_ue(bs, 0);        /* bit_depth_luma_minus8 */
+        bitstream_put_ue(bs, 0);        /* bit_depth_chroma_minus8 */
+        bitstream_put_ui(bs, 0, 1);     /* qpprime_y_zero_transform_bypass_flag */
+        bitstream_put_ui(bs, 0, 1);     /* seq_scaling_matrix_present_flag */
+    }
+
+    bitstream_put_ue(bs, seq_param->seq_fields.bits.log2_max_frame_num_minus4); /* log2_max_frame_num_minus4 */
+    bitstream_put_ue(bs, seq_param->seq_fields.bits.pic_order_cnt_type);        /* pic_order_cnt_type */
+
+    if (seq_param->seq_fields.bits.pic_order_cnt_type == 0)
+        bitstream_put_ue(bs, seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);     /* log2_max_pic_order_cnt_lsb_minus4 */
+    else {
+        assert(0);
+    }
+
+    bitstream_put_ue(bs, seq_param->max_num_ref_frames);        /* num_ref_frames */
+    bitstream_put_ui(bs, 0, 1);                                 /* gaps_in_frame_num_value_allowed_flag */
+
+    bitstream_put_ue(bs, seq_param->picture_width_in_mbs - 1);  /* pic_width_in_mbs_minus1 */
+    bitstream_put_ue(bs, seq_param->picture_height_in_mbs - 1); /* pic_height_in_map_units_minus1 */
+    bitstream_put_ui(bs, seq_param->seq_fields.bits.frame_mbs_only_flag, 1);    /* frame_mbs_only_flag */
+
+    if (!seq_param->seq_fields.bits.frame_mbs_only_flag) {
+        assert(0);
+    }
+
+    bitstream_put_ui(bs, seq_param->seq_fields.bits.direct_8x8_inference_flag, 1);      /* direct_8x8_inference_flag */
+    bitstream_put_ui(bs, seq_param->frame_cropping_flag, 1);            /* frame_cropping_flag */
+
+    if (seq_param->frame_cropping_flag) {
+        bitstream_put_ue(bs, seq_param->frame_crop_left_offset);        /* frame_crop_left_offset */
+        bitstream_put_ue(bs, seq_param->frame_crop_right_offset);       /* frame_crop_right_offset */
+        bitstream_put_ue(bs, seq_param->frame_crop_top_offset);         /* frame_crop_top_offset */
+        bitstream_put_ue(bs, seq_param->frame_crop_bottom_offset);      /* frame_crop_bottom_offset */
+    }
+
+    if ( frame_bit_rate < 0 ) {
+        bitstream_put_ui(bs, 0, 1); /* vui_parameters_present_flag */
+    } else {
+        bitstream_put_ui(bs, 1, 1); /* vui_parameters_present_flag */
+        bitstream_put_ui(bs, 0, 1); /* aspect_ratio_info_present_flag */
+        bitstream_put_ui(bs, 0, 1); /* overscan_info_present_flag */
+        bitstream_put_ui(bs, 0, 1); /* video_signal_type_present_flag */
+        bitstream_put_ui(bs, 0, 1); /* chroma_loc_info_present_flag */
+        bitstream_put_ui(bs, 1, 1); /* timing_info_present_flag */
+        {
+            bitstream_put_ui(bs, 15, 32);
+            bitstream_put_ui(bs, 900, 32);
+            bitstream_put_ui(bs, 1, 1);
+        }
+        bitstream_put_ui(bs, 1, 1); /* nal_hrd_parameters_present_flag */
+        {
+            // hrd_parameters
+            bitstream_put_ue(bs, 0);    /* cpb_cnt_minus1 */
+            bitstream_put_ui(bs, 4, 4); /* bit_rate_scale */
+            bitstream_put_ui(bs, 6, 4); /* cpb_size_scale */
+
+            bitstream_put_ue(bs, frame_bit_rate - 1); /* bit_rate_value_minus1[0] */
+            bitstream_put_ue(bs, frame_bit_rate*8 - 1); /* cpb_size_value_minus1[0] */
+            bitstream_put_ui(bs, 1, 1);  /* cbr_flag[0] */
+
+            bitstream_put_ui(bs, 23, 5);   /* initial_cpb_removal_delay_length_minus1 */
+            bitstream_put_ui(bs, 23, 5);   /* cpb_removal_delay_length_minus1 */
+            bitstream_put_ui(bs, 23, 5);   /* dpb_output_delay_length_minus1 */
+            bitstream_put_ui(bs, 23, 5);   /* time_offset_length  */
+        }
+        bitstream_put_ui(bs, 0, 1);   /* vcl_hrd_parameters_present_flag */
+        bitstream_put_ui(bs, 0, 1);   /* low_delay_hrd_flag */
+
+        bitstream_put_ui(bs, 0, 1); /* pic_struct_present_flag */
+        bitstream_put_ui(bs, 0, 1); /* bitstream_restriction_flag */
+    }
+
+    rbsp_trailing_bits(bs);     /* rbsp_trailing_bits */
+}
+
+static void pps_rbsp(bitstream *bs, VAEncPictureParameterBufferH264 *pic_param)
+{
+
+    bitstream_put_ue(bs, pic_param->pic_parameter_set_id);      /* pic_parameter_set_id */
+    bitstream_put_ue(bs, pic_param->seq_parameter_set_id);      /* seq_parameter_set_id */
+
+    bitstream_put_ui(bs, pic_param->pic_fields.bits.entropy_coding_mode_flag, 1);  /* entropy_coding_mode_flag */
+
+    bitstream_put_ui(bs, 0, 1);                         /* pic_order_present_flag: 0 */
+
+    bitstream_put_ue(bs, 0);                            /* num_slice_groups_minus1 */
+
+    bitstream_put_ue(bs, pic_param->num_ref_idx_l0_active_minus1);      /* num_ref_idx_l0_active_minus1 */
+    bitstream_put_ue(bs, pic_param->num_ref_idx_l1_active_minus1);      /* num_ref_idx_l1_active_minus1 1 */
+
+    bitstream_put_ui(bs, pic_param->pic_fields.bits.weighted_pred_flag, 1);     /* weighted_pred_flag: 0 */
+    bitstream_put_ui(bs, pic_param->pic_fields.bits.weighted_bipred_idc, 2);	/* weighted_bipred_idc: 0 */
+
+    bitstream_put_se(bs, pic_param->pic_init_qp - 26);  /* pic_init_qp_minus26 */
+    bitstream_put_se(bs, 0);                            /* pic_init_qs_minus26 */
+    bitstream_put_se(bs, 0);                            /* chroma_qp_index_offset */
+
+    bitstream_put_ui(bs, pic_param->pic_fields.bits.deblocking_filter_control_present_flag, 1); /* deblocking_filter_control_present_flag */
+    bitstream_put_ui(bs, 0, 1);                         /* constrained_intra_pred_flag */
+    bitstream_put_ui(bs, 0, 1);                         /* redundant_pic_cnt_present_flag */
+
+    /* more_rbsp_data */
+    bitstream_put_ui(bs, pic_param->pic_fields.bits.transform_8x8_mode_flag, 1);    /*transform_8x8_mode_flag */
+    bitstream_put_ui(bs, 0, 1);                         /* pic_scaling_matrix_present_flag */
+    bitstream_put_se(bs, pic_param->second_chroma_qp_index_offset );    /*second_chroma_qp_index_offset */
+
+    rbsp_trailing_bits(bs);
+}
+
+int build_packed_seq_buffer(unsigned char **header_buffer, VAProfile profile, VAEncSequenceParameterBufferH264 *seq_param)
+{
+    bitstream bs;
+
+    bitstream_start(&bs);
+    nal_start_code_prefix(&bs);
+    nal_header(&bs, NAL_REF_IDC_HIGH, NAL_SPS);
+    sps_rbsp(&bs, profile, seq_param->bits_per_second, seq_param);
+    bitstream_end(&bs);
+
+    *header_buffer = (unsigned char *)bs.buffer;
+    return bs.bit_offset;
+}
+
+int build_packed_pic_buffer(unsigned char **header_buffer, VAEncPictureParameterBufferH264 *pic_param)
+{
+    bitstream bs;
+
+    bitstream_start(&bs);
+    nal_start_code_prefix(&bs);
+    nal_header(&bs, NAL_REF_IDC_HIGH, NAL_PPS);
+    pps_rbsp(&bs, pic_param);
+    bitstream_end(&bs);
+
+    *header_buffer = (unsigned char *)bs.buffer;
+    return bs.bit_offset;
+}
+
+int build_packed_sei_buffer_timing(unsigned int init_cpb_removal_length,
+				unsigned int init_cpb_removal_delay,
+				unsigned int init_cpb_removal_delay_offset,
+				unsigned int cpb_removal_length,
+				unsigned int cpb_removal_delay,
+				unsigned int dpb_output_length,
+				unsigned int dpb_output_delay,
+				unsigned char **sei_buffer)
+{
+    unsigned char *byte_buf;
+    int bp_byte_size, i, pic_byte_size;
+
+    bitstream nal_bs;
+    bitstream sei_bp_bs, sei_pic_bs;
+
+    bitstream_start(&sei_bp_bs);
+    bitstream_put_ue(&sei_bp_bs, 0);       /*seq_parameter_set_id*/
+    bitstream_put_ui(&sei_bp_bs, init_cpb_removal_delay, cpb_removal_length);
+    bitstream_put_ui(&sei_bp_bs, init_cpb_removal_delay_offset, cpb_removal_length);
+    if ( sei_bp_bs.bit_offset & 0x7) {
+        bitstream_put_ui(&sei_bp_bs, 1, 1);
+    }
+    bitstream_end(&sei_bp_bs);
+    bp_byte_size = (sei_bp_bs.bit_offset + 7) / 8;
+
+    bitstream_start(&sei_pic_bs);
+    bitstream_put_ui(&sei_pic_bs, cpb_removal_delay, cpb_removal_length);
+    bitstream_put_ui(&sei_pic_bs, dpb_output_delay, dpb_output_length);
+    if ( sei_pic_bs.bit_offset & 0x7) {
+        bitstream_put_ui(&sei_pic_bs, 1, 1);
+    }
+    bitstream_end(&sei_pic_bs);
+    pic_byte_size = (sei_pic_bs.bit_offset + 7) / 8;
+
+    bitstream_start(&nal_bs);
+    nal_start_code_prefix(&nal_bs);
+    nal_header(&nal_bs, NAL_REF_IDC_NONE, NAL_SEI);
+
+    /* Write the SEI buffer period data */
+    bitstream_put_ui(&nal_bs, 0, 8);
+    bitstream_put_ui(&nal_bs, bp_byte_size, 8);
+
+    byte_buf = (unsigned char *)sei_bp_bs.buffer;
+    for(i = 0; i < bp_byte_size; i++) {
+        bitstream_put_ui(&nal_bs, byte_buf[i], 8);
+    }
+    free(byte_buf);
+	/* write the SEI timing data */
+    bitstream_put_ui(&nal_bs, 0x01, 8);
+    bitstream_put_ui(&nal_bs, pic_byte_size, 8);
+
+    byte_buf = (unsigned char *)sei_pic_bs.buffer;
+    for(i = 0; i < pic_byte_size; i++) {
+        bitstream_put_ui(&nal_bs, byte_buf[i], 8);
+    }
+    free(byte_buf);
+
+    rbsp_trailing_bits(&nal_bs);
+    bitstream_end(&nal_bs);
+
+    *sei_buffer = (unsigned char *)nal_bs.buffer;
+
+    return nal_bs.bit_offset;
+}
+
+#endif