[FFmpeg-cvslog] Merge commit '95414eb2dc63a6f934275b4ed33dedd4369f2c49'

Mark Thompson git at videolan.org
Sun Mar 12 18:03:40 EET 2017


ffmpeg | branch: master | Mark Thompson <sw at jkqxz.net> | Sun Mar 12 15:19:05 2017 +0000| [15887a410c5ae271c59e5bc6d60ae443e6c40ac7] | committer: Mark Thompson

Merge commit '95414eb2dc63a6f934275b4ed33dedd4369f2c49'

* commit '95414eb2dc63a6f934275b4ed33dedd4369f2c49':
  qsv: print more complete error messages

Merged-by: Mark Thompson <sw at jkqxz.net>

> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=15887a410c5ae271c59e5bc6d60ae443e6c40ac7
---

 libavcodec/qsv.c          | 133 +++++++++++++++++++++++++++-------------------
 libavcodec/qsv_internal.h |   5 +-
 libavcodec/qsvdec.c       |  17 ++----
 libavcodec/qsvenc.c       |  22 ++++----
 4 files changed, 97 insertions(+), 80 deletions(-)

diff --git a/libavcodec/qsv.c b/libavcodec/qsv.c
index 028a496..76c7826 100644
--- a/libavcodec/qsv.c
+++ b/libavcodec/qsv.c
@@ -70,39 +70,67 @@ int ff_qsv_profile_to_mfx(enum AVCodecID codec_id, int profile)
     return MFX_PROFILE_UNKNOWN;
 }
 
-int ff_qsv_error(int mfx_err)
+static const struct {
+    mfxStatus   mfxerr;
+    int         averr;
+    const char *desc;
+} qsv_errors[] = {
+    { MFX_ERR_NONE,                     0,               "success"                              },
+    { MFX_ERR_UNKNOWN,                  AVERROR_UNKNOWN, "unknown error"                        },
+    { MFX_ERR_NULL_PTR,                 AVERROR(EINVAL), "NULL pointer"                         },
+    { MFX_ERR_UNSUPPORTED,              AVERROR(ENOSYS), "unsupported"                          },
+    { MFX_ERR_MEMORY_ALLOC,             AVERROR(ENOMEM), "failed to allocate memory"            },
+    { MFX_ERR_NOT_ENOUGH_BUFFER,        AVERROR(ENOMEM), "insufficient input/output buffer"     },
+    { MFX_ERR_INVALID_HANDLE,           AVERROR(EINVAL), "invalid handle"                       },
+    { MFX_ERR_LOCK_MEMORY,              AVERROR(EIO),    "failed to lock the memory block"      },
+    { MFX_ERR_NOT_INITIALIZED,          AVERROR_BUG,     "not initialized"                      },
+    { MFX_ERR_NOT_FOUND,                AVERROR(ENOSYS), "specified object was not found"       },
+    { MFX_ERR_MORE_DATA,                AVERROR(EAGAIN), "expect more data at input"            },
+    { MFX_ERR_MORE_SURFACE,             AVERROR(EAGAIN), "expect more surface at output"        },
+    { MFX_ERR_ABORTED,                  AVERROR_UNKNOWN, "operation aborted"                    },
+    { MFX_ERR_DEVICE_LOST,              AVERROR(EIO),    "device lost"                          },
+    { MFX_ERR_INCOMPATIBLE_VIDEO_PARAM, AVERROR(EINVAL), "incompatible video parameters"        },
+    { MFX_ERR_INVALID_VIDEO_PARAM,      AVERROR(EINVAL), "invalid video parameters"             },
+    { MFX_ERR_UNDEFINED_BEHAVIOR,       AVERROR_BUG,     "undefined behavior"                   },
+    { MFX_ERR_DEVICE_FAILED,            AVERROR(EIO),    "device failed"                        },
+    { MFX_ERR_MORE_BITSTREAM,           AVERROR(EAGAIN), "expect more bitstream at output"      },
+    { MFX_ERR_INCOMPATIBLE_AUDIO_PARAM, AVERROR(EINVAL), "incompatible audio parameters"        },
+    { MFX_ERR_INVALID_AUDIO_PARAM,      AVERROR(EINVAL), "invalid audio parameters"             },
+
+    { MFX_WRN_IN_EXECUTION,             0,               "operation in execution"               },
+    { MFX_WRN_DEVICE_BUSY,              0,               "device busy"                          },
+    { MFX_WRN_VIDEO_PARAM_CHANGED,      0,               "video parameters changed"             },
+    { MFX_WRN_PARTIAL_ACCELERATION,     0,               "partial acceleration"                 },
+    { MFX_WRN_INCOMPATIBLE_VIDEO_PARAM, 0,               "incompatible video parameters"        },
+    { MFX_WRN_VALUE_NOT_CHANGED,        0,               "value is saturated"                   },
+    { MFX_WRN_OUT_OF_RANGE,             0,               "value out of range"                   },
+    { MFX_WRN_FILTER_SKIPPED,           0,               "filter skipped"                       },
+    { MFX_WRN_INCOMPATIBLE_AUDIO_PARAM, 0,               "incompatible audio parameters"        },
+};
+
+int ff_qsv_map_error(mfxStatus mfx_err, const char **desc)
 {
-    switch (mfx_err) {
-    case MFX_ERR_NONE:
-        return 0;
-    case MFX_ERR_MEMORY_ALLOC:
-    case MFX_ERR_NOT_ENOUGH_BUFFER:
-        return AVERROR(ENOMEM);
-    case MFX_ERR_INVALID_HANDLE:
-        return AVERROR(EINVAL);
-    case MFX_ERR_DEVICE_FAILED:
-    case MFX_ERR_DEVICE_LOST:
-    case MFX_ERR_LOCK_MEMORY:
-        return AVERROR(EIO);
-    case MFX_ERR_NULL_PTR:
-    case MFX_ERR_UNDEFINED_BEHAVIOR:
-    case MFX_ERR_NOT_INITIALIZED:
-        return AVERROR_BUG;
-    case MFX_ERR_UNSUPPORTED:
-    case MFX_ERR_NOT_FOUND:
-        return AVERROR(ENOSYS);
-    case MFX_ERR_MORE_DATA:
-    case MFX_ERR_MORE_SURFACE:
-    case MFX_ERR_MORE_BITSTREAM:
-        return AVERROR(EAGAIN);
-    case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
-    case MFX_ERR_INVALID_VIDEO_PARAM:
-        return AVERROR(EINVAL);
-    case MFX_ERR_ABORTED:
-    case MFX_ERR_UNKNOWN:
-    default:
-        return AVERROR_UNKNOWN;
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(qsv_errors); i++) {
+        if (qsv_errors[i].mfxerr == mfx_err) {
+            if (desc)
+                *desc = qsv_errors[i].desc;
+            return qsv_errors[i].averr;
+        }
     }
+    if (desc)
+        *desc = "unknown error";
+    return AVERROR_UNKNOWN;
+}
+
+int ff_qsv_print_error(void *log_ctx, mfxStatus err,
+                       const char *error_string)
+{
+    const char *desc;
+    int ret;
+    ret = ff_qsv_map_error(err, &desc);
+    av_log(log_ctx, AV_LOG_ERROR, "%s: %s (%d)\n", error_string, desc, err);
+    return ret;
 }
 
 int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
