This example shows how to do QSV-accelerated H.264 decoding with output frames in the GPU video surfaces.
#include "config.h"
#include <stdio.h>
{
int ret;
frames_hwctx = frames_ctx->
hwctx;
frames_hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
if (ret < 0)
}
pix_fmts++;
}
fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
}
{
int ret = 0;
if (ret < 0) {
fprintf(stderr, "Error during decoding\n");
return ret;
}
while (ret >= 0) {
int i, j;
break;
else if (ret < 0) {
fprintf(stderr, "Error during decoding\n");
return ret;
}
if (ret < 0) {
fprintf(stderr, "Error transferring the data to system memory\n");
goto fail;
}
for (j = 0; j < (sw_frame->
height >> (i > 0)); j++)
fail:
if (ret < 0)
return ret;
}
return 0;
}
int main(
int argc,
char **argv)
{
int ret, i;
if (argc < 3) {
fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
return 1;
}
if (ret < 0) {
fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
goto finish;
}
video_st = st;
else
}
if (!video_st) {
fprintf(stderr, "No H.264 video stream in the input file\n");
goto finish;
}
"auto", NULL, 0);
if (ret < 0) {
fprintf(stderr, "Cannot open the hardware device\n");
goto finish;
}
if (!decoder) {
fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
goto finish;
}
goto finish;
}
goto finish;
}
}
if (ret < 0) {
fprintf(stderr, "Error opening the decoder: ");
goto finish;
}
if (ret < 0) {
fprintf(stderr, "Error opening the output context: ");
goto finish;
}
if (!
frame || !sw_frame) {
goto finish;
}
while (ret >= 0) {
if (ret < 0)
break;
}
finish:
if (ret < 0) {
char buf[1024];
fprintf(stderr, "%s\n", buf);
}
return ret;
}
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
int frame_type
A combination of MFX_MEMTYPE_* describing the frame pool.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
AVPixelFormat
Pixel format.
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
#define AVERROR_EOF
End of file.
uint8_t * data
The data buffer.
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
AVStream ** streams
A list of all streams in the file.
int main(int argc, char **argv)
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
int width
The allocated dimensions of the frames in this pool.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx, AVFrame *frame, AVFrame *sw_frame, AVPacket *pkt, AVIOContext *output_ctx)
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
#define FF_ARRAY_ELEMS(a)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
#define AVIO_FLAG_WRITE
write-only
static AVCodecContext * decoder_ctx
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_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.
@ AVDISCARD_ALL
discard all
AVCodecParameters * codecpar
Codec parameters associated with this stream.
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ctx)
Allocate an AVHWFramesContext tied to a given device context.
int extradata_size
Size of the extradata content in bytes.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
AVBufferRef * hw_device_ref
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
This struct describes a set or pool of "hardware" frames (i.e.
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
void * opaque
Private data of the user, can be used to carry app specific stuff.
#define AV_INPUT_BUFFER_PADDING_SIZE
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
main external API structure.
int index
stream index in AVFormatContext
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
This struct is allocated as AVHWFramesContext.hwctx.
int coded_width
Bitstream width / height, may be different from width/height e.g.
int initial_pool_size
Initial size of the frame pool.
A reference to a data buffer.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
This structure stores compressed data.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.