FFmpeg  4.3.7
venc_data_dump.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <stdio.h>
20 #include <stdint.h>
21 #include <stdlib.h>
22 
23 #include "libavutil/common.h"
24 #include "libavutil/dict.h"
25 #include "libavutil/error.h"
27 
28 #include "libavformat/avformat.h"
29 
30 #include "libavcodec/avcodec.h"
31 
32 static int decode_read(AVCodecContext *decoder, AVFrame *frame, int flush, int max_frames)
33 {
34  const int ret_done = flush ? AVERROR_EOF : AVERROR(EAGAIN);
35  int ret = 0;
36 
37  while (ret >= 0 &&
38  (max_frames == 0 || decoder->frame_number < max_frames)) {
39  AVFrameSideData *sd;
40 
41  ret = avcodec_receive_frame(decoder, frame);
42  if (ret < 0)
43  return (ret == ret_done) ? 0 : ret;
44 
45  fprintf(stdout, "frame %d\n", decoder->frame_number - 1);
46 
48  if (sd) {
50 
51  fprintf(stdout, "AVVideoEncParams %d\n", par->type);
52  fprintf(stdout, "qp %d\n", par->qp);
53  for (int i = 0; i < FF_ARRAY_ELEMS(par->delta_qp); i++)
54  for (int j = 0; j < FF_ARRAY_ELEMS(par->delta_qp[i]); j++) {
55  if (par->delta_qp[i][j])
56  fprintf(stdout, "delta_qp[%d][%d] %"PRId32"\n", i, j, par->delta_qp[i][j]);
57  }
58 
59  if (par->nb_blocks) {
60  fprintf(stdout, "nb_blocks %d\n", par->nb_blocks);
61  for (int i = 0; i < par->nb_blocks; i++) {
63 
64  fprintf(stdout, "block %d %d:%d %dx%d %"PRId32"\n",
65  i, b->src_x, b->src_y, b->w, b->h, b->delta_qp);
66  }
67  }
68  }
69 
70  av_frame_unref(frame);
71 
72  if (max_frames && decoder->frame_number == max_frames)
73  return 1;
74  }
75 
76  return (max_frames == 0 || decoder->frame_number < max_frames) ? 0 : 1;
77 }
78 
79 static int decoder_init(AVFormatContext *demuxer, int stream_idx,
81 {
82  const AVCodec *codec;
83  int ret;
84 
85  if (stream_idx < 0 || stream_idx >= demuxer->nb_streams)
86  return AVERROR(EINVAL);
87 
88  codec = avcodec_find_decoder(demuxer->streams[stream_idx]->codecpar->codec_id);
89  if (!codec)
91 
92  *dec = avcodec_alloc_context3(codec);
93  if (!*dec)
94  return AVERROR(ENOMEM);
95 
96  ret = avcodec_open2(*dec, NULL, opts);
97  if (ret < 0)
98  return ret;
99 
100  return 0;
101 }
102 
103 int main(int argc, char **argv)
104 {
105  AVFormatContext *demuxer = NULL;
108 
109  AVPacket *pkt = NULL;
110  AVFrame *frame = NULL;
111 
112  unsigned int stream_idx, max_frames;
113  const char *filename, *thread_type = NULL, *nb_threads = NULL;
114  int ret = 0;
115 
116  if (argc <= 3) {
117  fprintf(stderr, "Usage: %s <input file> <stream index> <max frame count> [<thread count> <thread type>]\n", argv[0]);
118  return 0;
119  }
120 
121  filename = argv[1];
122  stream_idx = strtol(argv[2], NULL, 0);
123  max_frames = strtol(argv[3], NULL, 0);
124  if (argc > 5) {
125  nb_threads = argv[4];
126  thread_type = argv[5];
127  }
128 
129  ret = av_dict_set(&opts, "threads", nb_threads, 0);
130  ret |= av_dict_set(&opts, "thread_type", thread_type, 0);
131  ret |= av_dict_set(&opts, "export_side_data", "venc_params", 0);
132 
133  ret = avformat_open_input(&demuxer, filename, NULL, NULL);
134  if (ret < 0) {
135  fprintf(stderr, "Error opening input file: %d\n", ret);
136  return ret;
137  }
138 
139  ret = decoder_init(demuxer, stream_idx, &decoder, &opts);
140  if (ret < 0) {
141  fprintf(stderr, "Error initializing decoder\n");
142  goto finish;
143  }
144 
145  pkt = av_packet_alloc();
146  frame = av_frame_alloc();
147  if (!pkt || !frame) {
148  ret = AVERROR(ENOMEM);
149  goto finish;
150  }
151 
152  while (ret >= 0) {
153  ret = av_read_frame(demuxer, pkt);
154  if (ret < 0)
155  goto flush;
156  if (pkt->stream_index != stream_idx) {
157  av_packet_unref(pkt);
158  continue;
159  }
160 
161  ret = avcodec_send_packet(decoder, pkt);
162  if (ret < 0) {
163  fprintf(stderr, "Error decoding: %d\n", ret);
164  goto finish;
165  }
166  av_packet_unref(pkt);
167 
168  ret = decode_read(decoder, frame, 0, max_frames);
169  if (ret < 0) {
170  fprintf(stderr, "Error decoding: %d\n", ret);
171  goto finish;
172  } else if (ret > 0) {
173  ret = 0;
174  goto finish;
175  }
176  }
177 
178 flush:
179  avcodec_send_packet(decoder, NULL);
180  ret = decode_read(decoder, frame, 1, max_frames);
181  if (ret < 0) {
182  fprintf(stderr, "Error flushing: %d\n", ret);
183  goto finish;
184  }
185  ret = 0;
186 
187 finish:
188  av_dict_free(&opts);
189  av_packet_free(&pkt);
190  av_frame_free(&frame);
191  avcodec_free_context(&decoder);
192  avformat_close_input(&demuxer);
193 
194  return ret;
195 }
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
static void flush(AVCodecContext *avctx)
int32_t qp
Base quantisation parameter for the frame.
int32_t delta_qp
Difference between this block&#39;s final quantization parameter and the corresponding per-frame value...
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
const char * b
Definition: vf_curves.c:116
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:536
int src_x
Distance in luma pixels from the top-left corner of the visible frame to the top-left corner of the b...
static AVPacket pkt
AVCodec.
Definition: codec.h:190
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:739
int32_t delta_qp[4][2]
Quantisation parameter offset from the base (per-frame) qp for a given plane (first index) and AC/DC ...
Format I/O context.
Definition: avformat.h:1351
Public dictionary API.
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:64
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
Data structure for storing block-level encoding information.
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
static AVFrame * frame
Structure to hold side data for an AVFrame.
Definition: frame.h:206
static void finish(void)
Definition: movenc.c:345
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:203
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:649
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
enum AVVideoEncParamsType type
Type of the parameters (the codec they are used with).
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
AVDictionary * opts
Definition: movenc.c:50
Video encoding parameters for a given frame.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:157
int w
Width and height of the block in luma pixels.
static const chunk_decoder decoder[8]
Definition: dfa.c:330
#define FF_ARRAY_ELEMS(a)
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:586
Libavcodec external API header.
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
main external API structure.
Definition: avcodec.h:526
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
uint8_t * data
Definition: frame.h:208
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:571
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1780
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:919
unsigned int nb_blocks
Number of blocks in the array.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
Main libavformat public API header.
common internal and external API header
int main(int argc, char **argv)
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4498
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:52
static int decoder_init(AVFormatContext *demuxer, int stream_idx, AVCodecContext **dec, AVDictionary **opts)
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:53
Encoding parameters for a video frame, as described by AVVideoEncParams.
Definition: frame.h:186
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
int stream_index
Definition: packet.h:357
This structure stores compressed data.
Definition: packet.h:332
static int decode_read(AVCodecContext *decoder, AVFrame *frame, int flush, int max_frames)