00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "avformat.h"
00022 #include "riff.h"
00023
00024
00025
00026
00027 #define CHECK_SUBSEQUENT_NSVS
00028
00029
00030
00031
00032
00033 #define NSV_MAX_RESYNC (500*1024)
00034 #define NSV_MAX_RESYNC_TRIES 300
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084 #ifdef DEBUG
00085 #define PRINT(_v) printf _v
00086 #else
00087 #define PRINT(_v)
00088 #endif
00089
00090 #if 0
00091 struct NSVf_header {
00092 uint32_t chunk_tag;
00093 uint32_t chunk_size;
00094 uint32_t file_size;
00095 uint32_t file_length;
00096 uint32_t info_strings_size;
00097 uint32_t table_entries;
00098 uint32_t table_entries_used;
00099 };
00100
00101 struct NSVs_header {
00102 uint32_t chunk_tag;
00103 uint32_t v4cc;
00104 uint32_t a4cc;
00105 uint16_t vwidth;
00106 uint16_t vheight;
00107 uint8_t framerate;
00108 uint16_t unknown;
00109 };
00110
00111 struct nsv_avchunk_header {
00112 uint8_t vchunk_size_lsb;
00113 uint16_t vchunk_size_msb;
00114 uint16_t achunk_size;
00115 };
00116
00117 struct nsv_pcm_header {
00118 uint8_t bits_per_sample;
00119 uint8_t channel_count;
00120 uint16_t sample_rate;
00121 };
00122 #endif
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132 #define T_NSVF MKTAG('N', 'S', 'V', 'f')
00133 #define T_NSVS MKTAG('N', 'S', 'V', 's')
00134 #define T_TOC2 MKTAG('T', 'O', 'C', '2')
00135 #define T_NONE MKTAG('N', 'O', 'N', 'E')
00136 #define T_SUBT MKTAG('S', 'U', 'B', 'T')
00137 #define T_ASYN MKTAG('A', 'S', 'Y', 'N')
00138 #define T_KEYF MKTAG('K', 'E', 'Y', 'F')
00139
00140 #define TB_NSVF MKBETAG('N', 'S', 'V', 'f')
00141 #define TB_NSVS MKBETAG('N', 'S', 'V', 's')
00142
00143
00144 #define NSV_ST_VIDEO 0
00145 #define NSV_ST_AUDIO 1
00146 #define NSV_ST_SUBT 2
00147
00148 enum NSVStatus {
00149 NSV_UNSYNC,
00150 NSV_FOUND_NSVF,
00151 NSV_HAS_READ_NSVF,
00152 NSV_FOUND_NSVS,
00153 NSV_HAS_READ_NSVS,
00154 NSV_FOUND_BEEF,
00155 NSV_GOT_VIDEO,
00156 NSV_GOT_AUDIO,
00157 };
00158
00159 typedef struct NSVStream {
00160 int frame_offset;
00161
00162 int scale;
00163 int rate;
00164 int sample_size;
00165 int start;
00166
00167 int new_frame_offset;
00168 int cum_len;
00169 } NSVStream;
00170
00171 typedef struct {
00172 int base_offset;
00173 int NSVf_end;
00174 uint32_t *nsvs_file_offset;
00175 int index_entries;
00176 enum NSVStatus state;
00177 AVPacket ahead[2];
00178
00179 int64_t duration;
00180 uint32_t vtag, atag;
00181 uint16_t vwidth, vheight;
00182 int16_t avsync;
00183 AVRational framerate;
00184 uint32_t *nsvs_timestamps;
00185
00186 } NSVContext;
00187
00188 static const AVCodecTag nsv_codec_video_tags[] = {
00189 { CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') },
00190 { CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
00191 { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
00192 { CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },
00193 { CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
00194 { CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') },
00195 { CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
00196 { CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
00197 { CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
00198
00199
00200
00201
00202 { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
00203 { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },
00204 { CODEC_ID_NONE, 0 },
00205 };
00206
00207 static const AVCodecTag nsv_codec_audio_tags[] = {
00208 { CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
00209 { CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') },
00210 { CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') },
00211 { CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') },
00212 { CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') },
00213 { CODEC_ID_NONE, 0 },
00214 };
00215
00216
00217 static int nsv_read_chunk(AVFormatContext *s, int fill_header);
00218
00219 #ifdef DEBUG
00220 static void print_tag(const char *str, unsigned int tag, int size)
00221 {
00222 printf("%s: tag=%c%c%c%c\n",
00223 str, tag & 0xff,
00224 (tag >> 8) & 0xff,
00225 (tag >> 16) & 0xff,
00226 (tag >> 24) & 0xff);
00227 }
00228 #endif
00229
00230
00231 static int nsv_resync(AVFormatContext *s)
00232 {
00233 NSVContext *nsv = s->priv_data;
00234 ByteIOContext *pb = s->pb;
00235 uint32_t v = 0;
00236 int i;
00237
00238 PRINT(("%s(), offset = %"PRId64", state = %d\n", __FUNCTION__, url_ftell(pb), nsv->state));
00239
00240
00241
00242 for (i = 0; i < NSV_MAX_RESYNC; i++) {
00243 if (url_feof(pb)) {
00244 PRINT(("NSV EOF\n"));
00245 nsv->state = NSV_UNSYNC;
00246 return -1;
00247 }
00248 v <<= 8;
00249 v |= get_byte(pb);
00250
00251
00252
00253
00254
00255
00256 if ((v & 0x0000ffff) == 0xefbe) {
00257 PRINT(("NSV resynced on BEEF after %d bytes\n", i+1));
00258 nsv->state = NSV_FOUND_BEEF;
00259 return 0;
00260 }
00261
00262 if (v == TB_NSVF) {
00263 PRINT(("NSV resynced on NSVf after %d bytes\n", i+1));
00264 nsv->state = NSV_FOUND_NSVF;
00265 return 0;
00266 }
00267 if (v == MKBETAG('N', 'S', 'V', 's')) {
00268 PRINT(("NSV resynced on NSVs after %d bytes\n", i+1));
00269 nsv->state = NSV_FOUND_NSVS;
00270 return 0;
00271 }
00272
00273 }
00274 PRINT(("NSV sync lost\n"));
00275 return -1;
00276 }
00277
00278 static int nsv_parse_NSVf_header(AVFormatContext *s, AVFormatParameters *ap)
00279 {
00280 NSVContext *nsv = s->priv_data;
00281 ByteIOContext *pb = s->pb;
00282 unsigned int file_size, size;
00283 int64_t duration;
00284 int strings_size;
00285 int table_entries;
00286 int table_entries_used;
00287
00288 PRINT(("%s()\n", __FUNCTION__));
00289
00290 nsv->state = NSV_UNSYNC;
00291
00292 size = get_le32(pb);
00293 if (size < 28)
00294 return -1;
00295 nsv->NSVf_end = size;
00296
00297
00298 file_size = (uint32_t)get_le32(pb);
00299 PRINT(("NSV NSVf chunk_size %u\n", size));
00300 PRINT(("NSV NSVf file_size %u\n", file_size));
00301
00302 nsv->duration = duration = get_le32(pb);
00303 PRINT(("NSV NSVf duration %"PRId64" ms\n", duration));
00304
00305
00306 strings_size = get_le32(pb);
00307 table_entries = get_le32(pb);
00308 table_entries_used = get_le32(pb);
00309 PRINT(("NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",
00310 strings_size, table_entries, table_entries_used));
00311 if (url_feof(pb))
00312 return -1;
00313
00314 PRINT(("NSV got header; filepos %"PRId64"\n", url_ftell(pb)));
00315
00316 if (strings_size > 0) {
00317 char *strings;
00318 char *p, *endp;
00319 char *token, *value;
00320 char quote;
00321
00322 p = strings = av_mallocz(strings_size + 1);
00323 endp = strings + strings_size;
00324 get_buffer(pb, strings, strings_size);
00325 while (p < endp) {
00326 while (*p == ' ')
00327 p++;
00328 if (p >= endp-2)
00329 break;
00330 token = p;
00331 p = strchr(p, '=');
00332 if (!p || p >= endp-2)
00333 break;
00334 *p++ = '\0';
00335 quote = *p++;
00336 value = p;
00337 p = strchr(p, quote);
00338 if (!p || p >= endp)
00339 break;
00340 *p++ = '\0';
00341 PRINT(("NSV NSVf INFO: %s='%s'\n", token, value));
00342 av_metadata_set2(&s->metadata, token, value, 0);
00343 }
00344 av_free(strings);
00345 }
00346 if (url_feof(pb))
00347 return -1;
00348
00349 PRINT(("NSV got infos; filepos %"PRId64"\n", url_ftell(pb)));
00350
00351 if (table_entries_used > 0) {
00352 int i;
00353 nsv->index_entries = table_entries_used;
00354 if((unsigned)table_entries_used >= UINT_MAX / sizeof(uint32_t))
00355 return -1;
00356 nsv->nsvs_file_offset = av_malloc((unsigned)table_entries_used * sizeof(uint32_t));
00357
00358 for(i=0;i<table_entries_used;i++)
00359 nsv->nsvs_file_offset[i] = get_le32(pb) + size;
00360
00361 if(table_entries > table_entries_used &&
00362 get_le32(pb) == MKTAG('T','O','C','2')) {
00363 nsv->nsvs_timestamps = av_malloc((unsigned)table_entries_used*sizeof(uint32_t));
00364 for(i=0;i<table_entries_used;i++) {
00365 nsv->nsvs_timestamps[i] = get_le32(pb);
00366 }
00367 }
00368 }
00369
00370 PRINT(("NSV got index; filepos %"PRId64"\n", url_ftell(pb)));
00371
00372 #ifdef DEBUG_DUMP_INDEX
00373 #define V(v) ((v<0x20 || v > 127)?'.':v)
00374
00375 PRINT(("NSV %d INDEX ENTRIES:\n", table_entries));
00376 PRINT(("NSV [dataoffset][fileoffset]\n", table_entries));
00377 for (i = 0; i < table_entries; i++) {
00378 unsigned char b[8];
00379 url_fseek(pb, size + nsv->nsvs_file_offset[i], SEEK_SET);
00380 get_buffer(pb, b, 8);
00381 PRINT(("NSV [0x%08lx][0x%08lx]: %02x %02x %02x %02x %02x %02x %02x %02x"
00382 "%c%c%c%c%c%c%c%c\n",
00383 nsv->nsvs_file_offset[i], size + nsv->nsvs_file_offset[i],
00384 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7],
00385 V(b[0]), V(b[1]), V(b[2]), V(b[3]), V(b[4]), V(b[5]), V(b[6]), V(b[7]) ));
00386 }
00387
00388 #undef V
00389 #endif
00390
00391 url_fseek(pb, nsv->base_offset + size, SEEK_SET);
00392
00393 if (url_feof(pb))
00394 return -1;
00395 nsv->state = NSV_HAS_READ_NSVF;
00396 return 0;
00397 }
00398
00399 static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)
00400 {
00401 NSVContext *nsv = s->priv_data;
00402 ByteIOContext *pb = s->pb;
00403 uint32_t vtag, atag;
00404 uint16_t vwidth, vheight;
00405 AVRational framerate;
00406 int i;
00407 AVStream *st;
00408 NSVStream *nst;
00409 PRINT(("%s()\n", __FUNCTION__));
00410
00411 vtag = get_le32(pb);
00412 atag = get_le32(pb);
00413 vwidth = get_le16(pb);
00414 vheight = get_le16(pb);
00415 i = get_byte(pb);
00416
00417 PRINT(("NSV NSVs framerate code %2x\n", i));
00418 if(i&0x80) {
00419 int t=(i & 0x7F)>>2;
00420 if(t<16) framerate = (AVRational){1, t+1};
00421 else framerate = (AVRational){t-15, 1};
00422
00423 if(i&1){
00424 framerate.num *= 1000;
00425 framerate.den *= 1001;
00426 }
00427
00428 if((i&3)==3) framerate.num *= 24;
00429 else if((i&3)==2) framerate.num *= 25;
00430 else framerate.num *= 30;
00431 }
00432 else
00433 framerate= (AVRational){i, 1};
00434
00435 nsv->avsync = get_le16(pb);
00436 nsv->framerate = framerate;
00437 #ifdef DEBUG
00438 print_tag("NSV NSVs vtag", vtag, 0);
00439 print_tag("NSV NSVs atag", atag, 0);
00440 PRINT(("NSV NSVs vsize %dx%d\n", vwidth, vheight));
00441 #endif
00442
00443
00444 if (s->nb_streams == 0) {
00445 nsv->vtag = vtag;
00446 nsv->atag = atag;
00447 nsv->vwidth = vwidth;
00448 nsv->vheight = vwidth;
00449 if (vtag != T_NONE) {
00450 int i;
00451 st = av_new_stream(s, NSV_ST_VIDEO);
00452 if (!st)
00453 goto fail;
00454
00455 nst = av_mallocz(sizeof(NSVStream));
00456 if (!nst)
00457 goto fail;
00458 st->priv_data = nst;
00459 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
00460 st->codec->codec_tag = vtag;
00461 st->codec->codec_id = ff_codec_get_id(nsv_codec_video_tags, vtag);
00462 st->codec->width = vwidth;
00463 st->codec->height = vheight;
00464 st->codec->bits_per_coded_sample = 24;
00465
00466 av_set_pts_info(st, 64, framerate.den, framerate.num);
00467 st->start_time = 0;
00468 st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den);
00469
00470 for(i=0;i<nsv->index_entries;i++) {
00471 if(nsv->nsvs_timestamps) {
00472 av_add_index_entry(st, nsv->nsvs_file_offset[i], nsv->nsvs_timestamps[i],
00473 0, 0, AVINDEX_KEYFRAME);
00474 } else {
00475 int64_t ts = av_rescale(i*nsv->duration/nsv->index_entries, framerate.num, 1000*framerate.den);
00476 av_add_index_entry(st, nsv->nsvs_file_offset[i], ts, 0, 0, AVINDEX_KEYFRAME);
00477 }
00478 }
00479 }
00480 if (atag != T_NONE) {
00481 #ifndef DISABLE_AUDIO
00482 st = av_new_stream(s, NSV_ST_AUDIO);
00483 if (!st)
00484 goto fail;
00485
00486 nst = av_mallocz(sizeof(NSVStream));
00487 if (!nst)
00488 goto fail;
00489 st->priv_data = nst;
00490 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
00491 st->codec->codec_tag = atag;
00492 st->codec->codec_id = ff_codec_get_id(nsv_codec_audio_tags, atag);
00493
00494 st->need_parsing = AVSTREAM_PARSE_FULL;
00495
00496
00497 av_set_pts_info(st, 64, 1, framerate.num*1000);
00498 st->start_time = 0;
00499 st->duration = (int64_t)nsv->duration * framerate.num;
00500 #endif
00501 }
00502 #ifdef CHECK_SUBSEQUENT_NSVS
00503 } else {
00504 if (nsv->vtag != vtag || nsv->atag != atag || nsv->vwidth != vwidth || nsv->vheight != vwidth) {
00505 PRINT(("NSV NSVs header values differ from the first one!!!\n"));
00506
00507 }
00508 #endif
00509 }
00510
00511 nsv->state = NSV_HAS_READ_NSVS;
00512 return 0;
00513 fail:
00514
00515 nsv->state = NSV_UNSYNC;
00516 return -1;
00517 }
00518
00519 static int nsv_read_header(AVFormatContext *s, AVFormatParameters *ap)
00520 {
00521 NSVContext *nsv = s->priv_data;
00522 int i, err;
00523
00524 PRINT(("%s()\n", __FUNCTION__));
00525 PRINT(("filename '%s'\n", s->filename));
00526
00527 nsv->state = NSV_UNSYNC;
00528 nsv->ahead[0].data = nsv->ahead[1].data = NULL;
00529
00530 for (i = 0; i < NSV_MAX_RESYNC_TRIES; i++) {
00531 if (nsv_resync(s) < 0)
00532 return -1;
00533 if (nsv->state == NSV_FOUND_NSVF)
00534 err = nsv_parse_NSVf_header(s, ap);
00535
00536 if (nsv->state == NSV_FOUND_NSVS) {
00537 err = nsv_parse_NSVs_header(s, ap);
00538 break;
00539 }
00540 }
00541 if (s->nb_streams < 1)
00542 return -1;
00543
00544 err = nsv_read_chunk(s, 1);
00545
00546 PRINT(("parsed header\n"));
00547 return 0;
00548 }
00549
00550 static int nsv_read_chunk(AVFormatContext *s, int fill_header)
00551 {
00552 NSVContext *nsv = s->priv_data;
00553 ByteIOContext *pb = s->pb;
00554 AVStream *st[2] = {NULL, NULL};
00555 NSVStream *nst;
00556 AVPacket *pkt;
00557 int i, err = 0;
00558 uint8_t auxcount;
00559 uint32_t vsize;
00560 uint16_t asize;
00561 uint16_t auxsize;
00562 uint32_t auxtag;
00563
00564 PRINT(("%s(%d)\n", __FUNCTION__, fill_header));
00565
00566 if (nsv->ahead[0].data || nsv->ahead[1].data)
00567 return 0;
00568
00569 null_chunk_retry:
00570 if (url_feof(pb))
00571 return -1;
00572
00573 for (i = 0; i < NSV_MAX_RESYNC_TRIES && nsv->state < NSV_FOUND_NSVS && !err; i++)
00574 err = nsv_resync(s);
00575 if (err < 0)
00576 return err;
00577 if (nsv->state == NSV_FOUND_NSVS)
00578 err = nsv_parse_NSVs_header(s, NULL);
00579 if (err < 0)
00580 return err;
00581 if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF)
00582 return -1;
00583
00584 auxcount = get_byte(pb);
00585 vsize = get_le16(pb);
00586 asize = get_le16(pb);
00587 vsize = (vsize << 4) | (auxcount >> 4);
00588 auxcount &= 0x0f;
00589 PRINT(("NSV CHUNK %d aux, %u bytes video, %d bytes audio\n", auxcount, vsize, asize));
00590
00591 for (i = 0; i < auxcount; i++) {
00592 auxsize = get_le16(pb);
00593 auxtag = get_le32(pb);
00594 PRINT(("NSV aux data: '%c%c%c%c', %d bytes\n",
00595 (auxtag & 0x0ff),
00596 ((auxtag >> 8) & 0x0ff),
00597 ((auxtag >> 16) & 0x0ff),
00598 ((auxtag >> 24) & 0x0ff),
00599 auxsize));
00600 url_fskip(pb, auxsize);
00601 vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t);
00602 }
00603
00604 if (url_feof(pb))
00605 return -1;
00606 if (!vsize && !asize) {
00607 nsv->state = NSV_UNSYNC;
00608 goto null_chunk_retry;
00609 }
00610
00611
00612 if (s->streams[0])
00613 st[s->streams[0]->id] = s->streams[0];
00614 if (s->streams[1])
00615 st[s->streams[1]->id] = s->streams[1];
00616
00617 if (vsize) {
00618 nst = st[NSV_ST_VIDEO]->priv_data;
00619 pkt = &nsv->ahead[NSV_ST_VIDEO];
00620 av_get_packet(pb, pkt, vsize);
00621 pkt->stream_index = st[NSV_ST_VIDEO]->index;
00622 pkt->dts = nst->frame_offset;
00623 pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0;
00624
00625
00626
00627
00628 }
00629 if(st[NSV_ST_VIDEO])
00630 ((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset++;
00631
00632 if (asize) {
00633 nst = st[NSV_ST_AUDIO]->priv_data;
00634 pkt = &nsv->ahead[NSV_ST_AUDIO];
00635
00636
00637 if (asize && st[NSV_ST_AUDIO]->codec->codec_tag == MKTAG('P', 'C', 'M', ' ')) {
00638 uint8_t bps;
00639 uint8_t channels;
00640 uint16_t samplerate;
00641 bps = get_byte(pb);
00642 channels = get_byte(pb);
00643 samplerate = get_le16(pb);
00644 asize-=4;
00645 PRINT(("NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate));
00646 if (fill_header) {
00647 st[NSV_ST_AUDIO]->need_parsing = AVSTREAM_PARSE_NONE;
00648 if (bps != 16) {
00649 PRINT(("NSV AUDIO bit/sample != 16 (%d)!!!\n", bps));
00650 }
00651 bps /= channels;
00652 if (bps == 8)
00653 st[NSV_ST_AUDIO]->codec->codec_id = CODEC_ID_PCM_U8;
00654 samplerate /= 4;
00655 channels = 1;
00656 st[NSV_ST_AUDIO]->codec->channels = channels;
00657 st[NSV_ST_AUDIO]->codec->sample_rate = samplerate;
00658 PRINT(("NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate));
00659 }
00660 }
00661 av_get_packet(pb, pkt, asize);
00662 pkt->stream_index = st[NSV_ST_AUDIO]->index;
00663 pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0;
00664 if( nsv->state == NSV_HAS_READ_NSVS && st[NSV_ST_VIDEO] ) {
00665
00666 pkt->dts = (((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset-1);
00667 pkt->dts *= (int64_t)1000 * nsv->framerate.den;
00668 pkt->dts += (int64_t)nsv->avsync * nsv->framerate.num;
00669 PRINT(("NSV AUDIO: sync:%d, dts:%"PRId64, nsv->avsync, pkt->dts));
00670 }
00671 nst->frame_offset++;
00672 }
00673
00674 nsv->state = NSV_UNSYNC;
00675 return 0;
00676 }
00677
00678
00679 static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt)
00680 {
00681 NSVContext *nsv = s->priv_data;
00682 int i, err = 0;
00683
00684 PRINT(("%s()\n", __FUNCTION__));
00685
00686
00687 if (nsv->ahead[0].data == NULL && nsv->ahead[1].data == NULL)
00688 err = nsv_read_chunk(s, 0);
00689 if (err < 0)
00690 return err;
00691
00692
00693 for (i = 0; i < 2; i++) {
00694 if (nsv->ahead[i].data) {
00695 PRINT(("%s: using cached packet[%d]\n", __FUNCTION__, i));
00696
00697 memcpy(pkt, &nsv->ahead[i], sizeof(AVPacket));
00698 nsv->ahead[i].data = NULL;
00699 return pkt->size;
00700 }
00701 }
00702
00703
00704 return -1;
00705 }
00706
00707 static int nsv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
00708 {
00709 NSVContext *nsv = s->priv_data;
00710 AVStream *st = s->streams[stream_index];
00711 NSVStream *nst = st->priv_data;
00712 int index;
00713
00714 index = av_index_search_timestamp(st, timestamp, flags);
00715 if(index < 0)
00716 return -1;
00717
00718 url_fseek(s->pb, st->index_entries[index].pos, SEEK_SET);
00719 nst->frame_offset = st->index_entries[index].timestamp;
00720 nsv->state = NSV_UNSYNC;
00721 return 0;
00722 }
00723
00724 static int nsv_read_close(AVFormatContext *s)
00725 {
00726
00727 NSVContext *nsv = s->priv_data;
00728
00729 av_freep(&nsv->nsvs_file_offset);
00730 av_freep(&nsv->nsvs_timestamps);
00731 if (nsv->ahead[0].data)
00732 av_free_packet(&nsv->ahead[0]);
00733 if (nsv->ahead[1].data)
00734 av_free_packet(&nsv->ahead[1]);
00735
00736 #if 0
00737
00738 for(i=0;i<s->nb_streams;i++) {
00739 AVStream *st = s->streams[i];
00740 NSVStream *ast = st->priv_data;
00741 if(ast){
00742 av_free(ast->index_entries);
00743 av_free(ast);
00744 }
00745 av_free(st->codec->palctrl);
00746 }
00747
00748 #endif
00749 return 0;
00750 }
00751
00752 static int nsv_probe(AVProbeData *p)
00753 {
00754 int i;
00755
00756
00757
00758 if (p->buf[0] == 'N' && p->buf[1] == 'S' &&
00759 p->buf[2] == 'V' && (p->buf[3] == 'f' || p->buf[3] == 's'))
00760 return AVPROBE_SCORE_MAX;
00761
00762
00763
00764
00765 for (i = 1; i < p->buf_size - 3; i++) {
00766 if (p->buf[i+0] == 'N' && p->buf[i+1] == 'S' &&
00767 p->buf[i+2] == 'V' && p->buf[i+3] == 's')
00768 return AVPROBE_SCORE_MAX-20;
00769 }
00770
00771 if (av_match_ext(p->filename, "nsv"))
00772 return AVPROBE_SCORE_MAX/2;
00773
00774 return 0;
00775 }
00776
00777 AVInputFormat nsv_demuxer = {
00778 "nsv",
00779 NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
00780 sizeof(NSVContext),
00781 nsv_probe,
00782 nsv_read_header,
00783 nsv_read_packet,
00784 nsv_read_close,
00785 nsv_read_seek,
00786 };