text: /*
   * Copyright (c) 2018 Georg Ottinger. All Rights Reserved.
   *
   * 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, sub license, 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 (including the
   * next paragraph) 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 NON-INFRINGEMENT.
   * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
   */
  
  /* This file includes code taken from vp9enc.c (libva-utils) copyright 2017
   * by Intel Cooperation and licensed under same conditions.
   * This file includes code ported from vaapiencoder_vp8.cpp (libyami) copyright
   * by 2014-2016 Intel Corporation. https://github.com/intel/libyami
   * The original copyright and licence statement as below.
   */
  
   /*
    * Copyright (C) 2014-2016 Intel Corporation. All rights reserved.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
  
  #include <stdbool.h>
  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  #include <getopt.h>
  #include <unistd.h>
  #include <inttypes.h>
  
  #include <sys/time.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <sys/mman.h>
  #include <fcntl.h>
  #include <assert.h>
  #include <time.h>
  #include <stdlib.h>
  #include <pthread.h>
  
  #include <va/va.h>
  #include <va/va_enc_vp8.h>
  #include "va_display.h"
  
  #define MAX_XY_RESOLUTION       16364
  
  #define KEY_FRAME               0
  #define INTER_FRAME             1
  
  #define NUM_REF_SURFACES        4
  #define NUM_INPUT_SURFACES      2
  #define NUM_SURFACES_TOTAL      (NUM_REF_SURFACES+NUM_INPUT_SURFACES)
  #define SID_INPUT_PICTURE_0     (NUM_REF_SURFACES)
  #define SID_INPUT_PICTURE_1     (NUM_REF_SURFACES+1)
  #define NUM_BUFFERS             10
  
  #define VP8ENC_OK               0
  #define VP8ENC_FAIL             -1
  #define PARSE_OPTIONS_OK        0
  #define PARSE_OPTIONS_FAIL      -1
  
  #ifndef N_ELEMENTS
  #define N_ELEMENTS(array) (sizeof(array)/sizeof(array[0]))
  #endif
  
  #ifndef CHECK_VASTATUS
  #define CHECK_VASTATUS(va_status,func)                                  \
      if (va_status != VA_STATUS_SUCCESS) {                               \
          fprintf(stderr,"%s:%s (%d) failed,exit\n", __func__, func, __LINE__); \
          exit(1);                                                        \
      }
  #endif
  
  
  
  static const struct option long_opts[] = {
      {"help", no_argument, NULL, 0 },
      {"rcmode", required_argument, NULL, 1 },
      {"qp", required_argument, NULL, 2 },
      {"intra_period", required_argument, NULL, 3 },
      {"fb", required_argument, NULL, 4 },
      {"lf_level", required_argument, NULL, 5 },
      {"hrd_win", required_argument, NULL, 6},
      {"vbr_max", required_argument, NULL, 7},
      {"fn_num", required_argument, NULL, 8},
      {"error_resilient", no_argument, NULL, 9},
      {"debug", no_argument, NULL, 10},
      {"temp_svc", required_argument, NULL, 11},
      {"repeat", required_argument, NULL, 12},
      {NULL, no_argument, NULL, 0 }
  };
  
  
  static const int default_rc_modes[4] = {
      VA_RC_CQP, // 0
      VA_RC_CBR, // 1
      VA_RC_VBR, // 2
      VA_RC_NONE
  };
  
  struct vp8enc_settings {
    int width;
    int height;
    int frame_rate;
    int frame_size;
    int loop_filter_level;
    int clamp_qindex_low;
    int clamp_qindex_high;
    int intra_period;
    int quantization_parameter;
    int frame_bitrate;
    int max_variable_bitrate;
    int rc_mode;
    int num_frames;
    VAEntrypoint vaapi_entry_point;
    int codedbuf_size;
    int hrd_window;
    int error_resilient;
    int debug;
    int temporal_svc_layers;
    int repeat_times;
  };
  
  
  static struct vp8enc_settings settings =
    {
      //Default Values - unless otherwise specified with command line options
      .frame_rate = 30,
      .loop_filter_level = 19,
      .clamp_qindex_low = 9,
      .clamp_qindex_high = 127,
      .intra_period = 30,
      .quantization_parameter = 60,
      .frame_bitrate = -1,
      .max_variable_bitrate = -1,
      .num_frames = 0,
      .rc_mode = VA_RC_CQP,
      .vaapi_entry_point = VAEntrypointEncSlice, //VAEntrypointEncSliceLP would be LowPower Mode - but not supported with VP8Encoder
      .hrd_window = 1500,
      .error_resilient = 0,
      .debug = 0,
      .temporal_svc_layers = 1,
      .repeat_times = 1,
   };
  
   struct vp8enc_vaapi_context {
       VADisplay display;
       VAProfile profile;
       VAContextID context_id;
       VAConfigID config_id;
       VAEncSequenceParameterBufferVP8 seq_param;
       VAEncPictureParameterBufferVP8 pic_param;
       VAQMatrixBufferVP8 q_matrix;
       VASurfaceID surfaces[NUM_SURFACES_TOTAL];
       VASurfaceID recon_surface, last_ref_surface, golden_ref_surface, alt_ref_surface;
       VASurfaceID input_surface;
       VABufferID codedbuf_buf_id;
       VABufferID va_buffers[NUM_BUFFERS];
       int num_va_buffers;
       int is_golden_refreshed;
       struct {
         VAEncMiscParameterBuffer header;
         VAEncMiscParameterHRD data;
       } hrd_param;
       struct {
         VAEncMiscParameterBuffer header;
         VAEncMiscParameterFrameRate data;
       } frame_rate_param;
       struct {
         VAEncMiscParameterBuffer header;
         VAEncMiscParameterRateControl data;
       } rate_control_param;
       struct {
         pthread_t id;
         int value;
         FILE *input_fp;
         int input_surface_num;
         VASurfaceID input_surface;
         int processed_frame;
       } upload_thread;
  };
  
  static struct vp8enc_vaapi_context vaapi_context;
  
  
  /********************************************
  *
  * START: IVF Container Releated Stuff
  *
  ********************************************/
  static void
  vp8enc_write_word(char *ptr, uint32_t value)
  {
      uint8_t *tmp;
  
      tmp = (uint8_t *)ptr;
      *(tmp) = (value >> 0) & 0XFF;
      *(tmp + 1) = (value >> 8) & 0XFF;
  }
  
  static void
  vp8enc_write_dword(char *ptr, uint32_t value)
  {
      uint8_t *tmp;
  
      tmp = (uint8_t *)ptr;
      *(tmp) = (value >> 0) & 0XFF;
      *(tmp + 1) = (value >> 8) & 0XFF;
      *(tmp + 2) = (value >> 16) & 0XFF;
      *(tmp + 3) = (value >> 24) & 0XFF;
  }
  
  static void
  vp8enc_write_qword(char *ptr, uint64_t value)
  {
      uint8_t *tmp;
  
      tmp = (uint8_t *)ptr;
      *(tmp) = (value >> 0) & 0XFF;
      *(tmp + 1) = (value >> 8) & 0XFF;
      *(tmp + 2) = (value >> 16) & 0XFF;
      *(tmp + 3) = (value >> 24) & 0XFF;
      *(tmp + 4) = (value >> 32) & 0XFF;
      *(tmp + 5) = (value >> 40) & 0XFF;
      *(tmp + 6) = (value >> 48) & 0XFF;
      *(tmp + 7) = (value >> 56) & 0XFF;
  }
  
  static void
  vp8enc_write_frame_header(FILE *vp8_output,uint32_t data_length, uint64_t timestamp)
  {
    char header[12];
  
    vp8enc_write_dword(header, data_length);
    vp8enc_write_qword(header + 4, timestamp );
  
    fwrite(header, 1, 12, vp8_output);
  }
  
  static void
  vp8enc_write_ivf_header(FILE *vp8_file)
  {
  
  
  #define VP8_FOURCC    0x30385056
  
      char header[32];
  
      header[0] = 'D';
      header[1] = 'K';
      header[2] = 'I';
      header[3] = 'F';
  
      vp8enc_write_word(header + 4, 0);
      vp8enc_write_word(header + 6, 32);
      vp8enc_write_dword(header + 8, VP8_FOURCC);
      vp8enc_write_word(header + 12, settings.width);
      vp8enc_write_word(header + 14, settings.height);
      vp8enc_write_dword(header + 16, settings.frame_rate);
      vp8enc_write_dword(header + 20, 1);
      vp8enc_write_dword(header + 24, settings.num_frames * settings.repeat_times);
      vp8enc_write_dword(header + 28, 0);
  
      fwrite(header, 1, 32, vp8_file);
  }
  
  /********************************************
  *
  * END: IVF Container Releated Stuff
  *
  ********************************************/
  
  
  /********************************************
  *
  * START: Read YUV Input File Releated Stuff
  *
  ********************************************/
  static void
  vp8enc_upload_yuv_to_surface(FILE *yuv_fp, VASurfaceID surface_id, int current_frame)
  {
      VAImage surface_image;
      VAStatus va_status;
      void *surface_p = NULL;
      uint8_t *y_src, *u_src, *v_src;
      uint8_t *y_dst, *u_dst, *v_dst;
      int y_size = settings.width * settings.height;
      int u_size = (settings.width >> 1) * (settings.height >> 1);
      int row, col;
      char *yuv_mmap_ptr = NULL;
      unsigned long long frame_start_pos, mmap_start;
      int mmap_size;
  
      frame_start_pos = (unsigned long long)current_frame * settings.frame_size;
  
      mmap_start = frame_start_pos & (~0xfff);
      mmap_size = (settings.frame_size + (frame_start_pos & 0xfff) + 0xfff) & (~0xfff);
      yuv_mmap_ptr = mmap(0, mmap_size, PROT_READ, MAP_SHARED,
                  fileno(yuv_fp), mmap_start);
  
      if (yuv_mmap_ptr == MAP_FAILED) {
        fprintf(stderr,"Error: Failed to mmap YUV file.\n");
        assert(0);
      }
  
      y_src = (uint8_t*)yuv_mmap_ptr+(frame_start_pos & 0xfff);
      u_src = y_src + y_size; /* UV offset for NV12 */
      v_src = y_src + y_size + u_size;
  
  
      va_status = vaDeriveImage(vaapi_context.display, surface_id, &surface_image);
      CHECK_VASTATUS(va_status,"vaDeriveImage");
  
      vaMapBuffer(vaapi_context.display, surface_image.buf, &surface_p);
      assert(VA_STATUS_SUCCESS == va_status);
  
  
      y_dst = surface_p + surface_image.offsets[0];
      u_dst = surface_p + surface_image.offsets[1]; /* UV offset for NV12 */
      v_dst = surface_p + surface_image.offsets[2];
  
      /* Y plane */
      for (row = 0; row < surface_image.height; row++) {
          memcpy(y_dst, y_src, surface_image.width);
          y_dst += surface_image.pitches[0];
          y_src += settings.width;
      }
  
      if (surface_image.format.fourcc == VA_FOURCC_NV12) { /* UV plane */
          for (row = 0; row < surface_image.height / 2; row++) {
              for (col = 0; col < surface_image.width / 2; col++) {
                  u_dst[col * 2] = u_src[col];
                  u_dst[col * 2 + 1] = v_src[col];
              }
  
              u_dst += surface_image.pitches[1];
              u_src += (settings.width / 2);
              v_src += (settings.width / 2);
          }
      } else if (surface_image.format.fourcc == VA_FOURCC_YV12 ||
                 surface_image.format.fourcc == VA_FOURCC_I420) {
          const int U = surface_image.format.fourcc == VA_FOURCC_I420 ? 1 : 2;
          const int V = surface_image.format.fourcc == VA_FOURCC_I420 ? 2 : 1;
  
          u_dst = surface_p + surface_image.offsets[U];
          v_dst = surface_p + surface_image.offsets[V];
  
          for (row = 0; row < surface_image.height / 2; row++) {
              memcpy(u_dst, u_src, surface_image.width / 2);
              memcpy(v_dst, v_src, surface_image.width / 2);
              u_dst += surface_image.pitches[U];
              v_dst += surface_image.pitches[V];
              u_src += (settings.width / 2);
              v_src += (settings.width / 2);
          }
      }
  
      vaUnmapBuffer(vaapi_context.display, surface_image.buf);
      vaDestroyImage(vaapi_context.display, surface_image.image_id);
  
      if (yuv_mmap_ptr)
        munmap(yuv_mmap_ptr, mmap_size);
  }
  
  static void *
  vp8enc_upload_thread_function(void *data)
  {
      vp8enc_upload_yuv_to_surface(vaapi_context.upload_thread.input_fp, vaapi_context.upload_thread.input_surface,vaapi_context.upload_thread.processed_frame);
  
      return NULL;
  }
  /********************************************
  *
  * END: Read YUV Input File Releated Stuff
  *
  ********************************************/
  
  void vp8enc_init_QMatrix(VAQMatrixBufferVP8 *qMatrix)
  {
    // When segmentation is disabled, only quantization_index[0] will be used
    size_t i;
    for (i = 0; i < N_ELEMENTS(qMatrix->quantization_index); i++) {
        qMatrix->quantization_index[i] = settings.quantization_parameter;
    }
  
    for (i = 0; i < N_ELEMENTS(qMatrix->quantization_index_delta); i++) {
        qMatrix->quantization_index_delta[i] = 0;
    }
  }
  
  void vp8enc_init_SequenceParameterBuffer(VAEncSequenceParameterBufferVP8* seqParam)
  {
    size_t i;
  
    memset(seqParam, 0, sizeof(VAEncSequenceParameterBufferVP8));
  
    seqParam->frame_width = settings.width;
    seqParam->frame_height = settings.height;
  
    if(settings.frame_bitrate > 0)
      seqParam->bits_per_second = settings.frame_bitrate * 1000;
    else
      seqParam->bits_per_second = 0;
  
    seqParam->intra_period = settings.intra_period;
    seqParam->error_resilient = settings.error_resilient;
  
    for (i = 0; i < N_ELEMENTS(seqParam->reference_frames); i++)
       seqParam->reference_frames[i] = VA_INVALID_ID;
  }
  
  void vp8enc_init_PictureParameterBuffer(VAEncPictureParameterBufferVP8 *picParam)
  {
    size_t i;
    memset(picParam, 0, sizeof(VAEncPictureParameterBufferVP8));
  
    picParam->ref_last_frame = VA_INVALID_SURFACE;
    picParam->ref_gf_frame = VA_INVALID_SURFACE;
    picParam->ref_arf_frame = VA_INVALID_SURFACE;
  
    /* always show it */
    picParam->pic_flags.bits.show_frame = 1;
  
    for (i = 0; i < N_ELEMENTS(picParam->loop_filter_level); i++) {
        picParam->loop_filter_level[i] = settings.loop_filter_level;
    }
  
    picParam->clamp_qindex_low = settings.clamp_qindex_low;
    picParam->clamp_qindex_high = settings.clamp_qindex_high;
  
  }
  
  void vp8enc_set_refreshparameter_for_svct_2layers(VAEncPictureParameterBufferVP8 *picParam, int current_frame, int *is_golden_refreshed)
  {
    //Pattern taken from libyami
  
    picParam->ref_flags.bits.no_ref_arf = 1;
  
    if(! *is_golden_refreshed)
      picParam->ref_flags.bits.no_ref_gf = 1;
  
    switch(current_frame % 2) {
      case 0:
        //Layer 0
        picParam->pic_flags.bits.refresh_last = 1;
        picParam->ref_flags.bits.no_ref_gf = 1;
        picParam->ref_flags.bits.temporal_id = 0;
        break;
      case 1:
        //Layer 1
        picParam->pic_flags.bits.refresh_golden_frame = 1;
        *is_golden_refreshed = 1;
        picParam->ref_flags.bits.temporal_id = 1;
        break;
    }
  }
  
  void vp8enc_set_refreshparameter_for_svct_3layers(VAEncPictureParameterBufferVP8 *picParam, int current_frame,int *is_golden_refreshed)
  {
    //Pattern taken from libyami - Note that the alternate frame is never referenced,
    //this is because, libyami implementation suggests to be able to drop individual
    //frames from Layer 2 on bad network connections
    picParam->ref_flags.bits.no_ref_arf = 1;
  
    if(! *is_golden_refreshed)
      picParam->ref_flags.bits.no_ref_gf = 1;
  
    switch(current_frame % 4) {
      case 0:
        //Layer 0
        picParam->pic_flags.bits.refresh_last = 1;
        picParam->ref_flags.bits.no_ref_gf = 1;
        picParam->ref_flags.bits.temporal_id = 0;
        break;
      case 1:
      case 3:
        //Layer 2
        picParam->pic_flags.bits.refresh_alternate_frame  = 1;
        picParam->ref_flags.bits.temporal_id = 2;
        break;
      case 2:
        //Layer 1
        picParam->pic_flags.bits.refresh_golden_frame = 1;
        *is_golden_refreshed = 1;
        picParam->ref_flags.bits.temporal_id = 1;
        break;
    }
  }
  
  void vp8enc_reset_picture_parameter_references(VAEncPictureParameterBufferVP8 *picParam)
  {
    picParam->ref_last_frame = VA_INVALID_SURFACE;
    picParam->ref_gf_frame = VA_INVALID_SURFACE;
    picParam->ref_arf_frame = VA_INVALID_SURFACE;
    picParam->pic_flags.bits.refresh_last = 0;
    picParam->pic_flags.bits.refresh_golden_frame = 0;
    picParam->pic_flags.bits.refresh_alternate_frame = 0;
    picParam->pic_flags.bits.copy_buffer_to_golden = 0;
    picParam->pic_flags.bits.copy_buffer_to_alternate = 0;
    picParam->ref_flags.bits.no_ref_last = 0;
    picParam->ref_flags.bits.no_ref_gf = 0;
    picParam->ref_flags.bits.no_ref_arf = 0;
  }
  
  void vp8enc_update_picture_parameter(int frame_type, int current_frame)
  {
    VAEncPictureParameterBufferVP8 *picParam = &vaapi_context.pic_param;
  
    picParam->reconstructed_frame = vaapi_context.recon_surface;
  
    vp8enc_reset_picture_parameter_references(picParam);
  
    if (frame_type == KEY_FRAME)
    {
      picParam->ref_flags.bits.force_kf = 1;
      picParam->pic_flags.bits.frame_type = KEY_FRAME;
      vaapi_context.is_golden_refreshed = 0;
      return;
    }
  
    // INTER_FRAME
    picParam->ref_flags.bits.force_kf = 0;
    picParam->pic_flags.bits.frame_type = INTER_FRAME;
  
    switch(settings.temporal_svc_layers)
    {
      case 1:
        //Standard behavoir only 1 Temporal Layer
        picParam->pic_flags.bits.refresh_last = 1;
        picParam->pic_flags.bits.copy_buffer_to_golden = 1;
        picParam->pic_flags.bits.copy_buffer_to_alternate = 2;
        picParam->ref_flags.bits.temporal_id = 0;
        break;
      case 2:
        //2 Temporal Layers
        vp8enc_set_refreshparameter_for_svct_2layers(picParam,current_frame,&vaapi_context.is_golden_refreshed);
        break;
      case 3:
        //3 Temporal Layers
        vp8enc_set_refreshparameter_for_svct_3layers(picParam,current_frame,&vaapi_context.is_golden_refreshed);
        break;
      default:
        //should never happen
        fprintf(stderr,"Error: Only 1,2 or 3 TemporalLayers supported.\n");
        assert(0);
        break;
    }
  
    if(!picParam->ref_flags.bits.no_ref_last)
      picParam->ref_last_frame = vaapi_context.last_ref_surface;
    if(!picParam->ref_flags.bits.no_ref_gf)
      picParam->ref_gf_frame = vaapi_context.golden_ref_surface;
    if(!picParam->ref_flags.bits.no_ref_arf)
      picParam->ref_arf_frame = vaapi_context.alt_ref_surface;
  
  }
  
  VASurfaceID vp8enc_get_unused_surface()
  {
    VASurfaceID current_surface;
    size_t i = 0;
  
    for (i = 0; i < NUM_REF_SURFACES; i++) {
          current_surface = vaapi_context.surfaces[i];
  
          if(current_surface != vaapi_context.last_ref_surface && current_surface != vaapi_context.golden_ref_surface && current_surface != vaapi_context.alt_ref_surface)
            return current_surface;
    }
  
    //No unused surface found - should never happen.
    fprintf(stderr, "Error: No unused surface found!\n");
    assert(0);
  
  }
  
  VASurfaceID vp8enc_update_reference(VASurfaceID current_surface, VASurfaceID second_copy_surface, bool refresh_with_recon, int copy_flag)
  {
    if(refresh_with_recon)
      return vaapi_context.recon_surface;
    switch(copy_flag)
    {
      case 0:
        return current_surface;
      case 1:
        return vaapi_context.last_ref_surface;
      case 2:
        return second_copy_surface;
      default: // should never happen
        fprintf(stderr, "Error: Invalid copy_buffer_to_X flag\n");
        assert(0);
    }
  
    return VA_INVALID_ID; // should never happen
  }
  
  
  void vp8enc_update_reference_list(int frame_type)
  {
  
    VAEncPictureParameterBufferVP8 *picParam = &vaapi_context.pic_param;
  
    if (frame_type == KEY_FRAME)
    {
       vaapi_context.last_ref_surface = vaapi_context.recon_surface;
       vaapi_context.golden_ref_surface = vaapi_context.recon_surface;
       vaapi_context.alt_ref_surface = vaapi_context.recon_surface;
    } else { // INTER_FRAME
       //check refresh_X and copy_buffer_to_golden_X and update references accordingly
       if(picParam->pic_flags.bits.refresh_last)
         vaapi_context.last_ref_surface = vaapi_context.recon_surface;
       vaapi_context.golden_ref_surface = vp8enc_update_reference(vaapi_context.golden_ref_surface,vaapi_context.alt_ref_surface,picParam->pic_flags.bits.refresh_golden_frame, picParam->pic_flags.bits.copy_buffer_to_golden );
       vaapi_context.alt_ref_surface = vp8enc_update_reference(vaapi_context.alt_ref_surface,vaapi_context.golden_ref_surface,picParam->pic_flags.bits.refresh_alternate_frame, picParam->pic_flags.bits.copy_buffer_to_alternate );
    }
  
    vaapi_context.recon_surface = vp8enc_get_unused_surface();
  }
  
  void vp8enc_init_MiscParameterBuffers(VAEncMiscParameterHRD *hrd, VAEncMiscParameterFrameRate *frame_rate, VAEncMiscParameterRateControl *rate_control)
  {
    if(hrd != NULL)
    {
      if(settings.frame_bitrate)
      {
        hrd->initial_buffer_fullness = settings.frame_bitrate * settings.hrd_window / 2;
        hrd->buffer_size = settings.frame_bitrate * settings.hrd_window;
      } else {
        hrd->initial_buffer_fullness = 0;
        hrd->buffer_size = 0;
      }
    }
  
    if(frame_rate != NULL)
    {
      frame_rate->framerate = settings.frame_rate;
    }
  
    if (rate_control != NULL)
    {
      rate_control->window_size = settings.hrd_window;
      rate_control->initial_qp = settings.quantization_parameter;
      rate_control->min_qp = settings.clamp_qindex_low;
      //rate_control->rc_flags.bits.disable_bit_stuffing = 1;
  
      if(settings.rc_mode == VA_RC_VBR)
      {
        rate_control->bits_per_second = settings.max_variable_bitrate * 1000;
        rate_control->target_percentage = (settings.frame_bitrate * 100) / settings.max_variable_bitrate;
      } else {
        rate_control->bits_per_second = settings.frame_bitrate * 1000;
        rate_control->target_percentage = 95;
  
      }
    }
  }
  
  void vp8enc_create_EncoderPipe()
  {
    VAEntrypoint entrypoints[5];
    int num_entrypoints;
    int i;
    bool entrypoint_found;
    VAConfigAttrib conf_attrib[2];
    VASurfaceAttrib surface_attrib;
    int major_ver, minor_ver;
    VAStatus va_status;
  
    vaapi_context.display = va_open_display();
    va_status = vaInitialize(vaapi_context.display, &major_ver, &minor_ver);
    CHECK_VASTATUS(va_status, "vaInitialize");
  
    vaQueryConfigEntrypoints(vaapi_context.display, vaapi_context.profile, entrypoints,
                             &num_entrypoints);
  
    entrypoint_found = true;
    for(i = 0; i < num_entrypoints;i++)
    {
      if (entrypoints[i] == settings.vaapi_entry_point)
        entrypoint_found = true;
    }
  
    if(entrypoint_found == false)
    {
      fprintf(stderr,"Error: VAEntrypoint not found!\n");
      assert(0);
    }
  
    /* find out the format for the render target, and rate control mode */
    conf_attrib[0].type = VAConfigAttribRTFormat;
    conf_attrib[1].type = VAConfigAttribRateControl;
    vaGetConfigAttributes(vaapi_context.display, vaapi_context.profile, settings.vaapi_entry_point,
                          &conf_attrib[0], 2);
  
    if ((conf_attrib[0].value & VA_RT_FORMAT_YUV420) == 0) {
        fprintf(stderr, "Error: Input colorspace YUV420 not supported, exit\n");
        assert(0);
    }
  
    if ((conf_attrib[1].value & settings.rc_mode) == 0) {
        /* Can't find matched RC mode */
        fprintf(stderr, "Error: Can't find the desired RC mode, exit\n");
        assert(0);
    }
  
    conf_attrib[0].value = VA_RT_FORMAT_YUV420; /* set to desired RT format */
    conf_attrib[1].value = settings.rc_mode; /* set to desired RC mode */
  
    va_status = vaCreateConfig(vaapi_context.display, vaapi_context.profile, settings.vaapi_entry_point,
                               &conf_attrib[0], 2,&vaapi_context.config_id);
    CHECK_VASTATUS(va_status, "vaCreateConfig");
  
    surface_attrib.type = VASurfaceAttribPixelFormat;
    surface_attrib.flags = VA_SURFACE_ATTRIB_SETTABLE;
    surface_attrib.value.type = VAGenericValueTypeInteger;
    surface_attrib.value.value.i = VA_FOURCC_NV12;
  
    // Create surface (Reference Surfaces + Input Surfaces)
    va_status = vaCreateSurfaces(
        vaapi_context.display,
        VA_RT_FORMAT_YUV420, settings.width, settings.height,
        vaapi_context.surfaces, NUM_SURFACES_TOTAL,
        &surface_attrib, 1
    );
  
    CHECK_VASTATUS(va_status, "vaCreateSurfaces");
  
    vaapi_context.recon_surface = vaapi_context.surfaces[0];
    vaapi_context.last_ref_surface = VA_INVALID_SURFACE;
    vaapi_context.golden_ref_surface = VA_INVALID_SURFACE;
    vaapi_context.alt_ref_surface = VA_INVALID_SURFACE;
    vaapi_context.input_surface = vaapi_context.surfaces[NUM_REF_SURFACES]; // input surfaces trail the reference surfaces
  
    /* Create a context for this Encoder pipe */
    /* the surface is added to the render_target list when creating the context */
    va_status = vaCreateContext(vaapi_context.display, vaapi_context.config_id,
                                settings.width, settings.height,
                                VA_PROGRESSIVE,
                                vaapi_context.surfaces, NUM_SURFACES_TOTAL,
                                &vaapi_context.context_id);
  
    CHECK_VASTATUS(va_status, "vaCreateContext");
  
  
  }
  
  void vp8enc_destory_EncoderPipe()
  {
      pthread_join(vaapi_context.upload_thread.id,NULL);
      vaDestroySurfaces(vaapi_context.display, vaapi_context.surfaces, NUM_SURFACES_TOTAL);
      vaDestroyContext(vaapi_context.display,vaapi_context.context_id);
      vaDestroyConfig(vaapi_context.display,vaapi_context.config_id);
      vaTerminate(vaapi_context.display);
      va_close_display(vaapi_context.display);
  }
  
  
  void vp8enc_init_VaapiContext()
  {
    size_t i;
    vaapi_context.profile = VAProfileVP8Version0_3;
  
    vp8enc_init_SequenceParameterBuffer(&vaapi_context.seq_param);
    vp8enc_init_PictureParameterBuffer(&vaapi_context.pic_param);
    vp8enc_init_QMatrix(&vaapi_context.q_matrix);
  
    vaapi_context.hrd_param.header.type = VAEncMiscParameterTypeHRD;
    vaapi_context.frame_rate_param.header.type = VAEncMiscParameterTypeFrameRate;
    vaapi_context.rate_control_param.header.type = VAEncMiscParameterTypeRateControl;
    vp8enc_init_MiscParameterBuffers(&vaapi_context.hrd_param.data, &vaapi_context.frame_rate_param.data,&vaapi_context.rate_control_param.data);
  
    for(i = 0; i < N_ELEMENTS(vaapi_context.va_buffers);i++)
      vaapi_context.va_buffers[i] = VA_INVALID_ID;
    vaapi_context.num_va_buffers = 0;
  
    vaapi_context.is_golden_refreshed = 0;
  }
  
  
  
  static int
  vp8enc_store_coded_buffer(FILE *vp8_fp,uint64_t timestamp)
  {
      VACodedBufferSegment *coded_buffer_segment;
      uint8_t *coded_mem;
      int data_length;
      VAStatus va_status;
      VASurfaceStatus surface_status;
      size_t w_items;
  
      va_status = vaSyncSurface(vaapi_context.display, vaapi_context.recon_surface);
      CHECK_VASTATUS(va_status,"vaSyncSurface");
  
      surface_status = 0;
      va_status = vaQuerySurfaceStatus(vaapi_context.display, vaapi_context.recon_surface, &surface_status);
      CHECK_VASTATUS(va_status,"vaQuerySurfaceStatus");
  
      va_status = vaMapBuffer(vaapi_context.display, vaapi_context.codedbuf_buf_id, (void **)(&coded_buffer_segment));
      CHECK_VASTATUS(va_status,"vaMapBuffer");
      coded_mem = coded_buffer_segment->buf;
  
      if (coded_buffer_segment->status & VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK) {
          fprintf(stderr,"Error: CodeBuffer Size too small\n");
          vaUnmapBuffer(vaapi_context.display, vaapi_context.codedbuf_buf_id);
          assert(0);
      }
  
      data_length = coded_buffer_segment->size;
  
      vp8enc_write_frame_header(vp8_fp, data_length,timestamp);
  
      do {
          w_items = fwrite(coded_mem, data_length, 1, vp8_fp);
      } while (w_items != 1);
  
      if(settings.debug)
        fprintf(stderr,"Timestamp: %ld Bytes written %d\n",timestamp,data_length);
  
      vaUnmapBuffer(vaapi_context.display, vaapi_context.codedbuf_buf_id);
  
      return 0;
  }
  
  size_t vp8enc_get_FileSize(FILE *fp)
  {
    struct stat st;
    fstat(fileno(fp), &st);
    return st.st_size;
  }
  
  int vp8enc_prepare_buffers(int frame_type)
  {
    int num_buffers = 0;
    VABufferID *va_buffers;
    VAStatus va_status;
    VAEncPictureParameterBufferVP8 *picParam = &vaapi_context.pic_param;
  
  
    va_buffers = vaapi_context.va_buffers;
    /* coded buffer */
    va_status = vaCreateBuffer(vaapi_context.display,
                                 vaapi_context.context_id,
                                 VAEncCodedBufferType,
                                 settings.codedbuf_size, 1, NULL,
                                 &vaapi_context.codedbuf_buf_id);
    CHECK_VASTATUS(va_status,"vaCreateBuffer");
  
    /* sequence parameter set */
    va_status = vaCreateBuffer(vaapi_context.display,
                               vaapi_context.context_id,
                               VAEncSequenceParameterBufferType,
                               sizeof(vaapi_context.seq_param), 1, &vaapi_context.seq_param,
                               va_buffers);
    CHECK_VASTATUS(va_status,"vaCreateBuffer");
  
    va_buffers ++; num_buffers++;
  
    /* picture parameter set */
    picParam->coded_buf = vaapi_context.codedbuf_buf_id;
  
    va_status = vaCreateBuffer(vaapi_context.display,
                               vaapi_context.context_id,
                               VAEncPictureParameterBufferType,
                               sizeof(vaapi_context.pic_param), 1, &vaapi_context.pic_param,
                               va_buffers);
    CHECK_VASTATUS(va_status,"vaCreateBuffer");
    va_buffers ++; num_buffers++;
  
  
  
    /* hrd parameter */
    vaCreateBuffer(vaapi_context.display,
                   vaapi_context.context_id,
                   VAEncMiscParameterBufferType,
                   sizeof(vaapi_context.hrd_param), 1, &vaapi_context.hrd_param,
                   va_buffers);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");
  
    va_buffers ++; num_buffers++;
  
    /* QMatrix */
    va_status = vaCreateBuffer(vaapi_context.display,
                         vaapi_context.context_id,
                         VAQMatrixBufferType,
                         sizeof(vaapi_context.q_matrix), 1, &vaapi_context.q_matrix,
                         va_buffers);
    CHECK_VASTATUS(va_status,"vaCreateBuffer");
  
  
    va_buffers ++; num_buffers++;
    /* Create the Misc FR/RC buffer under non-CQP mode */
    if (settings.rc_mode != VA_RC_CQP && frame_type == KEY_FRAME) {
      vaCreateBuffer(vaapi_context.display,
                         vaapi_context.context_id,
                         VAEncMiscParameterBufferType,
                         sizeof(vaapi_context.frame_rate_param),1,&vaapi_context.frame_rate_param,
                         va_buffers);
      CHECK_VASTATUS(va_status, "vaCreateBuffer");
  
      va_buffers ++; num_buffers++;
  
      vaCreateBuffer(vaapi_context.display,
                         vaapi_context.context_id,
                         VAEncMiscParameterBufferType,
                         sizeof(vaapi_context.rate_control_param),1,&vaapi_context.rate_control_param,
                         va_buffers);
      CHECK_VASTATUS(va_status, "vaCreateBuffer");
  
      va_buffers ++; num_buffers++;
    }
  
    vaapi_context.num_va_buffers = num_buffers;
  
    return num_buffers;
  }
  
  
  
  
  static void
  vp8enc_render_picture()
  {
      VAStatus va_status;
  
      va_status = vaBeginPicture(vaapi_context.display,
                                 vaapi_context.context_id,
                                 vaapi_context.input_surface);
      CHECK_VASTATUS(va_status,"vaBeginPicture");
  
  
      va_status = vaRenderPicture(vaapi_context.display,
                                  vaapi_context.context_id,
                                  vaapi_context.va_buffers,
                                  vaapi_context.num_va_buffers);
      CHECK_VASTATUS(va_status,"vaRenderPicture");
  
      va_status = vaEndPicture(vaapi_context.display, vaapi_context.context_id);
      CHECK_VASTATUS(va_status,"vaEndPicture");
  
  }
  
  void vp8enc_destroy_buffers()
  {
    int i;
    VAStatus va_status;
  
    for(i = 0; i < vaapi_context.num_va_buffers; i++) {
      if (vaapi_context.va_buffers[i] != VA_INVALID_ID) {
        va_status = vaDestroyBuffer(vaapi_context.display, vaapi_context.va_buffers[i]);
        CHECK_VASTATUS(va_status,"vaDestroyBuffer");
        vaapi_context.va_buffers[i] = VA_INVALID_ID;
      }
    }
  
    if (vaapi_context.codedbuf_buf_id != VA_INVALID_ID) {
      va_status = vaDestroyBuffer(vaapi_context.display, vaapi_context.codedbuf_buf_id);
      CHECK_VASTATUS(va_status,"vaDestroyBuffer");
      vaapi_context.codedbuf_buf_id = VA_INVALID_ID;
    }
  
  }
  void vp8enc_show_help ()
  {
    printf("Usage: vp8enc <width> <height> <input_yuvfile> <output_vp8> additional_option\n");
    printf("output_vp8 should use *.ivf\n");
    printf("The additional option is listed\n");
    printf("-f <frame rate> \n");
    printf("--intra_period <key_frame interval>\n");
    printf("--qp <quantization parameter> \n");
    printf("--rcmode <rate control mode> 0: CQP, 1: CBR, 2: VBR\n");
    printf("--fb <bitrate> (kbps unit)\n");
    printf("--lf_level <loop filter level>  [0-63]\n");
    printf("--hrd_win <num>  [1000-8000]\n");
    printf("--vbr_max <num> (kbps unit. It should be greater than fb)\n");
    printf("--fn_num <num>\n  how many frames to be encoded\n");
    printf("--error_resilient Turn on Error resilient mode\n");
    printf("--debug Turn debug info on\n");
    printf("--temp_svc <num> Number of temporal layers 2 or 3\n");
    printf("--repeat <num> Number of times to repeat the encoding\n");
  }
  
  void parameter_check(const char *param, int val, int min, int max)
  {
    if(val < min || val > max)
    {
      fprintf(stderr,"Error: %s out of range (%d..%d) \n",param,min,max);
      exit(VP8ENC_FAIL);
    }
  }
  
  void parameter_check_positive(const char *param, int val, int min)
  {
    if(val < 1)
    {
      fprintf(stderr,"Error: %s demands a positive value greater than %d \n",param,min);
      exit(VP8ENC_FAIL);
    }
  }
  
  int parse_options(int ac,char *av[])
  {
    int c, long_index, tmp_input;
    while (1) {
        c = getopt_long_only(ac,av,"hf:?",long_opts,&long_index);
  
        if (c == -1)
            break;
  
        switch(c) {
        case 'f':
            tmp_input = atoi(optarg);
            parameter_check_positive("-f",tmp_input,1);
            settings.frame_rate = tmp_input;
            break;
        case 1:
            tmp_input = atoi(optarg);
            parameter_check("--rcmode", tmp_input, 0, 2);
            settings.rc_mode = default_rc_modes[tmp_input];
            break;
        case 2:
            tmp_input = atoi(optarg);
            parameter_check("--qp", tmp_input, 0, 255);
            settings.quantization_parameter = tmp_input;
            break;
        case 3:
            tmp_input = atoi(optarg);
            parameter_check_positive("--intra_period",tmp_input,1);
            settings.intra_period = tmp_input;
            break;
        case 4:
            tmp_input = atoi(optarg);
            parameter_check_positive("--fb",tmp_input,1);
            settings.frame_bitrate = tmp_input;
            break;
        case 5:
            tmp_input = atoi(optarg);
            parameter_check("--lf_level",tmp_input, 0, 63);
            settings.loop_filter_level = tmp_input;
            break;
        case 6:
            tmp_input = atoi(optarg);
            parameter_check("--hrd_win",tmp_input,1000,8000);
            settings.hrd_window = tmp_input;
            break;
        case 7:
            tmp_input = atoi(optarg);
            parameter_check_positive("--vbr_max",tmp_input,1);
            settings.max_variable_bitrate = tmp_input;
            break;
        case 8:
            tmp_input = atoi(optarg);
            parameter_check_positive("--fn_num" ,tmp_input,1);
            settings.num_frames = tmp_input;
            break;
        case 9:
            settings.error_resilient = 1;
            break;
        case 10:
            settings.debug = 1;
            break;
        case 11:
            tmp_input = atoi(optarg);
            parameter_check("--temp_svc",tmp_input,2,3);
            settings.temporal_svc_layers = tmp_input;
            break;
        case 12:
            tmp_input = atoi(optarg);
            parameter_check("--repeat", tmp_input, 1, 1000000);
            settings.repeat_times = tmp_input;
            break;
        case 'h':
        case 0:
        default:
            return PARSE_OPTIONS_FAIL;
            break;
      }
    }
    return PARSE_OPTIONS_OK;
  }
  
  int main(int argc, char *argv[])
  {
    int current_frame, frame_type;
    FILE *fp_vp8_output = NULL;
    FILE *fp_yuv_input = NULL;
    uint64_t timestamp;
    struct timeval t1,t2;
    double fps, elapsed_time;
  
  
    if(argc < 5) {
        vp8enc_show_help();
        return VP8ENC_FAIL;
    }
  
    if(parse_options(argc-4, &argv[4]) != PARSE_OPTIONS_OK)
    {
      vp8enc_show_help();
      return VP8ENC_FAIL;
    }
  
    settings.width = atoi(argv[1]);
    parameter_check("Width", settings.width, 16, MAX_XY_RESOLUTION);
  
    settings.height = atoi(argv[2]);
    parameter_check("Height", settings.height, 16, MAX_XY_RESOLUTION);
  
    if( settings.rc_mode == VA_RC_VBR && settings.max_variable_bitrate < settings.frame_bitrate)
    {
        fprintf(stderr,"Error: max. variable bitrate should be greater than frame bitrate (--vbr_max >= --fb)\n");
        return VP8ENC_FAIL;
    }
  
    if(argv[3]) {
      fp_yuv_input = fopen(argv[3],"rb");
    }
    if(fp_yuv_input == NULL)
    {
      fprintf(stderr,"Error: Couldn't open input file.\n");
      return VP8ENC_FAIL;
    }
    vaapi_context.upload_thread.input_fp = fp_yuv_input;
  
    fp_vp8_output = fopen(argv[4],"wb");
    if(fp_vp8_output == NULL)
    {
      fprintf(stderr,"Error: Couldn't open output file.\n");
      return VP8ENC_FAIL;
    }
  
    if( settings.temporal_svc_layers == 2 && settings.intra_period % 2)
        fprintf(stderr,"Warning: Choose Key-Frame interval (--intra_period) to be integer mutliply of 2 to match temporal layer pattern");
  
    if ( settings.temporal_svc_layers == 3 && settings.intra_period % 4 )
        fprintf(stderr,"Warning: Choose Key-Frame interval (--intra_period) to be integer mutliply of 4 to match temporal layer pattern");
  
  
    settings.frame_size = settings.width * settings.height * 3 / 2; //NV12 Colorspace - For a 2x2 group of pixels, you have 4 Y samples and 1 U and 1 V sample.
    if(!settings.num_frames)
      settings.num_frames = vp8enc_get_FileSize(fp_yuv_input)/(size_t)settings.frame_size;
    settings.codedbuf_size = settings.width * settings.height; //just a generous assumptions
  
    fprintf(stderr,"Info: Encoding total of %d frames.\n",settings.num_frames);
  
    gettimeofday(&t1,0); //Measure Runtime
  
    vp8enc_init_VaapiContext();
    vp8enc_create_EncoderPipe();
  
    vp8enc_write_ivf_header(fp_vp8_output);
  
    current_frame = 0;
    timestamp = 0;
    vaapi_context.input_surface = vaapi_context.surfaces[SID_INPUT_PICTURE_0];
    vaapi_context.upload_thread.input_surface_num = SID_INPUT_PICTURE_0;
  
    while (current_frame < settings.num_frames * settings.repeat_times)
    {
      fprintf(stderr,"\rProcessing frame: %d",current_frame);
  
      if ( (current_frame % settings.intra_period) == 0)
        frame_type = KEY_FRAME;
      else
        frame_type = INTER_FRAME;
  
      if(current_frame == 0) {
        // Preload first input_surface
        vp8enc_upload_yuv_to_surface(fp_yuv_input, vaapi_context.input_surface, current_frame); //prefill
      } else {
        // wait for input processing thread to finish
        pthread_join(vaapi_context.upload_thread.id, NULL);
        vaapi_context.input_surface = vaapi_context.upload_thread.input_surface;
      }
  
      // Start Upload thread
      if((current_frame + 1) < settings.num_frames * settings.repeat_times) {
        vaapi_context.upload_thread.processed_frame = (current_frame % settings.num_frames - 1) + 1;
  
        if(vaapi_context.upload_thread.input_surface_num == SID_INPUT_PICTURE_0)
          vaapi_context.upload_thread.input_surface_num = SID_INPUT_PICTURE_1;
        else
          vaapi_context.upload_thread.input_surface_num = SID_INPUT_PICTURE_0;
  
        vaapi_context.upload_thread.input_surface = vaapi_context.surfaces[vaapi_context.upload_thread.input_surface_num];
        vaapi_context.upload_thread.value = pthread_create(&vaapi_context.upload_thread.id,NULL,vp8enc_upload_thread_function,NULL);
      }
  
  
      vp8enc_update_picture_parameter(frame_type, current_frame);
      vp8enc_prepare_buffers(frame_type);
  
      vp8enc_render_picture();
  
      vp8enc_store_coded_buffer(fp_vp8_output, timestamp);
      vp8enc_destroy_buffers();
  
      vp8enc_update_reference_list(frame_type);
  
      current_frame ++;
      timestamp ++;
    }
  
    vp8enc_destory_EncoderPipe();
    fclose(fp_vp8_output);
    fclose(fp_yuv_input);
  
    gettimeofday(&t2,0);
    elapsed_time = (double)(t2.tv_sec-t1.tv_sec)+(double)(t2.tv_usec-t1.tv_usec)/1000000.0;
    fps = (double)current_frame/elapsed_time;
  
    fprintf(stderr, "\nProcessed %d frames in %.0f ms (%.2f FPS)\n",current_frame,elapsed_time*1000.0,fps);
  
    return VP8ENC_OK;
  }
  