FFmpeg
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 "avio_internal.h"
28 #include "internal.h"
29 #include "riff.h"
30 
31 static const AVCodecTag nuv_audio_tags[] = {
32  { AV_CODEC_ID_PCM_S16LE, MKTAG('R', 'A', 'W', 'A') },
33  { AV_CODEC_ID_MP3, MKTAG('L', 'A', 'M', 'E') },
34  { AV_CODEC_ID_NONE, 0 },
35 };
36 
37 typedef struct NUVContext {
38  int v_id;
39  int a_id;
41 } NUVContext;
42 
43 typedef enum {
44  NUV_VIDEO = 'V',
46  NUV_AUDIO = 'A',
47  NUV_SEEKP = 'R',
50 
51 static int nuv_probe(const AVProbeData *p)
52 {
53  if (!memcmp(p->buf, "NuppelVideo", 12))
54  return AVPROBE_SCORE_MAX;
55  if (!memcmp(p->buf, "MythTVVideo", 12))
56  return AVPROBE_SCORE_MAX;
57  return 0;
58 }
59 
60 /// little macro to sanitize packet size
61 #define PKTSIZE(s) (s & 0xffffff)
62 
63 /**
64  * @brief read until we found all data needed for decoding
65  * @param vst video stream of which to change parameters
66  * @param ast video stream of which to change parameters
67  * @param myth set if this is a MythTVVideo format file
68  * @return 0 or AVERROR code
69  */
71  AVStream *ast, int myth)
72 {
73  nuv_frametype frametype;
74 
75  if (!vst && !myth)
76  return 1; // no codec data needed
77  while (!avio_feof(pb)) {
78  int size, subtype, ret;
79 
80  frametype = avio_r8(pb);
81  switch (frametype) {
82  case NUV_EXTRADATA:
83  subtype = avio_r8(pb);
84  avio_skip(pb, 6);
85  size = PKTSIZE(avio_rl32(pb));
86  if (vst && subtype == 'R') {
87  if ((ret = ff_get_extradata(NULL, vst->codecpar, pb, size)) < 0)
88  return ret;
89  size = 0;
90  if (!myth)
91  return 0;
92  }
93  break;
94  case NUV_MYTHEXT:
95  avio_skip(pb, 7);
96  size = PKTSIZE(avio_rl32(pb));
97  if (size != 128 * 4)
98  break;
99  avio_rl32(pb); // version
100  if (vst) {
101  vst->codecpar->codec_tag = avio_rl32(pb);
102  vst->codecpar->codec_id =
104  if (vst->codecpar->codec_tag == MKTAG('R', 'J', 'P', 'G'))
106  } else
107  avio_skip(pb, 4);
108 
109  if (ast) {
110  int id;
111 
112  ast->codecpar->codec_tag = avio_rl32(pb);
113  ast->codecpar->sample_rate = avio_rl32(pb);
114  if (ast->codecpar->sample_rate <= 0) {
115  av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", ast->codecpar->sample_rate);
116  return AVERROR_INVALIDDATA;
117  }
119  ast->codecpar->channels = avio_rl32(pb);
120  ast->codecpar->channel_layout = 0;
121  if (ast->codecpar->channels <= 0) {
122  av_log(s, AV_LOG_ERROR, "Invalid channels %d\n", ast->codecpar->channels);
123  return AVERROR_INVALIDDATA;
124  }
125 
128  if (id == AV_CODEC_ID_NONE) {
130  if (id == AV_CODEC_ID_PCM_S16LE)
132  0, 0, ~1);
133  }
134  ast->codecpar->codec_id = id;
135 
137  } else
138  avio_skip(pb, 4 * 4);
139 
140  size -= 6 * 4;
141  avio_skip(pb, size);
142  return 0;
143  case NUV_SEEKP:
144  size = 11;
145  break;
146  default:
147  avio_skip(pb, 7);
148  size = PKTSIZE(avio_rl32(pb));
149  break;
150  }
151  avio_skip(pb, size);
152  }
153 
154  return 0;
155 }
156 
158 {
159  NUVContext *ctx = s->priv_data;
160  AVIOContext *pb = s->pb;
161  char id_string[12];
162  double aspect, fps;
163  int is_mythtv, width, height, v_packs, a_packs, ret;
164  AVStream *vst = NULL, *ast = NULL;
165 
166  avio_read(pb, id_string, 12);
167  is_mythtv = !memcmp(id_string, "MythTVVideo", 12);
168  avio_skip(pb, 5); // version string
169  avio_skip(pb, 3); // padding
170  width = avio_rl32(pb);
171  height = avio_rl32(pb);
172  avio_rl32(pb); // unused, "desiredwidth"
173  avio_rl32(pb); // unused, "desiredheight"
174  avio_r8(pb); // 'P' == progressive, 'I' == interlaced
175  avio_skip(pb, 3); // padding
176  aspect = av_int2double(avio_rl64(pb));
177  if (aspect > 0.9999 && aspect < 1.0001)
178  aspect = 4.0 / 3.0;
179  fps = av_int2double(avio_rl64(pb));
180  if (fps < 0.0f) {
181  if (s->error_recognition & AV_EF_EXPLODE) {
182  av_log(s, AV_LOG_ERROR, "Invalid frame rate %f\n", fps);
183  return AVERROR_INVALIDDATA;
184  } else {
185  av_log(s, AV_LOG_WARNING, "Invalid frame rate %f, setting to 0.\n", fps);
186  fps = 0.0f;
187  }
188  }
189 
190  // number of packets per stream type, -1 means unknown, e.g. streaming
191  v_packs = avio_rl32(pb);
192  a_packs = avio_rl32(pb);
193  avio_rl32(pb); // text
194 
195  avio_rl32(pb); // keyframe distance (?)
196 
197  if (v_packs) {
198  vst = avformat_new_stream(s, NULL);
199  if (!vst)
200  return AVERROR(ENOMEM);
201  ctx->v_id = vst->index;
202 
204  if (ret < 0)
205  return ret;
206 
209  vst->codecpar->width = width;
210  vst->codecpar->height = height;
211  vst->codecpar->bits_per_coded_sample = 10;
212  vst->sample_aspect_ratio = av_d2q(aspect * height / width,
213  10000);
214 #if FF_API_R_FRAME_RATE
215  vst->r_frame_rate =
216 #endif
217  vst->avg_frame_rate = av_d2q(fps, 60000);
218  avpriv_set_pts_info(vst, 32, 1, 1000);
219  } else
220  ctx->v_id = -1;
221 
222  if (a_packs) {
223  ast = avformat_new_stream(s, NULL);
224  if (!ast)
225  return AVERROR(ENOMEM);
226  ctx->a_id = ast->index;
227 
228  ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
229  ast->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
230  ast->codecpar->channels = 2;
231  ast->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
232  ast->codecpar->sample_rate = 44100;
233  ast->codecpar->bit_rate = 2 * 2 * 44100 * 8;
234  ast->codecpar->block_align = 2 * 2;
235  ast->codecpar->bits_per_coded_sample = 16;
236  avpriv_set_pts_info(ast, 32, 1, 1000);
237  } else
238  ctx->a_id = -1;
239 
240  if ((ret = get_codec_data(s, pb, vst, ast, is_mythtv)) < 0)
241  return ret;
242 
243  ctx->rtjpg_video = vst && vst->codecpar->codec_id == AV_CODEC_ID_NUV;
244 
245  return 0;
246 }
247 
248 #define HDRSIZE 12
249 
251 {
252  NUVContext *ctx = s->priv_data;
253  AVIOContext *pb = s->pb;
254  uint8_t hdr[HDRSIZE];
255  nuv_frametype frametype;
256  int ret, size;
257 
258  while (!avio_feof(pb)) {
259  int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;
260  uint64_t pos = avio_tell(pb);
261 
262  ret = ffio_read_size(pb, hdr, HDRSIZE);
263  if (ret < 0)
264  return ret;
265 
266  frametype = hdr[0];
267  size = PKTSIZE(AV_RL32(&hdr[8]));
268 
269  switch (frametype) {
270  case NUV_EXTRADATA:
271  if (!ctx->rtjpg_video) {
272  avio_skip(pb, size);
273  break;
274  }
275  case NUV_VIDEO:
276  if (ctx->v_id < 0) {
277  av_log(s, AV_LOG_ERROR, "Video packet in file without video stream!\n");
278  avio_skip(pb, size);
279  break;
280  }
281  ret = av_new_packet(pkt, copyhdrsize + size);
282  if (ret < 0)
283  return ret;
284 
285  pkt->pos = pos;
286  pkt->flags |= hdr[2] == 0 ? AV_PKT_FLAG_KEY : 0;
287  pkt->pts = AV_RL32(&hdr[4]);
288  pkt->stream_index = ctx->v_id;
289  memcpy(pkt->data, hdr, copyhdrsize);
290  ret = avio_read(pb, pkt->data + copyhdrsize, size);
291  if (ret < 0) {
292  return ret;
293  }
294  if (ret < size)
295  av_shrink_packet(pkt, copyhdrsize + ret);
296  return 0;
297  case NUV_AUDIO:
298  if (ctx->a_id < 0) {
299  av_log(s, AV_LOG_ERROR, "Audio packet in file without audio stream!\n");
300  avio_skip(pb, size);
301  break;
302  }
303  ret = av_get_packet(pb, pkt, size);
305  pkt->pos = pos;
306  pkt->pts = AV_RL32(&hdr[4]);
307  pkt->stream_index = ctx->a_id;
308  if (ret < 0)
309  return ret;
310  return 0;
311  case NUV_SEEKP:
312  // contains no data, size value is invalid
313  break;
314  default:
315  avio_skip(pb, size);
316  break;
317  }
318  }
319 
320  return AVERROR(EIO);
321 }
322 
323 /**
324  * \brief looks for the string RTjjjjjjjjjj in the stream too resync reading
325  * \return 1 if the syncword is found 0 otherwise.
326  */
327 static int nuv_resync(AVFormatContext *s, int64_t pos_limit) {
328  AVIOContext *pb = s->pb;
329  uint32_t tag = 0;
330  while(!avio_feof(pb) && avio_tell(pb) < pos_limit) {
331  tag = (tag << 8) | avio_r8(pb);
332  if (tag == MKBETAG('R','T','j','j') &&
333  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j') &&
334  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j'))
335  return 1;
336  }
337  return 0;
338 }
339 
340 /**
341  * \brief attempts to read a timestamp from stream at the given stream position
342  * \return timestamp if successful and AV_NOPTS_VALUE if failure
343  */
344 static int64_t nuv_read_dts(AVFormatContext *s, int stream_index,
345  int64_t *ppos, int64_t pos_limit)
346 {
347  NUVContext *ctx = s->priv_data;
348  AVIOContext *pb = s->pb;
349  uint8_t hdr[HDRSIZE];
350  nuv_frametype frametype;
351  int size, key, idx;
352  int64_t pos, dts;
353 
354  if (avio_seek(pb, *ppos, SEEK_SET) < 0)
355  return AV_NOPTS_VALUE;
356 
357  if (!nuv_resync(s, pos_limit))
358  return AV_NOPTS_VALUE;
359 
360  while (!avio_feof(pb) && avio_tell(pb) < pos_limit) {
361  if (avio_read(pb, hdr, HDRSIZE) < HDRSIZE)
362  return AV_NOPTS_VALUE;
363  frametype = hdr[0];
364  size = PKTSIZE(AV_RL32(&hdr[8]));
365  switch (frametype) {
366  case NUV_SEEKP:
367  break;
368  case NUV_AUDIO:
369  case NUV_VIDEO:
370  if (frametype == NUV_VIDEO) {
371  idx = ctx->v_id;
372  key = hdr[2] == 0;
373  } else {
374  idx = ctx->a_id;
375  key = 1;
376  }
377  if (stream_index == idx) {
378 
379  pos = avio_tell(s->pb) - HDRSIZE;
380  dts = AV_RL32(&hdr[4]);
381 
382  // TODO - add general support in av_gen_search, so it adds positions after reading timestamps
383  av_add_index_entry(s->streams[stream_index], pos, dts, size + HDRSIZE, 0,
384  key ? AVINDEX_KEYFRAME : 0);
385 
386  *ppos = pos;
387  return dts;
388  }
389  default:
390  avio_skip(pb, size);
391  break;
392  }
393  }
394  return AV_NOPTS_VALUE;
395 }
396 
397 
399  .name = "nuv",
400  .long_name = NULL_IF_CONFIG_SMALL("NuppelVideo"),
401  .priv_data_size = sizeof(NUVContext),
407 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:314
NUV_EXTRADATA
@ NUV_EXTRADATA
Definition: nuv.c:45
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:368
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:724
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:469
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:43
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:344
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:191
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:924
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:31
intfloat.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:797
NUVContext
Definition: nuv.c:37
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:429
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:114
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: seek.c:117
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:486
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:468
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:424
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
ff_nuv_demuxer
const AVInputFormat ff_nuv_demuxer
Definition: nuv.c:398
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:773
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:638
AVCodecTag
Definition: internal.h:50
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:99
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:643
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
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:134
ctx
AVFormatContext * ctx
Definition: movenc.c:48
key
const char * key
Definition: hwcontext_opencl.c:168
NUV_MYTHEXT
@ NUV_MYTHEXT
Definition: nuv.c:48
f
#define f(width, name)
Definition: cbs_vp9.c:255
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:402
AVFormatContext
Format I/O context.
Definition: avformat.h:1109
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1004
nuv_packet
static int nuv_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nuv.c:250
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:70
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1335
PKTSIZE
#define PKTSIZE(s)
little macro to sanitize packet size
Definition: nuv.c:61
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:742
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:117
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:325
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:357
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
NUV_AUDIO
@ NUV_AUDIO
Definition: nuv.c:46
NUVContext::rtjpg_video
int rtjpg_video
Definition: nuv.c:40
NUVContext::v_id
int v_id
Definition: nuv.c:38
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:913
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:379
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
avio_internal.h
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
NUVContext::a_id
int a_id
Definition: nuv.c:39
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:196
NUV_SEEKP
@ NUV_SEEKP
Definition: nuv.c:47
tag
uint32_t tag
Definition: movenc.c:1595
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:857
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
NUV_VIDEO
@ NUV_VIDEO
Definition: nuv.c:44
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
nuv_header
static int nuv_header(AVFormatContext *s)
Definition: nuv.c:157
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:858
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:34
channel_layout.h
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:993
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, 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:1146
AVPacket::stream_index
int stream_index
Definition: packet.h:375
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:333
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:248
AVPacket
This structure stores compressed data.
Definition: packet.h:350
riff.h
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:393
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:750
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:780
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:327
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:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ffio_read_size
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:674
read_timestamp
static int64_t read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: seek.c:273
nuv_probe
static int nuv_probe(const AVProbeData *p)
Definition: nuv.c:51
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:318
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:360