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         output_value |= negative_flag << (out_int_bits + out_frac_bits);
  82     }
  83     return output_value;
  84 }
  85
  86 static pthread_mutex_t free_hevc_surface_lock = PTHREAD_MUTEX_INITIALIZER;
  87
  88 void
  89 gen_free_hevc_surface(void **data)
  90 {
  91     GenHevcSurface *hevc_surface;
  92
  93     pthread_mutex_lock(&free_hevc_surface_lock);
  94
  95     hevc_surface = *data;
  96
  97     if (!hevc_surface) {
  98         pthread_mutex_unlock(&free_hevc_surface_lock);
  99         return;
 100     }
 101
 102     dri_bo_unreference(hevc_surface->motion_vector_temporal_bo);
 103     hevc_surface->motion_vector_temporal_bo = NULL;
 104
 105     if (hevc_surface->nv12_surface_obj) {
 106         i965_DestroySurfaces(hevc_surface->ctx, &hevc_surface->nv12_surface_id, 1);
 107         hevc_surface->nv12_surface_id = VA_INVALID_SURFACE;
 108         hevc_surface->nv12_surface_obj = NULL;
 109     }
 110
 111     free(hevc_surface);
 112     *data = NULL;
 113
 114     pthread_mutex_unlock(&free_hevc_surface_lock);
 115 }
 116
 117 static pthread_mutex_t free_vp9_surface_lock = PTHREAD_MUTEX_INITIALIZER;
 118
 119 void gen_free_vp9_surface(void **data)
 120 {
 121     GenVP9Surface *vp9_surface;
 122
 123     pthread_mutex_lock(&free_vp9_surface_lock);
 124
 125     vp9_surface = *data;
 126
 127     if (!vp9_surface) {
 128         pthread_mutex_unlock(&free_vp9_surface_lock);
 129         return;
 130     }
 131
 132     free(vp9_surface);
 133     *data = NULL;
 134
 135     pthread_mutex_unlock(&free_vp9_surface_lock);
 136 }
 137
 138 extern VAStatus
 139 i965_DestroySurfaces(VADriverContextP ctx,
 140                      VASurfaceID *surface_list,
 141                      int num_surfaces);
 142
 143 static pthread_mutex_t free_vdenc_avc_surface_lock = PTHREAD_MUTEX_INITIALIZER;
 144
 145 void
 146 vdenc_free_avc_surface(void **data)
 147 {
 148     VDEncAvcSurface *avc_surface;
 149
 150     pthread_mutex_lock(&free_vdenc_avc_surface_lock);
 151
 152     avc_surface = *data;
 153
 154     if (!avc_surface) {
 155         pthread_mutex_unlock(&free_vdenc_avc_surface_lock);
 156         return;
 157     }
 158
 159     if (avc_surface->scaled_4x_surface_obj) {
 160         i965_DestroySurfaces(avc_surface->ctx, &avc_surface->scaled_4x_surface_id, 1);
 161         avc_surface->scaled_4x_surface_id = VA_INVALID_SURFACE;
 162         avc_surface->scaled_4x_surface_obj = NULL;
 163     }
 164
 165     free(avc_surface);
 166     *data = NULL;
 167
 168     pthread_mutex_unlock(&free_vdenc_avc_surface_lock);
 169 }