LCOV - code coverage report
Current view: top level - src/libavutil - utils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 26 50 52.0 %
Date: 2017-01-21 09:32:20 Functions: 5 9 55.6 %

          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        5120 : unsigned avutil_version(void)
      39             : {
      40             :     static int checks_done;
      41        5120 :     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        5120 :     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        5120 :     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        5120 :     checks_done = 1;
      65        5120 :     return LIBAVUTIL_VERSION_INT;
      66             : }
      67             : 
      68        5120 : const char *avutil_configuration(void)
      69             : {
      70        5120 :     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       29567 : const char *av_get_media_type_string(enum AVMediaType media_type)
      80             : {
      81       29567 :     switch (media_type) {
      82       18799 :     case AVMEDIA_TYPE_VIDEO:      return "video";
      83       10509 :     case AVMEDIA_TYPE_AUDIO:      return "audio";
      84         110 :     case AVMEDIA_TYPE_DATA:       return "data";
      85         144 :     case AVMEDIA_TYPE_SUBTITLE:   return "subtitle";
      86           5 :     case AVMEDIA_TYPE_ATTACHMENT: return "attachment";
      87           0 :     default:                      return NULL;
      88             :     }
      89             : }
      90             : 
      91        1619 : char av_get_picture_type_char(enum AVPictureType pict_type)
      92             : {
      93        1619 :     switch (pict_type) {
      94         253 :     case AV_PICTURE_TYPE_I:  return 'I';
      95        1335 :     case AV_PICTURE_TYPE_P:  return 'P';
      96          30 :     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           0 : AVRational av_get_time_base_q(void)
     125             : {
     126           0 :     return (AVRational){1, AV_TIME_BASE};
     127             : }
     128             : 
     129           0 : void av_assert0_fpu(void) {
     130             : #if HAVE_MMX_INLINE
     131             :     uint16_t state[14];
     132           0 :      __asm volatile (
     133             :         "fstenv %0 \n\t"
     134             :         : "+m" (state)
     135             :         :
     136             :         : "memory"
     137             :     );
     138           0 :     av_assert0((state[4] & 3) == 3);
     139             : #endif
     140           0 : }

Generated by: LCOV version 1.12