FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
qsvdec.c
Go to the documentation of this file.
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 
32 #include "config.h"
33 
34 #include <stdio.h>
35 
36 #include "libavformat/avformat.h"
37 #include "libavformat/avio.h"
38 
39 #include "libavcodec/avcodec.h"
40 
41 #include "libavutil/buffer.h"
42 #include "libavutil/error.h"
43 #include "libavutil/hwcontext.h"
45 #include "libavutil/mem.h"
46 
47 typedef struct DecodeContext {
50 
51 static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
52 {
53  while (*pix_fmts != AV_PIX_FMT_NONE) {
54  if (*pix_fmts == AV_PIX_FMT_QSV) {
55  DecodeContext *decode = avctx->opaque;
56  AVHWFramesContext *frames_ctx;
57  AVQSVFramesContext *frames_hwctx;
58  int ret;
59 
60  /* create a pool of surfaces to be used by the decoder */
62  if (!avctx->hw_frames_ctx)
63  return AV_PIX_FMT_NONE;
64  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
65  frames_hwctx = frames_ctx->hwctx;
66 
67  frames_ctx->format = AV_PIX_FMT_QSV;
68  frames_ctx->sw_format = avctx->sw_pix_fmt;
69  frames_ctx->width = FFALIGN(avctx->coded_width, 32);
70  frames_ctx->height = FFALIGN(avctx->coded_height, 32);
71  frames_ctx->initial_pool_size = 32;
72 
73  frames_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
74 
75  ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
76  if (ret < 0)
77  return AV_PIX_FMT_NONE;
78 
79  return AV_PIX_FMT_QSV;
80  }
81 
82  pix_fmts++;
83  }
84 
85  fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
86 
87  return AV_PIX_FMT_NONE;
88 }
89 
91  AVFrame *frame, AVFrame *sw_frame,
92  AVPacket *pkt, AVIOContext *output_ctx)
93 {
94  int ret = 0;
95 
96  ret = avcodec_send_packet(decoder_ctx, pkt);
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 
105  ret = avcodec_receive_frame(decoder_ctx, frame);
106  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
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. */
116  ret = av_hwframe_transfer_data(sw_frame, frame, 0);
117  if (ret < 0) {
118  fprintf(stderr, "Error transferring the data to system memory\n");
119  goto fail;
120  }
121 
122  for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
123  for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
124  avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
125 
126 fail:
127  av_frame_unref(sw_frame);
128  av_frame_unref(frame);
129 
130  if (ret < 0)
131  return ret;
132  }
133 
134  return 0;
135 }
136 
137 int main(int argc, char **argv)
138 {
139  AVFormatContext *input_ctx = NULL;
141  AVCodecContext *decoder_ctx = NULL;
142  const AVCodec *decoder;
143 
144  AVPacket pkt = { 0 };
145  AVFrame *frame = NULL, *sw_frame = NULL;
146 
147  DecodeContext decode = { NULL };
148 
149  AVIOContext *output_ctx = NULL;
150 
151  int ret, i;
152 
153  av_register_all();
154 
155  if (argc < 3) {
156  fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
157  return 1;
158  }
159 
160  /* open the input file */
161  ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
162  if (ret < 0) {
163  fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
164  goto finish;
165  }
166 
167  /* find the first H.264 video stream */
168  for (i = 0; i < input_ctx->nb_streams; i++) {
169  AVStream *st = input_ctx->streams[i];
170 
171  if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
172  video_st = st;
173  else
174  st->discard = AVDISCARD_ALL;
175  }
176  if (!video_st) {
177  fprintf(stderr, "No H.264 video stream in the input file\n");
178  goto finish;
179  }
180 
181  /* open the hardware device */
183  "auto", NULL, 0);
184  if (ret < 0) {
185  fprintf(stderr, "Cannot open the hardware device\n");
186  goto finish;
187  }
188 
189  /* initialize the decoder */
190  decoder = avcodec_find_decoder_by_name("h264_qsv");
191  if (!decoder) {
192  fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
193  goto finish;
194  }
195 
196  decoder_ctx = avcodec_alloc_context3(decoder);
197  if (!decoder_ctx) {
198  ret = AVERROR(ENOMEM);
199  goto finish;
200  }
201  decoder_ctx->codec_id = AV_CODEC_ID_H264;
202  if (video_st->codecpar->extradata_size) {
203  decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
205  if (!decoder_ctx->extradata) {
206  ret = AVERROR(ENOMEM);
207  goto finish;
208  }
209  memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
210  video_st->codecpar->extradata_size);
211  decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
212  }
213  decoder_ctx->refcounted_frames = 1;
214 
215  decoder_ctx->opaque = &decode;
216  decoder_ctx->get_format = get_format;
217 
218  ret = avcodec_open2(decoder_ctx, NULL, NULL);
219  if (ret < 0) {
220  fprintf(stderr, "Error opening the decoder: ");
221  goto finish;
222  }
223 
224  /* open the output stream */
225  ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
226  if (ret < 0) {
227  fprintf(stderr, "Error opening the output context: ");
228  goto finish;
229  }
230 
231  frame = av_frame_alloc();
232  sw_frame = av_frame_alloc();
233  if (!frame || !sw_frame) {
234  ret = AVERROR(ENOMEM);
235  goto finish;
236  }
237 
238  /* actual decoding */
239  while (ret >= 0) {
240  ret = av_read_frame(input_ctx, &pkt);
241  if (ret < 0)
242  break;
243 
244  if (pkt.stream_index == video_st->index)
245  ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
246 
247  av_packet_unref(&pkt);
248  }
249 
250  /* flush the decoder */
251  pkt.data = NULL;
252  pkt.size = 0;
253  ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
254 
255 finish:
256  if (ret < 0) {
257  char buf[1024];
258  av_strerror(ret, buf, sizeof(buf));
259  fprintf(stderr, "%s\n", buf);
260  }
261 
262  avformat_close_input(&input_ctx);
263 
264  av_frame_free(&frame);
265  av_frame_free(&sw_frame);
266 
267  avcodec_free_context(&decoder_ctx);
268 
270 
271  avio_close(output_ctx);
272 
273  return ret;
274 }
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1098
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
Buffered I/O operations.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1689
int frame_type
A combination of MFX_MEMTYPE_* describing the frame pool.
Definition: hwcontext_qsv.h:49
Memory handling functions.
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:42
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3838
int index
stream index in AVFormatContext
Definition: avformat.h:873
int size
Definition: avcodec.h:1415
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:655
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:228
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:208
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
discard all
Definition: avcodec.h:791
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3365
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
Format I/O context.
Definition: avformat.h:1325
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1602
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1393
static AVFrame * frame
static void finish(void)
Definition: movenc.c:345
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.
Definition: hwcontext.c:569
uint8_t * data
Definition: avcodec.h:1414
#define AVERROR_EOF
End of file.
Definition: error.h:55
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:216
#define FFALIGN(x, a)
Definition: macros.h:48
int width
Definition: frame.h:259
static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
Definition: qsvdec.c:51
int main(int argc, char **argv)
Definition: qsvdec.c:137
error code definitions
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1134
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:709
AVStream * video_st
Definition: movenc.c:59
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:329
#define fail()
Definition: checkasm.h:113
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3856
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
Definition: hwcontext.c:439
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1381
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:198
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:157
static const chunk_decoder decoder[8]
Definition: dfa.c:330
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3168
#define FF_ARRAY_ELEMS(a)
Stream structure.
Definition: avformat.h:872
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:642
Libavcodec external API header.
static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx, AVFrame *frame, AVFrame *sw_frame, AVPacket *pkt, AVIOContext *output_ctx)
Definition: qsvdec.c:90
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
Definition: options.c:172
enum AVCodecID codec_id
Definition: avcodec.h:1512
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
main external API structure.
Definition: avcodec.h:1502
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:590
uint8_t * data
The data buffer.
Definition: buffer.h:89
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:161
void * buf
Definition: avisynth_c.h:690
int extradata_size
Definition: avcodec.h:1603
int coded_height
Definition: avcodec.h:1689
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: avcodec.h:1753
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:123
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:218
refcounted data buffer API
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:614
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1712
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
Definition: avcodec.h:2328
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:510
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: utils.c:1256
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:105
A reference to a data buffer.
Definition: buffer.h:81
Main libavformat public API header.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:243
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4350
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:770
int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:515
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3852
int height
Definition: frame.h:259
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1014
int stream_index
Definition: avcodec.h:1416
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:927
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:221
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1391
void av_register_all(void)
Initialize libavformat and register all the muxers, demuxers and protocols.
Definition: allformats.c:395
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3019
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:1544
AVBufferRef * hw_device_ref
Definition: qsvdec.c:48