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 "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;
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 (vst->codecpar->extradata) {
87  av_freep(&vst->codecpar->extradata);
88  vst->codecpar->extradata_size = 0;
89  }
90  if (ff_get_extradata(NULL, vst->codecpar, pb, size) < 0)
91  return AVERROR(ENOMEM);
92  size = 0;
93  if (!myth)
94  return 0;
95  }
96  break;
97  case NUV_MYTHEXT:
98  avio_skip(pb, 7);
99  size = PKTSIZE(avio_rl32(pb));
100  if (size != 128 * 4)
101  break;
102  avio_rl32(pb); // version
103  if (vst) {
104  vst->codecpar->codec_tag = avio_rl32(pb);
105  vst->codecpar->codec_id =
107  if (vst->codecpar->codec_tag == MKTAG('R', 'J', 'P', 'G'))
109  } else
110  avio_skip(pb, 4);
111 
112  if (ast) {
113  int id;
114 
115  ast->codecpar->codec_tag = avio_rl32(pb);
116  ast->codecpar->sample_rate = avio_rl32(pb);
117  if (ast->codecpar->sample_rate <= 0) {
118  av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", ast->codecpar->sample_rate);
119  return AVERROR_INVALIDDATA;
120  }
122  ast->codecpar->channels = avio_rl32(pb);
123  ast->codecpar->channel_layout = 0;
124 
127  if (id == AV_CODEC_ID_NONE) {
128  id = ff_codec_get_id(nuv_audio_tags, ast->codecpar->codec_tag);
129  if (id == AV_CODEC_ID_PCM_S16LE)
131  0, 0, ~1);
132  }
133  ast->codecpar->codec_id = id;
134 
136  } else
137  avio_skip(pb, 4 * 4);
138 
139  size -= 6 * 4;
140  avio_skip(pb, size);
141  return 0;
142  case NUV_SEEKP:
143  size = 11;
144  break;
145  default:
146  avio_skip(pb, 7);
147  size = PKTSIZE(avio_rl32(pb));
148  break;
149  }
150  avio_skip(pb, size);
151  }
152 
153  return 0;
154 }
155 
157 {
158  NUVContext *ctx = s->priv_data;
159  AVIOContext *pb = s->pb;
160  char id_string[12];
161  double aspect, fps;
162  int is_mythtv, width, height, v_packs, a_packs, ret;
163  AVStream *vst = NULL, *ast = NULL;
164 
165  avio_read(pb, id_string, 12);
166  is_mythtv = !memcmp(id_string, "MythTVVideo", 12);
167  avio_skip(pb, 5); // version string
168  avio_skip(pb, 3); // padding
169  width = avio_rl32(pb);
170  height = avio_rl32(pb);
171  avio_rl32(pb); // unused, "desiredwidth"
172  avio_rl32(pb); // unused, "desiredheight"
173  avio_r8(pb); // 'P' == progressive, 'I' == interlaced
174  avio_skip(pb, 3); // padding
175  aspect = av_int2double(avio_rl64(pb));
176  if (aspect > 0.9999 && aspect < 1.0001)
177  aspect = 4.0 / 3.0;
178  fps = av_int2double(avio_rl64(pb));
179  if (fps < 0.0f) {
180  if (s->error_recognition & AV_EF_EXPLODE) {
181  av_log(s, AV_LOG_ERROR, "Invalid frame rate %f\n", fps);
182  return AVERROR_INVALIDDATA;
183  } else {
184  av_log(s, AV_LOG_WARNING, "Invalid frame rate %f, setting to 0.\n", fps);
185  fps = 0.0f;
186  }
187  }
188 
189  // number of packets per stream type, -1 means unknown, e.g. streaming
190  v_packs = avio_rl32(pb);
191  a_packs = avio_rl32(pb);
192  avio_rl32(pb); // text
193 
194  avio_rl32(pb); // keyframe distance (?)
195 
196  if (v_packs) {
197  vst = avformat_new_stream(s, NULL);
198  if (!vst)
199  return AVERROR(ENOMEM);
200  ctx->v_id = vst->index;
201 
202  ret = av_image_check_size(width, height, 0, s);
203  if (ret < 0)
204  return ret;
205 
208  vst->codecpar->width = width;
209  vst->codecpar->height = height;
210  vst->codecpar->bits_per_coded_sample = 10;
211  vst->sample_aspect_ratio = av_d2q(aspect * height / width,
212  10000);
213 #if FF_API_R_FRAME_RATE
214  vst->r_frame_rate =
215 #endif
216  vst->avg_frame_rate = av_d2q(fps, 60000);
217  avpriv_set_pts_info(vst, 32, 1, 1000);
218  } else
219  ctx->v_id = -1;
220 
221  if (a_packs) {
222  ast = avformat_new_stream(s, NULL);
223  if (!ast)
224  return AVERROR(ENOMEM);
225  ctx->a_id = ast->index;
226 
227  ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
228  ast->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
229  ast->codecpar->channels = 2;
230  ast->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
231  ast->codecpar->sample_rate = 44100;
232  ast->codecpar->bit_rate = 2 * 2 * 44100 * 8;
233  ast->codecpar->block_align = 2 * 2;
234  ast->codecpar->bits_per_coded_sample = 16;
235  avpriv_set_pts_info(ast, 32, 1, 1000);
236  } else
237  ctx->a_id = -1;
238 
239  if ((ret = get_codec_data(s, pb, vst, ast, is_mythtv)) < 0)
240  return ret;
241 
242  ctx->rtjpg_video = vst && vst->codecpar->codec_id == AV_CODEC_ID_NUV;
243 
244  return 0;
245 }
246 
247 #define HDRSIZE 12
248 
250 {
251  NUVContext *ctx = s->priv_data;
252  AVIOContext *pb = s->pb;
253  uint8_t hdr[HDRSIZE];
254  nuv_frametype frametype;
255  int ret, size;
256 
257  while (!avio_feof(pb)) {
258  int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;
259  uint64_t pos = avio_tell(pb);
260 
261  ret = avio_read(pb, hdr, HDRSIZE);
262  if (ret < HDRSIZE)
263  return ret < 0 ? ret : AVERROR(EIO);
264 
265  frametype = hdr[0];
266  size = PKTSIZE(AV_RL32(&hdr[8]));
267 
268  switch (frametype) {
269  case NUV_EXTRADATA:
270  if (!ctx->rtjpg_video) {
271  avio_skip(pb, size);
272  break;
273  }
274  case NUV_VIDEO:
275  if (ctx->v_id < 0) {
276  av_log(s, AV_LOG_ERROR, "Video packet in file without video stream!\n");
277  avio_skip(pb, size);
278  break;
279  }
280  ret = av_new_packet(pkt, copyhdrsize + size);
281  if (ret < 0)
282  return ret;
283 
284  pkt->pos = pos;
285  pkt->flags |= hdr[2] == 0 ? AV_PKT_FLAG_KEY : 0;
286  pkt->pts = AV_RL32(&hdr[4]);
287  pkt->stream_index = ctx->v_id;
288  memcpy(pkt->data, hdr, copyhdrsize);
289  ret = avio_read(pb, pkt->data + copyhdrsize, size);
290  if (ret < 0) {
291  av_packet_unref(pkt);
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);
304  pkt->flags |= AV_PKT_FLAG_KEY;
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),
405  .read_timestamp = nuv_read_dts,
407 };
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:2039
Definition: nuv.c:36
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3124
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:101
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:4882
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3953
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int index
stream index in AVFormatContext
Definition: avformat.h:882
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
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
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
const char * key
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
Format I/O context.
Definition: avformat.h:1358
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
uint8_t
int width
Video only.
Definition: avcodec.h:4019
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:801
#define f(width, name)
Definition: cbs_vp9.c:255
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4455
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
#define height
uint8_t * data
Definition: avcodec.h:1477
uint32_t tag
Definition: movenc.c:1496
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:310
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
nuv_frametype
Definition: nuv.c:42
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4055
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:648
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
#define AVINDEX_KEYFRAME
Definition: avformat.h:817
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:770
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:565
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3949
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
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3971
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:639
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
int v_id
Definition: nuv.c:37
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
audio channel layout utility functions
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
#define width
static int nuv_probe(const AVProbeData *p)
Definition: nuv.c:50
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2701
AVInputFormat ff_nuv_demuxer
Definition: nuv.c:398
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
Stream structure.
Definition: avformat.h:881
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define PKTSIZE(s)
little macro to sanitize packet size
Definition: nuv.c:60
#define HDRSIZE
Definition: nuv.c:247
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
int a_id
Definition: nuv.c:38
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:468
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:3136
int rtjpg_video
Definition: nuv.c:39
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
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
#define flags(name, subs,...)
Definition: cbs_av1.c:561
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
Definition: nuv.c:46
int sample_rate
Audio only.
Definition: avcodec.h:4063
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
full parsing and repack
Definition: avformat.h:800
Main libavformat public API header.
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:194
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1625
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:3305
static int nuv_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nuv.c:249
#define MKBETAG(a, b, c, d)
Definition: common.h:367
Definition: nuv.c:45
void * priv_data
Format private data.
Definition: avformat.h:1386
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3995
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3967
int channels
Audio only.
Definition: avcodec.h:4059
Definition: nuv.c:43
#define av_freep(p)
static int nuv_header(AVFormatContext *s)
Definition: nuv.c:156
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:358
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3957
static const AVCodecTag nuv_audio_tags[]
Definition: nuv.c:30
int stream_index
Definition: avcodec.h:1479
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1005
enum AVCodecID id
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1454
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:778
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248