1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/*
* Intel MediaSDK QSV encoder/decoder shared code
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <mfx/mfxvideo.h>
#include "libavutil/error.h"
#include "avcodec.h"
#include "qsv_internal.h"
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
{
switch (codec_id) {
case AV_CODEC_ID_H264:
return MFX_CODEC_AVC;
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
return MFX_CODEC_MPEG2;
case AV_CODEC_ID_VC1:
return MFX_CODEC_VC1;
default:
break;
}
return AVERROR(ENOSYS);
}
int ff_qsv_error(int mfx_err)
{
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;
}
}
/**
* @brief Initialize a MSDK session
*
* Media SDK is based on sessions, so this is the prerequisite
* initialization for HW acceleration. For Windows the session is
* complete and ready to use, for Linux a display handle is
* required. For releases of Media Server Studio >= 2015 R4 the
* render nodes interface is preferred (/dev/dri/renderD).
* Using Media Server Studio 2015 R4 or newer is recommended
* but the older /dev/dri/card interface is also searched
* for broader compatibility.
*
* @param avctx ffmpeg metadata for this codec context
* @param session the MSDK session used
*/
int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session)
{
mfxIMPL impl = MFX_IMPL_AUTO_ANY;
mfxVersion ver = { { QSV_VERSION_MINOR, QSV_VERSION_MAJOR } };
const char *desc;
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);
}
// this code is only required for Linux. It searches for a valid
// display handle. First in /dev/dri/renderD then in /dev/dri/card
#ifdef AVCODEC_QSV_LINUX_SESSION_HANDLE
// VAAPI display handle
VADisplay va_dpy = NULL;
VAStatus va_res = VA_STATUS_SUCCESS;
int major_version = 0, minor_version = 0;
int fd = -1;
char adapterpath[256];
int adapter_num;
//search for valid graphics device
for (adapter_num = 0;adapter_num < 6;adapter_num++) {
if (adapter_num<3) {
snprintf(adapterpath,sizeof(adapterpath),
"/dev/dri/renderD%d", adapter_num+128);
} else {
snprintf(adapterpath,sizeof(adapterpath),
"/dev/dri/card%d", adapter_num-3);
}
fd = open(adapterpath, O_RDWR);
if (fd < 0) {
av_log(avctx, AV_LOG_ERROR,
"mfx init: %s fd open failed\n", adapterpath);
continue;
}
va_dpy = vaGetDisplayDRM(fd);
if (!va_dpy) {
av_log(avctx, AV_LOG_ERROR,
"mfx init: %s vaGetDisplayDRM failed\n", adapterpath);
close(fd);
continue;
}
va_res = vaInitialize(va_dpy, &major_version, &minor_version);
if (VA_STATUS_SUCCESS != va_res) {
av_log(avctx, AV_LOG_ERROR,
"mfx init: %s vaInitialize failed\n", adapterpath);
close(fd);
fd = -1;
continue;
} else {
av_log(avctx, AV_LOG_VERBOSE,
"mfx initialization: %s vaInitialize successful\n",adapterpath);
break;
}
}
MFXVideoCORE_SetHandle((*session), (mfxHandleType)MFX_HANDLE_VA_DISPLAY, (mfxHDL)va_dpy);
#endif //AVCODEC_QSV_LINUX_SESSION_HANDLE
MFXQueryIMPL(*session, &impl);
switch (MFX_IMPL_BASETYPE(impl)) {
case MFX_IMPL_SOFTWARE:
desc = "software";
break;
case MFX_IMPL_HARDWARE:
case MFX_IMPL_HARDWARE2:
case MFX_IMPL_HARDWARE3:
case MFX_IMPL_HARDWARE4:
desc = "hardware accelerated";
break;
default:
desc = "unknown";
}
av_log(avctx, AV_LOG_VERBOSE,
"Initialized an internal MFX session using %s implementation\n",
desc);
return 0;
}
|
