LCOV - code coverage report
Current view: top level - libavutil - error.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 12 13 92.3 %
Date: 2017-12-15 02:19:58 Functions: 1 1 100.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             : #undef _GNU_SOURCE
      20             : #define _XOPEN_SOURCE 600 /* XSI-compliant version of strerror_r */
      21             : #include "avutil.h"
      22             : #include "avstring.h"
      23             : #include "common.h"
      24             : 
      25             : struct error_entry {
      26             :     int num;
      27             :     const char *tag;
      28             :     const char *str;
      29             : };
      30             : 
      31             : #define ERROR_TAG(tag) AVERROR_##tag, #tag
      32             : #define EERROR_TAG(tag) AVERROR(tag), #tag
      33             : #define AVERROR_INPUT_AND_OUTPUT_CHANGED (AVERROR_INPUT_CHANGED | AVERROR_OUTPUT_CHANGED)
      34             : static const struct error_entry error_entries[] = {
      35             :     { ERROR_TAG(BSF_NOT_FOUND),      "Bitstream filter not found"                     },
      36             :     { ERROR_TAG(BUG),                "Internal bug, should not have happened"         },
      37             :     { ERROR_TAG(BUG2),               "Internal bug, should not have happened"         },
      38             :     { ERROR_TAG(BUFFER_TOO_SMALL),   "Buffer too small"                               },
      39             :     { ERROR_TAG(DECODER_NOT_FOUND),  "Decoder not found"                              },
      40             :     { ERROR_TAG(DEMUXER_NOT_FOUND),  "Demuxer not found"                              },
      41             :     { ERROR_TAG(ENCODER_NOT_FOUND),  "Encoder not found"                              },
      42             :     { ERROR_TAG(EOF),                "End of file"                                    },
      43             :     { ERROR_TAG(EXIT),               "Immediate exit requested"                       },
      44             :     { ERROR_TAG(EXTERNAL),           "Generic error in an external library"           },
      45             :     { ERROR_TAG(FILTER_NOT_FOUND),   "Filter not found"                               },
      46             :     { ERROR_TAG(INPUT_CHANGED),      "Input changed"                                  },
      47             :     { ERROR_TAG(INVALIDDATA),        "Invalid data found when processing input"       },
      48             :     { ERROR_TAG(MUXER_NOT_FOUND),    "Muxer not found"                                },
      49             :     { ERROR_TAG(OPTION_NOT_FOUND),   "Option not found"                               },
      50             :     { ERROR_TAG(OUTPUT_CHANGED),     "Output changed"                                 },
      51             :     { ERROR_TAG(PATCHWELCOME),       "Not yet implemented in FFmpeg, patches welcome" },
      52             :     { ERROR_TAG(PROTOCOL_NOT_FOUND), "Protocol not found"                             },
      53             :     { ERROR_TAG(STREAM_NOT_FOUND),   "Stream not found"                               },
      54             :     { ERROR_TAG(UNKNOWN),            "Unknown error occurred"                         },
      55             :     { ERROR_TAG(EXPERIMENTAL),       "Experimental feature"                           },
      56             :     { ERROR_TAG(INPUT_AND_OUTPUT_CHANGED), "Input and output changed"                 },
      57             :     { ERROR_TAG(HTTP_BAD_REQUEST),   "Server returned 400 Bad Request"         },
      58             :     { ERROR_TAG(HTTP_UNAUTHORIZED),  "Server returned 401 Unauthorized (authorization failed)" },
      59             :     { ERROR_TAG(HTTP_FORBIDDEN),     "Server returned 403 Forbidden (access denied)" },
      60             :     { ERROR_TAG(HTTP_NOT_FOUND),     "Server returned 404 Not Found"           },
      61             :     { ERROR_TAG(HTTP_OTHER_4XX),     "Server returned 4XX Client Error, but not one of 40{0,1,3,4}" },
      62             :     { ERROR_TAG(HTTP_SERVER_ERROR),  "Server returned 5XX Server Error reply" },
      63             : #if !HAVE_STRERROR_R
      64             :     { EERROR_TAG(E2BIG),             "Argument list too long" },
      65             :     { EERROR_TAG(EACCES),            "Permission denied" },
      66             :     { EERROR_TAG(EAGAIN),            "Resource temporarily unavailable" },
      67             :     { EERROR_TAG(EBADF),             "Bad file descriptor" },
      68             :     { EERROR_TAG(EBUSY),             "Device or resource busy" },
      69             :     { EERROR_TAG(ECHILD),            "No child processes" },
      70             :     { EERROR_TAG(EDEADLK),           "Resource deadlock avoided" },
      71             :     { EERROR_TAG(EDOM),              "Numerical argument out of domain" },
      72             :     { EERROR_TAG(EEXIST),            "File exists" },
      73             :     { EERROR_TAG(EFAULT),            "Bad address" },
      74             :     { EERROR_TAG(EFBIG),             "File too large" },
      75             :     { EERROR_TAG(EILSEQ),            "Illegal byte sequence" },
      76             :     { EERROR_TAG(EINTR),             "Interrupted system call" },
      77             :     { EERROR_TAG(EINVAL),            "Invalid argument" },
      78             :     { EERROR_TAG(EIO),               "I/O error" },
      79             :     { EERROR_TAG(EISDIR),            "Is a directory" },
      80             :     { EERROR_TAG(EMFILE),            "Too many open files" },
      81             :     { EERROR_TAG(EMLINK),            "Too many links" },
      82             :     { EERROR_TAG(ENAMETOOLONG),      "File name too long" },
      83             :     { EERROR_TAG(ENFILE),            "Too many open files in system" },
      84             :     { EERROR_TAG(ENODEV),            "No such device" },
      85             :     { EERROR_TAG(ENOENT),            "No such file or directory" },
      86             :     { EERROR_TAG(ENOEXEC),           "Exec format error" },
      87             :     { EERROR_TAG(ENOLCK),            "No locks available" },
      88             :     { EERROR_TAG(ENOMEM),            "Cannot allocate memory" },
      89             :     { EERROR_TAG(ENOSPC),            "No space left on device" },
      90             :     { EERROR_TAG(ENOSYS),            "Function not implemented" },
      91             :     { EERROR_TAG(ENOTDIR),           "Not a directory" },
      92             :     { EERROR_TAG(ENOTEMPTY),         "Directory not empty" },
      93             :     { EERROR_TAG(ENOTTY),            "Inappropriate I/O control operation" },
      94             :     { EERROR_TAG(ENXIO),             "No such device or address" },
      95             :     { EERROR_TAG(EPERM),             "Operation not permitted" },
      96             :     { EERROR_TAG(EPIPE),             "Broken pipe" },
      97             :     { EERROR_TAG(ERANGE),            "Result too large" },
      98             :     { EERROR_TAG(EROFS),             "Read-only file system" },
      99             :     { EERROR_TAG(ESPIPE),            "Illegal seek" },
     100             :     { EERROR_TAG(ESRCH),             "No such process" },
     101             :     { EERROR_TAG(EXDEV),             "Cross-device link" },
     102             : #endif
     103             : };
     104             : 
     105         585 : int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
     106             : {
     107         585 :     int ret = 0, i;
     108         585 :     const struct error_entry *entry = NULL;
     109             : 
     110       10315 :     for (i = 0; i < FF_ARRAY_ELEMS(error_entries); i++) {
     111       10145 :         if (errnum == error_entries[i].num) {
     112         415 :             entry = &error_entries[i];
     113         415 :             break;
     114             :         }
     115             :     }
     116         585 :     if (entry) {
     117         415 :         av_strlcpy(errbuf, entry->str, errbuf_size);
     118             :     } else {
     119             : #if HAVE_STRERROR_R
     120         170 :         ret = AVERROR(strerror_r(AVUNERROR(errnum), errbuf, errbuf_size));
     121             : #else
     122             :         ret = -1;
     123             : #endif
     124         170 :         if (ret < 0)
     125           0 :             snprintf(errbuf, errbuf_size, "Error number %d occurred", errnum);
     126             :     }
     127             : 
     128         585 :     return ret;
     129             : }

Generated by: LCOV version 1.13