media_driver/linux/common/codec/ddi/media_libvpx_vp9.cpp - third_party/github.com/intel/media-driver - Git at Google

 /*
 * Copyright (c) 2017, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
 //!
 //! \file     media_libvpx_vp9.cpp
 //! \brief    Defines the VP9 structure/function that is from libvpx
 //!

 /*
  * This file defines some functions related with vp9 enc, and
  * they are ported from libvpx (https://github.com/webmproject/libvpx/).
  * The original copyright and licence statement as below.
  */

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the media_libvpx.LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file media_libvpx.PATENTS.  All contributing project authors may
  *  be found in the media_libvpx.AUTHORS file in the root of the source tree.
  */

 #include <stdio.h>
 #include <stdint.h>
 #include "media_libva_encoder.h"
 #include "media_libvpx_vp9.h"

 struct vp9_write_bit_buffer {
     uint8_t *bit_buffer;
     int bit_offset;
 };

 static
 void vp9_wb_write_bit(struct vp9_write_bit_buffer *wb, int bit)
 {
     const int off = wb->bit_offset;
     const int p = off / 8;
     const int q = 7 - off % 8;

     if (q == 7)
     {
         wb->bit_buffer[p] = bit << q;
     }
     else
     {
         wb->bit_buffer[p] &= ~(1 << q);
         wb->bit_buffer[p] |= bit << q;
     }
     wb->bit_offset = off + 1;
 }

 static
 void vp9_wb_write_literal(struct vp9_write_bit_buffer *wb, int data, int bits)
 {
     int bit;
     for (bit = bits - 1; bit >= 0; bit--)
         vp9_wb_write_bit(wb, (data >> bit) & 1);
 }

 static
 void write_bitdepth_colorspace_sampling(uint32_t codecProfile,
                                         struct vp9_write_bit_buffer *wb)
 {

     if (codecProfile >= VP9_PROFILE_2)
     {
         /* Profile 2 can support 10/12 bits */
         /* Currently it is 10 bits */
         vp9_wb_write_literal(wb, 0, 1);
     }

     /* Add the default color-space */
     vp9_wb_write_literal(wb, 0, 3);
     vp9_wb_write_bit(wb, 0);  // 0: [16, 235] (i.e. xvYCC), 1: [0, 255]

     if ((codecProfile == VP9_PROFILE_1) ||
         (codecProfile == VP9_PROFILE_3))
     {
         /* sub_sampling_x/y */
         /* Currently the sub_sampling_x = 0, sub_sampling_y = 0 */
         vp9_wb_write_bit(wb, 0);
         vp9_wb_write_bit(wb, 0);
         vp9_wb_write_bit(wb, 0); // unused
     }
 }

 #define    MAX_TILE_WIDTH_B64    64
 #define    MIN_TILE_WIDTH_B64    4

 static int get_min_log2_tile_cols(const int sb_cols)
 {
     int min_log2 = 0;

     while ((MAX_TILE_WIDTH_B64 << min_log2) < sb_cols)
         ++min_log2;

     return min_log2;
 }

 static int get_max_log2_tile_cols(const int sb_cols)
 {
     int max_log2 = 1;

     while ((sb_cols >> max_log2) >= MIN_TILE_WIDTH_B64)
         ++max_log2;

     return max_log2 - 1;
 }

 bool Vp9WriteUncompressHeader(struct _DDI_ENCODE_CONTEXT *ddiEncContext,
                                 uint32_t codecProfile,
                                 uint8_t  *headerData,
                                 uint32_t *headerLen,
                                 vp9_header_bitoffset *headerBitoffset)
 {
 #define    VP9_SYNC_CODE_0    0x49
 #define    VP9_SYNC_CODE_1    0x83
 #define    VP9_SYNC_CODE_2    0x42

 #define    VP9_FRAME_MARKER   0x2

 #define    REFS_PER_FRAME     3

 #define    REF_FRAMES_LOG2    3
 #define    REF_FRAMES         (1 << REF_FRAMES_LOG2)

 #define    VP9_KEY_FRAME      0

     if ((ddiEncContext == nullptr) ||
         (headerData == nullptr) ||
         (headerLen == nullptr) ||
         (headerBitoffset == nullptr))
         return false;

     CODEC_VP9_ENCODE_PIC_PARAMS *picParam = (CODEC_VP9_ENCODE_PIC_PARAMS *)ddiEncContext->pPicParams;
     CODEC_VP9_ENCODE_SEGMENT_PARAMS *segParams = (CODEC_VP9_ENCODE_SEGMENT_PARAMS *)ddiEncContext->pVpxSegParams;

     if (picParam == nullptr)
         return false;

     struct vp9_write_bit_buffer *wb, vp9_wb;

     memset(headerBitoffset, 0, sizeof(vp9_header_bitoffset));

     vp9_wb.bit_buffer = (uint8_t *)headerData;
     vp9_wb.bit_offset = 0;
     wb = &vp9_wb;
     vp9_wb_write_literal(wb, VP9_FRAME_MARKER, 2);

     /* Only Profile0/1/2/3 is supported */
     if (codecProfile > VP9_PROFILE_3)
         codecProfile = VP9_PROFILE_0;

     switch(codecProfile)
     {
     case VP9_PROFILE_0:
         //Profile 0
         vp9_wb_write_literal(wb, 0, 2);
         break;
     case VP9_PROFILE_1:
         //Profile 1
         vp9_wb_write_literal(wb, 2, 2);
         break;
     case VP9_PROFILE_2:
         //Profile 2
         vp9_wb_write_literal(wb, 1, 2);
         break;
     case VP9_PROFILE_3:
         vp9_wb_write_literal(wb, 6, 3);
         break;
     default:
         break;
     }

     vp9_wb_write_bit(wb, 0);  // show_existing_frame
     vp9_wb_write_bit(wb, picParam->PicFlags.fields.frame_type);
     vp9_wb_write_bit(wb, picParam->PicFlags.fields.show_frame);
     vp9_wb_write_bit(wb, picParam->PicFlags.fields.error_resilient_mode);

     if (picParam->PicFlags.fields.frame_type == VP9_KEY_FRAME)
     {
         vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
         vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
         vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);

         write_bitdepth_colorspace_sampling(codecProfile, wb);

         /* write the encoded frame size */
         vp9_wb_write_literal(wb, picParam->DstFrameWidthMinus1, 16);
         vp9_wb_write_literal(wb, picParam->DstFrameHeightMinus1, 16);
         /* write display size */
         if ((picParam->DstFrameWidthMinus1 != picParam->SrcFrameWidthMinus1) ||
             (picParam->DstFrameHeightMinus1 != picParam->SrcFrameHeightMinus1))
         {
             vp9_wb_write_bit(wb, 1);
             vp9_wb_write_literal(wb, picParam->SrcFrameWidthMinus1, 16);
             vp9_wb_write_literal(wb, picParam->SrcFrameHeightMinus1, 16);
         }
         else
         {
             vp9_wb_write_bit(wb, 0);
         }
     }
     else
     {
         /* for the non-Key frame */
         if (!picParam->PicFlags.fields.show_frame)
         {
             vp9_wb_write_bit(wb, picParam->PicFlags.fields.intra_only);
         }

         if (!picParam->PicFlags.fields.error_resilient_mode)
         {
             vp9_wb_write_literal(wb, picParam->PicFlags.fields.reset_frame_context, 2);
         }

         if (picParam->PicFlags.fields.intra_only)
         {
             vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
             vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
             vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);

             /* Add the bit_depth for VP9Profile1/2/3 */
             if (codecProfile)
                 write_bitdepth_colorspace_sampling(codecProfile, wb);

             /* write the refreshed_frame_flags */
             vp9_wb_write_literal(wb, picParam->RefFlags.fields.refresh_frame_flags, REF_FRAMES);
             /* write the encoded frame size */
             vp9_wb_write_literal(wb, picParam->DstFrameWidthMinus1, 16);
             vp9_wb_write_literal(wb, picParam->DstFrameHeightMinus1, 16);
             /* write display size */
             if ((picParam->DstFrameWidthMinus1 != picParam->SrcFrameWidthMinus1) ||
                 (picParam->DstFrameHeightMinus1 != picParam->SrcFrameHeightMinus1))
             {
                 vp9_wb_write_bit(wb, 1);
                 vp9_wb_write_literal(wb, picParam->SrcFrameWidthMinus1, 16);
                 vp9_wb_write_literal(wb, picParam->SrcFrameHeightMinus1, 16);
             }
             else
             {
                 vp9_wb_write_bit(wb, 0);
             }
         }
         else
         {
             /* The refresh_frame_map is  for the next frame so that it can select Last/Godlen/Alt ref_index */
             /*
             if ((picParam->RefFlags.fields.ref_frame_ctrl_l0) & (1 << 0))
                 refresh_flags = 1 << picParam->RefFlags.fields.ref_last_idx;
             if ((picParam->RefFlags.fields.ref_frame_ctrl_l0) & (1 << 0))
                 refresh_flags = 1 << picParam->RefFlags.fields.ref_last_idx;
             if ((picParam->RefFlags.fields.ref_frame_ctrl_l0) & (1 << 0))
                 refresh_flags = 1 << picParam->RefFlags.fields.ref_last_idx;
             */
             vp9_wb_write_literal(wb, picParam->RefFlags.fields.refresh_frame_flags, REF_FRAMES);

             vp9_wb_write_literal(wb, picParam->RefFlags.fields.LastRefIdx, REF_FRAMES_LOG2);
             vp9_wb_write_bit(wb, picParam->RefFlags.fields.LastRefSignBias);
             vp9_wb_write_literal(wb, picParam->RefFlags.fields.GoldenRefIdx, REF_FRAMES_LOG2);
             vp9_wb_write_bit(wb, picParam->RefFlags.fields.GoldenRefSignBias);
             vp9_wb_write_literal(wb, picParam->RefFlags.fields.AltRefIdx, REF_FRAMES_LOG2);
             vp9_wb_write_bit(wb, picParam->RefFlags.fields.AltRefSignBias);

             /* write three bits with zero so that it can parse width/height directly */
             vp9_wb_write_literal(wb, 0, 3);
             vp9_wb_write_literal(wb, picParam->DstFrameWidthMinus1, 16);
             vp9_wb_write_literal(wb, picParam->DstFrameHeightMinus1, 16);

             /* write display size */
             if ((picParam->DstFrameWidthMinus1 != picParam->SrcFrameWidthMinus1) ||
                 (picParam->DstFrameHeightMinus1 != picParam->SrcFrameHeightMinus1))
             {
                 vp9_wb_write_bit(wb, 1);
                 vp9_wb_write_literal(wb, picParam->SrcFrameWidthMinus1, 16);
                 vp9_wb_write_literal(wb, picParam->SrcFrameHeightMinus1, 16);
             }
             else
             {
                 vp9_wb_write_bit(wb, 0);
             }

             vp9_wb_write_bit(wb, picParam->PicFlags.fields.allow_high_precision_mv);

 #define    SWITCHABLE_FILTER    4
 #define    FILTER_MASK          3

             if (picParam->PicFlags.fields.mcomp_filter_type == SWITCHABLE_FILTER)
             {
                 vp9_wb_write_bit(wb, 1);
             }
             else
             {
                 const int filter_to_literal[4] = { 1, 0, 2, 3 };
                 uint8_t filter_flag = picParam->PicFlags.fields.mcomp_filter_type;
                 filter_flag = filter_flag & FILTER_MASK;
                 vp9_wb_write_bit(wb, 0);
                 vp9_wb_write_literal(wb, filter_to_literal[filter_flag], 2);
             }
         }
     }

     /* write refresh_frame_context/paralle frame_decoding */
     if (!picParam->PicFlags.fields.error_resilient_mode)
     {
         vp9_wb_write_bit(wb, picParam->PicFlags.fields.refresh_frame_context);
         vp9_wb_write_bit(wb, picParam->PicFlags.fields.frame_parallel_decoding_mode);
     }

     vp9_wb_write_literal(wb, picParam->PicFlags.fields.frame_context_idx, 2);

     /* write loop filter */
     headerBitoffset->bit_offset_lf_level = wb->bit_offset;
     vp9_wb_write_literal(wb, picParam->filter_level, 6);
     vp9_wb_write_literal(wb, picParam->sharpness_level, 3);

     {
         int i, mode_flag;

         vp9_wb_write_bit(wb, 1);
         vp9_wb_write_bit(wb, 1);
         headerBitoffset->bit_offset_ref_lf_delta = wb->bit_offset;
         for (i = 0; i < 4; i++)
         {
             /*
              * This check is skipped to prepare the bit_offset_lf_ref
             if (picParam->LFRefDelta[i] == 0) {
                 vp9_wb_write_bit(wb, 0);
                 continue;
             }
              */
             vp9_wb_write_bit(wb, 1);
             mode_flag = picParam->LFRefDelta[i];
             if (mode_flag >= 0)
             {
                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
                 vp9_wb_write_bit(wb, 0);
             }
             else
             {
                 mode_flag = -mode_flag;
                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
                 vp9_wb_write_bit(wb, 1);
             }
         }

         headerBitoffset->bit_offset_mode_lf_delta = wb->bit_offset;
         for (i = 0; i < 2; i++)
         {
             /*
              * This check is skipped to prepare the bit_offset_lf_mode
             if (picParam->LFModeDelta[i] == 0) {
                 vp9_wb_write_bit(wb, 0);
                 continue;
             }
              */
             vp9_wb_write_bit(wb, 1);
             mode_flag = picParam->LFRefDelta[i];
             if (mode_flag >= 0)
             {
                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
                 vp9_wb_write_bit(wb, 0);
             }
             else
             {
                 mode_flag = -mode_flag;
                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
                 vp9_wb_write_bit(wb, 1);
             }
         }
     }

     /* write basic quantizer */
     headerBitoffset->bit_offset_qindex = wb->bit_offset;
     vp9_wb_write_literal(wb, picParam->LumaACQIndex, 8);
     if (picParam->LumaDCQIndexDelta)
     {
         int delta_q = picParam->LumaDCQIndexDelta;
         vp9_wb_write_bit(wb, 1);
         vp9_wb_write_literal(wb, abs(delta_q), 4);
         vp9_wb_write_bit(wb, delta_q < 0);
     }
     else
     {
         vp9_wb_write_bit(wb, 0);
     }

     if (picParam->ChromaDCQIndexDelta)
     {
         int delta_q = picParam->ChromaDCQIndexDelta;
         vp9_wb_write_bit(wb, 1);
         vp9_wb_write_literal(wb, abs(delta_q), 4);
         vp9_wb_write_bit(wb, delta_q < 0);
     }
     else
     {
         vp9_wb_write_bit(wb, 0);
     }

     if (picParam->ChromaACQIndexDelta)
     {
         int delta_q = picParam->ChromaACQIndexDelta;
         vp9_wb_write_bit(wb, 1);
         vp9_wb_write_literal(wb, abs(delta_q), 4);
         vp9_wb_write_bit(wb, delta_q < 0);
     }
     else
     {
         vp9_wb_write_bit(wb, 0);
     }

     vp9_wb_write_bit(wb, picParam->PicFlags.fields.segmentation_enabled);
     if (picParam->PicFlags.fields.segmentation_enabled)
     {
         int i;

 #define VP9_MAX_PROB    255
         vp9_wb_write_bit(wb, picParam->PicFlags.fields.segmentation_update_map);
         headerBitoffset->bit_offset_segmentation = wb->bit_offset;
         if (picParam->PicFlags.fields.segmentation_update_map)
         {
             /* write the seg_tree_probs */
             /* segment_tree_probs/segment_pred_probs are not passed.
              * So the hard-coded prob is writen
              */
             for (i = 0; i < 7; i++)
             {
                 vp9_wb_write_bit(wb, 1);
                 vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
             }

             vp9_wb_write_bit(wb, picParam->PicFlags.fields.segmentation_temporal_update);
             if (picParam->PicFlags.fields.segmentation_temporal_update)
             {
                 for (i = 0; i < 3; i++)
                 {
                     vp9_wb_write_bit(wb, 1);
                     vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
                 }
             }
         }

         /* write the segment_data info */
         vp9_wb_write_bit(wb, picParam->PicFlags.fields.seg_update_data);
         if (picParam->PicFlags.fields.seg_update_data)
         {
             CODEC_VP9_ENCODE_SEG_PARAMS *seg_data;
             int seg_delta;

             /* abs_delta should be zero */
             vp9_wb_write_bit(wb, 0);
             for (i = 0; i < 8; i++)
             {
                 seg_data = &segParams->SegData[i];

                 /* The segment qindex delta */
                 /* This check is skipped */
                 /* if (seg_data->SegmentQIndexDelta != 0) */
                 if (1)
                 {
                     vp9_wb_write_bit(wb, 1);
                     seg_delta = seg_data->SegmentQIndexDelta;
                     vp9_wb_write_literal(wb, abs(seg_delta), 8);
                     vp9_wb_write_bit(wb, seg_delta < 0);
                 }
                 else
                 {
                     vp9_wb_write_bit(wb, 0);
                 }

                 /* The segment lf delta */
                 /* if (seg_data->SegmentLFLevelDelta != 0) */
                 if (1)
                 {
                     vp9_wb_write_bit(wb, 1);
                     seg_delta = seg_data->SegmentLFLevelDelta;
                     vp9_wb_write_literal(wb, abs(seg_delta), 6);
                     vp9_wb_write_bit(wb, seg_delta < 0);
                 }
                 else
                 {
                     vp9_wb_write_bit(wb, 0);
                 }

                 /* segment reference flag */
                 vp9_wb_write_bit(wb, seg_data->SegmentFlags.fields.SegmentReferenceEnabled);
                 if (seg_data->SegmentFlags.fields.SegmentReferenceEnabled)
                 {
                     vp9_wb_write_literal(wb, seg_data->SegmentFlags.fields.SegmentReference, 2);
                 }

                 /* segment skip flag */
                 vp9_wb_write_bit(wb, seg_data->SegmentFlags.fields.SegmentSkipped);
             }
         }
     }

     /* write tile info */
     {
         int sb_cols = (picParam->DstFrameWidthMinus1 + 64) / 64;
         int min_log2_tile_cols, max_log2_tile_cols;
         int col_data;

         /* write tile column info */
         min_log2_tile_cols = get_min_log2_tile_cols(sb_cols);
         max_log2_tile_cols = get_max_log2_tile_cols(sb_cols);

         col_data = picParam->log2_tile_columns - min_log2_tile_cols;
         while (col_data--)
         {
             vp9_wb_write_bit(wb, 1);
         }
         if (picParam->log2_tile_columns < max_log2_tile_cols)
         {
             vp9_wb_write_bit(wb, 0);
         }

         /* write tile row info */
         vp9_wb_write_bit(wb, picParam->log2_tile_rows);
         if (picParam->log2_tile_rows)
         {
             vp9_wb_write_bit(wb, (picParam->log2_tile_rows != 1));
         }
     }

     /* get the bit_offset of the first partition size */
     headerBitoffset->bit_offset_first_partition_size = wb->bit_offset;

     /* reserve the space for writing the first partitions ize */
     vp9_wb_write_literal(wb, 0, 16);

     *headerLen = (wb->bit_offset + 7) / 8;

     return true;
 }
	/*
	* Copyright (c) 2017, Intel Corporation
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included
	* in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	* OTHER DEALINGS IN THE SOFTWARE.
	*/
	//!
	//! \file media_libvpx_vp9.cpp
	//! \brief Defines the VP9 structure/function that is from libvpx
	//!

	/*
	* This file defines some functions related with vp9 enc, and
	* they are ported from libvpx (https://github.com/webmproject/libvpx/).
	* The original copyright and licence statement as below.
	*/

	/*
	* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the media_libvpx.LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file media_libvpx.PATENTS. All contributing project authors may
	* be found in the media_libvpx.AUTHORS file in the root of the source tree.
	*/

	#include <stdio.h>
	#include <stdint.h>
	#include "media_libva_encoder.h"
	#include "media_libvpx_vp9.h"

	struct vp9_write_bit_buffer {
	uint8_t *bit_buffer;
	int bit_offset;
	};

	static
	void vp9_wb_write_bit(struct vp9_write_bit_buffer *wb, int bit)
	{
	const int off = wb->bit_offset;
	const int p = off / 8;
	const int q = 7 - off % 8;

	if (q == 7)
	{
	wb->bit_buffer[p] = bit << q;
	}
	else
	{
	wb->bit_buffer[p] &= ~(1 << q);
	wb->bit_buffer[p] \|= bit << q;
	}
	wb->bit_offset = off + 1;
	}

	static
	void vp9_wb_write_literal(struct vp9_write_bit_buffer *wb, int data, int bits)
	{
	int bit;
	for (bit = bits - 1; bit >= 0; bit--)
	vp9_wb_write_bit(wb, (data >> bit) & 1);
	}

	static
	void write_bitdepth_colorspace_sampling(uint32_t codecProfile,
	struct vp9_write_bit_buffer *wb)
	{

	if (codecProfile >= VP9_PROFILE_2)
	{
	/* Profile 2 can support 10/12 bits */
	/* Currently it is 10 bits */
	vp9_wb_write_literal(wb, 0, 1);
	}

	/* Add the default color-space */
	vp9_wb_write_literal(wb, 0, 3);
	vp9_wb_write_bit(wb, 0); // 0: [16, 235] (i.e. xvYCC), 1: [0, 255]

	if ((codecProfile == VP9_PROFILE_1) \|\|
	(codecProfile == VP9_PROFILE_3))
	{
	/* sub_sampling_x/y */
	/* Currently the sub_sampling_x = 0, sub_sampling_y = 0 */
	vp9_wb_write_bit(wb, 0);
	vp9_wb_write_bit(wb, 0);
	vp9_wb_write_bit(wb, 0); // unused
	}
	}

	#define MAX_TILE_WIDTH_B64 64
	#define MIN_TILE_WIDTH_B64 4

	static int get_min_log2_tile_cols(const int sb_cols)
	{
	int min_log2 = 0;

	while ((MAX_TILE_WIDTH_B64 << min_log2) < sb_cols)
	++min_log2;

	return min_log2;
	}

	static int get_max_log2_tile_cols(const int sb_cols)
	{
	int max_log2 = 1;

	while ((sb_cols >> max_log2) >= MIN_TILE_WIDTH_B64)
	++max_log2;

	return max_log2 - 1;
	}

	bool Vp9WriteUncompressHeader(struct _DDI_ENCODE_CONTEXT *ddiEncContext,
	uint32_t codecProfile,
	uint8_t *headerData,
	uint32_t *headerLen,
	vp9_header_bitoffset *headerBitoffset)
	{
	#define VP9_SYNC_CODE_0 0x49
	#define VP9_SYNC_CODE_1 0x83
	#define VP9_SYNC_CODE_2 0x42

	#define VP9_FRAME_MARKER 0x2

	#define REFS_PER_FRAME 3

	#define REF_FRAMES_LOG2 3
	#define REF_FRAMES (1 << REF_FRAMES_LOG2)

	#define VP9_KEY_FRAME 0

	if ((ddiEncContext == nullptr) \|\|
	(headerData == nullptr) \|\|
	(headerLen == nullptr) \|\|
	(headerBitoffset == nullptr))
	return false;

	CODEC_VP9_ENCODE_PIC_PARAMS picParam = (CODEC_VP9_ENCODE_PIC_PARAMS )ddiEncContext->pPicParams;
	CODEC_VP9_ENCODE_SEGMENT_PARAMS segParams = (CODEC_VP9_ENCODE_SEGMENT_PARAMS )ddiEncContext->pVpxSegParams;

	if (picParam == nullptr)
	return false;

	struct vp9_write_bit_buffer *wb, vp9_wb;

	memset(headerBitoffset, 0, sizeof(vp9_header_bitoffset));

	vp9_wb.bit_buffer = (uint8_t *)headerData;
	vp9_wb.bit_offset = 0;
	wb = &vp9_wb;
	vp9_wb_write_literal(wb, VP9_FRAME_MARKER, 2);

	/* Only Profile0/1/2/3 is supported */
	if (codecProfile > VP9_PROFILE_3)
	codecProfile = VP9_PROFILE_0;

	switch(codecProfile)
	{
	case VP9_PROFILE_0:
	//Profile 0
	vp9_wb_write_literal(wb, 0, 2);
	break;
	case VP9_PROFILE_1:
	//Profile 1
	vp9_wb_write_literal(wb, 2, 2);
	break;
	case VP9_PROFILE_2:
	//Profile 2
	vp9_wb_write_literal(wb, 1, 2);
	break;
	case VP9_PROFILE_3:
	vp9_wb_write_literal(wb, 6, 3);
	break;
	default:
	break;
	}

	vp9_wb_write_bit(wb, 0); // show_existing_frame
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.frame_type);
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.show_frame);
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.error_resilient_mode);

	if (picParam->PicFlags.fields.frame_type == VP9_KEY_FRAME)
	{
	vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
	vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
	vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);

	write_bitdepth_colorspace_sampling(codecProfile, wb);

	/* write the encoded frame size */
	vp9_wb_write_literal(wb, picParam->DstFrameWidthMinus1, 16);
	vp9_wb_write_literal(wb, picParam->DstFrameHeightMinus1, 16);
	/* write display size */
	if ((picParam->DstFrameWidthMinus1 != picParam->SrcFrameWidthMinus1) \|\|
	(picParam->DstFrameHeightMinus1 != picParam->SrcFrameHeightMinus1))
	{
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, picParam->SrcFrameWidthMinus1, 16);
	vp9_wb_write_literal(wb, picParam->SrcFrameHeightMinus1, 16);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}
	}
	else
	{
	/* for the non-Key frame */
	if (!picParam->PicFlags.fields.show_frame)
	{
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.intra_only);
	}

	if (!picParam->PicFlags.fields.error_resilient_mode)
	{
	vp9_wb_write_literal(wb, picParam->PicFlags.fields.reset_frame_context, 2);
	}

	if (picParam->PicFlags.fields.intra_only)
	{
	vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
	vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
	vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);

	/* Add the bit_depth for VP9Profile1/2/3 */
	if (codecProfile)
	write_bitdepth_colorspace_sampling(codecProfile, wb);

	/* write the refreshed_frame_flags */
	vp9_wb_write_literal(wb, picParam->RefFlags.fields.refresh_frame_flags, REF_FRAMES);
	/* write the encoded frame size */
	vp9_wb_write_literal(wb, picParam->DstFrameWidthMinus1, 16);
	vp9_wb_write_literal(wb, picParam->DstFrameHeightMinus1, 16);
	/* write display size */
	if ((picParam->DstFrameWidthMinus1 != picParam->SrcFrameWidthMinus1) \|\|
	(picParam->DstFrameHeightMinus1 != picParam->SrcFrameHeightMinus1))
	{
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, picParam->SrcFrameWidthMinus1, 16);
	vp9_wb_write_literal(wb, picParam->SrcFrameHeightMinus1, 16);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}
	}
	else
	{
	/* The refresh_frame_map is for the next frame so that it can select Last/Godlen/Alt ref_index */
	/*
	if ((picParam->RefFlags.fields.ref_frame_ctrl_l0) & (1 << 0))
	refresh_flags = 1 << picParam->RefFlags.fields.ref_last_idx;
	if ((picParam->RefFlags.fields.ref_frame_ctrl_l0) & (1 << 0))
	refresh_flags = 1 << picParam->RefFlags.fields.ref_last_idx;
	if ((picParam->RefFlags.fields.ref_frame_ctrl_l0) & (1 << 0))
	refresh_flags = 1 << picParam->RefFlags.fields.ref_last_idx;
	*/
	vp9_wb_write_literal(wb, picParam->RefFlags.fields.refresh_frame_flags, REF_FRAMES);

	vp9_wb_write_literal(wb, picParam->RefFlags.fields.LastRefIdx, REF_FRAMES_LOG2);
	vp9_wb_write_bit(wb, picParam->RefFlags.fields.LastRefSignBias);
	vp9_wb_write_literal(wb, picParam->RefFlags.fields.GoldenRefIdx, REF_FRAMES_LOG2);
	vp9_wb_write_bit(wb, picParam->RefFlags.fields.GoldenRefSignBias);
	vp9_wb_write_literal(wb, picParam->RefFlags.fields.AltRefIdx, REF_FRAMES_LOG2);
	vp9_wb_write_bit(wb, picParam->RefFlags.fields.AltRefSignBias);

	/* write three bits with zero so that it can parse width/height directly */
	vp9_wb_write_literal(wb, 0, 3);
	vp9_wb_write_literal(wb, picParam->DstFrameWidthMinus1, 16);
	vp9_wb_write_literal(wb, picParam->DstFrameHeightMinus1, 16);

	/* write display size */
	if ((picParam->DstFrameWidthMinus1 != picParam->SrcFrameWidthMinus1) \|\|
	(picParam->DstFrameHeightMinus1 != picParam->SrcFrameHeightMinus1))
	{
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, picParam->SrcFrameWidthMinus1, 16);
	vp9_wb_write_literal(wb, picParam->SrcFrameHeightMinus1, 16);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}

	vp9_wb_write_bit(wb, picParam->PicFlags.fields.allow_high_precision_mv);

	#define SWITCHABLE_FILTER 4
	#define FILTER_MASK 3

	if (picParam->PicFlags.fields.mcomp_filter_type == SWITCHABLE_FILTER)
	{
	vp9_wb_write_bit(wb, 1);
	}
	else
	{
	const int filter_to_literal[4] = { 1, 0, 2, 3 };
	uint8_t filter_flag = picParam->PicFlags.fields.mcomp_filter_type;
	filter_flag = filter_flag & FILTER_MASK;
	vp9_wb_write_bit(wb, 0);
	vp9_wb_write_literal(wb, filter_to_literal[filter_flag], 2);
	}
	}
	}

	/* write refresh_frame_context/paralle frame_decoding */
	if (!picParam->PicFlags.fields.error_resilient_mode)
	{
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.refresh_frame_context);
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.frame_parallel_decoding_mode);
	}

	vp9_wb_write_literal(wb, picParam->PicFlags.fields.frame_context_idx, 2);

	/* write loop filter */
	headerBitoffset->bit_offset_lf_level = wb->bit_offset;
	vp9_wb_write_literal(wb, picParam->filter_level, 6);
	vp9_wb_write_literal(wb, picParam->sharpness_level, 3);

	{
	int i, mode_flag;

	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_bit(wb, 1);
	headerBitoffset->bit_offset_ref_lf_delta = wb->bit_offset;
	for (i = 0; i < 4; i++)
	{
	/*
	* This check is skipped to prepare the bit_offset_lf_ref
	if (picParam->LFRefDelta[i] == 0) {
	vp9_wb_write_bit(wb, 0);
	continue;
	}
	*/
	vp9_wb_write_bit(wb, 1);
	mode_flag = picParam->LFRefDelta[i];
	if (mode_flag >= 0)
	{
	vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
	vp9_wb_write_bit(wb, 0);
	}
	else
	{
	mode_flag = -mode_flag;
	vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
	vp9_wb_write_bit(wb, 1);
	}
	}

	headerBitoffset->bit_offset_mode_lf_delta = wb->bit_offset;
	for (i = 0; i < 2; i++)
	{
	/*
	* This check is skipped to prepare the bit_offset_lf_mode
	if (picParam->LFModeDelta[i] == 0) {
	vp9_wb_write_bit(wb, 0);
	continue;
	}
	*/
	vp9_wb_write_bit(wb, 1);
	mode_flag = picParam->LFRefDelta[i];
	if (mode_flag >= 0)
	{
	vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
	vp9_wb_write_bit(wb, 0);
	}
	else
	{
	mode_flag = -mode_flag;
	vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
	vp9_wb_write_bit(wb, 1);
	}
	}
	}

	/* write basic quantizer */
	headerBitoffset->bit_offset_qindex = wb->bit_offset;
	vp9_wb_write_literal(wb, picParam->LumaACQIndex, 8);
	if (picParam->LumaDCQIndexDelta)
	{
	int delta_q = picParam->LumaDCQIndexDelta;
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, abs(delta_q), 4);
	vp9_wb_write_bit(wb, delta_q < 0);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}

	if (picParam->ChromaDCQIndexDelta)
	{
	int delta_q = picParam->ChromaDCQIndexDelta;
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, abs(delta_q), 4);
	vp9_wb_write_bit(wb, delta_q < 0);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}

	if (picParam->ChromaACQIndexDelta)
	{
	int delta_q = picParam->ChromaACQIndexDelta;
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, abs(delta_q), 4);
	vp9_wb_write_bit(wb, delta_q < 0);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}

	vp9_wb_write_bit(wb, picParam->PicFlags.fields.segmentation_enabled);
	if (picParam->PicFlags.fields.segmentation_enabled)
	{
	int i;

	#define VP9_MAX_PROB 255
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.segmentation_update_map);
	headerBitoffset->bit_offset_segmentation = wb->bit_offset;
	if (picParam->PicFlags.fields.segmentation_update_map)
	{
	/* write the seg_tree_probs */
	/* segment_tree_probs/segment_pred_probs are not passed.
	* So the hard-coded prob is writen
	*/
	for (i = 0; i < 7; i++)
	{
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
	}

	vp9_wb_write_bit(wb, picParam->PicFlags.fields.segmentation_temporal_update);
	if (picParam->PicFlags.fields.segmentation_temporal_update)
	{
	for (i = 0; i < 3; i++)
	{
	vp9_wb_write_bit(wb, 1);
	vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
	}
	}
	}

	/* write the segment_data info */
	vp9_wb_write_bit(wb, picParam->PicFlags.fields.seg_update_data);
	if (picParam->PicFlags.fields.seg_update_data)
	{
	CODEC_VP9_ENCODE_SEG_PARAMS *seg_data;
	int seg_delta;

	/* abs_delta should be zero */
	vp9_wb_write_bit(wb, 0);
	for (i = 0; i < 8; i++)
	{
	seg_data = &segParams->SegData[i];

	/* The segment qindex delta */
	/* This check is skipped */
	/* if (seg_data->SegmentQIndexDelta != 0) */
	if (1)
	{
	vp9_wb_write_bit(wb, 1);
	seg_delta = seg_data->SegmentQIndexDelta;
	vp9_wb_write_literal(wb, abs(seg_delta), 8);
	vp9_wb_write_bit(wb, seg_delta < 0);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}

	/* The segment lf delta */
	/* if (seg_data->SegmentLFLevelDelta != 0) */
	if (1)
	{
	vp9_wb_write_bit(wb, 1);
	seg_delta = seg_data->SegmentLFLevelDelta;
	vp9_wb_write_literal(wb, abs(seg_delta), 6);
	vp9_wb_write_bit(wb, seg_delta < 0);
	}
	else
	{
	vp9_wb_write_bit(wb, 0);
	}

	/* segment reference flag */
	vp9_wb_write_bit(wb, seg_data->SegmentFlags.fields.SegmentReferenceEnabled);
	if (seg_data->SegmentFlags.fields.SegmentReferenceEnabled)
	{
	vp9_wb_write_literal(wb, seg_data->SegmentFlags.fields.SegmentReference, 2);
	}

	/* segment skip flag */
	vp9_wb_write_bit(wb, seg_data->SegmentFlags.fields.SegmentSkipped);
	}
	}
	}

	/* write tile info */
	{
	int sb_cols = (picParam->DstFrameWidthMinus1 + 64) / 64;
	int min_log2_tile_cols, max_log2_tile_cols;
	int col_data;

	/* write tile column info */
	min_log2_tile_cols = get_min_log2_tile_cols(sb_cols);
	max_log2_tile_cols = get_max_log2_tile_cols(sb_cols);

	col_data = picParam->log2_tile_columns - min_log2_tile_cols;
	while (col_data--)
	{
	vp9_wb_write_bit(wb, 1);
	}
	if (picParam->log2_tile_columns < max_log2_tile_cols)
	{
	vp9_wb_write_bit(wb, 0);
	}

	/* write tile row info */
	vp9_wb_write_bit(wb, picParam->log2_tile_rows);
	if (picParam->log2_tile_rows)
	{
	vp9_wb_write_bit(wb, (picParam->log2_tile_rows != 1));
	}
	}

	/* get the bit_offset of the first partition size */
	headerBitoffset->bit_offset_first_partition_size = wb->bit_offset;

	/* reserve the space for writing the first partitions ize */
	vp9_wb_write_literal(wb, 0, 16);

	*headerLen = (wb->bit_offset + 7) / 8;

	return true;
	}