1 /*
2 * Copyright (c) 2015 Anton Khirnov
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 * THE SOFTWARE.
21 */
22
23 /**
24 * @file
25 * Intel QSV-accelerated H.264 decoding example.
26 *
27 * @example qsvdec.c
28 * This example shows how to do QSV-accelerated H.264 decoding with output
29 * frames in the GPU video surfaces.
30 */
31
33
34 #include <stdio.h>
35
38
40
46
50
52 {
58 int ret;
59
60 /* create a pool of surfaces to be used by the decoder */
65 frames_hwctx = frames_ctx->
hwctx;
66
72
73 frames_hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
74
76 if (ret < 0)
78
80 }
81
82 pix_fmts++;
83 }
84
85 fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
86
88 }
89
93 {
94 int ret = 0;
95
97 if (ret < 0) {
98 fprintf(stderr, "Error during decoding\n");
99 return ret;
100 }
101
102 while (ret >= 0) {
103 int i, j;
104
107 break;
108 else if (ret < 0) {
109 fprintf(stderr, "Error during decoding\n");
110 return ret;
111 }
112
113 /* A real program would do something useful with the decoded frame here.
114 * We just retrieve the raw data and write it to a file, which is rather
115 * useless but pedagogic. */
117 if (ret < 0) {
118 fprintf(stderr, "Error transferring the data to system memory\n");
120 }
121
123 for (j = 0; j < (sw_frame->
height >> (i > 0)); j++)
125
129
130 if (ret < 0)
131 return ret;
132 }
133
134 return 0;
135 }
136
137 int main(
int argc,
char **argv)
138 {
143
146
148
150
151 int ret, i;
152
153 if (argc < 3) {
154 fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
155 return 1;
156 }
157
158 /* open the input file */
160 if (ret < 0) {
161 fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
163 }
164
165 /* find the first H.264 video stream */
168
170 video_st = st;
171 else
173 }
174 if (!video_st) {
175 fprintf(stderr, "No H.264 video stream in the input file\n");
177 }
178
179 /* open the hardware device */
182 if (ret < 0) {
183 fprintf(stderr, "Cannot open the hardware device\n");
185 }
186
187 /* initialize the decoder */
189 if (!decoder) {
190 fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
192 }
193
195 if (!decoder_ctx) {
198 }
206 }
210 }
211
214
216 if (ret < 0) {
217 fprintf(stderr, "Error opening the decoder: ");
219 }
220
221 /* open the output stream */
223 if (ret < 0) {
224 fprintf(stderr, "Error opening the output context: ");
226 }
227
230 if (!frame || !sw_frame) {
233 }
234
235 /* actual decoding */
236 while (ret >= 0) {
238 if (ret < 0)
239 break;
240
242 ret =
decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
243
245 }
246
247 /* flush the decoder */
250 ret =
decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
251
253 if (ret < 0) {
256 fprintf(stderr, "%s\n", buf);
257 }
258
260
263
265
267
269
270 return ret;
271 }
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
This structure describes decoded (raw) audio or video data.
int coded_width
Bitstream width / height, may be different from width/height e.g.
int frame_type
A combination of MFX_MEMTYPE_* describing the frame pool.
Memory handling functions.
This struct is allocated as AVHWFramesContext.hwctx.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
static AVCodecContext * decoder_ctx
int index
stream index in AVFormatContext
#define AVIO_FLAG_WRITE
write-only
int width
The allocated dimensions of the frames in this pool.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
AVStream ** streams
A list of all streams in the file.
int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)
Open a device of the specified type and create an AVHWDeviceContext for it.
#define AVERROR_EOF
End of file.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
int main(int argc, char **argv)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
int extradata_size
Size of the extradata content in bytes.
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
int initial_pool_size
Initial size of the frame pool.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
static const chunk_decoder decoder[8]
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
#define FF_ARRAY_ELEMS(a)
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Libavcodec external API header.
static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx, AVFrame *frame, AVFrame *sw_frame, AVPacket *pkt, AVIOContext *output_ctx)
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
uint8_t * data
The data buffer.
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
This struct describes a set or pool of "hardware" frames (i.e.
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
refcounted data buffer API
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
static enum AVPixelFormat pix_fmts[]
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
A reference to a data buffer.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
AVPixelFormat
Pixel format.
This structure stores compressed data.
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
void * opaque
Private data of the user, can be used to carry app specific stuff.
AVBufferRef * hw_device_ref