Home | History | Annotate | Download | only in osal 
      1 /*
      2  *
      3  * Copyright 2012 Samsung Electronics S.LSI Co. LTD
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at
      8  *
      9  *      http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  */
     17 
     18 /*
     19  * @file        Exynos_OSAL_ETC.c
     20  * @brief
     21  * @author      SeungBeom Kim (sbcrux.kim (at) samsung.com)
     22  * @version     2.0.0
     23  * @history
     24  *   2012.02.20 : Create
     25  */
     26 
     27 #include <stdio.h>
     28 #include <stdlib.h>
     29 #include <string.h>
     30 #include <sys/time.h>
     31 
     32 #include "Exynos_OSAL_Memory.h"
     33 #include "Exynos_OSAL_ETC.h"
     34 #include "Exynos_OSAL_Log.h"
     35 
     36 static struct timeval perfStart[PERF_ID_MAX+1], perfStop[PERF_ID_MAX+1];
     37 static unsigned long perfTime[PERF_ID_MAX+1], totalPerfTime[PERF_ID_MAX+1];
     38 static unsigned int perfFrameCount[PERF_ID_MAX+1], perfOver30ms[PERF_ID_MAX+1];
     39 
     40 #ifndef HAVE_GETLINE
     41 ssize_t getline(char **ppLine, size_t *pLen, FILE *pStream)
     42 {
     43     char *pCurrentPointer = NULL;
     44     size_t const chunk = 512;
     45 
     46     size_t defaultBufferSize = chunk + 1;
     47     size_t retSize = 0;
     48 
     49     if (*ppLine == NULL) {
     50         *ppLine = (char *)malloc(defaultBufferSize);
     51         if (*ppLine == NULL) {
     52             retSize = -1;
     53             goto EXIT;
     54         }
     55         *pLen = defaultBufferSize;
     56     }
     57     else {
     58         if (*pLen < defaultBufferSize) {
     59             *ppLine = (char *)realloc(*ppLine, defaultBufferSize);
     60             if (*ppLine == NULL) {
     61                 retSize = -1;
     62                 goto EXIT;
     63             }
     64             *pLen = defaultBufferSize;
     65         }
     66     }
     67 
     68     while (1) {
     69         size_t i;
     70         size_t j = 0;
     71         size_t readByte = 0;
     72 
     73         pCurrentPointer = *ppLine + readByte;
     74 
     75         i = fread(pCurrentPointer, 1, chunk, pStream);
     76         if (i < chunk && ferror(pStream)) {
     77             retSize = -1;
     78             goto EXIT;
     79         }
     80         while (j < i) {
     81             ++j;
     82             if (*pCurrentPointer++ == (char)'\n') {
     83                 *pCurrentPointer = '\0';
     84                 if (j != i) {
     85                     if (fseek(pStream, j - i, SEEK_CUR)) {
     86                         retSize = -1;
     87                         goto EXIT;
     88                 }
     89                     if (feof(pStream))
     90                         clearerr(pStream);
     91                 }
     92                 readByte += j;
     93                 retSize = readByte;
     94                 goto EXIT;
     95             }
     96         }
     97 
     98         readByte += j;
     99         if (feof(pStream)) {
    100             if (readByte) {
    101                 retSize = readByte;
    102                 goto EXIT;
    103             }
    104             if (!i) {
    105                 retSize = -1;
    106                 goto EXIT;
    107             }
    108         }
    109 
    110         i = ((readByte + (chunk * 2)) / chunk) * chunk;
    111         if (i != *pLen) {
    112             *ppLine = (char *)realloc(*ppLine, i);
    113             if (*ppLine == NULL) {
    114                 retSize = -1;
    115                 goto EXIT;
    116         }
    117             *pLen = i;
    118         }
    119     }
    120 
    121 EXIT:
    122     return retSize;
    123 }
    124 #endif /* HAVE_GETLINE */
    125 
    126 OMX_PTR Exynos_OSAL_Strcpy(OMX_PTR dest, OMX_PTR src)
    127 {
    128     return strcpy(dest, src);
    129 }
    130 
    131 OMX_PTR Exynos_OSAL_Strncpy(OMX_PTR dest, OMX_PTR src, size_t num)
    132 {
    133     return strncpy(dest, src, num);
    134 }
    135 
    136 OMX_S32 Exynos_OSAL_Strcmp(OMX_PTR str1, OMX_PTR str2)
    137 {
    138     return strcmp(str1, str2);
    139 }
    140 
    141 OMX_S32 Exynos_OSAL_Strncmp(OMX_PTR str1, OMX_PTR str2, size_t num)
    142 {
    143     return strncmp(str1, str2, num);
    144 }
    145 
    146 OMX_PTR Exynos_OSAL_Strcat(OMX_PTR dest, OMX_PTR src)
    147 {
    148     return strcat(dest, src);
    149 }
    150 
    151 OMX_PTR Exynos_OSAL_Strncat(OMX_PTR dest, OMX_PTR src, size_t num)
    152 {
    153     return strncat(dest, src, num);
    154 }
    155 
    156 size_t Exynos_OSAL_Strlen(const char *str)
    157 {
    158     return strlen(str);
    159 }
    160 
    161 static OMX_U32 MeasureTime(struct timeval *start, struct timeval *stop)
    162 {
    163     unsigned long sec, usec, time;
    164 
    165     sec = stop->tv_sec - start->tv_sec;
    166     if (stop->tv_usec >= start->tv_usec) {
    167         usec = stop->tv_usec - start->tv_usec;
    168     } else {
    169         usec = stop->tv_usec + 1000000 - start->tv_usec;
    170         sec--;
    171     }
    172 
    173     time = sec * 1000000 + (usec);
    174 
    175     return time;
    176 }
    177 
    178 void Exynos_OSAL_PerfInit(PERF_ID_TYPE id)
    179 {
    180     memset(&perfStart[id], 0, sizeof(perfStart[id]));
    181     memset(&perfStop[id], 0, sizeof(perfStop[id]));
    182     perfTime[id] = 0;
    183     totalPerfTime[id] = 0;
    184     perfFrameCount[id] = 0;
    185     perfOver30ms[id] = 0;
    186 }
    187 
    188 void Exynos_OSAL_PerfStart(PERF_ID_TYPE id)
    189 {
    190     gettimeofday(&perfStart[id], NULL);
    191 }
    192 
    193 void Exynos_OSAL_PerfStop(PERF_ID_TYPE id)
    194 {
    195     gettimeofday(&perfStop[id], NULL);
    196 
    197     perfTime[id] = MeasureTime(&perfStart[id], &perfStop[id]);
    198     totalPerfTime[id] += perfTime[id];
    199     perfFrameCount[id]++;
    200 
    201     if (perfTime[id] > 30000)
    202         perfOver30ms[id]++;
    203 }
    204 
    205 OMX_U32 Exynos_OSAL_PerfFrame(PERF_ID_TYPE id)
    206 {
    207     return perfTime[id];
    208 }
    209 
    210 OMX_U32 Exynos_OSAL_PerfTotal(PERF_ID_TYPE id)
    211 {
    212     return totalPerfTime[id];
    213 }
    214 
    215 OMX_U32 Exynos_OSAL_PerfFrameCount(PERF_ID_TYPE id)
    216 {
    217     return perfFrameCount[id];
    218 }
    219 
    220 int Exynos_OSAL_PerfOver30ms(PERF_ID_TYPE id)
    221 {
    222     return perfOver30ms[id];
    223 }
    224 
    225 void Exynos_OSAL_PerfPrint(OMX_STRING prefix, PERF_ID_TYPE id)
    226 {
    227     OMX_U32 perfTotal;
    228     int frameCount;
    229 
    230     frameCount = Exynos_OSAL_PerfFrameCount(id);
    231     perfTotal = Exynos_OSAL_PerfTotal(id);
    232 
    233     Exynos_OSAL_Log(EXYNOS_LOG_INFO, "%s Frame Count: %d", prefix, frameCount);
    234     Exynos_OSAL_Log(EXYNOS_LOG_INFO, "%s Avg Time: %.2f ms, Over 30ms: %d",
    235                 prefix, (float)perfTotal / (float)(frameCount * 1000),
    236                 Exynos_OSAL_PerfOver30ms(id));
    237 }
    238