FFmpeg  5.1.1
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 static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
48 {
49  while (*pix_fmts != AV_PIX_FMT_NONE) {
50  if (*pix_fmts == AV_PIX_FMT_QSV) {
51  return AV_PIX_FMT_QSV;
52  }
53 
54  pix_fmts++;
55  }
56 
57  fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
58 
59  return AV_PIX_FMT_NONE;
60 }
61 
63  AVFrame *frame, AVFrame *sw_frame,
64  AVPacket *pkt, AVIOContext *output_ctx)
65 {
66  int ret = 0;
67 
69  if (ret < 0) {
70  fprintf(stderr, "Error during decoding\n");
71  return ret;
72  }
73 
74  while (ret >= 0) {
75  int i, j;
76 
78  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
79  break;
80  else if (ret < 0) {
81  fprintf(stderr, "Error during decoding\n");
82  return ret;
83  }
84 
85  /* A real program would do something useful with the decoded frame here.
86  * We just retrieve the raw data and write it to a file, which is rather
87  * useless but pedagogic. */
88  ret = av_hwframe_transfer_data(sw_frame, frame, 0);
89  if (ret < 0) {
90  fprintf(stderr, "Error transferring the data to system memory\n");
91  goto fail;
92  }
93 
94  for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
95  for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
96  avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
97 
98 fail:
99  av_frame_unref(sw_frame);
101 
102  if (ret < 0)
103  return ret;
104  }
105 
106  return 0;
107 }
108 
109 int main(int argc, char **argv)
110 {
111  AVFormatContext *input_ctx = NULL;
112  AVStream *video_st = NULL;
113  AVCodecContext *decoder_ctx = NULL;
114  const AVCodec *decoder;
115 
116  AVPacket *pkt = NULL;
117  AVFrame *frame = NULL, *sw_frame = NULL;
118 
119  AVIOContext *output_ctx = NULL;
120 
121  int ret, i;
122 
123  AVBufferRef *device_ref = NULL;
124 
125  if (argc < 3) {
126  fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
127  return 1;
128  }
129 
130  /* open the input file */
131  ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
132  if (ret < 0) {
133  fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
134  goto finish;
135  }
136 
137  /* find the first H.264 video stream */
138  for (i = 0; i < input_ctx->nb_streams; i++) {
139  AVStream *st = input_ctx->streams[i];
140 
141  if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
142  video_st = st;
143  else
144  st->discard = AVDISCARD_ALL;
145  }
146  if (!video_st) {
147  fprintf(stderr, "No H.264 video stream in the input file\n");
148  goto finish;
149  }
150 
151  /* open the hardware device */
152  ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_QSV,
153  "auto", NULL, 0);
154  if (ret < 0) {
155  fprintf(stderr, "Cannot open the hardware device\n");
156  goto finish;
157  }
158 
159  /* initialize the decoder */
160  decoder = avcodec_find_decoder_by_name("h264_qsv");
161  if (!decoder) {
162  fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
163  goto finish;
164  }
165 
167  if (!decoder_ctx) {
168  ret = AVERROR(ENOMEM);
169  goto finish;
170  }
172  if (video_st->codecpar->extradata_size) {
175  if (!decoder_ctx->extradata) {
176  ret = AVERROR(ENOMEM);
177  goto finish;
178  }
179  memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
180  video_st->codecpar->extradata_size);
182  }
183 
184 
185  decoder_ctx->hw_device_ctx = av_buffer_ref(device_ref);
187 
188  ret = avcodec_open2(decoder_ctx, NULL, NULL);
189  if (ret < 0) {
190  fprintf(stderr, "Error opening the decoder: ");
191  goto finish;
192  }
193 
194  /* open the output stream */
195  ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
196  if (ret < 0) {
197  fprintf(stderr, "Error opening the output context: ");
198  goto finish;
199  }
200 
201  frame = av_frame_alloc();
202  sw_frame = av_frame_alloc();
203  pkt = av_packet_alloc();
204  if (!frame || !sw_frame || !pkt) {
205  ret = AVERROR(ENOMEM);
206  goto finish;
207  }
208 
209  /* actual decoding */
210  while (ret >= 0) {
211  ret = av_read_frame(input_ctx, pkt);
212  if (ret < 0)
213  break;
214 
215  if (pkt->stream_index == video_st->index)
216  ret = decode_packet(decoder_ctx, frame, sw_frame, pkt, output_ctx);
217 
219  }
220 
221  /* flush the decoder */
222  ret = decode_packet(decoder_ctx, frame, sw_frame, NULL, output_ctx);
223 
224 finish:
225  if (ret < 0) {
226  char buf[1024];
227  av_strerror(ret, buf, sizeof(buf));
228  fprintf(stderr, "%s\n", buf);
229  }
230 
231  avformat_close_input(&input_ctx);
232 
234  av_frame_free(&sw_frame);
236 
238 
239  av_buffer_unref(&device_ref);
240 
241  avio_close(output_ctx);
242 
243  return ret;
244 }
Libavcodec external API header.
Main libavformat public API header.
Buffered I/O operations.
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:629
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
refcounted data buffer API
static AVPacket * pkt
static AVFrame * frame
error code definitions
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition: defs.h:40
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
#define AVERROR_EOF
End of file.
Definition: error.h:57
#define AVERROR(e)
Definition: error.h:45
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
void * av_mallocz(size_t size) av_malloc_attrib
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
int av_hwdevice_ctx_create(AVBufferRef **device_ctx, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)
Open a device of the specified type and create an AVHWDeviceContext for it.
@ AV_HWDEVICE_TYPE_QSV
Definition: hwcontext.h:33
An API-specific header for AV_HWDEVICE_TYPE_QSV.
#define FF_ARRAY_ELEMS(a)
Definition: macros.h:53
Memory handling functions.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:212
int main(int argc, char **argv)
Definition: qsvdec.c:109
static int decode_packet(AVCodecContext *decoder_ctx, AVFrame *frame, AVFrame *sw_frame, AVPacket *pkt, AVIOContext *output_ctx)
Definition: qsvdec.c:62
static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
Definition: qsvdec.c:47
A reference to a data buffer.
Definition: buffer.h:82
main external API structure.
Definition: avcodec.h:389
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Callback to negotiate the pixel format.
Definition: avcodec.h:653
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:490
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1930
enum AVCodecID codec_id
Definition: avcodec.h:399
int extradata_size
Definition: avcodec.h:491
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:79
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:75
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVCodec.
Definition: codec.h:196
Format I/O context.
Definition: avformat.h:1213
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1269
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1281
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
int width
Definition: frame.h:397
int height
Definition: frame.h:397
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
Bytestream IO Context.
Definition: avio.h:162
This structure stores compressed data.
Definition: packet.h:351
int stream_index
Definition: packet.h:376
Stream structure.
Definition: avformat.h:948
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:1010
int index
stream index in AVFormatContext
Definition: avformat.h:956
static AVCodecContext * decoder_ctx