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, 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) {
124  id = ff_codec_get_id(nuv_audio_tags, ast->codecpar->codec_tag);
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 
198  ret = av_image_check_size(width, height, 0, s);
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  av_packet_unref(pkt);
288  return ret;
289  }
290  if (ret < size)
291  av_shrink_packet(pkt, copyhdrsize + ret);
292  return 0;
293  case NUV_AUDIO:
294  if (ctx->a_id < 0) {
295  av_log(s, AV_LOG_ERROR, "Audio packet in file without audio stream!\n");
296  avio_skip(pb, size);
297  break;
298  }
299  ret = av_get_packet(pb, pkt, size);
300  pkt->flags |= AV_PKT_FLAG_KEY;
301  pkt->pos = pos;
302  pkt->pts = AV_RL32(&hdr[4]);
303  pkt->stream_index = ctx->a_id;
304  if (ret < 0)
305  return ret;
306  return 0;
307  case NUV_SEEKP:
308  // contains no data, size value is invalid
309  break;
310  default:
311  avio_skip(pb, size);
312  break;
313  }
314  }
315 
316  return AVERROR(EIO);
317 }
318 
319 /**
320  * \brief looks for the string RTjjjjjjjjjj in the stream too resync reading
321  * \return 1 if the syncword is found 0 otherwise.
322  */
323 static int nuv_resync(AVFormatContext *s, int64_t pos_limit) {
324  AVIOContext *pb = s->pb;
325  uint32_t tag = 0;
326  while(!avio_feof(pb) && avio_tell(pb) < pos_limit) {
327  tag = (tag << 8) | avio_r8(pb);
328  if (tag == MKBETAG('R','T','j','j') &&
329  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j') &&
330  (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j'))
331  return 1;
332  }
333  return 0;
334 }
335 
336 /**
337  * \brief attempts to read a timestamp from stream at the given stream position
338  * \return timestamp if successful and AV_NOPTS_VALUE if failure
339  */
340 static int64_t nuv_read_dts(AVFormatContext *s, int stream_index,
341  int64_t *ppos, int64_t pos_limit)
342 {
343  NUVContext *ctx = s->priv_data;
344  AVIOContext *pb = s->pb;
345  uint8_t hdr[HDRSIZE];
346  nuv_frametype frametype;
347  int size, key, idx;
348  int64_t pos, dts;
349 
350  if (avio_seek(pb, *ppos, SEEK_SET) < 0)
351  return AV_NOPTS_VALUE;
352 
353  if (!nuv_resync(s, pos_limit))
354  return AV_NOPTS_VALUE;
355 
356  while (!avio_feof(pb) && avio_tell(pb) < pos_limit) {
357  if (avio_read(pb, hdr, HDRSIZE) < HDRSIZE)
358  return AV_NOPTS_VALUE;
359  frametype = hdr[0];
360  size = PKTSIZE(AV_RL32(&hdr[8]));
361  switch (frametype) {
362  case NUV_SEEKP:
363  break;
364  case NUV_AUDIO:
365  case NUV_VIDEO:
366  if (frametype == NUV_VIDEO) {
367  idx = ctx->v_id;
368  key = hdr[2] == 0;
369  } else {
370  idx = ctx->a_id;
371  key = 1;
372  }
373  if (stream_index == idx) {
374 
375  pos = avio_tell(s->pb) - HDRSIZE;
376  dts = AV_RL32(&hdr[4]);
377 
378  // TODO - add general support in av_gen_search, so it adds positions after reading timestamps
379  av_add_index_entry(s->streams[stream_index], pos, dts, size + HDRSIZE, 0,
380  key ? AVINDEX_KEYFRAME : 0);
381 
382  *ppos = pos;
383  return dts;
384  }
385  default:
386  avio_skip(pb, size);
387  break;
388  }
389  }
390  return AV_NOPTS_VALUE;
391 }
392 
393 
395  .name = "nuv",
396  .long_name = NULL_IF_CONFIG_SMALL("NuppelVideo"),
397  .priv_data_size = sizeof(NUVContext),
401  .read_timestamp = nuv_read_dts,
403 };
#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:2051
Definition: nuv.c:36
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3160
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:1514
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:4931
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3987
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:942
int index
stream index in AVFormatContext
Definition: avformat.h:881
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:334
const char * key
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
Format I/O context.
Definition: avformat.h:1357
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:4053
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:803
#define f(width, name)
Definition: cbs_vp9.c:255
enum AVStreamParseType need_parsing
Definition: avformat.h:1098
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4504
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1425
#define height
uint8_t * data
Definition: avcodec.h:1494
uint32_t tag
Definition: movenc.c:1532
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:308
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:4089
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:650
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1526
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:816
#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:772
#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:569
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3983
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:340
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:953
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1500
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:641
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:2722
AVInputFormat ff_nuv_demuxer
Definition: nuv.c:394
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
Stream structure.
Definition: avformat.h:880
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:243
AVIOContext * pb
I/O context.
Definition: avformat.h:1399
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:3172
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:323
#define flags(name, subs,...)
Definition: cbs_av1.c:564
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:4097
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
full parsing and repack
Definition: avformat.h:799
Main libavformat public API header.
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:192
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1624
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:3341
static int nuv_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nuv.c:245
#define MKBETAG(a, b, c, d)
Definition: common.h:367
Definition: nuv.c:45
void * priv_data
Format private data.
Definition: avformat.h:1385
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4029
int channels
Audio only.
Definition: avcodec.h:4093
Definition: nuv.c:43
static int nuv_header(AVFormatContext *s)
Definition: nuv.c:152
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:1027
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:361
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3991
static const AVCodecTag nuv_audio_tags[]
Definition: nuv.c:30
int stream_index
Definition: avcodec.h:1496
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:1004
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:1471
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:780
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1487
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248