@@ -154,9 +182,10 @@ static int qsv_load_plugins(mfxSession session, const char *load_plugins,
 
         ret = MFXVideoUSER_Load(session, &uid, 1);
         if (ret < 0) {
-            av_log(logctx, AV_LOG_ERROR, "Could not load the requested plugin: %s\n",
-                   plugin);
-            err = ff_qsv_error(ret);
+            char errorbuf[128];
+            snprintf(errorbuf, sizeof(errorbuf),
+                     "Could not load the requested plugin '%s'", plugin);
+            err = ff_qsv_print_error(logctx, ret, errorbuf);
             goto load_plugin_fail;
         }
 
@@ -182,10 +211,9 @@ int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session,
     int ret;
 
     ret = MFXInit(impl, &ver, session);
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error initializing an internal MFX session\n");
-        return ff_qsv_error(ret);
-    }
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error initializing an internal MFX session");
 
     ret = qsv_load_plugins(*session, load_plugins, avctx);
     if (ret < 0) {
@@ -298,10 +326,9 @@ int ff_qsv_init_session_hwcontext(AVCodecContext *avctx, mfxSession *psession,
     err = MFXQueryIMPL(parent_session, &impl);
     if (err == MFX_ERR_NONE)
         err = MFXQueryVersion(parent_session, &ver);
-    if (err != MFX_ERR_NONE) {
-        av_log(avctx, AV_LOG_ERROR, "Error querying the session attributes\n");
-        return ff_qsv_error(err);
-    }
+    if (err != MFX_ERR_NONE)
+        return ff_qsv_print_error(avctx, err,
+                                  "Error querying the session attributes");
 
     for (i = 0; i < FF_ARRAY_ELEMS(handle_types); i++) {
         err = MFXVideoCORE_GetHandle(parent_session, handle_types[i], &handle);
@@ -317,18 +344,15 @@ int ff_qsv_init_session_hwcontext(AVCodecContext *avctx, mfxSession *psession,
     }
 
     err = MFXInit(impl, &ver, &session);
-    if (err != MFX_ERR_NONE) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Error initializing a child MFX session: %d\n", err);
-        return ff_qsv_error(err);
-    }
+    if (err != MFX_ERR_NONE)
+        return ff_qsv_print_error(avctx, err,
+                                  "Error initializing a child MFX session");
 
     if (handle) {
         err = MFXVideoCORE_SetHandle(session, handle_type, handle);
-        if (err != MFX_ERR_NONE) {
-            av_log(avctx, AV_LOG_ERROR, "Error setting a HW handle: %d\n", err);
-            return ff_qsv_error(err);
-        }
+        if (err != MFX_ERR_NONE)
+            return ff_qsv_print_error(avctx, err,
+                                      "Error setting a HW handle");
     }
 
     ret = qsv_load_plugins(session, load_plugins, avctx);
@@ -350,10 +374,9 @@ int ff_qsv_init_session_hwcontext(AVCodecContext *avctx, mfxSession *psession,
             qsv_frames_ctx->mids[i] = frames_hwctx->surfaces[i].Data.MemId;
 
         err = MFXVideoCORE_SetFrameAllocator(session, &frame_allocator);
-        if (err != MFX_ERR_NONE) {
-            av_log(avctx, AV_LOG_ERROR, "Error setting a frame allocator: %d\n", err);
-            return ff_qsv_error(err);
-        }
+        if (err != MFX_ERR_NONE)
+            return ff_qsv_print_error(avctx, err,
+                                      "Error setting a frame allocator");
     }
 
     *psession = session;
diff --git a/libavcodec/qsv_internal.h b/libavcodec/qsv_internal.h
index 5d2a216..eb8e3a5 100644
--- a/libavcodec/qsv_internal.h
+++ b/libavcodec/qsv_internal.h
@@ -60,7 +60,10 @@ typedef struct QSVFramesContext {
 /**
  * Convert a libmfx error code into an ffmpeg error code.
  */
-int ff_qsv_error(int mfx_err);
+int ff_qsv_map_error(mfxStatus mfx_err, const char **desc);
+
+int ff_qsv_print_error(void *log_ctx, mfxStatus err,
+                       const char *error_string);
 
 int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id);
 int ff_qsv_profile_to_mfx(enum AVCodecID codec_id, int profile);
diff --git a/libavcodec/qsvdec.c b/libavcodec/qsvdec.c
index 258042d..06056a3 100644
--- a/libavcodec/qsvdec.c
+++ b/libavcodec/qsvdec.c
@@ -176,16 +176,9 @@ static int qsv_decode_init(AVCodecContext *avctx, QSVContext *q)
     param.NumExtParam = q->nb_ext_buffers;
 
     ret = MFXVideoDECODE_Init(q->session, &param);
-    if (ret < 0) {
-        if (MFX_ERR_INVALID_VIDEO_PARAM==ret) {
-            av_log(avctx, AV_LOG_ERROR,
-                   "Error initializing the MFX video decoder, unsupported video\n");
-        } else {
-            av_log(avctx, AV_LOG_ERROR,
-                   "Error initializing the MFX video decoder %d\n", ret);
-        }
-        return ff_qsv_error(ret);
-    }
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error initializing the MFX video decoder");
 
     q->frame_info = param.mfx.FrameInfo;
 
@@ -321,9 +314,9 @@ static int qsv_decode(AVCodecContext *avctx, QSVContext *q,
         ret != MFX_ERR_MORE_DATA &&
         ret != MFX_WRN_VIDEO_PARAM_CHANGED &&
         ret != MFX_ERR_MORE_SURFACE) {
-        av_log(avctx, AV_LOG_ERROR, "Error during QSV decoding.\n");
         av_freep(&sync);
-        return ff_qsv_error(ret);
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error during QSV decoding.");
     }
 
     /* make sure we do not enter an infinite loop if the SDK
diff --git a/libavcodec/qsvenc.c b/libavcodec/qsvenc.c
index 6e67a24..a0ea965 100644
--- a/libavcodec/qsvenc.c
+++ b/libavcodec/qsvenc.c
@@ -591,7 +591,8 @@ static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
 
     ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
     if (ret < 0)
-        return ff_qsv_error(ret);
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error calling GetVideoParam");
 
     q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
 
@@ -740,10 +741,9 @@ int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
         return ret;
 
     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
-        return ff_qsv_error(ret);
-    }
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error querying the encoding parameters");
 
     if (opaque_alloc) {
         ret = qsv_init_opaque_alloc(avctx, q);
@@ -781,12 +781,9 @@ int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
     }
 
     ret = MFXVideoENCODE_Init(q->session, &q->param);
-    if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
-        av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
-    } else if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
-        return ff_qsv_error(ret);
-    }
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error initializing the encoder");
 
     ret = qsv_retrieve_enc_params(avctx, q);
     if (ret < 0) {
@@ -998,7 +995,8 @@ static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,
         av_packet_unref(&new_pkt);
         av_freep(&bs);
         av_freep(&sync);
-        return (ret == MFX_ERR_MORE_DATA) ? 0 : ff_qsv_error(ret);
+        return (ret == MFX_ERR_MORE_DATA) ?
+               0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
     }
 
     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)


======================================================================

diff --cc libavcodec/qsv.c
index 028a496,14f16bc..76c7826
--- a/libavcodec/qsv.c
+++ b/libavcodec/qsv.c
@@@ -54,55 -54,67 +54,83 @@@ int ff_qsv_codec_id_to_mfx(enum AVCodec
      return AVERROR(ENOSYS);
  }
  
 +int ff_qsv_profile_to_mfx(enum AVCodecID codec_id, int profile)
 +{
 +    if (profile == FF_PROFILE_UNKNOWN)
 +        return MFX_PROFILE_UNKNOWN;
 +    switch (codec_id) {
 +    case AV_CODEC_ID_H264:
 +    case AV_CODEC_ID_HEVC:
 +        return profile;
 +    case AV_CODEC_ID_VC1:
 +        return 4 * profile + 1;
 +    case AV_CODEC_ID_MPEG2VIDEO:
 +        return 0x10 * profile;
 +    }
 +    return MFX_PROFILE_UNKNOWN;
 +}
 +
- int ff_qsv_error(int mfx_err)
+ static const struct {
+     mfxStatus   mfxerr;
+     int         averr;
+     const char *desc;
+ } qsv_errors[] = {
+     { MFX_ERR_NONE,                     0,               "success"                              },
+     { MFX_ERR_UNKNOWN,                  AVERROR_UNKNOWN, "unknown error"                        },
+     { MFX_ERR_NULL_PTR,                 AVERROR(EINVAL), "NULL pointer"                         },
+     { MFX_ERR_UNSUPPORTED,              AVERROR(ENOSYS), "unsupported"                          },
+     { MFX_ERR_MEMORY_ALLOC,             AVERROR(ENOMEM), "failed to allocate memory"            },
+     { MFX_ERR_NOT_ENOUGH_BUFFER,        AVERROR(ENOMEM), "insufficient input/output buffer"     },
+     { MFX_ERR_INVALID_HANDLE,           AVERROR(EINVAL), "invalid handle"                       },
+     { MFX_ERR_LOCK_MEMORY,              AVERROR(EIO),    "failed to lock the memory block"      },
+     { MFX_ERR_NOT_INITIALIZED,          AVERROR_BUG,     "not initialized"                      },
+     { MFX_ERR_NOT_FOUND,                AVERROR(ENOSYS), "specified object was not found"       },
+     { MFX_ERR_MORE_DATA,                AVERROR(EAGAIN), "expect more data at input"            },
+     { MFX_ERR_MORE_SURFACE,             AVERROR(EAGAIN), "expect more surface at output"        },
+     { MFX_ERR_ABORTED,                  AVERROR_UNKNOWN, "operation aborted"                    },
+     { MFX_ERR_DEVICE_LOST,              AVERROR(EIO),    "device lost"                          },
+     { MFX_ERR_INCOMPATIBLE_VIDEO_PARAM, AVERROR(EINVAL), "incompatible video parameters"        },
+     { MFX_ERR_INVALID_VIDEO_PARAM,      AVERROR(EINVAL), "invalid video parameters"             },
+     { MFX_ERR_UNDEFINED_BEHAVIOR,       AVERROR_BUG,     "undefined behavior"                   },
+     { MFX_ERR_DEVICE_FAILED,            AVERROR(EIO),    "device failed"                        },
+     { MFX_ERR_MORE_BITSTREAM,           AVERROR(EAGAIN), "expect more bitstream at output"      },
+     { MFX_ERR_INCOMPATIBLE_AUDIO_PARAM, AVERROR(EINVAL), "incompatible audio parameters"        },
+     { MFX_ERR_INVALID_AUDIO_PARAM,      AVERROR(EINVAL), "invalid audio parameters"             },
+ 
+     { MFX_WRN_IN_EXECUTION,             0,               "operation in execution"               },
+     { MFX_WRN_DEVICE_BUSY,              0,               "device busy"                          },
+     { MFX_WRN_VIDEO_PARAM_CHANGED,      0,               "video parameters changed"             },
+     { MFX_WRN_PARTIAL_ACCELERATION,     0,               "partial acceleration"                 },
+     { MFX_WRN_INCOMPATIBLE_VIDEO_PARAM, 0,               "incompatible video parameters"        },
+     { MFX_WRN_VALUE_NOT_CHANGED,        0,               "value is saturated"                   },
+     { MFX_WRN_OUT_OF_RANGE,             0,               "value out of range"                   },
+     { MFX_WRN_FILTER_SKIPPED,           0,               "filter skipped"                       },
+     { MFX_WRN_INCOMPATIBLE_AUDIO_PARAM, 0,               "incompatible audio parameters"        },
+ };
+ 
+ int ff_qsv_map_error(mfxStatus mfx_err, const char **desc)
  {
-     switch (mfx_err) {
-     case MFX_ERR_NONE:
-         return 0;
-     case MFX_ERR_MEMORY_ALLOC:
-     case MFX_ERR_NOT_ENOUGH_BUFFER:
-         return AVERROR(ENOMEM);
-     case MFX_ERR_INVALID_HANDLE:
-         return AVERROR(EINVAL);
-     case MFX_ERR_DEVICE_FAILED:
-     case MFX_ERR_DEVICE_LOST:
-     case MFX_ERR_LOCK_MEMORY:
-         return AVERROR(EIO);
-     case MFX_ERR_NULL_PTR:
-     case MFX_ERR_UNDEFINED_BEHAVIOR:
-     case MFX_ERR_NOT_INITIALIZED:
-         return AVERROR_BUG;
-     case MFX_ERR_UNSUPPORTED:
-     case MFX_ERR_NOT_FOUND:
-         return AVERROR(ENOSYS);
-     case MFX_ERR_MORE_DATA:
-     case MFX_ERR_MORE_SURFACE:
-     case MFX_ERR_MORE_BITSTREAM:
-         return AVERROR(EAGAIN);
-     case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
-     case MFX_ERR_INVALID_VIDEO_PARAM:
-         return AVERROR(EINVAL);
-     case MFX_ERR_ABORTED:
-     case MFX_ERR_UNKNOWN:
-     default:
-         return AVERROR_UNKNOWN;
+     int i;
+     for (i = 0; i < FF_ARRAY_ELEMS(qsv_errors); i++) {
+         if (qsv_errors[i].mfxerr == mfx_err) {
+             if (desc)
+                 *desc = qsv_errors[i].desc;
+             return qsv_errors[i].averr;
+         }
      }
+     if (desc)
+         *desc = "unknown error";
+     return AVERROR_UNKNOWN;
+ }
+ 
+ int ff_qsv_print_error(void *log_ctx, mfxStatus err,
+                        const char *error_string)
+ {
+     const char *desc;
+     int ret;
+     ret = ff_qsv_map_error(err, &desc);
+     av_log(log_ctx, AV_LOG_ERROR, "%s: %s (%d)\n", error_string, desc, err);
+     return ret;
  }
  
  int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
diff --cc libavcodec/qsv_internal.h
index 5d2a216,03b2f65..eb8e3a5
--- a/libavcodec/qsv_internal.h
+++ b/libavcodec/qsv_internal.h
@@@ -58,12 -55,14 +58,15 @@@ typedef struct QSVFramesContext 
  } QSVFramesContext;
  
  /**
 - * Convert a libmfx error code into a libav error code.
 + * Convert a libmfx error code into an ffmpeg error code.
   */
- int ff_qsv_error(int mfx_err);
+ int ff_qsv_map_error(mfxStatus mfx_err, const char **desc);
+ 
+ int ff_qsv_print_error(void *log_ctx, mfxStatus err,
+                        const char *error_string);
  
  int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id);
 +int ff_qsv_profile_to_mfx(enum AVCodecID codec_id, int profile);
  
  int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc);
  



More information about the ffmpeg-cvslog mailing list