FFmpeg
qsv_transcode.c
Go to the documentation of this file.
1 /*
2  * Permission is hereby granted, free of charge, to any person obtaining a copy
3  * of this software and associated documentation files (the "Software"), to deal
4  * in the Software without restriction, including without limitation the rights
5  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
6  * copies of the Software, and to permit persons to whom the Software is
7  * furnished to do so, subject to the following conditions:
8  *
9  * The above copyright notice and this permission notice shall be included in
10  * all copies or substantial portions of the Software.
11  *
12  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
17  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
18  * THE SOFTWARE.
19  */
20 
21 /**
22  * @file Intel QSV-accelerated video transcoding API usage example
23  * @example qsv_transcode.c
24  *
25  * Perform QSV-accelerated transcoding and show to dynamically change
26  * encoder's options.
27  *
28  * Usage: qsv_transcode input_stream codec output_stream initial option
29  * { frame_number new_option }
30  * e.g: - qsv_transcode input.mp4 h264_qsv output_h264.mp4 "g 60"
31  * - qsv_transcode input.mp4 hevc_qsv output_hevc.mp4 "g 60 async_depth 1"
32  * 100 "g 120"
33  * (initialize codec with gop_size 60 and change it to 120 after 100
34  * frames)
35  */
36 
37 #include <stdio.h>
38 #include <errno.h>
39 
40 #include <libavutil/hwcontext.h>
41 #include <libavcodec/avcodec.h>
42 #include <libavformat/avformat.h>
43 #include <libavutil/opt.h>
44 
45 static AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
46 static AVBufferRef *hw_device_ctx = NULL;
47 static AVCodecContext *decoder_ctx = NULL, *encoder_ctx = NULL;
48 static int video_stream = -1;
49 
50 typedef struct DynamicSetting {
52  char* optstr;
55 static int setting_number;
57 
58 static int str_to_dict(char* optstr, AVDictionary **opt)
59 {
60  char *key, *value;
61  if (strlen(optstr) == 0)
62  return 0;
63  key = strtok(optstr, " ");
64  if (key == NULL)
65  return AVERROR(ENAVAIL);
66  value = strtok(NULL, " ");
67  if (value == NULL)
68  return AVERROR(ENAVAIL);
69  av_dict_set(opt, key, value, 0);
70  do {
71  key = strtok(NULL, " ");
72  if (key == NULL)
73  return 0;
74  value = strtok(NULL, " ");
75  if (value == NULL)
76  return AVERROR(ENAVAIL);
77  av_dict_set(opt, key, value, 0);
78  } while(key != NULL);
79  return 0;
80 }
81 
83 {
84  AVDictionary *opts = NULL;
85  int ret = 0;
86  static int frame_number = 0;
87  frame_number++;
89  frame_number == dynamic_setting[current_setting_number].frame_number) {
90  AVDictionaryEntry *e = NULL;
92  if (ret < 0) {
93  fprintf(stderr, "The dynamic parameter is wrong\n");
94  goto fail;
95  }
96  /* Set common option. The dictionary will be freed and replaced
97  * by a new one containing all options not found in common option list.
98  * Then this new dictionary is used to set private option. */
99  if ((ret = av_opt_set_dict(avctx, &opts)) < 0)
100  goto fail;
101  /* Set codec specific option */
102  if ((ret = av_opt_set_dict(avctx->priv_data, &opts)) < 0)
103  goto fail;
104  /* There is no "framerate" option in commom option list. Use "-r" to set
105  * framerate, which is compatible with ffmpeg commandline. The video is
106  * assumed to be average frame rate, so set time_base to 1/framerate. */
107  e = av_dict_get(opts, "r", NULL, 0);
108  if (e) {
109  avctx->framerate = av_d2q(atof(e->value), INT_MAX);
111  }
112  }
113 fail:
114  av_dict_free(&opts);
115  return ret;
116 }
117 
118 static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
119 {
120  while (*pix_fmts != AV_PIX_FMT_NONE) {
121  if (*pix_fmts == AV_PIX_FMT_QSV) {
122  return AV_PIX_FMT_QSV;
123  }
124 
125  pix_fmts++;
126  }
127 
128  fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
129 
130  return AV_PIX_FMT_NONE;
131 }
132 
133 static int open_input_file(char *filename)
134 {
135  int ret;
136  const AVCodec *decoder = NULL;
137  AVStream *video = NULL;
138 
139  if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
140  fprintf(stderr, "Cannot open input file '%s', Error code: %s\n",
141  filename, av_err2str(ret));
142  return ret;
143  }
144 
145  if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
146  fprintf(stderr, "Cannot find input stream information. Error code: %s\n",
147  av_err2str(ret));
148  return ret;
149  }
150 
151  ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
152  if (ret < 0) {
153  fprintf(stderr, "Cannot find a video stream in the input file. "
154  "Error code: %s\n", av_err2str(ret));
155  return ret;
156  }
157  video_stream = ret;
158  video = ifmt_ctx->streams[video_stream];
159 
160  switch(video->codecpar->codec_id) {
161  case AV_CODEC_ID_H264:
162  decoder = avcodec_find_decoder_by_name("h264_qsv");
163  break;
164  case AV_CODEC_ID_HEVC:
165  decoder = avcodec_find_decoder_by_name("hevc_qsv");
166  break;
167  case AV_CODEC_ID_VP9:
168  decoder = avcodec_find_decoder_by_name("vp9_qsv");
169  break;
170  case AV_CODEC_ID_VP8:
171  decoder = avcodec_find_decoder_by_name("vp8_qsv");
172  break;
173  case AV_CODEC_ID_AV1:
174  decoder = avcodec_find_decoder_by_name("av1_qsv");
175  break;
177  decoder = avcodec_find_decoder_by_name("mpeg2_qsv");
178  break;
179  case AV_CODEC_ID_MJPEG:
180  decoder = avcodec_find_decoder_by_name("mjpeg_qsv");
181  break;
182  default:
183  fprintf(stderr, "Codec is not supportted by qsv\n");
184  return AVERROR(ENAVAIL);
185  }
186 
187  if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
188  return AVERROR(ENOMEM);
189 
190  if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
191  fprintf(stderr, "avcodec_parameters_to_context error. Error code: %s\n",
192  av_err2str(ret));
193  return ret;
194  }
196 
198  if (!decoder_ctx->hw_device_ctx) {
199  fprintf(stderr, "A hardware device reference create failed.\n");
200  return AVERROR(ENOMEM);
201  }
204  if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
205  fprintf(stderr, "Failed to open codec for decoding. Error code: %s\n",
206  av_err2str(ret));
207 
208  return ret;
209 }
210 
211 static int encode_write(AVPacket *enc_pkt, AVFrame *frame)
212 {
213  int ret = 0;
214 
215  av_packet_unref(enc_pkt);
216 
217  if((ret = dynamic_set_parameter(encoder_ctx)) < 0) {
218  fprintf(stderr, "Failed to set dynamic parameter. Error code: %s\n",
219  av_err2str(ret));
220  goto end;
221  }
222 
223  if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
224  fprintf(stderr, "Error during encoding. Error code: %s\n", av_err2str(ret));
225  goto end;
226  }
227  while (1) {
228  if (ret = avcodec_receive_packet(encoder_ctx, enc_pkt))
229  break;
230  enc_pkt->stream_index = 0;
232  ofmt_ctx->streams[0]->time_base);
233  if ((ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt)) < 0) {
234  fprintf(stderr, "Error during writing data to output file. "
235  "Error code: %s\n", av_err2str(ret));
236  return ret;
237  }
238  }
239 
240 end:
241  if (ret == AVERROR_EOF)
242  return 0;
243  ret = ((ret == AVERROR(EAGAIN)) ? 0:-1);
244  return ret;
245 }
246 
247 static int dec_enc(AVPacket *pkt, const AVCodec *enc_codec, char *optstr)
248 {
249  AVFrame *frame;
250  int ret = 0;
251 
253  if (ret < 0) {
254  fprintf(stderr, "Error during decoding. Error code: %s\n", av_err2str(ret));
255  return ret;
256  }
257 
258  while (ret >= 0) {
259  if (!(frame = av_frame_alloc()))
260  return AVERROR(ENOMEM);
261 
263  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
265  return 0;
266  } else if (ret < 0) {
267  fprintf(stderr, "Error while decoding. Error code: %s\n", av_err2str(ret));
268  goto fail;
269  }
270  if (!encoder_ctx->hw_frames_ctx) {
271  AVDictionaryEntry *e = NULL;
272  AVDictionary *opts = NULL;
273  AVStream *ost;
274  /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
275  Only after we get a decoded frame, can we obtain its hw_frames_ctx */
277  if (!encoder_ctx->hw_frames_ctx) {
278  ret = AVERROR(ENOMEM);
279  goto fail;
280  }
281  /* set AVCodecContext Parameters for encoder, here we keep them stay
282  * the same as decoder.
283  */
288  if ((ret = str_to_dict(optstr, &opts)) < 0) {
289  fprintf(stderr, "Failed to set encoding parameter.\n");
290  goto fail;
291  }
292  /* There is no "framerate" option in commom option list. Use "-r" to
293  * set framerate, which is compatible with ffmpeg commandline. The
294  * video is assumed to be average frame rate, so set time_base to
295  * 1/framerate. */
296  e = av_dict_get(opts, "r", NULL, 0);
297  if (e) {
298  encoder_ctx->framerate = av_d2q(atof(e->value), INT_MAX);
300  }
301  if ((ret = avcodec_open2(encoder_ctx, enc_codec, &opts)) < 0) {
302  fprintf(stderr, "Failed to open encode codec. Error code: %s\n",
303  av_err2str(ret));
304  av_dict_free(&opts);
305  goto fail;
306  }
307  av_dict_free(&opts);
308 
309  if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
310  fprintf(stderr, "Failed to allocate stream for output format.\n");
311  ret = AVERROR(ENOMEM);
312  goto fail;
313  }
314 
317  if (ret < 0) {
318  fprintf(stderr, "Failed to copy the stream parameters. "
319  "Error code: %s\n", av_err2str(ret));
320  goto fail;
321  }
322 
323  /* write the stream header */
324  if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
325  fprintf(stderr, "Error while writing stream header. "
326  "Error code: %s\n", av_err2str(ret));
327  goto fail;
328  }
329  }
332  if ((ret = encode_write(pkt, frame)) < 0)
333  fprintf(stderr, "Error during encoding and writing.\n");
334 
335 fail:
337  if (ret < 0)
338  return ret;
339  }
340  return 0;
341 }
342 
343 int main(int argc, char **argv)
344 {
345  const AVCodec *enc_codec;
346  int ret = 0;
347  AVPacket *dec_pkt;
348 
349  if (argc < 5 || (argc - 5) % 2) {
350  av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file> <encoder> <output file>"
351  " <\"encoding option set 0\"> [<frame_number> <\"encoding options set 1\">]...\n", argv[0]);
352  return 1;
353  }
354  setting_number = (argc - 5) / 2;
357  for (int i = 0; i < setting_number; i++) {
358  dynamic_setting[i].frame_number = atoi(argv[i*2 + 5]);
359  dynamic_setting[i].optstr = argv[i*2 + 6];
360  }
361 
363  if (ret < 0) {
364  fprintf(stderr, "Failed to create a QSV device. Error code: %s\n", av_err2str(ret));
365  goto end;
366  }
367 
368  dec_pkt = av_packet_alloc();
369  if (!dec_pkt) {
370  fprintf(stderr, "Failed to allocate decode packet\n");
371  goto end;
372  }
373 
374  if ((ret = open_input_file(argv[1])) < 0)
375  goto end;
376 
377  if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
378  fprintf(stderr, "Could not find encoder '%s'\n", argv[2]);
379  ret = -1;
380  goto end;
381  }
382 
383  if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
384  fprintf(stderr, "Failed to deduce output format from file extension. Error code: "
385  "%s\n", av_err2str(ret));
386  goto end;
387  }
388 
389  if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
390  ret = AVERROR(ENOMEM);
391  goto end;
392  }
393 
394  ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
395  if (ret < 0) {
396  fprintf(stderr, "Cannot open output file. "
397  "Error code: %s\n", av_err2str(ret));
398  goto end;
399  }
400 
401  /* read all packets and only transcoding video */
402  while (ret >= 0) {
403  if ((ret = av_read_frame(ifmt_ctx, dec_pkt)) < 0)
404  break;
405 
406  if (video_stream == dec_pkt->stream_index)
407  ret = dec_enc(dec_pkt, enc_codec, argv[4]);
408 
409  av_packet_unref(dec_pkt);
410  }
411 
412  /* flush decoder */
413  av_packet_unref(dec_pkt);
414  if ((ret = dec_enc(dec_pkt, enc_codec, argv[4])) < 0) {
415  fprintf(stderr, "Failed to flush decoder %s\n", av_err2str(ret));
416  goto end;
417  }
418 
419  /* flush encoder */
420  if ((ret = encode_write(dec_pkt, NULL)) < 0) {
421  fprintf(stderr, "Failed to flush encoder %s\n", av_err2str(ret));
422  goto end;
423  }
424 
425  /* write the trailer for output stream */
426  if ((ret = av_write_trailer(ofmt_ctx)) < 0)
427  fprintf(stderr, "Failed to write trailer %s\n", av_err2str(ret));
428 
429 end:
435  av_packet_free(&dec_pkt);
437  return ret;
438 }
Libavcodec external API header.
Main libavformat public API header.
int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
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:624
static AVPacket * pkt
Definition: demux_decode.c:55
static AVFrame * frame
Definition: demux_decode.c:54
int av_opt_set_dict(void *obj, struct AVDictionary **options)
Set all the options from a given dictionary on an object.
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
const AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
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:79
@ AV_CODEC_ID_AV1
Definition: codec_id.h:283
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
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.
void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, const AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
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.
void av_dict_free(AVDictionary **m)
Free all the memory allocated for an AVDictionary struct and all keys and values.
struct AVDictionary AVDictionary
Definition: dict.h:94
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define AVERROR_EOF
End of file.
Definition: error.h:57
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
#define AVERROR(e)
Definition: error.h:45
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.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level.
AVRational av_d2q(double d, int max) av_const
Convert a double precision floating point number to a rational.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const
Rescale a 64-bit integer by 2 rational numbers.
void av_freep(void *ptr)
Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family,...
void * av_malloc(size_t size) av_malloc_attrib
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
AVOptions.
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:240
static AVBufferRef * hw_device_ctx
Definition: qsv_transcode.c:46
static int dec_enc(AVPacket *pkt, const AVCodec *enc_codec, char *optstr)
static AVFormatContext * ifmt_ctx
Definition: qsv_transcode.c:45
static AVFormatContext * ofmt_ctx
Definition: qsv_transcode.c:45
int main(int argc, char **argv)
static DynamicSetting * dynamic_setting
Definition: qsv_transcode.c:54
static int current_setting_number
Definition: qsv_transcode.c:56
static AVCodecContext * encoder_ctx
Definition: qsv_transcode.c:47
static int str_to_dict(char *optstr, AVDictionary **opt)
Definition: qsv_transcode.c:58
static int encode_write(AVPacket *enc_pkt, AVFrame *frame)
static int open_input_file(char *filename)
static int dynamic_set_parameter(AVCodecContext *avctx)
Definition: qsv_transcode.c:82
static AVCodecContext * decoder_ctx
Definition: qsv_transcode.c:47
static int setting_number
Definition: qsv_transcode.c:55
static int video_stream
Definition: qsv_transcode.c:48
static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
A reference to a data buffer.
Definition: buffer.h:82
main external API structure.
Definition: avcodec.h:426
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:635
int width
picture width / height.
Definition: avcodec.h:598
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1764
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Callback to negotiate the pixel format.
Definition: avcodec.h:689
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1887
AVRational framerate
Definition: avcodec.h:1750
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:548
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1928
void * priv_data
Definition: avcodec.h:453
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:62
AVCodec.
Definition: codec.h:184
char * value
Definition: dict.h:91
Format I/O context.
Definition: avformat.h:1104
AVIOContext * pb
I/O context.
Definition: avformat.h:1146
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1172
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
This structure stores compressed data.
Definition: packet.h:351
int stream_index
Definition: packet.h:376
Stream structure.
Definition: avformat.h:838
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:861
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:877
static AVStream * ost