/libavformat/nsvdec.c
C | 746 lines | 551 code | 86 blank | 109 comment | 141 complexity | 455caae6bd442e4ea6782fffae61328b MD5 | raw 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 85struct 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 95struct 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 105struct 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 111struct 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 142enum NSVStatus { 143 NSV_UNSYNC, 144 NSV_FOUND_NSVF, 145 NSV_HAS_READ_NSVF, 146 NSV_FOUND_NSVS, 147 NSV_HAS_READ_NSVS, 148 NSV_FOUND_BEEF, 149 NSV_GOT_VIDEO, 150 NSV_GOT_AUDIO, 151}; 152 153typedef 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 165typedef struct NSVContext { 166 int base_offset; 167 int NSVf_end; 168 uint32_t *nsvs_file_offset; 169 int index_entries; 170 enum NSVStatus state; 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; 177 AVRational framerate; 178 uint32_t *nsvs_timestamps; 179 int nsvf; 180} NSVContext; 181 182static const AVCodecTag nsv_codec_video_tags[] = { 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_RAWVIDEO, MKTAG('R', 'G', 'B', '3') }, 199 { AV_CODEC_ID_NONE, 0 }, 200}; 201 202static const AVCodecTag nsv_codec_audio_tags[] = { 203 { AV_CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') }, 204 { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') }, 205 { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') }, 206 { AV_CODEC_ID_AAC, MKTAG('V', 'L', 'B', ' ') }, 207 { AV_CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') }, 208 { AV_CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') }, 209 { AV_CODEC_ID_NONE, 0 }, 210}; 211 212//static int nsv_load_index(AVFormatContext *s); 213static int nsv_read_chunk(AVFormatContext *s, int fill_header); 214static int nsv_read_close(AVFormatContext *s); 215 216/* try to find something we recognize, and set the state accordingly */ 217static int nsv_resync(AVFormatContext *s) 218{ 219 NSVContext *nsv = s->priv_data; 220 AVIOContext *pb = s->pb; 221 uint32_t v = 0; 222 int i; 223 224 for (i = 0; i < NSV_MAX_RESYNC; i++) { 225 if (avio_feof(pb)) { 226 av_log(s, AV_LOG_TRACE, "NSV EOF\n"); 227 nsv->state = NSV_UNSYNC; 228 return -1; 229 } 230 v <<= 8; 231 v |= avio_r8(pb); 232 if (i < 8) { 233 av_log(s, AV_LOG_TRACE, "NSV resync: [%d] = %02"PRIx32"\n", i, v & 0x0FF); 234 } 235 236 if ((v & 0x0000ffff) == 0xefbe) { /* BEEF */ 237 av_log(s, AV_LOG_TRACE, "NSV resynced on BEEF after %d bytes\n", i+1); 238 nsv->state = NSV_FOUND_BEEF; 239 return 0; 240 } 241 /* we read as big-endian, thus the MK*BE* */ 242 if (v == TB_NSVF) { /* NSVf */ 243 av_log(s, AV_LOG_TRACE, "NSV resynced on NSVf after %d bytes\n", i+1); 244 nsv->state = NSV_FOUND_NSVF; 245 return 0; 246 } 247 if (v == MKBETAG('N', 'S', 'V', 's')) { /* NSVs */ 248 av_log(s, AV_LOG_TRACE, "NSV resynced on NSVs after %d bytes\n", i+1); 249 nsv->state = NSV_FOUND_NSVS; 250 return 0; 251 } 252 253 } 254 av_log(s, AV_LOG_TRACE, "NSV sync lost\n"); 255 return -1; 256} 257 258static int nsv_parse_NSVf_header(AVFormatContext *s) 259{ 260 NSVContext *nsv = s->priv_data; 261 AVIOContext *pb = s->pb; 262 unsigned int av_unused file_size; 263 unsigned int size; 264 int64_t duration; 265 int strings_size; 266 int table_entries; 267 int table_entries_used; 268 269 nsv->state = NSV_UNSYNC; /* in case we fail */ 270 271 if (nsv->nsvf) { 272 av_log(s, AV_LOG_TRACE, "Multiple NSVf\n"); 273 return 0; 274 } 275 nsv->nsvf = 1; 276 277 size = avio_rl32(pb); 278 if (size < 28) 279 return -1; 280 nsv->NSVf_end = size; 281 282 file_size = (uint32_t)avio_rl32(pb); 283 av_log(s, AV_LOG_TRACE, "NSV NSVf chunk_size %u\n", size); 284 av_log(s, AV_LOG_TRACE, "NSV NSVf file_size %u\n", file_size); 285 286 nsv->duration = duration = avio_rl32(pb); /* in ms */ 287 av_log(s, AV_LOG_TRACE, "NSV NSVf duration %"PRId64" ms\n", duration); 288 // XXX: store it in AVStreams 289 290 strings_size = avio_rl32(pb); 291 table_entries = avio_rl32(pb); 292 table_entries_used = avio_rl32(pb); 293 av_log(s, AV_LOG_TRACE, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n", 294 strings_size, table_entries, table_entries_used); 295 if (avio_feof(pb)) 296 return -1; 297 298 av_log(s, AV_LOG_TRACE, "NSV got header; filepos %"PRId64"\n", avio_tell(pb)); 299 300 if (strings_size > 0) { 301 char *strings; /* last byte will be '\0' to play safe with str*() */ 302 char *p, *endp; 303 char *token, *value; 304 char quote; 305 306 p = strings = av_mallocz((size_t)strings_size + 1); 307 if (!p) 308 return AVERROR(ENOMEM); 309 endp = strings + strings_size; 310 avio_read(pb, strings, strings_size); 311 while (p < endp) { 312 while (*p == ' ') 313 p++; /* strip out spaces */ 314 if (p >= endp-2) 315 break; 316 token = p; 317 p = strchr(p, '='); 318 if (!p || p >= endp-2) 319 break; 320 *p++ = '\0'; 321 quote = *p++; 322 value = p; 323 p = strchr(p, quote); 324 if (!p || p >= endp) 325 break; 326 *p++ = '\0'; 327 av_log(s, AV_LOG_TRACE, "NSV NSVf INFO: %s='%s'\n", token, value); 328 av_dict_set(&s->metadata, token, value, 0); 329 } 330 av_free(strings); 331 } 332 if (avio_feof(pb)) 333 return -1; 334 335 av_log(s, AV_LOG_TRACE, "NSV got infos; filepos %"PRId64"\n", avio_tell(pb)); 336 337 if (table_entries_used > 0) { 338 int i; 339 nsv->index_entries = table_entries_used; 340 if((unsigned)table_entries_used >= UINT_MAX / sizeof(uint32_t)) 341 return -1; 342 nsv->nsvs_file_offset = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t)); 343 if (!nsv->nsvs_file_offset) 344 return AVERROR(ENOMEM); 345 346 for(i=0;i<table_entries_used;i++) { 347 if (avio_feof(pb)) 348 return AVERROR_INVALIDDATA; 349 nsv->nsvs_file_offset[i] = avio_rl32(pb) + size; 350 } 351 352 if(table_entries > table_entries_used && 353 avio_rl32(pb) == MKTAG('T','O','C','2')) { 354 nsv->nsvs_timestamps = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t)); 355 if (!nsv->nsvs_timestamps) 356 return AVERROR(ENOMEM); 357 for(i=0;i<table_entries_used;i++) { 358 nsv->nsvs_timestamps[i] = avio_rl32(pb); 359 } 360 } 361 } 362 363 av_log(s, AV_LOG_TRACE, "NSV got index; filepos %"PRId64"\n", avio_tell(pb)); 364 365 avio_seek(pb, nsv->base_offset + size, SEEK_SET); /* required for dumbdriving-271.nsv (2 extra bytes) */ 366 367 if (avio_feof(pb)) 368 return -1; 369 nsv->state = NSV_HAS_READ_NSVF; 370 return 0; 371} 372 373static int nsv_parse_NSVs_header(AVFormatContext *s) 374{ 375 NSVContext *nsv = s->priv_data; 376 AVIOContext *pb = s->pb; 377 uint32_t vtag, atag; 378 uint16_t vwidth, vheight; 379 AVRational framerate; 380 int i; 381 AVStream *st; 382 NSVStream *nst; 383 384 vtag = avio_rl32(pb); 385 atag = avio_rl32(pb); 386 vwidth = avio_rl16(pb); 387 vheight = avio_rl16(pb); 388 i = avio_r8(pb); 389 390 av_log(s, AV_LOG_TRACE, "NSV NSVs framerate code %2x\n", i); 391 if(i&0x80) { /* odd way of giving native framerates from docs */ 392 int t=(i & 0x7F)>>2; 393 if(t<16) framerate = (AVRational){1, t+1}; 394 else framerate = (AVRational){t-15, 1}; 395 396 if(i&1){ 397 framerate.num *= 1000; 398 framerate.den *= 1001; 399 } 400 401 if((i&3)==3) framerate.num *= 24; 402 else if((i&3)==2) framerate.num *= 25; 403 else framerate.num *= 30; 404 } 405 else 406 framerate= (AVRational){i, 1}; 407 408 nsv->avsync = avio_rl16(pb); 409 nsv->framerate = framerate; 410 411 av_log(s, AV_LOG_TRACE, "NSV NSVs vsize %dx%d\n", vwidth, vheight); 412 413 /* XXX change to ap != NULL ? */ 414 if (s->nb_streams == 0) { /* streams not yet published, let's do that */ 415 nsv->vtag = vtag; 416 nsv->atag = atag; 417 nsv->vwidth = vwidth; 418 nsv->vheight = vwidth; 419 if (vtag != T_NONE) { 420 int i; 421 st = avformat_new_stream(s, NULL); 422 if (!st) 423 goto fail; 424 425 st->id = NSV_ST_VIDEO; 426 nst = av_mallocz(sizeof(NSVStream)); 427 if (!nst) 428 goto fail; 429 st->priv_data = nst; 430 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; 431 st->codecpar->codec_tag = vtag; 432 st->codecpar->codec_id = ff_codec_get_id(nsv_codec_video_tags, vtag); 433 st->codecpar->width = vwidth; 434 st->codecpar->height = vheight; 435 st->codecpar->bits_per_coded_sample = 24; /* depth XXX */ 436 437 avpriv_set_pts_info(st, 64, framerate.den, framerate.num); 438 st->start_time = 0; 439 st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den); 440 441 for(i=0;i<nsv->index_entries;i++) { 442 if(nsv->nsvs_timestamps) { 443 av_add_index_entry(st, nsv->nsvs_file_offset[i], nsv->nsvs_timestamps[i], 444 0, 0, AVINDEX_KEYFRAME); 445 } else { 446 int64_t ts = av_rescale(i*nsv->duration/nsv->index_entries, framerate.num, 1000*framerate.den); 447 av_add_index_entry(st, nsv->nsvs_file_offset[i], ts, 0, 0, AVINDEX_KEYFRAME); 448 } 449 } 450 } 451 if (atag != T_NONE) { 452 st = avformat_new_stream(s, NULL); 453 if (!st) 454 goto fail; 455 456 st->id = NSV_ST_AUDIO; 457 nst = av_mallocz(sizeof(NSVStream)); 458 if (!nst) 459 goto fail; 460 st->priv_data = nst; 461 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; 462 st->codecpar->codec_tag = atag; 463 st->codecpar->codec_id = ff_codec_get_id(nsv_codec_audio_tags, atag); 464 465 st->need_parsing = AVSTREAM_PARSE_FULL; /* for PCM we will read a chunk later and put correct info */ 466 467 /* set timebase to common denominator of ms and framerate */ 468 avpriv_set_pts_info(st, 64, 1, framerate.num*1000); 469 st->start_time = 0; 470 st->duration = (int64_t)nsv->duration * framerate.num; 471 } 472 } else { 473 if (nsv->vtag != vtag || nsv->atag != atag || nsv->vwidth != vwidth || nsv->vheight != vwidth) { 474 av_log(s, AV_LOG_TRACE, "NSV NSVs header values differ from the first one!!!\n"); 475 //return -1; 476 } 477 } 478 479 nsv->state = NSV_HAS_READ_NSVS; 480 return 0; 481fail: 482 /* XXX */ 483 nsv->state = NSV_UNSYNC; 484 return -1; 485} 486 487static int nsv_read_header(AVFormatContext *s) 488{ 489 NSVContext *nsv = s->priv_data; 490 int i, err; 491 492 nsv->state = NSV_UNSYNC; 493 nsv->ahead[0].data = nsv->ahead[1].data = NULL; 494 495 for (i = 0; i < NSV_MAX_RESYNC_TRIES; i++) { 496 err = nsv_resync(s); 497 if (err < 0) 498 goto fail; 499 if (nsv->state == NSV_FOUND_NSVF) { 500 err = nsv_parse_NSVf_header(s); 501 if (err < 0) 502 goto fail; 503 } 504 /* we need the first NSVs also... */ 505 if (nsv->state == NSV_FOUND_NSVS) { 506 err = nsv_parse_NSVs_header(s); 507 if (err < 0) 508 goto fail; 509 break; /* we just want the first one */ 510 } 511 } 512 if (s->nb_streams < 1) { /* no luck so far */ 513 err = AVERROR_INVALIDDATA; 514 goto fail; 515 } 516 517 /* now read the first chunk, so we can attempt to decode more info */ 518 err = nsv_read_chunk(s, 1); 519fail: 520 if (err < 0) 521 nsv_read_close(s); 522 523 av_log(s, AV_LOG_TRACE, "parsed header\n"); 524 return err; 525} 526 527static int nsv_read_chunk(AVFormatContext *s, int fill_header) 528{ 529 NSVContext *nsv = s->priv_data; 530 AVIOContext *pb = s->pb; 531 AVStream *st[2] = {NULL, NULL}; 532 NSVStream *nst; 533 AVPacket *pkt; 534 int i, err = 0; 535 uint8_t auxcount; /* number of aux metadata, also 4 bits of vsize */ 536 uint32_t vsize; 537 uint16_t asize; 538 uint16_t auxsize; 539 int ret; 540 541 if (nsv->ahead[0].data || nsv->ahead[1].data) 542 return 0; //-1; /* hey! eat what you've in your plate first! */ 543 544null_chunk_retry: 545 if (avio_feof(pb)) 546 return -1; 547 548 for (i = 0; i < NSV_MAX_RESYNC_TRIES && nsv->state < NSV_FOUND_NSVS && !err; i++) 549 err = nsv_resync(s); 550 if (err < 0) 551 return err; 552 if (nsv->state == NSV_FOUND_NSVS) 553 err = nsv_parse_NSVs_header(s); 554 if (err < 0) 555 return err; 556 if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF) 557 return -1; 558 559 auxcount = avio_r8(pb); 560 vsize = avio_rl16(pb); 561 asize = avio_rl16(pb); 562 vsize = (vsize << 4) | (auxcount >> 4); 563 auxcount &= 0x0f; 564 av_log(s, AV_LOG_TRACE, "NSV CHUNK %d aux, %"PRIu32" bytes video, %d bytes audio\n", auxcount, vsize, asize); 565 /* skip aux stuff */ 566 for (i = 0; i < auxcount; i++) { 567 uint32_t av_unused auxtag; 568 auxsize = avio_rl16(pb); 569 auxtag = avio_rl32(pb); 570 avio_skip(pb, auxsize); 571 vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming brain-dead */ 572 } 573 574 if (avio_feof(pb)) 575 return -1; 576 if (!vsize && !asize) { 577 nsv->state = NSV_UNSYNC; 578 goto null_chunk_retry; 579 } 580 581 /* map back streams to v,a */ 582 if (s->nb_streams > 0) 583 st[s->streams[0]->id] = s->streams[0]; 584 if (s->nb_streams > 1) 585 st[s->streams[1]->id] = s->streams[1]; 586 587 if (vsize && st[NSV_ST_VIDEO]) { 588 nst = st[NSV_ST_VIDEO]->priv_data; 589 pkt = &nsv->ahead[NSV_ST_VIDEO]; 590 if ((ret = av_get_packet(pb, pkt, vsize)) < 0) 591 return ret; 592 pkt->stream_index = st[NSV_ST_VIDEO]->index;//NSV_ST_VIDEO; 593 pkt->dts = nst->frame_offset; 594 pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */ 595 for (i = 0; i < FFMIN(8, vsize); i++) 596 av_log(s, AV_LOG_TRACE, "NSV video: [%d] = %02x\n", i, pkt->data[i]); 597 } 598 if(st[NSV_ST_VIDEO]) 599 ((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset++; 600 601 if (asize && st[NSV_ST_AUDIO]) { 602 nst = st[NSV_ST_AUDIO]->priv_data; 603 pkt = &nsv->ahead[NSV_ST_AUDIO]; 604 /* read raw audio specific header on the first audio chunk... */ 605 /* on ALL audio chunks ?? seems so! */ 606 if (asize && st[NSV_ST_AUDIO]->codecpar->codec_tag == MKTAG('P', 'C', 'M', ' ')/* && fill_header*/) { 607 uint8_t bps; 608 uint8_t channels; 609 uint16_t samplerate; 610 bps = avio_r8(pb); 611 channels = avio_r8(pb); 612 samplerate = avio_rl16(pb); 613 if (!channels || !samplerate) 614 return AVERROR_INVALIDDATA; 615 asize-=4; 616 av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate); 617 if (fill_header) { 618 st[NSV_ST_AUDIO]->need_parsing = AVSTREAM_PARSE_NONE; /* we know everything */ 619 if (bps != 16) { 620 av_log(s, AV_LOG_TRACE, "NSV AUDIO bit/sample != 16 (%d)!!!\n", bps); 621 } 622 bps /= channels; // ??? 623 if (bps == 8) 624 st[NSV_ST_AUDIO]->codecpar->codec_id = AV_CODEC_ID_PCM_U8; 625 samplerate /= 4;/* UGH ??? XXX */ 626 channels = 1; 627 st[NSV_ST_AUDIO]->codecpar->channels = channels; 628 st[NSV_ST_AUDIO]->codecpar->sample_rate = samplerate; 629 av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate); 630 } 631 } 632 if ((ret = av_get_packet(pb, pkt, asize)) < 0) 633 return ret; 634 pkt->stream_index = st[NSV_ST_AUDIO]->index;//NSV_ST_AUDIO; 635 pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */ 636 if( nsv->state == NSV_HAS_READ_NSVS && st[NSV_ST_VIDEO] ) { 637 /* on a nsvs frame we have new information on a/v sync */ 638 pkt->dts = (((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset-1); 639 pkt->dts *= (int64_t)1000 * nsv->framerate.den; 640 pkt->dts += (int64_t)nsv->avsync * nsv->framerate.num; 641 av_log(s, AV_LOG_TRACE, "NSV AUDIO: sync:%d, dts:%"PRId64, nsv->avsync, pkt->dts); 642 } 643 nst->frame_offset++; 644 } 645 646 nsv->state = NSV_UNSYNC; 647 return 0; 648} 649 650 651static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt) 652{ 653 NSVContext *nsv = s->priv_data; 654 int i, err = 0; 655 656 /* in case we don't already have something to eat ... */ 657 if (!nsv->ahead[0].data && !nsv->ahead[1].data) 658 err = nsv_read_chunk(s, 0); 659 if (err < 0) 660 return err; 661 662 /* now pick one of the plates */ 663 for (i = 0; i < 2; i++) { 664 if (nsv->ahead[i].data) { 665 av_packet_move_ref(pkt, &nsv->ahead[i]); 666 return 0; 667 } 668 } 669 670 /* this restaurant is not provisioned :^] */ 671 return -1; 672} 673 674static int nsv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) 675{ 676 NSVContext *nsv = s->priv_data; 677 AVStream *st = s->streams[stream_index]; 678 NSVStream *nst = st->priv_data; 679 int index; 680 681 index = av_index_search_timestamp(st, timestamp, flags); 682 if(index < 0) 683 return -1; 684 685 if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0) 686 return -1; 687 688 nst->frame_offset = st->index_entries[index].timestamp; 689 nsv->state = NSV_UNSYNC; 690 return 0; 691} 692 693static int nsv_read_close(AVFormatContext *s) 694{ 695 NSVContext *nsv = s->priv_data; 696 697 av_freep(&nsv->nsvs_file_offset); 698 av_freep(&nsv->nsvs_timestamps); 699 if (nsv->ahead[0].data) 700 av_packet_unref(&nsv->ahead[0]); 701 if (nsv->ahead[1].data) 702 av_packet_unref(&nsv->ahead[1]); 703 return 0; 704} 705 706static int nsv_probe(const AVProbeData *p) 707{ 708 int i, score = 0; 709 710 /* check file header */ 711 /* streamed files might not have any header */ 712 if (p->buf[0] == 'N' && p->buf[1] == 'S' && 713 p->buf[2] == 'V' && (p->buf[3] == 'f' || p->buf[3] == 's')) 714 return AVPROBE_SCORE_MAX; 715 /* XXX: do streamed files always start at chunk boundary ?? */ 716 /* or do we need to search NSVs in the byte stream ? */ 717 /* seems the servers don't bother starting clean chunks... */ 718 /* sometimes even the first header is at 9KB or something :^) */ 719 for (i = 1; i < p->buf_size - 3; i++) { 720 if (AV_RL32(p->buf + i) == AV_RL32("NSVs")) { 721 /* Get the chunk size and check if at the end we are getting 0xBEEF */ 722 int vsize = AV_RL24(p->buf+i+19) >> 4; 723 int asize = AV_RL16(p->buf+i+22); 724 int offset = i + 23 + asize + vsize + 1; 725 if (offset <= p->buf_size - 2 && AV_RL16(p->buf + offset) == 0xBEEF) 726 return 4*AVPROBE_SCORE_MAX/5; 727 score = AVPROBE_SCORE_MAX/5; 728 } 729 } 730 /* so we'll have more luck on extension... */ 731 if (av_match_ext(p->filename, "nsv")) 732 return AVPROBE_SCORE_EXTENSION; 733 /* FIXME: add mime-type check */ 734 return score; 735} 736 737AVInputFormat ff_nsv_demuxer = { 738 .name = "nsv", 739 .long_name = NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"), 740 .priv_data_size = sizeof(NSVContext), 741 .read_probe = nsv_probe, 742 .read_header = nsv_read_header, 743 .read_packet = nsv_read_packet, 744 .read_close = nsv_read_close, 745 .read_seek = nsv_read_seek, 746};