src/intel_media_common.c

   1 /*
   2  * Copyright (C) 2006-2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28 #include <math.h>
  29
  30 #include "intel_driver.h"
  31 #include "intel_media.h"
  32 #include "i965_drv_video.h"
  33
  34 static pthread_mutex_t free_avc_surface_lock = PTHREAD_MUTEX_INITIALIZER;
  35
  36 void
  37 gen_free_avc_surface(void **data)
  38 {
  39     GenAvcSurface *avc_surface;
  40
  41     pthread_mutex_lock(&free_avc_surface_lock);
  42
  43     avc_surface = *data;
  44
  45     if (!avc_surface) {
  46         pthread_mutex_unlock(&free_avc_surface_lock);
  47         return;
  48     }
  49
  50
  51     dri_bo_unreference(avc_surface->dmv_top);
  52     avc_surface->dmv_top = NULL;
  53     dri_bo_unreference(avc_surface->dmv_bottom);
  54     avc_surface->dmv_bottom = NULL;
  55
  56     free(avc_surface);
  57     *data = NULL;
  58
  59     pthread_mutex_unlock(&free_avc_surface_lock);
  60 }
  61
  62 /* This is to convert one float to the given format interger.
  63  * For example: 1.25 to S1.6 or U2.6 and so on
  64  */
  65 int intel_format_convert(float src, int out_int_bits, int out_frac_bits,int out_sign_flag)
  66 {
  67      unsigned char negative_flag = (src < 0.0) ? 1 : 0;
  68      float src_1 = (!negative_flag)? src: -src ;
  69      unsigned int factor = 1 << out_frac_bits;
  70      int output_value = 0;
  71
  72      unsigned int integer_part  = floorf(src_1);
  73      unsigned int fraction_part = ((int)((src_1 - integer_part) * factor)) & (factor - 1) ;
  74
  75      output_value = (integer_part << out_frac_bits) | fraction_part;
  76
  77      if(negative_flag)
  78          output_value = (~output_value + 1) & ((1 <<(out_int_bits + out_frac_bits)) -1);
  79
  80      if(output_value != 0 && out_sign_flag == 1 && negative_flag)
  81      {
  82           output_value |= negative_flag <<(out_int_bits + out_frac_bits);
  83      }
  84      return output_value;
  85 }
  86
  87 static pthread_mutex_t free_hevc_surface_lock = PTHREAD_MUTEX_INITIALIZER;
  88
  89 void
  90 gen_free_hevc_surface(void **data)
  91 {
  92     GenHevcSurface *hevc_surface;
  93
  94     pthread_mutex_lock(&free_hevc_surface_lock);
  95
  96     hevc_surface = *data;
  97
  98     if (!hevc_surface) {
  99         pthread_mutex_unlock(&free_hevc_surface_lock);
 100         return;
 101     }
 102
 103     dri_bo_unreference(hevc_surface->motion_vector_temporal_bo);
 104     hevc_surface->motion_vector_temporal_bo = NULL;
 105
 106     if (hevc_surface->nv12_surface_obj) {
 107         i965_DestroySurfaces(hevc_surface->ctx, &hevc_surface->nv12_surface_id, 1);
 108         hevc_surface->nv12_surface_id = VA_INVALID_SURFACE;
 109         hevc_surface->nv12_surface_obj = NULL;
 110     }
 111
 112     free(hevc_surface);
 113     *data = NULL;
 114
 115     pthread_mutex_unlock(&free_hevc_surface_lock);
 116 }
 117
 118 static pthread_mutex_t free_vp9_surface_lock = PTHREAD_MUTEX_INITIALIZER;
 119
 120 void gen_free_vp9_surface(void **data)
 121 {
 122     GenVP9Surface *vp9_surface;
 123
 124     pthread_mutex_lock(&free_vp9_surface_lock);
 125
 126     vp9_surface = *data;
 127
 128     if (!vp9_surface) {
 129         pthread_mutex_unlock(&free_vp9_surface_lock);
 130         return;
 131     }
 132
 133     free(vp9_surface);
 134     *data = NULL;
 135
 136     pthread_mutex_unlock(&free_vp9_surface_lock);
 137 }
 138
 139 extern VAStatus
 140 i965_DestroySurfaces(VADriverContextP ctx,
 141                      VASurfaceID *surface_list,
 142                      int num_surfaces);
 143
 144 static pthread_mutex_t free_vdenc_avc_surface_lock = PTHREAD_MUTEX_INITIALIZER;
 145
 146 void
 147 vdenc_free_avc_surface(void **data)
 148 {
 149     VDEncAvcSurface *avc_surface;
 150
 151     pthread_mutex_lock(&free_vdenc_avc_surface_lock);
 152
 153     avc_surface = *data;
 154
 155     if (!avc_surface) {
 156         pthread_mutex_unlock(&free_vdenc_avc_surface_lock);
 157         return;
 158     }
 159
 160     if (avc_surface->scaled_4x_surface_obj) {
 161         i965_DestroySurfaces(avc_surface->ctx, &avc_surface->scaled_4x_surface_id, 1);
 162         avc_surface->scaled_4x_surface_id = VA_INVALID_SURFACE;
 163         avc_surface->scaled_4x_surface_obj = NULL;
 164     }
 165
 166     free(avc_surface);
 167     *data = NULL;
 168
 169     pthread_mutex_unlock(&free_vdenc_avc_surface_lock);
 170 }