2004-11-20 23:10:07 +00:00
|
|
|
/*
|
2006-10-23 08:57:54 +00:00
|
|
|
* NSV demuxer
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2004 The FFmpeg Project
|
2004-11-20 23:10:07 +00:00
|
|
|
*
|
2013-04-10 17:26:49 +00:00
|
|
|
* first version by Francois Revol <revol@free.fr>
|
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2004-11-20 23:10:07 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2004-11-20 23:10:07 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2004-11-20 23:10:07 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2004-11-20 23:10:07 +00:00
|
|
|
*/
|
2011-06-04 11:58:23 +00:00
|
|
|
|
2012-04-19 12:48:16 +00:00
|
|
|
#include "libavutil/attributes.h"
|
2011-06-04 11:58:23 +00:00
|
|
|
#include "libavutil/mathematics.h"
|
2004-11-20 23:10:07 +00:00
|
|
|
#include "avformat.h"
|
2011-11-29 18:28:15 +00:00
|
|
|
#include "internal.h"
|
2011-05-22 10:46:29 +00:00
|
|
|
#include "libavutil/dict.h"
|
2011-06-13 16:30:55 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2004-11-20 23:10:07 +00:00
|
|
|
|
|
|
|
/* max bytes to crawl for trying to resync
|
|
|
|
* stupid streaming servers don't start at chunk boundaries...
|
|
|
|
*/
|
|
|
|
#define NSV_MAX_RESYNC (500*1024)
|
|
|
|
#define NSV_MAX_RESYNC_TRIES 300
|
|
|
|
|
|
|
|
/*
|
|
|
|
* References:
|
|
|
|
* (1) http://www.multimedia.cx/nsv-format.txt
|
|
|
|
* seems someone came to the same conclusions as me, and updated it:
|
|
|
|
* (2) http://www.stud.ktu.lt/~vitslav/nsv/nsv-format.txt
|
|
|
|
* http://www.stud.ktu.lt/~vitslav/nsv/
|
2006-10-28 18:39:16 +00:00
|
|
|
* official docs
|
|
|
|
* (3) http://ultravox.aol.com/NSVFormat.rtf
|
2004-11-20 23:10:07 +00:00
|
|
|
* Sample files:
|
|
|
|
* (S1) http://www.nullsoft.com/nsv/samples/
|
|
|
|
* http://www.nullsoft.com/nsv/samples/faster.nsv
|
|
|
|
* http://streamripper.sourceforge.net/openbb/read.php?TID=492&page=4
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* notes on the header (Francois Revol):
|
2005-12-17 18:14:38 +00:00
|
|
|
*
|
|
|
|
* It is followed by strings, then a table, but nothing tells
|
2004-11-20 23:10:07 +00:00
|
|
|
* where the table begins according to (1). After checking faster.nsv,
|
|
|
|
* I believe NVSf[16-19] gives the size of the strings data
|
|
|
|
* (that is the offset of the data table after the header).
|
|
|
|
* After checking all samples from (S1) all confirms this.
|
|
|
|
*
|
2016-04-27 17:45:23 +00:00
|
|
|
* Then, about NSVf[12-15], faster.nsf has 179700. When viewing it in VLC,
|
2004-11-20 23:10:07 +00:00
|
|
|
* I noticed there was about 1 NVSs chunk/s, so I ran
|
|
|
|
* strings faster.nsv | grep NSVs | wc -l
|
2005-12-17 18:14:38 +00:00
|
|
|
* which gave me 180. That leads me to think that NSVf[12-15] might be the
|
2004-11-20 23:10:07 +00:00
|
|
|
* file length in milliseconds.
|
|
|
|
* Let's try that:
|
|
|
|
* 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
|
2016-04-27 17:45:23 +00:00
|
|
|
* except for nsvtrailer (which doesn't have an NSVf header), it reports correct time.
|
2004-11-20 23:10:07 +00:00
|
|
|
*
|
2005-12-17 18:14:38 +00:00
|
|
|
* nsvtrailer.nsv (S1) does not have any NSVf header, only NSVs chunks,
|
2004-11-20 23:10:07 +00:00
|
|
|
* so the header seems to not be mandatory. (for streaming).
|
2005-12-17 18:14:38 +00:00
|
|
|
*
|
2004-11-20 23:10:07 +00:00
|
|
|
* index slice duration check (excepts nsvtrailer.nsv):
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO:
|
|
|
|
* - handle timestamps !!!
|
|
|
|
* - use index
|
|
|
|
* - mime-type in probe()
|
|
|
|
* - seek
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
struct NSVf_header {
|
|
|
|
uint32_t chunk_tag; /* 'NSVf' */
|
|
|
|
uint32_t chunk_size;
|
2007-06-12 09:29:25 +00:00
|
|
|
uint32_t file_size; /* max 4GB ??? no one learns anything it seems :^) */
|
2004-11-20 23:10:07 +00:00
|
|
|
uint32_t file_length; //unknown1; /* what about MSB of file_size ? */
|
|
|
|
uint32_t info_strings_size; /* size of the info strings */ //unknown2;
|
|
|
|
uint32_t table_entries;
|
|
|
|
uint32_t table_entries_used; /* the left ones should be -1 */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct NSVs_header {
|
|
|
|
uint32_t chunk_tag; /* 'NSVs' */
|
|
|
|
uint32_t v4cc; /* or 'NONE' */
|
|
|
|
uint32_t a4cc; /* or 'NONE' */
|
2014-08-26 13:21:25 +00:00
|
|
|
uint16_t vwidth; /* av_assert0(vwidth%16==0) */
|
|
|
|
uint16_t vheight; /* av_assert0(vheight%16==0) */
|
2004-11-20 23:10:07 +00:00
|
|
|
uint8_t framerate; /* value = (framerate&0x80)?frtable[frameratex0x7f]:framerate */
|
|
|
|
uint16_t unknown;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct nsv_avchunk_header {
|
|
|
|
uint8_t vchunk_size_lsb;
|
|
|
|
uint16_t vchunk_size_msb; /* value = (vchunk_size_msb << 4) | (vchunk_size_lsb >> 4) */
|
|
|
|
uint16_t achunk_size;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct nsv_pcm_header {
|
|
|
|
uint8_t bits_per_sample;
|
|
|
|
uint8_t channel_count;
|
|
|
|
uint16_t sample_rate;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* variation from avi.h */
|
|
|
|
/*typedef struct CodecTag {
|
|
|
|
int id;
|
|
|
|
unsigned int tag;
|
|
|
|
} CodecTag;*/
|
|
|
|
|
|
|
|
/* tags */
|
|
|
|
|
|
|
|
#define T_NSVF MKTAG('N', 'S', 'V', 'f') /* file header */
|
|
|
|
#define T_NSVS MKTAG('N', 'S', 'V', 's') /* chunk header */
|
|
|
|
#define T_TOC2 MKTAG('T', 'O', 'C', '2') /* extra index marker */
|
|
|
|
#define T_NONE MKTAG('N', 'O', 'N', 'E') /* null a/v 4CC */
|
|
|
|
#define T_SUBT MKTAG('S', 'U', 'B', 'T') /* subtitle aux data */
|
|
|
|
#define T_ASYN MKTAG('A', 'S', 'Y', 'N') /* async a/v aux marker */
|
|
|
|
#define T_KEYF MKTAG('K', 'E', 'Y', 'F') /* video keyframe aux marker (addition) */
|
|
|
|
|
|
|
|
#define TB_NSVF MKBETAG('N', 'S', 'V', 'f')
|
|
|
|
#define TB_NSVS MKBETAG('N', 'S', 'V', 's')
|
|
|
|
|
2008-05-26 23:14:25 +00:00
|
|
|
/* hardcoded stream indexes */
|
2004-11-20 23:10:07 +00:00
|
|
|
#define NSV_ST_VIDEO 0
|
|
|
|
#define NSV_ST_AUDIO 1
|
|
|
|
#define NSV_ST_SUBT 2
|
|
|
|
|
|
|
|
enum NSVStatus {
|
|
|
|
NSV_UNSYNC,
|
|
|
|
NSV_FOUND_NSVF,
|
|
|
|
NSV_HAS_READ_NSVF,
|
|
|
|
NSV_FOUND_NSVS,
|
|
|
|
NSV_HAS_READ_NSVS,
|
|
|
|
NSV_FOUND_BEEF,
|
|
|
|
NSV_GOT_VIDEO,
|
|
|
|
NSV_GOT_AUDIO,
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct NSVStream {
|
|
|
|
int frame_offset; /* current frame (video) or byte (audio) counter
|
|
|
|
(used to compute the pts) */
|
|
|
|
int scale;
|
2005-12-17 18:14:38 +00:00
|
|
|
int rate;
|
2004-11-20 23:10:07 +00:00
|
|
|
int sample_size; /* audio only data */
|
|
|
|
int start;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
int new_frame_offset; /* temporary storage (used during seek) */
|
|
|
|
int cum_len; /* temporary storage (used during seek) */
|
|
|
|
} NSVStream;
|
|
|
|
|
2014-09-22 07:19:33 +00:00
|
|
|
typedef struct NSVContext {
|
2004-11-20 23:10:07 +00:00
|
|
|
int base_offset;
|
|
|
|
int NSVf_end;
|
2009-04-18 05:54:47 +00:00
|
|
|
uint32_t *nsvs_file_offset;
|
2004-11-20 23:10:07 +00:00
|
|
|
int index_entries;
|
|
|
|
enum NSVStatus state;
|
|
|
|
AVPacket ahead[2]; /* [v, a] if .data is !NULL there is something */
|
|
|
|
/* cached */
|
|
|
|
int64_t duration;
|
|
|
|
uint32_t vtag, atag;
|
|
|
|
uint16_t vwidth, vheight;
|
2006-10-28 17:28:04 +00:00
|
|
|
int16_t avsync;
|
2008-07-17 14:13:44 +00:00
|
|
|
AVRational framerate;
|
2009-04-22 19:37:57 +00:00
|
|
|
uint32_t *nsvs_timestamps;
|
2018-08-16 10:23:20 +00:00
|
|
|
int nsvf;
|
2004-11-20 23:10:07 +00:00
|
|
|
} NSVContext;
|
|
|
|
|
2007-01-21 01:39:17 +00:00
|
|
|
static const AVCodecTag nsv_codec_video_tags[] = {
|
2012-08-05 09:11:04 +00:00
|
|
|
{ AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') },
|
|
|
|
{ AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
|
|
|
|
{ AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
|
|
|
|
{ AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },
|
|
|
|
{ AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
|
|
|
|
{ AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') },
|
|
|
|
{ AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
|
|
|
|
{ AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
|
|
|
|
{ AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
|
2012-08-07 20:45:46 +00:00
|
|
|
{ AV_CODEC_ID_VP8, MKTAG('V', 'P', '8', '0') },
|
2004-11-20 23:10:07 +00:00
|
|
|
/*
|
2012-08-05 09:11:04 +00:00
|
|
|
{ AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },
|
|
|
|
{ AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },
|
2004-11-20 23:10:07 +00:00
|
|
|
*/
|
2012-08-05 09:11:04 +00:00
|
|
|
{ AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
|
|
|
|
{ AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },
|
|
|
|
{ AV_CODEC_ID_NONE, 0 },
|
2004-11-20 23:10:07 +00:00
|
|
|
};
|
|
|
|
|
2007-01-21 01:39:17 +00:00
|
|
|
static const AVCodecTag nsv_codec_audio_tags[] = {
|
2012-08-05 09:11:04 +00:00
|
|
|
{ AV_CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
|
|
|
|
{ AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') },
|
|
|
|
{ AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') },
|
2012-08-07 20:45:46 +00:00
|
|
|
{ AV_CODEC_ID_AAC, MKTAG('V', 'L', 'B', ' ') },
|
2012-08-05 09:11:04 +00:00
|
|
|
{ AV_CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') },
|
|
|
|
{ AV_CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') },
|
|
|
|
{ AV_CODEC_ID_NONE, 0 },
|
2004-11-20 23:10:07 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
//static int nsv_load_index(AVFormatContext *s);
|
|
|
|
static int nsv_read_chunk(AVFormatContext *s, int fill_header);
|
|
|
|
|
|
|
|
/* try to find something we recognize, and set the state accordingly */
|
|
|
|
static int nsv_resync(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
NSVContext *nsv = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2004-11-20 23:53:24 +00:00
|
|
|
uint32_t v = 0;
|
2004-11-20 23:10:07 +00:00
|
|
|
int i;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
for (i = 0; i < NSV_MAX_RESYNC; i++) {
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(pb)) {
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV EOF\n");
|
2004-11-20 23:10:07 +00:00
|
|
|
nsv->state = NSV_UNSYNC;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
v <<= 8;
|
2011-02-21 15:43:01 +00:00
|
|
|
v |= avio_r8(pb);
|
2004-11-20 23:10:07 +00:00
|
|
|
if (i < 8) {
|
2017-03-27 19:31:46 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV resync: [%d] = %02"PRIx32"\n", i, v & 0x0FF);
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
if ((v & 0x0000ffff) == 0xefbe) { /* BEEF */
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV resynced on BEEF after %d bytes\n", i+1);
|
2004-11-20 23:10:07 +00:00
|
|
|
nsv->state = NSV_FOUND_BEEF;
|
|
|
|
return 0;
|
|
|
|
}
|
2012-12-07 15:07:51 +00:00
|
|
|
/* we read as big-endian, thus the MK*BE* */
|
2004-11-20 23:10:07 +00:00
|
|
|
if (v == TB_NSVF) { /* NSVf */
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV resynced on NSVf after %d bytes\n", i+1);
|
2004-11-20 23:10:07 +00:00
|
|
|
nsv->state = NSV_FOUND_NSVF;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (v == MKBETAG('N', 'S', 'V', 's')) { /* NSVs */
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV resynced on NSVs after %d bytes\n", i+1);
|
2004-11-20 23:10:07 +00:00
|
|
|
nsv->state = NSV_FOUND_NSVS;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV sync lost\n");
|
2004-11-20 23:10:07 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-01-12 12:20:36 +00:00
|
|
|
static int nsv_parse_NSVf_header(AVFormatContext *s)
|
2004-11-20 23:10:07 +00:00
|
|
|
{
|
|
|
|
NSVContext *nsv = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2012-04-19 12:48:16 +00:00
|
|
|
unsigned int av_unused file_size;
|
2011-06-03 11:52:29 +00:00
|
|
|
unsigned int size;
|
2004-11-20 23:10:07 +00:00
|
|
|
int64_t duration;
|
|
|
|
int strings_size;
|
|
|
|
int table_entries;
|
|
|
|
int table_entries_used;
|
|
|
|
|
|
|
|
nsv->state = NSV_UNSYNC; /* in case we fail */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2018-08-16 10:23:20 +00:00
|
|
|
if (nsv->nsvf) {
|
|
|
|
av_log(s, AV_LOG_TRACE, "Multiple NSVf\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
nsv->nsvf = 1;
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
size = avio_rl32(pb);
|
2004-11-20 23:10:07 +00:00
|
|
|
if (size < 28)
|
|
|
|
return -1;
|
|
|
|
nsv->NSVf_end = size;
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
file_size = (uint32_t)avio_rl32(pb);
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVf chunk_size %u\n", size);
|
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVf file_size %u\n", file_size);
|
2004-11-20 23:10:07 +00:00
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
nsv->duration = duration = avio_rl32(pb); /* in ms */
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVf duration %"PRId64" ms\n", duration);
|
2004-11-20 23:10:07 +00:00
|
|
|
// XXX: store it in AVStreams
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
strings_size = avio_rl32(pb);
|
|
|
|
table_entries = avio_rl32(pb);
|
|
|
|
table_entries_used = avio_rl32(pb);
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",
|
2011-02-15 11:51:45 +00:00
|
|
|
strings_size, table_entries, table_entries_used);
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(pb))
|
2004-11-20 23:10:07 +00:00
|
|
|
return -1;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV got header; filepos %"PRId64"\n", avio_tell(pb));
|
2004-11-20 23:10:07 +00:00
|
|
|
|
|
|
|
if (strings_size > 0) {
|
|
|
|
char *strings; /* last byte will be '\0' to play safe with str*() */
|
|
|
|
char *p, *endp;
|
|
|
|
char *token, *value;
|
|
|
|
char quote;
|
|
|
|
|
2012-01-27 01:21:46 +00:00
|
|
|
p = strings = av_mallocz((size_t)strings_size + 1);
|
2011-12-29 20:31:22 +00:00
|
|
|
if (!p)
|
|
|
|
return AVERROR(ENOMEM);
|
2004-11-20 23:10:07 +00:00
|
|
|
endp = strings + strings_size;
|
2011-02-21 15:43:01 +00:00
|
|
|
avio_read(pb, strings, strings_size);
|
2004-11-20 23:10:07 +00:00
|
|
|
while (p < endp) {
|
|
|
|
while (*p == ' ')
|
|
|
|
p++; /* strip out spaces */
|
|
|
|
if (p >= endp-2)
|
|
|
|
break;
|
|
|
|
token = p;
|
|
|
|
p = strchr(p, '=');
|
|
|
|
if (!p || p >= endp-2)
|
|
|
|
break;
|
|
|
|
*p++ = '\0';
|
|
|
|
quote = *p++;
|
|
|
|
value = p;
|
|
|
|
p = strchr(p, quote);
|
|
|
|
if (!p || p >= endp)
|
|
|
|
break;
|
|
|
|
*p++ = '\0';
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVf INFO: %s='%s'\n", token, value);
|
2011-05-22 10:46:29 +00:00
|
|
|
av_dict_set(&s->metadata, token, value, 0);
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
av_free(strings);
|
|
|
|
}
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(pb))
|
2004-11-20 23:10:07 +00:00
|
|
|
return -1;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV got infos; filepos %"PRId64"\n", avio_tell(pb));
|
2004-11-20 23:10:07 +00:00
|
|
|
|
|
|
|
if (table_entries_used > 0) {
|
2009-04-22 19:37:57 +00:00
|
|
|
int i;
|
2004-11-20 23:10:07 +00:00
|
|
|
nsv->index_entries = table_entries_used;
|
2009-04-22 19:37:57 +00:00
|
|
|
if((unsigned)table_entries_used >= UINT_MAX / sizeof(uint32_t))
|
2005-01-08 14:21:33 +00:00
|
|
|
return -1;
|
2015-04-11 11:18:41 +00:00
|
|
|
nsv->nsvs_file_offset = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t));
|
2012-01-27 01:21:46 +00:00
|
|
|
if (!nsv->nsvs_file_offset)
|
|
|
|
return AVERROR(ENOMEM);
|
2009-04-22 19:37:57 +00:00
|
|
|
|
2017-08-29 21:59:21 +00:00
|
|
|
for(i=0;i<table_entries_used;i++) {
|
|
|
|
if (avio_feof(pb))
|
|
|
|
return AVERROR_INVALIDDATA;
|
2011-02-21 15:43:01 +00:00
|
|
|
nsv->nsvs_file_offset[i] = avio_rl32(pb) + size;
|
2017-08-29 21:59:21 +00:00
|
|
|
}
|
2009-04-22 19:37:57 +00:00
|
|
|
|
|
|
|
if(table_entries > table_entries_used &&
|
2011-02-21 15:43:01 +00:00
|
|
|
avio_rl32(pb) == MKTAG('T','O','C','2')) {
|
2015-04-11 11:18:41 +00:00
|
|
|
nsv->nsvs_timestamps = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t));
|
2012-01-27 01:21:46 +00:00
|
|
|
if (!nsv->nsvs_timestamps)
|
|
|
|
return AVERROR(ENOMEM);
|
2009-04-22 19:37:57 +00:00
|
|
|
for(i=0;i<table_entries_used;i++) {
|
2011-02-21 15:43:01 +00:00
|
|
|
nsv->nsvs_timestamps[i] = avio_rl32(pb);
|
2009-04-22 19:37:57 +00:00
|
|
|
}
|
|
|
|
}
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV got index; filepos %"PRId64"\n", avio_tell(pb));
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, nsv->base_offset + size, SEEK_SET); /* required for dumbdriving-271.nsv (2 extra bytes) */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(pb))
|
2004-11-20 23:10:07 +00:00
|
|
|
return -1;
|
|
|
|
nsv->state = NSV_HAS_READ_NSVF;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-12 12:20:36 +00:00
|
|
|
static int nsv_parse_NSVs_header(AVFormatContext *s)
|
2004-11-20 23:10:07 +00:00
|
|
|
{
|
|
|
|
NSVContext *nsv = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2004-11-20 23:10:07 +00:00
|
|
|
uint32_t vtag, atag;
|
|
|
|
uint16_t vwidth, vheight;
|
2005-04-26 21:46:46 +00:00
|
|
|
AVRational framerate;
|
|
|
|
int i;
|
2004-11-20 23:10:07 +00:00
|
|
|
AVStream *st;
|
|
|
|
NSVStream *nst;
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
vtag = avio_rl32(pb);
|
|
|
|
atag = avio_rl32(pb);
|
|
|
|
vwidth = avio_rl16(pb);
|
|
|
|
vheight = avio_rl16(pb);
|
|
|
|
i = avio_r8(pb);
|
2006-10-28 18:39:16 +00:00
|
|
|
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVs framerate code %2x\n", i);
|
2006-10-28 18:39:16 +00:00
|
|
|
if(i&0x80) { /* odd way of giving native framerates from docs */
|
|
|
|
int t=(i & 0x7F)>>2;
|
|
|
|
if(t<16) framerate = (AVRational){1, t+1};
|
|
|
|
else framerate = (AVRational){t-15, 1};
|
|
|
|
|
|
|
|
if(i&1){
|
|
|
|
framerate.num *= 1000;
|
|
|
|
framerate.den *= 1001;
|
|
|
|
}
|
|
|
|
|
|
|
|
if((i&3)==3) framerate.num *= 24;
|
|
|
|
else if((i&3)==2) framerate.num *= 25;
|
|
|
|
else framerate.num *= 30;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
framerate= (AVRational){i, 1};
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
nsv->avsync = avio_rl16(pb);
|
2008-07-17 14:13:44 +00:00
|
|
|
nsv->framerate = framerate;
|
2011-02-15 11:51:45 +00:00
|
|
|
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVs vsize %dx%d\n", vwidth, vheight);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
/* XXX change to ap != NULL ? */
|
|
|
|
if (s->nb_streams == 0) { /* streams not yet published, let's do that */
|
|
|
|
nsv->vtag = vtag;
|
|
|
|
nsv->atag = atag;
|
|
|
|
nsv->vwidth = vwidth;
|
|
|
|
nsv->vheight = vwidth;
|
|
|
|
if (vtag != T_NONE) {
|
2009-04-22 19:37:57 +00:00
|
|
|
int i;
|
2011-06-18 09:43:24 +00:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2004-11-20 23:10:07 +00:00
|
|
|
if (!st)
|
|
|
|
goto fail;
|
|
|
|
|
2011-06-18 09:43:24 +00:00
|
|
|
st->id = NSV_ST_VIDEO;
|
2004-11-20 23:10:07 +00:00
|
|
|
nst = av_mallocz(sizeof(NSVStream));
|
|
|
|
if (!nst)
|
|
|
|
goto fail;
|
|
|
|
st->priv_data = nst;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_tag = vtag;
|
|
|
|
st->codecpar->codec_id = ff_codec_get_id(nsv_codec_video_tags, vtag);
|
|
|
|
st->codecpar->width = vwidth;
|
|
|
|
st->codecpar->height = vheight;
|
|
|
|
st->codecpar->bits_per_coded_sample = 24; /* depth XXX */
|
2004-11-20 23:10:07 +00:00
|
|
|
|
2011-11-29 18:28:15 +00:00
|
|
|
avpriv_set_pts_info(st, 64, framerate.den, framerate.num);
|
2004-11-20 23:10:07 +00:00
|
|
|
st->start_time = 0;
|
2005-04-30 21:43:59 +00:00
|
|
|
st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den);
|
2009-04-22 19:37:57 +00:00
|
|
|
|
|
|
|
for(i=0;i<nsv->index_entries;i++) {
|
|
|
|
if(nsv->nsvs_timestamps) {
|
|
|
|
av_add_index_entry(st, nsv->nsvs_file_offset[i], nsv->nsvs_timestamps[i],
|
|
|
|
0, 0, AVINDEX_KEYFRAME);
|
|
|
|
} else {
|
|
|
|
int64_t ts = av_rescale(i*nsv->duration/nsv->index_entries, framerate.num, 1000*framerate.den);
|
|
|
|
av_add_index_entry(st, nsv->nsvs_file_offset[i], ts, 0, 0, AVINDEX_KEYFRAME);
|
|
|
|
}
|
|
|
|
}
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
if (atag != T_NONE) {
|
2011-06-18 09:43:24 +00:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2004-11-20 23:10:07 +00:00
|
|
|
if (!st)
|
|
|
|
goto fail;
|
|
|
|
|
2011-06-18 09:43:24 +00:00
|
|
|
st->id = NSV_ST_AUDIO;
|
2004-11-20 23:10:07 +00:00
|
|
|
nst = av_mallocz(sizeof(NSVStream));
|
|
|
|
if (!nst)
|
|
|
|
goto fail;
|
|
|
|
st->priv_data = nst;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_tag = atag;
|
|
|
|
st->codecpar->codec_id = ff_codec_get_id(nsv_codec_audio_tags, atag);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-04-15 13:51:57 +00:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_FULL; /* for PCM we will read a chunk later and put correct info */
|
2004-11-20 23:10:07 +00:00
|
|
|
|
2006-10-28 17:28:04 +00:00
|
|
|
/* set timebase to common denominator of ms and framerate */
|
2011-11-29 18:28:15 +00:00
|
|
|
avpriv_set_pts_info(st, 64, 1, framerate.num*1000);
|
2006-10-28 17:28:04 +00:00
|
|
|
st->start_time = 0;
|
|
|
|
st->duration = (int64_t)nsv->duration * framerate.num;
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (nsv->vtag != vtag || nsv->atag != atag || nsv->vwidth != vwidth || nsv->vheight != vwidth) {
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV NSVs header values differ from the first one!!!\n");
|
2004-11-20 23:10:07 +00:00
|
|
|
//return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsv->state = NSV_HAS_READ_NSVS;
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
/* XXX */
|
|
|
|
nsv->state = NSV_UNSYNC;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-01-12 12:20:36 +00:00
|
|
|
static int nsv_read_header(AVFormatContext *s)
|
2004-11-20 23:10:07 +00:00
|
|
|
{
|
|
|
|
NSVContext *nsv = s->priv_data;
|
2005-02-24 19:08:50 +00:00
|
|
|
int i, err;
|
2004-11-20 23:10:07 +00:00
|
|
|
|
|
|
|
nsv->state = NSV_UNSYNC;
|
|
|
|
nsv->ahead[0].data = nsv->ahead[1].data = NULL;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
for (i = 0; i < NSV_MAX_RESYNC_TRIES; i++) {
|
|
|
|
if (nsv_resync(s) < 0)
|
|
|
|
return -1;
|
2012-01-27 01:23:09 +00:00
|
|
|
if (nsv->state == NSV_FOUND_NSVF) {
|
2012-01-12 12:20:36 +00:00
|
|
|
err = nsv_parse_NSVf_header(s);
|
2012-01-27 01:23:09 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
2004-11-20 23:10:07 +00:00
|
|
|
/* we need the first NSVs also... */
|
|
|
|
if (nsv->state == NSV_FOUND_NSVS) {
|
2012-01-12 12:20:36 +00:00
|
|
|
err = nsv_parse_NSVs_header(s);
|
2012-01-27 01:23:09 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2004-11-20 23:10:07 +00:00
|
|
|
break; /* we just want the first one */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (s->nb_streams < 1) /* no luck so far */
|
|
|
|
return -1;
|
|
|
|
/* now read the first chunk, so we can attempt to decode more info */
|
|
|
|
err = nsv_read_chunk(s, 1);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "parsed header\n");
|
2011-06-13 16:28:54 +00:00
|
|
|
return err;
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int nsv_read_chunk(AVFormatContext *s, int fill_header)
|
|
|
|
{
|
|
|
|
NSVContext *nsv = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2004-11-20 23:10:07 +00:00
|
|
|
AVStream *st[2] = {NULL, NULL};
|
|
|
|
NSVStream *nst;
|
|
|
|
AVPacket *pkt;
|
|
|
|
int i, err = 0;
|
2004-11-20 23:53:24 +00:00
|
|
|
uint8_t auxcount; /* number of aux metadata, also 4 bits of vsize */
|
|
|
|
uint32_t vsize;
|
|
|
|
uint16_t asize;
|
|
|
|
uint16_t auxsize;
|
2015-01-18 19:52:25 +00:00
|
|
|
int ret;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
if (nsv->ahead[0].data || nsv->ahead[1].data)
|
|
|
|
return 0; //-1; /* hey! eat what you've in your plate first! */
|
|
|
|
|
|
|
|
null_chunk_retry:
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(pb))
|
2004-11-20 23:10:07 +00:00
|
|
|
return -1;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
for (i = 0; i < NSV_MAX_RESYNC_TRIES && nsv->state < NSV_FOUND_NSVS && !err; i++)
|
|
|
|
err = nsv_resync(s);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (nsv->state == NSV_FOUND_NSVS)
|
2012-01-12 12:20:36 +00:00
|
|
|
err = nsv_parse_NSVs_header(s);
|
2004-11-20 23:10:07 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF)
|
|
|
|
return -1;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
auxcount = avio_r8(pb);
|
|
|
|
vsize = avio_rl16(pb);
|
|
|
|
asize = avio_rl16(pb);
|
2004-11-20 23:10:07 +00:00
|
|
|
vsize = (vsize << 4) | (auxcount >> 4);
|
|
|
|
auxcount &= 0x0f;
|
2017-03-27 19:31:46 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV CHUNK %d aux, %"PRIu32" bytes video, %d bytes audio\n", auxcount, vsize, asize);
|
2004-11-20 23:10:07 +00:00
|
|
|
/* skip aux stuff */
|
|
|
|
for (i = 0; i < auxcount; i++) {
|
2012-04-19 12:48:16 +00:00
|
|
|
uint32_t av_unused auxtag;
|
2011-02-21 15:43:01 +00:00
|
|
|
auxsize = avio_rl16(pb);
|
|
|
|
auxtag = avio_rl32(pb);
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(pb, auxsize);
|
2016-04-27 17:45:23 +00:00
|
|
|
vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming brain-dead */
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(pb))
|
2004-11-20 23:10:07 +00:00
|
|
|
return -1;
|
|
|
|
if (!vsize && !asize) {
|
|
|
|
nsv->state = NSV_UNSYNC;
|
|
|
|
goto null_chunk_retry;
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
/* map back streams to v,a */
|
2012-01-24 21:20:26 +00:00
|
|
|
if (s->nb_streams > 0)
|
2004-11-20 23:10:07 +00:00
|
|
|
st[s->streams[0]->id] = s->streams[0];
|
2012-01-24 21:20:26 +00:00
|
|
|
if (s->nb_streams > 1)
|
2004-11-20 23:10:07 +00:00
|
|
|
st[s->streams[1]->id] = s->streams[1];
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-01-24 21:20:26 +00:00
|
|
|
if (vsize && st[NSV_ST_VIDEO]) {
|
2004-11-20 23:10:07 +00:00
|
|
|
nst = st[NSV_ST_VIDEO]->priv_data;
|
|
|
|
pkt = &nsv->ahead[NSV_ST_VIDEO];
|
2015-01-17 15:05:08 +00:00
|
|
|
if ((ret = av_get_packet(pb, pkt, vsize)) < 0)
|
|
|
|
return ret;
|
2004-11-20 23:10:07 +00:00
|
|
|
pkt->stream_index = st[NSV_ST_VIDEO]->index;//NSV_ST_VIDEO;
|
2007-03-21 11:05:35 +00:00
|
|
|
pkt->dts = nst->frame_offset;
|
2010-03-31 12:29:58 +00:00
|
|
|
pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */
|
2011-02-15 11:51:45 +00:00
|
|
|
for (i = 0; i < FFMIN(8, vsize); i++)
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV video: [%d] = %02x\n", i, pkt->data[i]);
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
2007-09-22 08:55:17 +00:00
|
|
|
if(st[NSV_ST_VIDEO])
|
2007-09-22 08:58:49 +00:00
|
|
|
((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset++;
|
2007-03-21 11:05:35 +00:00
|
|
|
|
2012-01-24 21:20:26 +00:00
|
|
|
if (asize && st[NSV_ST_AUDIO]) {
|
2004-11-20 23:10:07 +00:00
|
|
|
nst = st[NSV_ST_AUDIO]->priv_data;
|
|
|
|
pkt = &nsv->ahead[NSV_ST_AUDIO];
|
|
|
|
/* read raw audio specific header on the first audio chunk... */
|
|
|
|
/* on ALL audio chunks ?? seems so! */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (asize && st[NSV_ST_AUDIO]->codecpar->codec_tag == MKTAG('P', 'C', 'M', ' ')/* && fill_header*/) {
|
2004-11-20 23:10:07 +00:00
|
|
|
uint8_t bps;
|
|
|
|
uint8_t channels;
|
|
|
|
uint16_t samplerate;
|
2011-02-21 15:43:01 +00:00
|
|
|
bps = avio_r8(pb);
|
|
|
|
channels = avio_r8(pb);
|
|
|
|
samplerate = avio_rl16(pb);
|
2015-01-23 15:03:08 +00:00
|
|
|
if (!channels || !samplerate)
|
|
|
|
return AVERROR_INVALIDDATA;
|
2004-11-20 23:10:07 +00:00
|
|
|
asize-=4;
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate);
|
2004-11-20 23:10:07 +00:00
|
|
|
if (fill_header) {
|
2007-04-15 13:51:57 +00:00
|
|
|
st[NSV_ST_AUDIO]->need_parsing = AVSTREAM_PARSE_NONE; /* we know everything */
|
2004-11-20 23:10:07 +00:00
|
|
|
if (bps != 16) {
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV AUDIO bit/sample != 16 (%d)!!!\n", bps);
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
2015-01-28 09:34:31 +00:00
|
|
|
bps /= channels; // ???
|
2004-11-20 23:10:07 +00:00
|
|
|
if (bps == 8)
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
st[NSV_ST_AUDIO]->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
|
2004-11-20 23:10:07 +00:00
|
|
|
samplerate /= 4;/* UGH ??? XXX */
|
|
|
|
channels = 1;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
st[NSV_ST_AUDIO]->codecpar->channels = channels;
|
|
|
|
st[NSV_ST_AUDIO]->codecpar->sample_rate = samplerate;
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate);
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
}
|
2015-01-18 19:52:25 +00:00
|
|
|
if ((ret = av_get_packet(pb, pkt, asize)) < 0)
|
|
|
|
return ret;
|
2004-11-20 23:10:07 +00:00
|
|
|
pkt->stream_index = st[NSV_ST_AUDIO]->index;//NSV_ST_AUDIO;
|
2010-03-31 12:29:58 +00:00
|
|
|
pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */
|
2006-10-28 17:28:04 +00:00
|
|
|
if( nsv->state == NSV_HAS_READ_NSVS && st[NSV_ST_VIDEO] ) {
|
|
|
|
/* on a nsvs frame we have new information on a/v sync */
|
|
|
|
pkt->dts = (((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset-1);
|
2008-07-17 14:13:44 +00:00
|
|
|
pkt->dts *= (int64_t)1000 * nsv->framerate.den;
|
|
|
|
pkt->dts += (int64_t)nsv->avsync * nsv->framerate.num;
|
2015-03-16 08:57:35 +00:00
|
|
|
av_log(s, AV_LOG_TRACE, "NSV AUDIO: sync:%d, dts:%"PRId64, nsv->avsync, pkt->dts);
|
2006-10-28 17:28:04 +00:00
|
|
|
}
|
|
|
|
nst->frame_offset++;
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
nsv->state = NSV_UNSYNC;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
NSVContext *nsv = s->priv_data;
|
|
|
|
int i, err = 0;
|
|
|
|
|
|
|
|
/* in case we don't already have something to eat ... */
|
2014-08-14 20:31:24 +00:00
|
|
|
if (!nsv->ahead[0].data && !nsv->ahead[1].data)
|
2004-11-20 23:10:07 +00:00
|
|
|
err = nsv_read_chunk(s, 0);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
/* now pick one of the plates */
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
if (nsv->ahead[i].data) {
|
|
|
|
/* avoid the cost of new_packet + memcpy(->data) */
|
|
|
|
memcpy(pkt, &nsv->ahead[i], sizeof(AVPacket));
|
|
|
|
nsv->ahead[i].data = NULL; /* we ate that one */
|
|
|
|
return pkt->size;
|
|
|
|
}
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2016-04-27 17:45:23 +00:00
|
|
|
/* this restaurant is not provisioned :^] */
|
2004-11-20 23:10:07 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nsv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
|
|
|
|
{
|
2009-04-22 19:37:57 +00:00
|
|
|
NSVContext *nsv = s->priv_data;
|
|
|
|
AVStream *st = s->streams[stream_index];
|
|
|
|
NSVStream *nst = st->priv_data;
|
|
|
|
int index;
|
2004-11-20 23:10:07 +00:00
|
|
|
|
2009-04-22 19:37:57 +00:00
|
|
|
index = av_index_search_timestamp(st, timestamp, flags);
|
|
|
|
if(index < 0)
|
|
|
|
return -1;
|
|
|
|
|
2011-09-14 17:26:57 +00:00
|
|
|
if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2009-04-22 19:37:57 +00:00
|
|
|
nst->frame_offset = st->index_entries[index].timestamp;
|
|
|
|
nsv->state = NSV_UNSYNC;
|
|
|
|
return 0;
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int nsv_read_close(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
NSVContext *nsv = s->priv_data;
|
|
|
|
|
2009-04-22 19:37:57 +00:00
|
|
|
av_freep(&nsv->nsvs_file_offset);
|
|
|
|
av_freep(&nsv->nsvs_timestamps);
|
2010-03-03 17:26:00 +00:00
|
|
|
if (nsv->ahead[0].data)
|
2015-10-23 09:11:31 +00:00
|
|
|
av_packet_unref(&nsv->ahead[0]);
|
2010-03-03 17:26:00 +00:00
|
|
|
if (nsv->ahead[1].data)
|
2015-10-23 09:11:31 +00:00
|
|
|
av_packet_unref(&nsv->ahead[1]);
|
2004-11-20 23:10:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nsv_probe(AVProbeData *p)
|
|
|
|
{
|
2011-06-13 16:30:55 +00:00
|
|
|
int i, score = 0;
|
|
|
|
|
2004-11-20 23:10:07 +00:00
|
|
|
/* check file header */
|
|
|
|
/* streamed files might not have any header */
|
|
|
|
if (p->buf[0] == 'N' && p->buf[1] == 'S' &&
|
2007-04-08 11:37:04 +00:00
|
|
|
p->buf[2] == 'V' && (p->buf[3] == 'f' || p->buf[3] == 's'))
|
2004-11-20 23:10:07 +00:00
|
|
|
return AVPROBE_SCORE_MAX;
|
|
|
|
/* XXX: do streamed files always start at chunk boundary ?? */
|
|
|
|
/* or do we need to search NSVs in the byte stream ? */
|
|
|
|
/* seems the servers don't bother starting clean chunks... */
|
|
|
|
/* sometimes even the first header is at 9KB or something :^) */
|
|
|
|
for (i = 1; i < p->buf_size - 3; i++) {
|
2011-06-13 16:30:55 +00:00
|
|
|
if (AV_RL32(p->buf + i) == AV_RL32("NSVs")) {
|
2011-05-11 23:36:39 +00:00
|
|
|
/* Get the chunk size and check if at the end we are getting 0xBEEF */
|
2011-06-13 16:30:55 +00:00
|
|
|
int vsize = AV_RL24(p->buf+i+19) >> 4;
|
|
|
|
int asize = AV_RL16(p->buf+i+22);
|
|
|
|
int offset = i + 23 + asize + vsize + 1;
|
|
|
|
if (offset <= p->buf_size - 2 && AV_RL16(p->buf + offset) == 0xBEEF)
|
|
|
|
return 4*AVPROBE_SCORE_MAX/5;
|
|
|
|
score = AVPROBE_SCORE_MAX/5;
|
2011-05-11 23:36:39 +00:00
|
|
|
}
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
/* so we'll have more luck on extension... */
|
2010-01-17 15:57:51 +00:00
|
|
|
if (av_match_ext(p->filename, "nsv"))
|
2013-03-25 15:12:51 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION;
|
2004-11-20 23:10:07 +00:00
|
|
|
/* FIXME: add mime-type check */
|
2011-05-11 23:36:39 +00:00
|
|
|
return score;
|
2004-11-20 23:10:07 +00:00
|
|
|
}
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVInputFormat ff_nsv_demuxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "nsv",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
|
|
|
|
.priv_data_size = sizeof(NSVContext),
|
|
|
|
.read_probe = nsv_probe,
|
|
|
|
.read_header = nsv_read_header,
|
|
|
|
.read_packet = nsv_read_packet,
|
|
|
|
.read_close = nsv_read_close,
|
|
|
|
.read_seek = nsv_read_seek,
|
2004-11-20 23:10:07 +00:00
|
|
|
};
|