FFmpeg
nsvdec.c
Go to the documentation of this file.
1 /*
2  * NSV demuxer
3  * Copyright (c) 2004 The FFmpeg Project
4  *
5  * first version by Francois Revol <revol@free.fr>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "libavutil/attributes.h"
25 #include "libavutil/mathematics.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/intreadwrite.h"
30 
31 /* max bytes to crawl for trying to resync
32  * stupid streaming servers don't start at chunk boundaries...
33  */
34 #define NSV_MAX_RESYNC (500*1024)
35 #define NSV_MAX_RESYNC_TRIES 300
36 
37 /*
38  * References:
39  * (1) http://www.multimedia.cx/nsv-format.txt
40  * seems someone came to the same conclusions as me, and updated it:
41  * (2) http://www.stud.ktu.lt/~vitslav/nsv/nsv-format.txt
42  * http://www.stud.ktu.lt/~vitslav/nsv/
43  * official docs
44  * (3) http://ultravox.aol.com/NSVFormat.rtf
45  * Sample files:
46  * (S1) http://www.nullsoft.com/nsv/samples/
47  * http://www.nullsoft.com/nsv/samples/faster.nsv
48  * http://streamripper.sourceforge.net/openbb/read.php?TID=492&page=4
49  */
50 
51 /*
52  * notes on the header (Francois Revol):
53  *
54  * It is followed by strings, then a table, but nothing tells
55  * where the table begins according to (1). After checking faster.nsv,
56  * I believe NVSf[16-19] gives the size of the strings data
57  * (that is the offset of the data table after the header).
58  * After checking all samples from (S1) all confirms this.
59  *
60  * Then, about NSVf[12-15], faster.nsf has 179700. When viewing it in VLC,
61  * I noticed there was about 1 NVSs chunk/s, so I ran
62  * strings faster.nsv | grep NSVs | wc -l
63  * which gave me 180. That leads me to think that NSVf[12-15] might be the
64  * file length in milliseconds.
65  * Let's try that:
66  * for f in *.nsv; do HTIME="$(od -t x4 "$f" | head -1 | sed 's/.* //')"; echo "'$f' $((0x$HTIME))s = $((0x$HTIME/1000/60)):$((0x$HTIME/1000%60))"; done
67  * except for nsvtrailer (which doesn't have an NSVf header), it reports correct time.
68  *
69  * nsvtrailer.nsv (S1) does not have any NSVf header, only NSVs chunks,
70  * so the header seems to not be mandatory. (for streaming).
71  *
72  * index slice duration check (excepts nsvtrailer.nsv):
73  * for f in [^n]*.nsv; do DUR="$(ffmpeg -i "$f" 2>/dev/null | grep 'NSVf duration' | cut -d ' ' -f 4)"; IC="$(ffmpeg -i "$f" 2>/dev/null | grep 'INDEX ENTRIES' | cut -d ' ' -f 2)"; echo "duration $DUR, slite time $(($DUR/$IC))"; done
74  */
75 
76 /*
77  * TODO:
78  * - handle timestamps !!!
79  * - use index
80  * - mime-type in probe()
81  * - seek
82  */
83 
84 #if 0
85 struct NSVf_header {
86  uint32_t chunk_tag; /* 'NSVf' */
87  uint32_t chunk_size;
88  uint32_t file_size; /* max 4GB ??? no one learns anything it seems :^) */
89  uint32_t file_length; //unknown1; /* what about MSB of file_size ? */
90  uint32_t info_strings_size; /* size of the info strings */ //unknown2;
91  uint32_t table_entries;
92  uint32_t table_entries_used; /* the left ones should be -1 */
93 };
94 
95 struct NSVs_header {
96  uint32_t chunk_tag; /* 'NSVs' */
97  uint32_t v4cc; /* or 'NONE' */
98  uint32_t a4cc; /* or 'NONE' */
99  uint16_t vwidth; /* av_assert0(vwidth%16==0) */
100  uint16_t vheight; /* av_assert0(vheight%16==0) */
101  uint8_t framerate; /* value = (framerate&0x80)?frtable[frameratex0x7f]:framerate */
102  uint16_t unknown;
103 };
104 
105 struct nsv_avchunk_header {
106  uint8_t vchunk_size_lsb;
107  uint16_t vchunk_size_msb; /* value = (vchunk_size_msb << 4) | (vchunk_size_lsb >> 4) */
108  uint16_t achunk_size;
109 };
110 
111 struct nsv_pcm_header {
112  uint8_t bits_per_sample;
113  uint8_t channel_count;
114  uint16_t sample_rate;
115 };
116 #endif
117 
118 /* variation from avi.h */
119 /*typedef struct CodecTag {
120  int id;
121  unsigned int tag;
122 } CodecTag;*/
123 
124 /* tags */
125 
126 #define T_NSVF MKTAG('N', 'S', 'V', 'f') /* file header */
127 #define T_NSVS MKTAG('N', 'S', 'V', 's') /* chunk header */
128 #define T_TOC2 MKTAG('T', 'O', 'C', '2') /* extra index marker */
129 #define T_NONE MKTAG('N', 'O', 'N', 'E') /* null a/v 4CC */
130 #define T_SUBT MKTAG('S', 'U', 'B', 'T') /* subtitle aux data */
131 #define T_ASYN MKTAG('A', 'S', 'Y', 'N') /* async a/v aux marker */
132 #define T_KEYF MKTAG('K', 'E', 'Y', 'F') /* video keyframe aux marker (addition) */
133 
134 #define TB_NSVF MKBETAG('N', 'S', 'V', 'f')
135 #define TB_NSVS MKBETAG('N', 'S', 'V', 's')
136 
137 /* hardcoded stream indexes */
138 #define NSV_ST_VIDEO 0
139 #define NSV_ST_AUDIO 1
140 #define NSV_ST_SUBT 2
141 
142 enum NSVStatus {
151 };
152 
153 typedef struct NSVStream {
154  int frame_offset; /* current frame (video) or byte (audio) counter
155  (used to compute the pts) */
156  int scale;
157  int rate;
158  int sample_size; /* audio only data */
159  int start;
160 
161  int new_frame_offset; /* temporary storage (used during seek) */
162  int cum_len; /* temporary storage (used during seek) */
163 } NSVStream;
164 
165 typedef struct NSVContext {
167  int NSVf_end;
168  uint32_t *nsvs_file_offset;
171  AVPacket ahead[2]; /* [v, a] if .data is !NULL there is something */
172  /* cached */
173  int64_t duration;
174  uint32_t vtag, atag;
175  uint16_t vwidth, vheight;
176  int16_t avsync;
178  uint32_t *nsvs_timestamps;
179  int nsvf;
180 } NSVContext;
181 
183  { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') },
184  { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
185  { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
186  { AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },
187  { AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
188  { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') },
189  { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
190  { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
191  { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
192  { AV_CODEC_ID_VP8, MKTAG('V', 'P', '8', '0') },
193 /*
194  { AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },
195  { AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },
196 */
197  { AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
198  { AV_CODEC_ID_H264, MKTAG('H', '2', '6', '4') },
199  { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },
200  { AV_CODEC_ID_NONE, 0 },
201 };
202 
204  { AV_CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
205  { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') },
206  { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') },
207  { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'V', ' ') },
208  { AV_CODEC_ID_AAC, MKTAG('V', 'L', 'B', ' ') },
209  { AV_CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') },
210  { AV_CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') },
211  { AV_CODEC_ID_NONE, 0 },
212 };
213 
214 //static int nsv_load_index(AVFormatContext *s);
215 static int nsv_read_chunk(AVFormatContext *s, int fill_header);
216 
217 /* try to find something we recognize, and set the state accordingly */
219 {
220  NSVContext *nsv = s->priv_data;
221  AVIOContext *pb = s->pb;
222  uint32_t v = 0;
223  int i;
224 
225  for (i = 0; i < NSV_MAX_RESYNC; i++) {
226  if (avio_feof(pb)) {
227  av_log(s, AV_LOG_TRACE, "NSV EOF\n");
228  nsv->state = NSV_UNSYNC;
229  return -1;
230  }
231  v <<= 8;
232  v |= avio_r8(pb);
233  if (i < 8) {
234  av_log(s, AV_LOG_TRACE, "NSV resync: [%d] = %02"PRIx32"\n", i, v & 0x0FF);
235  }
236 
237  if ((v & 0x0000ffff) == 0xefbe) { /* BEEF */
238  av_log(s, AV_LOG_TRACE, "NSV resynced on BEEF after %d bytes\n", i+1);
239  nsv->state = NSV_FOUND_BEEF;
240  return 0;
241  }
242  /* we read as big-endian, thus the MK*BE* */
243  if (v == TB_NSVF) { /* NSVf */
244  av_log(s, AV_LOG_TRACE, "NSV resynced on NSVf after %d bytes\n", i+1);
245  nsv->state = NSV_FOUND_NSVF;
246  return 0;
247  }
248  if (v == MKBETAG('N', 'S', 'V', 's')) { /* NSVs */
249  av_log(s, AV_LOG_TRACE, "NSV resynced on NSVs after %d bytes\n", i+1);
250  nsv->state = NSV_FOUND_NSVS;
251  return 0;
252  }
253 
254  }
255  av_log(s, AV_LOG_TRACE, "NSV sync lost\n");
256  return -1;
257 }
258 
260 {
261  NSVContext *nsv = s->priv_data;
262  AVIOContext *pb = s->pb;
263  unsigned int av_unused file_size;
264  unsigned int size;
265  int64_t duration;
266  int strings_size;
267  int table_entries;
268  int table_entries_used;
269 
270  nsv->state = NSV_UNSYNC; /* in case we fail */
271 
272  if (nsv->nsvf) {
273  av_log(s, AV_LOG_TRACE, "Multiple NSVf\n");
274  return 0;
275  }
276  nsv->nsvf = 1;
277 
278  size = avio_rl32(pb);
279  if (size < 28)
280  return -1;
281  nsv->NSVf_end = size;
282 
283  file_size = (uint32_t)avio_rl32(pb);
284  av_log(s, AV_LOG_TRACE, "NSV NSVf chunk_size %u\n", size);
285  av_log(s, AV_LOG_TRACE, "NSV NSVf file_size %u\n", file_size);
286 
287  nsv->duration = duration = avio_rl32(pb); /* in ms */
288  av_log(s, AV_LOG_TRACE, "NSV NSVf duration %"PRId64" ms\n", duration);
289  // XXX: store it in AVStreams
290 
291  strings_size = avio_rl32(pb);
292  table_entries = avio_rl32(pb);
293  table_entries_used = avio_rl32(pb);
294  av_log(s, AV_LOG_TRACE, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",
295  strings_size, table_entries, table_entries_used);
296  if (avio_feof(pb))
297  return -1;
298 
299  av_log(s, AV_LOG_TRACE, "NSV got header; filepos %"PRId64"\n", avio_tell(pb));
300 
301  if (strings_size > 0) {
302  char *strings; /* last byte will be '\0' to play safe with str*() */
303  char *p, *endp;
304  char *token, *value;
305  char quote;
306 
307  p = strings = av_mallocz((size_t)strings_size + 1);
308  if (!p)
309  return AVERROR(ENOMEM);
310  endp = strings + strings_size;
311  avio_read(pb, strings, strings_size);
312  while (p < endp) {
313  while (*p == ' ')
314  p++; /* strip out spaces */
315  if (p >= endp-2)
316  break;
317  token = p;
318  p = strchr(p, '=');
319  if (!p || p >= endp-2)
320  break;
321  *p++ = '\0';
322  quote = *p++;
323  value = p;
324  p = strchr(p, quote);
325  if (!p || p >= endp)
326  break;
327  *p++ = '\0';
328  av_log(s, AV_LOG_TRACE, "NSV NSVf INFO: %s='%s'\n", token, value);
329  av_dict_set(&s->metadata, token, value, 0);
330  }
331  av_free(strings);
332  }
333  if (avio_feof(pb))
334  return -1;
335 
336  av_log(s, AV_LOG_TRACE, "NSV got infos; filepos %"PRId64"\n", avio_tell(pb));
337 
338  if (table_entries_used > 0) {
339  int i;
340  nsv->index_entries = table_entries_used;
341  if((unsigned)table_entries_used >= UINT_MAX / sizeof(uint32_t))
342  return -1;
343  nsv->nsvs_file_offset = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t));
344  if (!nsv->nsvs_file_offset)
345  return AVERROR(ENOMEM);
346 
347  for(i=0;i<table_entries_used;i++) {
348  if (avio_feof(pb))
349  return AVERROR_INVALIDDATA;
350  nsv->nsvs_file_offset[i] = avio_rl32(pb) + size;
351  }
352 
353  if(table_entries > table_entries_used &&
354  avio_rl32(pb) == MKTAG('T','O','C','2')) {
355  nsv->nsvs_timestamps = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t));
356  if (!nsv->nsvs_timestamps)
357  return AVERROR(ENOMEM);
358  for(i=0;i<table_entries_used;i++) {
359  nsv->nsvs_timestamps[i] = avio_rl32(pb);
360  }
361  }
362  }
363 
364  av_log(s, AV_LOG_TRACE, "NSV got index; filepos %"PRId64"\n", avio_tell(pb));
365 
366  avio_seek(pb, nsv->base_offset + size, SEEK_SET); /* required for dumbdriving-271.nsv (2 extra bytes) */
367 
368  if (avio_feof(pb))
369  return -1;
370  nsv->state = NSV_HAS_READ_NSVF;
371  return 0;
372 }
373 
375 {
376  NSVContext *nsv = s->priv_data;
377  AVIOContext *pb = s->pb;
378  uint32_t vtag, atag;
379  uint16_t vwidth, vheight;
381  int i;
382  AVStream *st;
383  NSVStream *nst;
384 
385  vtag = avio_rl32(pb);
386  atag = avio_rl32(pb);
387  vwidth = avio_rl16(pb);
388  vheight = avio_rl16(pb);
389  i = avio_r8(pb);
390 
391  av_log(s, AV_LOG_TRACE, "NSV NSVs framerate code %2x\n", i);
392  if(i&0x80) { /* odd way of giving native framerates from docs */
393  int t=(i & 0x7F)>>2;
394  if(t<16) framerate = (AVRational){1, t+1};
395  else framerate = (AVRational){t-15, 1};
396 
397  if(i&1){
398  framerate.num *= 1000;
399  framerate.den *= 1001;
400  }
401 
402  if((i&3)==3) framerate.num *= 24;
403  else if((i&3)==2) framerate.num *= 25;
404  else framerate.num *= 30;
405  }
406  else
407  framerate= (AVRational){i, 1};
408 
409  nsv->avsync = avio_rl16(pb);
410  nsv->framerate = framerate;
411 
412  av_log(s, AV_LOG_TRACE, "NSV NSVs vsize %dx%d\n", vwidth, vheight);
413 
414  /* XXX change to ap != NULL ? */
415  if (s->nb_streams == 0) { /* streams not yet published, let's do that */
416  nsv->vtag = vtag;
417  nsv->atag = atag;
418  nsv->vwidth = vwidth;
419  nsv->vheight = vwidth;
420  if (vtag != T_NONE) {
421  int i;
422  st = avformat_new_stream(s, NULL);
423  if (!st)
424  goto fail;
425 
426  st->id = NSV_ST_VIDEO;
427  nst = av_mallocz(sizeof(NSVStream));
428  if (!nst)
429  goto fail;
430  st->priv_data = nst;
432  st->codecpar->codec_tag = vtag;
434  st->codecpar->width = vwidth;
435  st->codecpar->height = vheight;
436  st->codecpar->bits_per_coded_sample = 24; /* depth XXX */
437 
438  avpriv_set_pts_info(st, 64, framerate.den, framerate.num);
439  st->start_time = 0;
440  st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den);
441 
442  for(i=0;i<nsv->index_entries;i++) {
443  if(nsv->nsvs_timestamps) {
445  0, 0, AVINDEX_KEYFRAME);
446  } else {
447  int64_t ts = av_rescale(i*nsv->duration/nsv->index_entries, framerate.num, 1000*framerate.den);
449  }
450  }
451  }
452  if (atag != T_NONE) {
453  st = avformat_new_stream(s, NULL);
454  if (!st)
455  goto fail;
456 
457  st->id = NSV_ST_AUDIO;
458  nst = av_mallocz(sizeof(NSVStream));
459  if (!nst)
460  goto fail;
461  st->priv_data = nst;
463  st->codecpar->codec_tag = atag;
465 
466  if (atag == MKTAG('A', 'A', 'V', ' ')) {
467  static const uint8_t aav_pce[] = {
468  0x12, 0x00, 0x05, 0x08, 0x48, 0x00,
469  0x20, 0x00, 0xC6, 0x40, 0x04, 0x4C,
470  0x61, 0x76, 0x63, 0x56, 0xE5, 0x00,
471  0x00, 0x00,
472  };
473  int ret;
474 
475  if ((ret = ff_alloc_extradata(st->codecpar, sizeof(aav_pce))) < 0)
476  return ret;
477 
478  st->codecpar->sample_rate = 44100;
479  memcpy(st->codecpar->extradata, aav_pce, sizeof(aav_pce));
480  }
481 
482  ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL; /* for PCM we will read a chunk later and put correct info */
483 
484  /* set timebase to common denominator of ms and framerate */
485  avpriv_set_pts_info(st, 64, 1, framerate.num*1000);
486  st->start_time = 0;
487  st->duration = (int64_t)nsv->duration * framerate.num;
488  }
489  } else {
490  if (nsv->vtag != vtag || nsv->atag != atag || nsv->vwidth != vwidth || nsv->vheight != vwidth) {
491  av_log(s, AV_LOG_TRACE, "NSV NSVs header values differ from the first one!!!\n");
492  //return -1;
493  }
494  }
495 
496  nsv->state = NSV_HAS_READ_NSVS;
497  return 0;
498 fail:
499  /* XXX */
500  nsv->state = NSV_UNSYNC;
501  return -1;
502 }
503 
505 {
506  NSVContext *nsv = s->priv_data;
507  int i, err;
508 
509  nsv->state = NSV_UNSYNC;
510  nsv->ahead[0].data = nsv->ahead[1].data = NULL;
511 
512  for (i = 0; i < NSV_MAX_RESYNC_TRIES; i++) {
513  err = nsv_resync(s);
514  if (err < 0)
515  return err;
516  if (nsv->state == NSV_FOUND_NSVF) {
517  err = nsv_parse_NSVf_header(s);
518  if (err < 0)
519  return err;
520  }
521  /* we need the first NSVs also... */
522  if (nsv->state == NSV_FOUND_NSVS) {
523  err = nsv_parse_NSVs_header(s);
524  if (err < 0)
525  return err;
526  break; /* we just want the first one */
527  }
528  }
529  if (s->nb_streams < 1) /* no luck so far */
530  return AVERROR_INVALIDDATA;
531 
532  /* now read the first chunk, so we can attempt to decode more info */
533  err = nsv_read_chunk(s, 1);
534 
535  av_log(s, AV_LOG_TRACE, "parsed header\n");
536  return err;
537 }
538 
539 static int nsv_read_chunk(AVFormatContext *s, int fill_header)
540 {
541  NSVContext *nsv = s->priv_data;
542  AVIOContext *pb = s->pb;
543  AVStream *st[2] = {NULL, NULL};
544  NSVStream *nst;
545  AVPacket *pkt;
546  int i, err = 0;
547  uint8_t auxcount; /* number of aux metadata, also 4 bits of vsize */
548  uint32_t vsize;
549  uint16_t asize;
550  uint16_t auxsize;
551  int ret;
552 
553  if (nsv->ahead[0].data || nsv->ahead[1].data)
554  return 0; //-1; /* hey! eat what you've in your plate first! */
555 
556 null_chunk_retry:
557  if (avio_feof(pb))
558  return -1;
559 
560  for (i = 0; i < NSV_MAX_RESYNC_TRIES && nsv->state < NSV_FOUND_NSVS && !err; i++)
561  err = nsv_resync(s);
562  if (err < 0)
563  return err;
564  if (nsv->state == NSV_FOUND_NSVS)
565  err = nsv_parse_NSVs_header(s);
566  if (err < 0)
567  return err;
568  if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF)
569  return -1;
570 
571  auxcount = avio_r8(pb);
572  vsize = avio_rl16(pb);
573  asize = avio_rl16(pb);
574  vsize = (vsize << 4) | (auxcount >> 4);
575  auxcount &= 0x0f;
576  av_log(s, AV_LOG_TRACE, "NSV CHUNK %d aux, %"PRIu32" bytes video, %d bytes audio\n", auxcount, vsize, asize);
577  /* skip aux stuff */
578  for (i = 0; i < auxcount; i++) {
579  uint32_t av_unused auxtag;
580  auxsize = avio_rl16(pb);
581  auxtag = avio_rl32(pb);
582  avio_skip(pb, auxsize);
583  vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming brain-dead */
584  }
585 
586  if (avio_feof(pb))
587  return -1;
588  if (!vsize && !asize) {
589  nsv->state = NSV_UNSYNC;
590  goto null_chunk_retry;
591  }
592 
593  /* map back streams to v,a */
594  if (s->nb_streams > 0)
595  st[s->streams[0]->id] = s->streams[0];
596  if (s->nb_streams > 1)
597  st[s->streams[1]->id] = s->streams[1];
598 
599  if (vsize && st[NSV_ST_VIDEO]) {
600  nst = st[NSV_ST_VIDEO]->priv_data;
601  pkt = &nsv->ahead[NSV_ST_VIDEO];
602  if ((ret = av_get_packet(pb, pkt, vsize)) < 0)
603  return ret;
604  pkt->stream_index = st[NSV_ST_VIDEO]->index;//NSV_ST_VIDEO;
605  pkt->dts = nst->frame_offset;
606  pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */
607  for (i = 0; i < FFMIN(8, vsize); i++)
608  av_log(s, AV_LOG_TRACE, "NSV video: [%d] = %02x\n", i, pkt->data[i]);
609  }
610  if(st[NSV_ST_VIDEO])
611  ((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset++;
612 
613  if (asize && st[NSV_ST_AUDIO]) {
614  nst = st[NSV_ST_AUDIO]->priv_data;
615  pkt = &nsv->ahead[NSV_ST_AUDIO];
616  /* read raw audio specific header on the first audio chunk... */
617  /* on ALL audio chunks ?? seems so! */
618  if (asize && st[NSV_ST_AUDIO]->codecpar->codec_tag == MKTAG('P', 'C', 'M', ' ')/* && fill_header*/) {
619  uint8_t bps;
620  uint8_t channels;
621  uint16_t samplerate;
622  bps = avio_r8(pb);
623  channels = avio_r8(pb);
624  samplerate = avio_rl16(pb);
625  if (!channels || !samplerate)
626  return AVERROR_INVALIDDATA;
627  asize-=4;
628  av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate);
629  if (fill_header) {
630  ffstream(st[NSV_ST_AUDIO])->need_parsing = AVSTREAM_PARSE_NONE; /* we know everything */
631  if (bps != 16) {
632  av_log(s, AV_LOG_TRACE, "NSV AUDIO bit/sample != 16 (%d)!!!\n", bps);
633  }
634  bps /= channels; // ???
635  if (bps == 8)
637  samplerate /= 4;/* UGH ??? XXX */
638  channels = 1;
640  st[NSV_ST_AUDIO]->codecpar->sample_rate = samplerate;
641  av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate);
642  }
643  }
644  if ((ret = av_get_packet(pb, pkt, asize)) < 0)
645  return ret;
646  pkt->stream_index = st[NSV_ST_AUDIO]->index;//NSV_ST_AUDIO;
647  pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */
648  if( nsv->state == NSV_HAS_READ_NSVS && st[NSV_ST_VIDEO] ) {
649  /* on a nsvs frame we have new information on a/v sync */
650  pkt->dts = (((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset-1);
651  pkt->dts *= (int64_t)1000 * nsv->framerate.den;
652  pkt->dts += (int64_t)nsv->avsync * nsv->framerate.num;
653  av_log(s, AV_LOG_TRACE, "NSV AUDIO: sync:%d, dts:%"PRId64, nsv->avsync, pkt->dts);
654  }
655  nst->frame_offset++;
656  }
657 
658  nsv->state = NSV_UNSYNC;
659  return 0;
660 }
661 
662 
664 {
665  NSVContext *nsv = s->priv_data;
666  int i, err = 0;
667 
668  /* in case we don't already have something to eat ... */
669  if (!nsv->ahead[0].data && !nsv->ahead[1].data)
670  err = nsv_read_chunk(s, 0);
671  if (err < 0)
672  return err;
673 
674  /* now pick one of the plates */
675  for (i = 0; i < 2; i++) {
676  if (nsv->ahead[i].data) {
677  av_packet_move_ref(pkt, &nsv->ahead[i]);
678  return 0;
679  }
680  }
681 
682  /* this restaurant is not provisioned :^] */
683  return -1;
684 }
685 
686 static int nsv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
687 {
688  NSVContext *nsv = s->priv_data;
689  AVStream *st = s->streams[stream_index];
690  FFStream *const sti = ffstream(st);
691  NSVStream *nst = st->priv_data;
692  int index;
693 
694  index = av_index_search_timestamp(st, timestamp, flags);
695  if(index < 0)
696  return -1;
697 
698  if (avio_seek(s->pb, sti->index_entries[index].pos, SEEK_SET) < 0)
699  return -1;
700 
702  nsv->state = NSV_UNSYNC;
703  return 0;
704 }
705 
707 {
708  NSVContext *nsv = s->priv_data;
709 
710  av_freep(&nsv->nsvs_file_offset);
711  av_freep(&nsv->nsvs_timestamps);
712  if (nsv->ahead[0].data)
713  av_packet_unref(&nsv->ahead[0]);
714  if (nsv->ahead[1].data)
715  av_packet_unref(&nsv->ahead[1]);
716  return 0;
717 }
718 
719 static int nsv_probe(const AVProbeData *p)
720 {
721  int i, score = 0;
722 
723  /* check file header */
724  /* streamed files might not have any header */
725  if (p->buf[0] == 'N' && p->buf[1] == 'S' &&
726  p->buf[2] == 'V' && (p->buf[3] == 'f' || p->buf[3] == 's'))
727  return AVPROBE_SCORE_MAX;
728  /* XXX: do streamed files always start at chunk boundary ?? */
729  /* or do we need to search NSVs in the byte stream ? */
730  /* seems the servers don't bother starting clean chunks... */
731  /* sometimes even the first header is at 9KB or something :^) */
732  for (i = 1; i < p->buf_size - 3; i++) {
733  if (AV_RL32(p->buf + i) == AV_RL32("NSVs")) {
734  /* Get the chunk size and check if at the end we are getting 0xBEEF */
735  int vsize = AV_RL24(p->buf+i+19) >> 4;
736  int asize = AV_RL16(p->buf+i+22);
737  int offset = i + 23 + asize + vsize + 1;
738  if (offset <= p->buf_size - 2 && AV_RL16(p->buf + offset) == 0xBEEF)
739  return 4*AVPROBE_SCORE_MAX/5;
740  score = AVPROBE_SCORE_MAX/5;
741  }
742  }
743  /* so we'll have more luck on extension... */
744  if (av_match_ext(p->filename, "nsv"))
746  /* FIXME: add mime-type check */
747  return score;
748 }
749 
751  .name = "nsv",
752  .long_name = NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
753  .priv_data_size = sizeof(NSVContext),
754  .flags_internal = FF_FMT_INIT_CLEANUP,
760 };
nsv_read_chunk
static int nsv_read_chunk(AVFormatContext *s, int fill_header)
Definition: nsvdec.c:539
NSVContext::nsvs_timestamps
uint32_t * nsvs_timestamps
Definition: nsvdec.c:178
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
NSV_FOUND_NSVF
@ NSV_FOUND_NSVF
Definition: nsvdec.c:144
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:76
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:47
NSV_HAS_READ_NSVS
@ NSV_HAS_READ_NSVS
Definition: nsvdec.c:147
NSV_HAS_READ_NSVF
@ NSV_HAS_READ_NSVF
Definition: nsvdec.c:145
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:58
NSVContext::base_offset
int base_offset
Definition: nsvdec.c:166
AVStream::priv_data
void * priv_data
Definition: avformat.h:964
NSVContext::avsync
int16_t avsync
Definition: nsvdec.c:176
NSVStatus
NSVStatus
Definition: nsvdec.c:142
NSV_ST_VIDEO
#define NSV_ST_VIDEO
Definition: nsvdec.c:138
NSVStream
Definition: nsvdec.c:153
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
av_unused
#define av_unused
Definition: attributes.h:131
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
AVPacket::data
uint8_t * data
Definition: packet.h:374
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:143
NSVStream::scale
int scale
Definition: nsvdec.c:156
NSVContext::NSVf_end
int NSVf_end
Definition: nsvdec.c:167
nsv_read_seek
static int nsv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: nsvdec.c:686
NSVStream::cum_len
int cum_len
Definition: nsvdec.c:162
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:66
mathematics.h
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
NSVContext::vheight
uint16_t vheight
Definition: nsvdec.c:175
ff_nsv_demuxer
const AVInputFormat ff_nsv_demuxer
Definition: nsvdec.c:750
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:815
NSVContext
Definition: nsvdec.c:165
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:465
framerate
int framerate
Definition: h264_levels.c:65
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:763
nsv_parse_NSVs_header
static int nsv_parse_NSVs_header(AVFormatContext *s)
Definition: nsvdec.c:374
T_NONE
#define T_NONE
Definition: nsvdec.c:129
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:473
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:413
fail
#define fail()
Definition: checkasm.h:134
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
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:120
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:510
NSVContext::vwidth
uint16_t vwidth
Definition: nsvdec.c:175
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:439
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:998
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:745
AVRational::num
int num
Numerator.
Definition: rational.h:59
nsv_read_header
static int nsv_read_header(AVFormatContext *s)
Definition: nsvdec.c:504
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:59
AVInputFormat
Definition: avformat.h:656
NSVContext::framerate
AVRational framerate
Definition: nsvdec.c:177
AVCodecTag
Definition: internal.h:49
duration
int64_t duration
Definition: movenc.c:64
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
NSVStream::rate
int rate
Definition: nsvdec.c:157
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
NSV_GOT_AUDIO
@ NSV_GOT_AUDIO
Definition: nsvdec.c:150
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:128
AVProbeData::filename
const char * filename
Definition: avformat.h:454
av_match_ext
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:40
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:809
channels
channels
Definition: aptx.h:31
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
NSV_FOUND_BEEF
@ NSV_FOUND_BEEF
Definition: nsvdec.c:148
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
AVFormatContext
Format I/O context.
Definition: avformat.h:1216
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
NSVContext::duration
int64_t duration
Definition: nsvdec.c:173
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:540
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVSTREAM_PARSE_NONE
@ AVSTREAM_PARSE_NONE
Definition: avformat.h:797
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
NSVContext::ahead
AVPacket ahead[2]
Definition: nsvdec.c:171
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:213
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:479
NSVStream::frame_offset
int frame_offset
Definition: nsvdec.c:154
index
int index
Definition: gxfenc.c:89
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:463
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:178
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:440
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:761
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
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:115
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:301
FFStream
Definition: internal.h:196
bps
unsigned bps
Definition: movenc.c:1648
size
int size
Definition: twinvq_data.h:10344
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
nsv_codec_video_tags
static const AVCodecTag nsv_codec_video_tags[]
Definition: nsvdec.c:182
AV_RL24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:93
nsv_read_packet
static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nsvdec.c:663
nsv_probe
static int nsv_probe(const AVProbeData *p)
Definition: nsvdec.c:719
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:634
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
AV_CODEC_ID_VP5
@ AV_CODEC_ID_VP5
Definition: codec_id.h:142
AV_CODEC_ID_VP3
@ AV_CODEC_ID_VP3
Definition: codec_id.h:81
NSVContext::vtag
uint32_t vtag
Definition: nsvdec.c:174
nsv_resync
static int nsv_resync(AVFormatContext *s)
Definition: nsvdec.c:218
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecParameters::height
int height
Definition: codec_par.h:129
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
nsv_parse_NSVf_header
static int nsv_parse_NSVf_header(AVFormatContext *s)
Definition: nsvdec.c:259
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
NSV_MAX_RESYNC
#define NSV_MAX_RESYNC
Definition: nsvdec.c:34
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
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
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:962
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:262
NSV_ST_AUDIO
#define NSV_ST_AUDIO
Definition: nsvdec.c:139
avformat.h
dict.h
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
NSV_GOT_VIDEO
@ NSV_GOT_VIDEO
Definition: nsvdec.c:149
AVRational::den
int den
Denominator.
Definition: rational.h:60
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:643
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:808
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:349
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:251
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:104
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:331
NSV_FOUND_NSVS
@ NSV_FOUND_NSVS
Definition: nsvdec.c:146
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:368
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:62
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:798
NSVContext::atag
uint32_t atag
Definition: nsvdec.c:174
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:328
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
TB_NSVF
#define TB_NSVF
Definition: nsvdec.c:134
NSVStream::start
int start
Definition: nsvdec.c:159
NSVContext::state
enum NSVStatus state
Definition: nsvdec.c:170
nsv_codec_audio_tags
static const AVCodecTag nsv_codec_audio_tags[]
Definition: nsvdec.c:203
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
NSVStream::new_frame_offset
int new_frame_offset
Definition: nsvdec.c:161
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:988
NSVContext::nsvf
int nsvf
Definition: nsvdec.c:179
NSV_MAX_RESYNC_TRIES
#define NSV_MAX_RESYNC_TRIES
Definition: nsvdec.c:35
nsv_read_close
static int nsv_read_close(AVFormatContext *s)
Definition: nsvdec.c:706
NSVStream::sample_size
int sample_size
Definition: nsvdec.c:158
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:240
NSV_UNSYNC
@ NSV_UNSYNC
Definition: nsvdec.c:143
NSVContext::nsvs_file_offset
uint32_t * nsvs_file_offset
Definition: nsvdec.c:168
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:238
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:377
NSVContext::index_entries
int index_entries
Definition: nsvdec.c:169