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  if ((ret = ffio_read_size(pb, id_string, 12)) < 0)
169  return ret;
170 
171  is_mythtv = !memcmp(id_string, "MythTVVideo", 12);
172  avio_skip(pb, 5); // version string
173  avio_skip(pb, 3); // padding
174  width = avio_rl32(pb);
175  height = avio_rl32(pb);
176  avio_rl32(pb); // unused, "desiredwidth"
177  avio_rl32(pb); // unused, "desiredheight"
178  avio_r8(pb); // 'P' == progressive, 'I' == interlaced
179  avio_skip(pb, 3); // padding
180  aspect = av_int2double(avio_rl64(pb));
181  if (aspect > 0.9999 && aspect < 1.0001)
182  aspect = 4.0 / 3.0;
183  fps = av_int2double(avio_rl64(pb));
184  if (fps < 0.0f) {
185  if (s->error_recognition & AV_EF_EXPLODE) {
186  av_log(s, AV_LOG_ERROR, "Invalid frame rate %f\n", fps);
187  return AVERROR_INVALIDDATA;
188  } else {
189  av_log(s, AV_LOG_WARNING, "Invalid frame rate %f, setting to 0.\n", fps);
190  fps = 0.0f;
191  }
192  }
193 
194  // number of packets per stream type, -1 means unknown, e.g. streaming
195  v_packs = avio_rl32(pb);
196  a_packs = avio_rl32(pb);
197  avio_rl32(pb); // text
198 
199  avio_rl32(pb); // keyframe distance (?)
200 
201  if (v_packs) {
202  vst = avformat_new_stream(s, NULL);
203  if (!vst)
204  return AVERROR(ENOMEM);
205  ctx->v_id = vst->index;
206 
208  if (ret < 0)
209  return ret;
210 
213  vst->codecpar->width = width;
214  vst->codecpar->height = height;
215  vst->codecpar->bits_per_coded_sample = 10;
216  vst->sample_aspect_ratio = av_d2q(aspect * height / width,
217  10000);
218 #if FF_API_R_FRAME_RATE
219  vst->r_frame_rate =
220 #endif
221  vst->avg_frame_rate = av_d2q(fps, 60000);
222  avpriv_set_pts_info(vst, 32, 1, 1000);
223  } else
224  ctx->v_id = -1;
225 
226  if (a_packs) {
227  ast = avformat_new_stream(s, NULL);
228  if (!ast)
229  return AVERROR(ENOMEM);
230  ctx->a_id = ast->index;
231 
232  ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
233  ast->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
234  ast->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
235  ast->codecpar->sample_rate = 44100;
236  ast->codecpar->bit_rate = 2 * 2 * 44100 * 8;
237  ast->codecpar->block_align = 2 * 2;
238  ast->codecpar->bits_per_coded_sample = 16;
239  avpriv_set_pts_info(ast, 32, 1, 1000);
240  } else
241  ctx->a_id = -1;
242 
243  if ((ret = get_codec_data(s, pb, vst, ast, is_mythtv)) < 0)
244  return ret;
245 
246  ctx->rtjpg_video = vst && vst->codecpar->codec_id == AV_CODEC_ID_NUV;
247 
248  return 0;
249 }
250 
251 #define HDRSIZE 12
252 
254 {
255  NUVContext *ctx = s->priv_data;
256  AVIOContext *pb = s->pb;
257  uint8_t hdr[HDRSIZE];
258  nuv_frametype frametype;
259  int ret, size;
260 
261  while (!avio_feof(pb)) {
262  int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;
263  uint64_t pos = avio_tell(pb);
264 
265  ret = ffio_read_size(pb, hdr, HDRSIZE);
266  if (ret < 0)
267  return ret;
268 
269  frametype = hdr[0];
270  size = PKTSIZE(AV_RL32(&hdr[8]));
271 
272  switch (frametype) {
273  case NUV_EXTRADATA:
274  if (!ctx->rtjpg_video) {
275  avio_skip(pb, size);
276  break;
277  }
278  case NUV_VIDEO:
279  if (ctx->v_id < 0) {
280  av_log(s, AV_LOG_ERROR, "Video packet in file without video stream!\n");
281  avio_skip(pb, size);
282  break;
283  }
284  ret = av_new_packet(pkt, copyhdrsize + size);
285  if (ret < 0)
286  return ret;
287 
288  pkt->pos = pos;
289  pkt->flags |= hdr[2] == 0 ? AV_PKT_FLAG_KEY : 0;
290  pkt->pts = AV_RL32(&hdr[4]);
291  pkt->stream_index = ctx->v_id;
292  memcpy(pkt->data, hdr, copyhdrsize);
293  ret = avio_read(pb, pkt->data + copyhdrsize, size);
294  if (ret < 0) {
295  return ret;
296  }
297  if (ret < size)
298  av_shrink_packet(pkt, copyhdrsize + ret);
299  return 0;
300  case NUV_AUDIO:
301  if (ctx->a_id < 0) {
302  av_log(s, AV_LOG_ERROR, "Audio packet in file without audio stream!\n");
303  avio_skip(pb, size);
304  break;
305  }
306  ret = av_get_packet(pb, pkt, size);
308  pkt->pos = pos;
309  pkt->pts = AV_RL32(&hdr[4]);
310  pkt->stream_index = ctx->a_id;
311  if (ret < 0)
312  return ret;
313  return 0;
314  case NUV_SEEKP:
315  // contains no data, size value is invalid
316  break;
317  default:
318  avio_skip(pb, size);
319  break;
320  }
321  }
322 
323  return AVERROR(EIO);
324 }
325 
326 /**
327  * \brief looks for the string RTjjjjjjjjjj in the stream too resync reading
328  * \return 1 if the syncword is found 0 otherwise.
329  */
330 static int nuv_resync(AVFormatContext *s, int64_t pos_limit) {
331  AVIOContext *pb = s->pb;
332  uint32_t tag = 0;
333  while(!avio_feof(pb) && avio_tell(pb) < pos_limit) {
334  tag = (tag << 8) | avio_r8(pb);
335  if (tag == MKBETAG('R','T','j','j') &&
336  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j') &&
337  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j'))
338  return 1;
339  }
340  return 0;
341 }
342 
343 /**
344  * \brief attempts to read a timestamp from stream at the given stream position
345  * \return timestamp if successful and AV_NOPTS_VALUE if failure
346  */
347 static int64_t nuv_read_dts(AVFormatContext *s, int stream_index,
348  int64_t *ppos, int64_t pos_limit)
349 {
350  NUVContext *ctx = s->priv_data;
351  AVIOContext *pb = s->pb;
352  uint8_t hdr[HDRSIZE];
353  nuv_frametype frametype;
354  int size, key, idx;
355  int64_t pos, dts;
356 
357  if (avio_seek(pb, *ppos, SEEK_SET) < 0)
358  return AV_NOPTS_VALUE;
359 
360  if (!nuv_resync(s, pos_limit))
361  return AV_NOPTS_VALUE;
362 
363  while (!avio_feof(pb) && avio_tell(pb) < pos_limit) {
364  if (avio_read(pb, hdr, HDRSIZE) < HDRSIZE)
365  return AV_NOPTS_VALUE;
366  frametype = hdr[0];
367  size = PKTSIZE(AV_RL32(&hdr[8]));
368  switch (frametype) {
369  case NUV_SEEKP:
370  break;
371  case NUV_AUDIO:
372  case NUV_VIDEO:
373  if (frametype == NUV_VIDEO) {
374  idx = ctx->v_id;
375  key = hdr[2] == 0;
376  } else {
377  idx = ctx->a_id;
378  key = 1;
379  }
380  if (stream_index == idx) {
381 
382  pos = avio_tell(s->pb) - HDRSIZE;
383  dts = AV_RL32(&hdr[4]);
384 
385  // TODO - add general support in av_gen_search, so it adds positions after reading timestamps
386  av_add_index_entry(s->streams[stream_index], pos, dts, size + HDRSIZE, 0,
387  key ? AVINDEX_KEYFRAME : 0);
388 
389  *ppos = pos;
390  return dts;
391  }
392  default:
393  avio_skip(pb, size);
394  break;
395  }
396  }
397  return AV_NOPTS_VALUE;
398 }
399 
400 
402  .p.name = "nuv",
403  .p.long_name = NULL_IF_CONFIG_SMALL("NuppelVideo"),
404  .p.flags = AVFMT_GENERIC_INDEX,
405  .priv_data_size = sizeof(NUVContext),
410 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:334
NUV_EXTRADATA
@ NUV_EXTRADATA
Definition: nuv.c:46
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
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:144
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:393
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
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
int64_t
long long int64_t
Definition: coverity.c:34
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:347
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:207
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:322
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:327
intfloat.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
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:338
NUVContext
Definition: nuv.c:38
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
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:867
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:358
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
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:122
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:480
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:447
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
AVCodecTag
Definition: internal.h:42
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
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: packet.c:98
ff_nuv_demuxer
const FFInputFormat ff_nuv_demuxer
Definition: nuv.c:401
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AV_CODEC_ID_NUV
@ AV_CODEC_ID_NUV
Definition: codec_id.h:136
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:119
ctx
AVFormatContext * ctx
Definition: movenc.c:49
key
const char * key
Definition: hwcontext_opencl.c:189
NUV_MYTHEXT
@ NUV_MYTHEXT
Definition: nuv.c:49
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:325
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
nuv_packet
static int nuv_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nuv.c:253
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:540
NULL
#define NULL
Definition: coverity.c:32
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:451
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
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:184
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:730
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
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:94
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:133
height
#define height
Definition: dsp.h:85
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:317
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:826
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:46
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
avio_internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
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:91
NUV_SEEKP
@ NUV_SEEKP
Definition: nuv.c:48
tag
uint32_t tag
Definition: movenc.c:1879
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
NUV_VIDEO
@ NUV_VIDEO
Definition: nuv.c:45
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
id
enum AVCodecID id
Definition: dts2pts.c:367
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:754
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:36
channel_layout.h
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:440
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:914
AVPacket::stream_index
int stream_index
Definition: packet.h:541
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
HDRSIZE
#define HDRSIZE
Definition: nuv.c:251
AVPacket
This structure stores compressed data.
Definition: packet.h:516
riff.h
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
FFInputFormat
Definition: demux.h:42
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:738
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
imgutils.h
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:330
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:662
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:281
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
width
#define width
Definition: dsp.h:85
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346