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