FFmpeg  4.3
nuv.c
Go to the documentation of this file.
1 /*
2  * NuppelVideo demuxer.
3  * Copyright (c) 2006 Reimar Doeffinger
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
23 #include "libavutil/imgutils.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/intfloat.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "riff.h"
29 
30 static const AVCodecTag nuv_audio_tags[] = {
31  { AV_CODEC_ID_PCM_S16LE, MKTAG('R', 'A', 'W', 'A') },
32  { AV_CODEC_ID_MP3, MKTAG('L', 'A', 'M', 'E') },
33  { AV_CODEC_ID_NONE, 0 },
34 };
35 
36 typedef struct NUVContext {
37  int v_id;
38  int a_id;
40 } NUVContext;
41 
42 typedef enum {
43  NUV_VIDEO = 'V',
45  NUV_AUDIO = 'A',
46  NUV_SEEKP = 'R',
49 
50 static int nuv_probe(const AVProbeData *p)
51 {
52  if (!memcmp(p->buf, "NuppelVideo", 12))
53  return AVPROBE_SCORE_MAX;
54  if (!memcmp(p->buf, "MythTVVideo", 12))
55  return AVPROBE_SCORE_MAX;
56  return 0;
57 }
58 
59 /// little macro to sanitize packet size
60 #define PKTSIZE(s) (s & 0xffffff)
61 
62 /**
63  * @brief read until we found all data needed for decoding
64  * @param vst video stream of which to change parameters
65  * @param ast video stream of which to change parameters
66  * @param myth set if this is a MythTVVideo format file
67  * @return 0 or AVERROR code
68  */
70  AVStream *ast, int myth)
71 {
72  nuv_frametype frametype;
73 
74  if (!vst && !myth)
75  return 1; // no codec data needed
76  while (!avio_feof(pb)) {
77  int size, subtype, ret;
78 
79  frametype = avio_r8(pb);
80  switch (frametype) {
81  case NUV_EXTRADATA:
82  subtype = avio_r8(pb);
83  avio_skip(pb, 6);
84  size = PKTSIZE(avio_rl32(pb));
85  if (vst && subtype == 'R') {
86  if ((ret = ff_get_extradata(NULL, vst->codecpar, pb, size)) < 0)
87  return ret;
88  size = 0;
89  if (!myth)
90  return 0;
91  }
92  break;
93  case NUV_MYTHEXT:
94  avio_skip(pb, 7);
95  size = PKTSIZE(avio_rl32(pb));
96  if (size != 128 * 4)
97  break;
98  avio_rl32(pb); // version
99  if (vst) {
100  vst->codecpar->codec_tag = avio_rl32(pb);
101  vst->codecpar->codec_id =
103  if (vst->codecpar->codec_tag == MKTAG('R', 'J', 'P', 'G'))
105  } else
106  avio_skip(pb, 4);
107 
108  if (ast) {
109  int id;
110 
111  ast->codecpar->codec_tag = avio_rl32(pb);
112  ast->codecpar->sample_rate = avio_rl32(pb);
113  if (ast->codecpar->sample_rate <= 0) {
114  av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", ast->codecpar->sample_rate);
115  return AVERROR_INVALIDDATA;
116  }
118  ast->codecpar->channels = avio_rl32(pb);
119  ast->codecpar->channel_layout = 0;
120 
123  if (id == AV_CODEC_ID_NONE) {
125  if (id == AV_CODEC_ID_PCM_S16LE)
127  0, 0, ~1);
128  }
129  ast->codecpar->codec_id = id;
130 
132  } else
133  avio_skip(pb, 4 * 4);
134 
135  size -= 6 * 4;
136  avio_skip(pb, size);
137  return 0;
138  case NUV_SEEKP:
139  size = 11;
140  break;
141  default:
142  avio_skip(pb, 7);
143  size = PKTSIZE(avio_rl32(pb));
144  break;
145  }
146  avio_skip(pb, size);
147  }
148 
149  return 0;
150 }
151 
153 {
154  NUVContext *ctx = s->priv_data;
155  AVIOContext *pb = s->pb;
156  char id_string[12];
157  double aspect, fps;
158  int is_mythtv, width, height, v_packs, a_packs, ret;
159  AVStream *vst = NULL, *ast = NULL;
160 
161  avio_read(pb, id_string, 12);
162  is_mythtv = !memcmp(id_string, "MythTVVideo", 12);
163  avio_skip(pb, 5); // version string
164  avio_skip(pb, 3); // padding
165  width = avio_rl32(pb);
166  height = avio_rl32(pb);
167  avio_rl32(pb); // unused, "desiredwidth"
168  avio_rl32(pb); // unused, "desiredheight"
169  avio_r8(pb); // 'P' == progressive, 'I' == interlaced
170  avio_skip(pb, 3); // padding
171  aspect = av_int2double(avio_rl64(pb));
172  if (aspect > 0.9999 && aspect < 1.0001)
173  aspect = 4.0 / 3.0;
174  fps = av_int2double(avio_rl64(pb));
175  if (fps < 0.0f) {
176  if (s->error_recognition & AV_EF_EXPLODE) {
177  av_log(s, AV_LOG_ERROR, "Invalid frame rate %f\n", fps);
178  return AVERROR_INVALIDDATA;
179  } else {
180  av_log(s, AV_LOG_WARNING, "Invalid frame rate %f, setting to 0.\n", fps);
181  fps = 0.0f;
182  }
183  }
184 
185  // number of packets per stream type, -1 means unknown, e.g. streaming
186  v_packs = avio_rl32(pb);
187  a_packs = avio_rl32(pb);
188  avio_rl32(pb); // text
189 
190  avio_rl32(pb); // keyframe distance (?)
191 
192  if (v_packs) {
193  vst = avformat_new_stream(s, NULL);
194  if (!vst)
195  return AVERROR(ENOMEM);
196  ctx->v_id = vst->index;
197 
199  if (ret < 0)
200  return ret;
201 
204  vst->codecpar->width = width;
205  vst->codecpar->height = height;
206  vst->codecpar->bits_per_coded_sample = 10;
207  vst->sample_aspect_ratio = av_d2q(aspect * height / width,
208  10000);
209 #if FF_API_R_FRAME_RATE
210  vst->r_frame_rate =
211 #endif
212  vst->avg_frame_rate = av_d2q(fps, 60000);
213  avpriv_set_pts_info(vst, 32, 1, 1000);
214  } else
215  ctx->v_id = -1;
216 
217  if (a_packs) {
218  ast = avformat_new_stream(s, NULL);
219  if (!ast)
220  return AVERROR(ENOMEM);
221  ctx->a_id = ast->index;
222 
223  ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
224  ast->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
225  ast->codecpar->channels = 2;
226  ast->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
227  ast->codecpar->sample_rate = 44100;
228  ast->codecpar->bit_rate = 2 * 2 * 44100 * 8;
229  ast->codecpar->block_align = 2 * 2;
230  ast->codecpar->bits_per_coded_sample = 16;
231  avpriv_set_pts_info(ast, 32, 1, 1000);
232  } else
233  ctx->a_id = -1;
234 
235  if ((ret = get_codec_data(s, pb, vst, ast, is_mythtv)) < 0)
236  return ret;
237 
238  ctx->rtjpg_video = vst && vst->codecpar->codec_id == AV_CODEC_ID_NUV;
239 
240  return 0;
241 }
242 
243 #define HDRSIZE 12
244 
246 {
247  NUVContext *ctx = s->priv_data;
248  AVIOContext *pb = s->pb;
249  uint8_t hdr[HDRSIZE];
250  nuv_frametype frametype;
251  int ret, size;
252 
253  while (!avio_feof(pb)) {
254  int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;
255  uint64_t pos = avio_tell(pb);
256 
257  ret = avio_read(pb, hdr, HDRSIZE);
258  if (ret < HDRSIZE)
259  return ret < 0 ? ret : AVERROR(EIO);
260 
261  frametype = hdr[0];
262  size = PKTSIZE(AV_RL32(&hdr[8]));
263 
264  switch (frametype) {
265  case NUV_EXTRADATA:
266  if (!ctx->rtjpg_video) {
267  avio_skip(pb, size);
268  break;
269  }
270  case NUV_VIDEO:
271  if (ctx->v_id < 0) {
272  av_log(s, AV_LOG_ERROR, "Video packet in file without video stream!\n");
273  avio_skip(pb, size);
274  break;
275  }
276  ret = av_new_packet(pkt, copyhdrsize + size);
277  if (ret < 0)
278  return ret;
279 
280  pkt->pos = pos;
281  pkt->flags |= hdr[2] == 0 ? AV_PKT_FLAG_KEY : 0;
282  pkt->pts = AV_RL32(&hdr[4]);
283  pkt->stream_index = ctx->v_id;
284  memcpy(pkt->data, hdr, copyhdrsize);
285  ret = avio_read(pb, pkt->data + copyhdrsize, size);
286  if (ret < 0) {
287  return ret;
288  }
289  if (ret < size)
290  av_shrink_packet(pkt, copyhdrsize + ret);
291  return 0;
292  case NUV_AUDIO:
293  if (ctx->a_id < 0) {
294  av_log(s, AV_LOG_ERROR, "Audio packet in file without audio stream!\n");
295  avio_skip(pb, size);
296  break;
297  }
298  ret = av_get_packet(pb, pkt, size);
300  pkt->pos = pos;
301  pkt->pts = AV_RL32(&hdr[4]);
302  pkt->stream_index = ctx->a_id;
303  if (ret < 0)
304  return ret;
305  return 0;
306  case NUV_SEEKP:
307  // contains no data, size value is invalid
308  break;
309  default:
310  avio_skip(pb, size);
311  break;
312  }
313  }
314 
315  return AVERROR(EIO);
316 }
317 
318 /**
319  * \brief looks for the string RTjjjjjjjjjj in the stream too resync reading
320  * \return 1 if the syncword is found 0 otherwise.
321  */
322 static int nuv_resync(AVFormatContext *s, int64_t pos_limit) {
323  AVIOContext *pb = s->pb;
324  uint32_t tag = 0;
325  while(!avio_feof(pb) && avio_tell(pb) < pos_limit) {
326  tag = (tag << 8) | avio_r8(pb);
327  if (tag == MKBETAG('R','T','j','j') &&
328  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j') &&
329  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j'))
330  return 1;
331  }
332  return 0;
333 }
334 
335 /**
336  * \brief attempts to read a timestamp from stream at the given stream position
337  * \return timestamp if successful and AV_NOPTS_VALUE if failure
338  */
339 static int64_t nuv_read_dts(AVFormatContext *s, int stream_index,
340  int64_t *ppos, int64_t pos_limit)
341 {
342  NUVContext *ctx = s->priv_data;
343  AVIOContext *pb = s->pb;
344  uint8_t hdr[HDRSIZE];
345  nuv_frametype frametype;
346  int size, key, idx;
347  int64_t pos, dts;
348 
349  if (avio_seek(pb, *ppos, SEEK_SET) < 0)
350  return AV_NOPTS_VALUE;
351 
352  if (!nuv_resync(s, pos_limit))
353  return AV_NOPTS_VALUE;
354 
355  while (!avio_feof(pb) && avio_tell(pb) < pos_limit) {
356  if (avio_read(pb, hdr, HDRSIZE) < HDRSIZE)
357  return AV_NOPTS_VALUE;
358  frametype = hdr[0];
359  size = PKTSIZE(AV_RL32(&hdr[8]));
360  switch (frametype) {
361  case NUV_SEEKP:
362  break;
363  case NUV_AUDIO:
364  case NUV_VIDEO:
365  if (frametype == NUV_VIDEO) {
366  idx = ctx->v_id;
367  key = hdr[2] == 0;
368  } else {
369  idx = ctx->a_id;
370  key = 1;
371  }
372  if (stream_index == idx) {
373 
374  pos = avio_tell(s->pb) - HDRSIZE;
375  dts = AV_RL32(&hdr[4]);
376 
377  // TODO - add general support in av_gen_search, so it adds positions after reading timestamps
378  av_add_index_entry(s->streams[stream_index], pos, dts, size + HDRSIZE, 0,
379  key ? AVINDEX_KEYFRAME : 0);
380 
381  *ppos = pos;
382  return dts;
383  }
384  default:
385  avio_skip(pb, size);
386  break;
387  }
388  }
389  return AV_NOPTS_VALUE;
390 }
391 
392 
394  .name = "nuv",
395  .long_name = NULL_IF_CONFIG_SMALL("NuppelVideo"),
396  .priv_data_size = sizeof(NUVContext),
400  .read_timestamp = nuv_read_dts,
402 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:301
NUV_EXTRADATA
@ NUV_EXTRADATA
Definition: nuv.c:44
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ff_get_pcm_codec_id
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
Select a PCM codec based on the given parameters.
Definition: utils.c:3170
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4519
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
ff_get_extradata
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:3339
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
av_int2double
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
nuv_frametype
nuv_frametype
Definition: nuv.c:42
nuv_read_dts
static int64_t nuv_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
attempts to read a timestamp from stream at the given stream position
Definition: nuv.c:339
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:192
AVPacket::data
uint8_t * data
Definition: packet.h:355
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:938
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
nuv_audio_tags
static const AVCodecTag nuv_audio_tags[]
Definition: nuv.c:30
intfloat.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:803
NUVContext
Definition: nuv.c:36
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:103
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:2045
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:463
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVInputFormat
Definition: avformat.h:636
AVCodecTag
Definition: internal.h:42
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:641
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
AV_CODEC_ID_NUV
@ AV_CODEC_ID_NUV
Definition: codec_id.h:133
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1083
ctx
AVFormatContext * ctx
Definition: movenc.c:48
key
const char * key
Definition: hwcontext_opencl.c:168
NUV_MYTHEXT
@ NUV_MYTHEXT
Definition: nuv.c:47
f
#define f(width, name)
Definition: cbs_vp9.c:255
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
nuv_packet
static int nuv_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nuv.c:245
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
get_codec_data
static int get_codec_data(AVFormatContext *s, AVIOContext *pb, AVStream *vst, AVStream *ast, int myth)
read until we found all data needed for decoding
Definition: nuv.c:69
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
PKTSIZE
#define PKTSIZE(s)
little macro to sanitize packet size
Definition: nuv.c:60
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
ff_nuv_demuxer
AVInputFormat ff_nuv_demuxer
Definition: nuv.c:393
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:747
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:186
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:332
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3158
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4938
size
int size
Definition: twinvq_data.h:11134
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
NUV_AUDIO
@ NUV_AUDIO
Definition: nuv.c:45
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:407
NUVContext::rtjpg_video
int rtjpg_video
Definition: nuv.c:39
NUVContext::v_id
int v_id
Definition: nuv.c:37
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:927
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
height
#define height
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
AVCodecParameters::height
int height
Definition: codec_par.h:127
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
uint8_t
uint8_t
Definition: audio_convert.c:194
NUVContext::a_id
int a_id
Definition: nuv.c:38
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:304
NUV_SEEKP
@ NUV_SEEKP
Definition: nuv.c:46
tag
uint32_t tag
Definition: movenc.c:1532
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:865
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
NUV_VIDEO
@ NUV_VIDEO
Definition: nuv.c:43
pos
unsigned int pos
Definition: spdifenc.c:410
avformat.h
nuv_header
static int nuv_header(AVFormatContext *s)
Definition: nuv.c:152
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:866
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
channel_layout.h
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AV_RL32
#define AV_RL32
Definition: intreadwrite.h:146
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:989
AVPacket::stream_index
int stream_index
Definition: packet.h:357
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
HDRSIZE
#define HDRSIZE
Definition: nuv.c:243
AVPacket
This structure stores compressed data.
Definition: packet.h:332
riff.h
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:375
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:755
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:786
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
nuv_resync
static int nuv_resync(AVFormatContext *s, int64_t pos_limit)
looks for the string RTjjjjjjjjjj in the stream too resync reading
Definition: nuv.c:322
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
nuv_probe
static int nuv_probe(const AVProbeData *p)
Definition: nuv.c:50
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:282
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356