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-10-18 21:45:51 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        5430 : unsigned avutil_version(void)
      39             : {
      40             :     static int checks_done;
      41        5430 :     if (checks_done)
      42           0 :         return LIBAVUTIL_VERSION_INT;
      43             : 
      44             : #if FF_API_VDPAU
      45             :     av_assert0(AV_PIX_FMT_VDA_VLD == 81); //check if the pix fmt enum has not had anything inserted or removed by mistake
      46             : #endif
      47             :     av_assert0(AV_SAMPLE_FMT_DBLP == 9);
      48             :     av_assert0(AVMEDIA_TYPE_ATTACHMENT == 4);
      49             :     av_assert0(AV_PICTURE_TYPE_BI == 7);
      50             :     av_assert0(LIBAVUTIL_VERSION_MICRO >= 100);
      51             :     av_assert0(HAVE_MMX2 == HAVE_MMXEXT);
      52             : 
      53             :     av_assert0(((size_t)-1) > 0); // C guarantees this but if false on a platform we care about revert at least b284e1ffe343d6697fb950d1ee517bafda8a9844
      54             : 
      55        5430 :     if (av_sat_dadd32(1, 2) != 5) {
      56           0 :         av_log(NULL, AV_LOG_FATAL, "Libavutil has been built with a broken binutils, please upgrade binutils and rebuild\n");
      57           0 :         abort();
      58             :     }
      59             : 
      60        5430 :     if (llrint(1LL<<60) != 1LL<<60) {
      61           0 :         av_log(NULL, AV_LOG_ERROR, "Libavutil has been linked to a broken llrint()\n");
      62             :     }
      63             : 
      64        5430 :     checks_done = 1;
      65        5430 :     return LIBAVUTIL_VERSION_INT;
      66             : }
      67             : 
      68        5430 : const char *avutil_configuration(void)
      69             : {
      70        5430 :     return FFMPEG_CONFIGURATION;
      71             : }
      72             : 
      73           0 : const char *avutil_license(void)
      74             : {
      75             : #define LICENSE_PREFIX "libavutil license: "
      76           0 :     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
      77             : }
      78             : 
      79       31036 : const char *av_get_media_type_string(enum AVMediaType media_type)
      80             : {
      81       31036 :     switch (media_type) {
      82       19758 :     case AVMEDIA_TYPE_VIDEO:      return "video";
      83       11001 :     case AVMEDIA_TYPE_AUDIO:      return "audio";
      84         116 :     case AVMEDIA_TYPE_DATA:       return "data";
      85         156 :     case AVMEDIA_TYPE_SUBTITLE:   return "subtitle";
      86           5 :     case AVMEDIA_TYPE_ATTACHMENT: return "attachment";
      87           0 :     default:                      return NULL;
      88             :     }
      89             : }
      90             : 
      91        1633 : char av_get_picture_type_char(enum AVPictureType pict_type)
      92             : {
      93        1633 :     switch (pict_type) {
      94         256 :     case AV_PICTURE_TYPE_I:  return 'I';
      95        1343 :     case AV_PICTURE_TYPE_P:  return 'P';
      96          33 :     case AV_PICTURE_TYPE_B:  return 'B';
      97           0 :     case AV_PICTURE_TYPE_S:  return 'S';
      98           0 :     case AV_PICTURE_TYPE_SI: return 'i';
      99           0 :     case AV_PICTURE_TYPE_SP: return 'p';
     100           0 :     case AV_PICTURE_TYPE_BI: return 'b';
     101           1 :     default:                 return '?';
     102             :     }
     103             : }
     104             : 
     105          40 : unsigned av_int_list_length_for_size(unsigned elsize,
     106             :                                      const void *list, uint64_t term)
     107             : {
     108             :     unsigned i;
     109             : 
     110          40 :     if (!list)
     111           0 :         return 0;
     112             : #define LIST_LENGTH(type) \
     113             :     { type t = term, *l = (type *)list; for (i = 0; l[i] != t; i++); }
     114          40 :     switch (elsize) {
     115           0 :     case 1: LIST_LENGTH(uint8_t);  break;
     116           0 :     case 2: LIST_LENGTH(uint16_t); break;
     117          40 :     case 4: LIST_LENGTH(uint32_t); break;
     118           0 :     case 8: LIST_LENGTH(uint64_t); break;
     119           0 :     default: av_assert0(!"valid element size");
     120             :     }
     121          40 :     return i;
     122             : }
     123             : 
     124       40632 : char *av_fourcc_make_string(char *buf, uint32_t fourcc)
     125             : {
     126             :     int i;
     127       40632 :     char *orig_buf = buf;
     128       40632 :     size_t buf_size = AV_FOURCC_MAX_STRING_SIZE;
     129             : 
     130      203160 :     for (i = 0; i < 4; i++) {
     131      162528 :         const int c = fourcc & 0xff;
     132      315767 :         const int print_chr = (c >= '0' && c <= '9') ||
     133      122384 :                               (c >= 'a' && c <= 'z') ||
     134      338029 :                               (c >= 'A' && c <= 'Z') ||
     135        4089 :                               (c && strchr(". -_", c));
     136      162528 :         const int len = snprintf(buf, buf_size, print_chr ? "%c" : "[%d]", c);
     137      162528 :         if (len < 0)
     138           0 :             break;
     139      162528 :         buf += len;
     140      162528 :         buf_size = buf_size > len ? buf_size - len : 0;
     141      162528 :         fourcc >>= 8;
     142             :     }
     143             : 
     144       40632 :     return orig_buf;
     145             : }
     146             : 
     147           0 : AVRational av_get_time_base_q(void)
     148             : {
     149           0 :     return (AVRational){1, AV_TIME_BASE};
     150             : }
     151             : 
     152           0 : void av_assert0_fpu(void) {
     153             : #if HAVE_MMX_INLINE
     154             :     uint16_t state[14];
     155           0 :      __asm__ volatile (
     156             :         "fstenv %0 \n\t"
     157             :         : "+m" (state)
     158             :         :
     159             :         : "memory"
     160             :     );
     161           0 :     av_assert0((state[4] & 3) == 3);
     162             : #endif
     163           0 : }

Generated by: LCOV version 1.13