LCOV - code coverage report
Current view: top level - libavutil - utils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 41 66 62.1 %
Date: 2017-12-15 02:19:58 Functions: 6 10 60.0 %

          Line data    Source code
       1             : /*
       2             :  * This file is part of FFmpeg.
       3             :  *
       4             :  * FFmpeg is free software; you can redistribute it and/or
       5             :  * modify it under the terms of the GNU Lesser General Public
       6             :  * License as published by the Free Software Foundation; either
       7             :  * version 2.1 of the License, or (at your option) any later version.
       8             :  *
       9             :  * FFmpeg is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             :  * Lesser General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public
      15             :  * License along with FFmpeg; if not, write to the Free Software
      16             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      17             :  */
      18             : 
      19             : #include "config.h"
      20             : #include "avutil.h"
      21             : #include "avassert.h"
      22             : #include "samplefmt.h"
      23             : #include "internal.h"
      24             : 
      25             : /**
      26             :  * @file
      27             :  * various utility functions
      28             :  */
      29             : 
      30             : #include "libavutil/ffversion.h"
      31             : const char av_util_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
      32             : 
      33           0 : const char *av_version_info(void)
      34             : {
      35           0 :     return FFMPEG_VERSION;
      36             : }
      37             : 
      38        5466 : unsigned avutil_version(void)
      39             : {
      40             :     static int checks_done;
      41        5466 :     if (checks_done)
      42           0 :         return LIBAVUTIL_VERSION_INT;
      43             : 
      44             :     av_assert0(AV_SAMPLE_FMT_DBLP == 9);
      45             :     av_assert0(AVMEDIA_TYPE_ATTACHMENT == 4);
      46             :     av_assert0(AV_PICTURE_TYPE_BI == 7);
      47             :     av_assert0(LIBAVUTIL_VERSION_MICRO >= 100);
      48             :     av_assert0(HAVE_MMX2 == HAVE_MMXEXT);
      49             : 
      50             :     av_assert0(((size_t)-1) > 0); // C guarantees this but if false on a platform we care about revert at least b284e1ffe343d6697fb950d1ee517bafda8a9844
      51             : 
      52        5466 :     if (av_sat_dadd32(1, 2) != 5) {
      53           0 :         av_log(NULL, AV_LOG_FATAL, "Libavutil has been built with a broken binutils, please upgrade binutils and rebuild\n");
      54           0 :         abort();
      55             :     }
      56             : 
      57        5466 :     if (llrint(1LL<<60) != 1LL<<60) {
      58           0 :         av_log(NULL, AV_LOG_ERROR, "Libavutil has been linked to a broken llrint()\n");
      59             :     }
      60             : 
      61        5466 :     checks_done = 1;
      62        5466 :     return LIBAVUTIL_VERSION_INT;
      63             : }
      64             : 
      65        5466 : const char *avutil_configuration(void)
      66             : {
      67        5466 :     return FFMPEG_CONFIGURATION;
      68             : }
      69             : 
      70           0 : const char *avutil_license(void)
      71             : {
      72             : #define LICENSE_PREFIX "libavutil license: "
      73           0 :     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
      74             : }
      75             : 
      76       31228 : const char *av_get_media_type_string(enum AVMediaType media_type)
      77             : {
      78       31228 :     switch (media_type) {
      79       19924 :     case AVMEDIA_TYPE_VIDEO:      return "video";
      80       11023 :     case AVMEDIA_TYPE_AUDIO:      return "audio";
      81         116 :     case AVMEDIA_TYPE_DATA:       return "data";
      82         160 :     case AVMEDIA_TYPE_SUBTITLE:   return "subtitle";
      83           5 :     case AVMEDIA_TYPE_ATTACHMENT: return "attachment";
      84           0 :     default:                      return NULL;
      85             :     }
      86             : }
      87             : 
      88        1633 : char av_get_picture_type_char(enum AVPictureType pict_type)
      89             : {
      90        1633 :     switch (pict_type) {
      91         256 :     case AV_PICTURE_TYPE_I:  return 'I';
      92        1343 :     case AV_PICTURE_TYPE_P:  return 'P';
      93          33 :     case AV_PICTURE_TYPE_B:  return 'B';
      94           0 :     case AV_PICTURE_TYPE_S:  return 'S';
      95           0 :     case AV_PICTURE_TYPE_SI: return 'i';
      96           0 :     case AV_PICTURE_TYPE_SP: return 'p';
      97           0 :     case AV_PICTURE_TYPE_BI: return 'b';
      98           1 :     default:                 return '?';
      99             :     }
     100             : }
     101             : 
     102          42 : unsigned av_int_list_length_for_size(unsigned elsize,
     103             :                                      const void *list, uint64_t term)
     104             : {
     105             :     unsigned i;
     106             : 
     107          42 :     if (!list)
     108           0 :         return 0;
     109             : #define LIST_LENGTH(type) \
     110             :     { type t = term, *l = (type *)list; for (i = 0; l[i] != t; i++); }
     111          42 :     switch (elsize) {
     112           0 :     case 1: LIST_LENGTH(uint8_t);  break;
     113           0 :     case 2: LIST_LENGTH(uint16_t); break;
     114          42 :     case 4: LIST_LENGTH(uint32_t); break;
     115           0 :     case 8: LIST_LENGTH(uint64_t); break;
     116           0 :     default: av_assert0(!"valid element size");
     117             :     }
     118          42 :     return i;
     119             : }
     120             : 
     121       41705 : char *av_fourcc_make_string(char *buf, uint32_t fourcc)
     122             : {
     123             :     int i;
     124       41705 :     char *orig_buf = buf;
     125       41705 :     size_t buf_size = AV_FOURCC_MAX_STRING_SIZE;
     126             : 
     127      208525 :     for (i = 0; i < 4; i++) {
     128      166820 :         const int c = fourcc & 0xff;
     129      324292 :         const int print_chr = (c >= '0' && c <= '9') ||
     130      125627 :                               (c >= 'a' && c <= 'z') ||
     131      347437 :                               (c >= 'A' && c <= 'Z') ||
     132        4149 :                               (c && strchr(". -_", c));
     133      166820 :         const int len = snprintf(buf, buf_size, print_chr ? "%c" : "[%d]", c);
     134      166820 :         if (len < 0)
     135           0 :             break;
     136      166820 :         buf += len;
     137      166820 :         buf_size = buf_size > len ? buf_size - len : 0;
     138      166820 :         fourcc >>= 8;
     139             :     }
     140             : 
     141       41705 :     return orig_buf;
     142             : }
     143             : 
     144           0 : AVRational av_get_time_base_q(void)
     145             : {
     146           0 :     return (AVRational){1, AV_TIME_BASE};
     147             : }
     148             : 
     149           0 : void av_assert0_fpu(void) {
     150             : #if HAVE_MMX_INLINE
     151             :     uint16_t state[14];
     152           0 :      __asm__ volatile (
     153             :         "fstenv %0 \n\t"
     154             :         : "+m" (state)
     155             :         :
     156             :         : "memory"
     157             :     );
     158           0 :     av_assert0((state[4] & 3) == 3);
     159             : #endif
     160           0 : }

Generated by: LCOV version 1.13