~ubuntu-branches/ubuntu/utopic/libav/utopic

* 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

* except for nstrailer (which doesn't have an NSVf header), it repports correct time.

* nsvtrailer.nsv (S1) does not have any NSVf header, only NSVs chunks,

* so the header seems to not be mandatory. (for streaming).

* 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

#ifdef DEBUG

#define PRINT(_v) printf _v

#else

#define PRINT(_v)

#endif

#if 0

struct NSVf_header {

uint32_t chunk_tag; /* 'NSVf' */

uint32_t chunk_size;

uint32_t file_size; /* max 4GB ??? no one learns anything it seems :^) */

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 */

};

100

101

struct NSVs_header {

102

uint32_t chunk_tag; /* 'NSVs' */

103

uint32_t v4cc; /* or 'NONE' */

104

uint32_t a4cc; /* or 'NONE' */

105

uint16_t vwidth; /* assert(vwidth%16==0) */

106

uint16_t vheight; /* assert(vheight%16==0) */

107

uint8_t framerate; /* value = (framerate&0x80)?frtable[frameratex0x7f]:framerate */

108

uint16_t unknown;

109

};

110

111

struct nsv_avchunk_header {

112

uint8_t vchunk_size_lsb;

113

uint16_t vchunk_size_msb; /* value = (vchunk_size_msb << 4) | (vchunk_size_lsb >> 4) */

114

uint16_t achunk_size;

115

};

116

117

struct nsv_pcm_header {

118

uint8_t bits_per_sample;

119

uint8_t channel_count;

120

uint16_t sample_rate;

121

};

122

#endif

123

124

/* variation from avi.h */

125

/*typedef struct CodecTag {

126

int id;

127

unsigned int tag;

128

} CodecTag;*/

129

130

/* tags */

131

132

#define T_NSVF MKTAG('N', 'S', 'V', 'f') /* file header */

133

#define T_NSVS MKTAG('N', 'S', 'V', 's') /* chunk header */

134

#define T_TOC2 MKTAG('T', 'O', 'C', '2') /* extra index marker */

135

#define T_NONE MKTAG('N', 'O', 'N', 'E') /* null a/v 4CC */

136

#define T_SUBT MKTAG('S', 'U', 'B', 'T') /* subtitle aux data */

137

#define T_ASYN MKTAG('A', 'S', 'Y', 'N') /* async a/v aux marker */

138

#define T_KEYF MKTAG('K', 'E', 'Y', 'F') /* video keyframe aux marker (addition) */

139

140

#define TB_NSVF MKBETAG('N', 'S', 'V', 'f')

141

#define TB_NSVS MKBETAG('N', 'S', 'V', 's')

142

143

/* hardcoded stream indexes */

144

#define NSV_ST_VIDEO 0

145

#define NSV_ST_AUDIO 1

146

#define NSV_ST_SUBT 2

147

148

enum NSVStatus {

149

NSV_UNSYNC,

150

NSV_FOUND_NSVF,

151

NSV_HAS_READ_NSVF,

152

NSV_FOUND_NSVS,

153

NSV_HAS_READ_NSVS,

154

NSV_FOUND_BEEF,

155

NSV_GOT_VIDEO,

156

NSV_GOT_AUDIO,

157

};

158

159

typedef struct NSVStream {

160

int frame_offset; /* current frame (video) or byte (audio) counter

161

(used to compute the pts) */

162

int scale;

163

int rate;

164

int sample_size; /* audio only data */

165

int start;

166

167

int new_frame_offset; /* temporary storage (used during seek) */

168

int cum_len; /* temporary storage (used during seek) */

169

} NSVStream;

170

171

typedef struct {

172

int base_offset;

173

int NSVf_end;

174

uint32_t *nsvs_file_offset;

175

int index_entries;

176

enum NSVStatus state;

177

AVPacket ahead[2]; /* [v, a] if .data is !NULL there is something */

178

/* cached */

179

int64_t duration;

180

uint32_t vtag, atag;

181

uint16_t vwidth, vheight;

182

int16_t avsync;

183

AVRational framerate;

184

uint32_t *nsvs_timestamps;

185

//DVDemuxContext* dv_demux;

186

} NSVContext;

187

188

static const AVCodecTag nsv_codec_video_tags[] = {

189

{ CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') },

190

{ CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },

191

{ CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },

192

{ CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },

193

{ CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },

194

{ CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') },

195

{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },

196

{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },

197

{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },

198

199

{ CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },

200

{ CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },

201

202

{ CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */

203

{ CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },

204

{ CODEC_ID_NONE, 0 },

205

};

206

207

static const AVCodecTag nsv_codec_audio_tags[] = {

208

{ CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },

209

{ CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') },

210

{ CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') },

211

{ CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') },

212

{ CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') },

213

{ CODEC_ID_NONE, 0 },

214

};

215

216

//static int nsv_load_index(AVFormatContext *s);

217

static int nsv_read_chunk(AVFormatContext *s, int fill_header);

218

219

#ifdef DEBUG

220

static void print_tag(const char *str, unsigned int tag, int size)

221

{

222

printf("%s: tag=%c%c%c%c\n",

223

str, tag & 0xff,

224

(tag >> 8) & 0xff,

225

(tag >> 16) & 0xff,

226

(tag >> 24) & 0xff);

227

}

228

#endif

229

230

/* try to find something we recognize, and set the state accordingly */

231

static int nsv_resync(AVFormatContext *s)

232

{

233

NSVContext *nsv = s->priv_data;

234

ByteIOContext *pb = s->pb;

235

uint32_t v = 0;

236

int i;

237

238

PRINT(("%s(), offset = %"PRId64", state = %d\n", __FUNCTION__, url_ftell(pb), nsv->state));

239

240

//nsv->state = NSV_UNSYNC;

241

242

for (i = 0; i < NSV_MAX_RESYNC; i++) {

243

if (url_feof(pb)) {

244

PRINT(("NSV EOF\n"));

245

nsv->state = NSV_UNSYNC;

246

return -1;

247

}

248

v <<= 8;

249

v |= get_byte(pb);

250

251

if (i < 8) {

252

PRINT(("NSV resync: [%d] = %02x\n", i, v & 0x0FF));

253

}

254

255

256

if ((v & 0x0000ffff) == 0xefbe) { /* BEEF */

257

PRINT(("NSV resynced on BEEF after %d bytes\n", i+1));

258

nsv->state = NSV_FOUND_BEEF;

259

return 0;

260

}

261

/* we read as big endian, thus the MK*BE* */

262

if (v == TB_NSVF) { /* NSVf */

263

PRINT(("NSV resynced on NSVf after %d bytes\n", i+1));

264

nsv->state = NSV_FOUND_NSVF;

265

return 0;

266

}

267

if (v == MKBETAG('N', 'S', 'V', 's')) { /* NSVs */

268

PRINT(("NSV resynced on NSVs after %d bytes\n", i+1));

269

nsv->state = NSV_FOUND_NSVS;

270

return 0;

271

}

272

273

}

274

PRINT(("NSV sync lost\n"));

275

return -1;

276

}

277

278

static int nsv_parse_NSVf_header(AVFormatContext *s, AVFormatParameters *ap)

279

{

280

NSVContext *nsv = s->priv_data;

281

ByteIOContext *pb = s->pb;

282

unsigned int file_size, size;

283

int64_t duration;

284

int strings_size;

285

int table_entries;

286

int table_entries_used;

287

288

PRINT(("%s()\n", __FUNCTION__));

289

290

nsv->state = NSV_UNSYNC; /* in case we fail */

291

292

size = get_le32(pb);

293

if (size < 28)

294

return -1;

295

nsv->NSVf_end = size;

296

297

//s->file_size = (uint32_t)get_le32(pb);

298

file_size = (uint32_t)get_le32(pb);

299

PRINT(("NSV NSVf chunk_size %u\n", size));

300

PRINT(("NSV NSVf file_size %u\n", file_size));

301

302

nsv->duration = duration = get_le32(pb); /* in ms */

303

PRINT(("NSV NSVf duration %"PRId64" ms\n", duration));

304

// XXX: store it in AVStreams

305

306

strings_size = get_le32(pb);

307

table_entries = get_le32(pb);

308

table_entries_used = get_le32(pb);

309

PRINT(("NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",

310

strings_size, table_entries, table_entries_used));

311

if (url_feof(pb))

312

return -1;

313

314

PRINT(("NSV got header; filepos %"PRId64"\n", url_ftell(pb)));

315

316

if (strings_size > 0) {

317

char *strings; /* last byte will be '\0' to play safe with str*() */

318

char *p, *endp;

319

char *token, *value;

320

char quote;

321

322

p = strings = av_mallocz(strings_size + 1);

323

endp = strings + strings_size;

324

get_buffer(pb, strings, strings_size);

325

while (p < endp) {

326

while (*p == ' ')

327

p++; /* strip out spaces */

328

if (p >= endp-2)

329

break;

330

token = p;

331

p = strchr(p, '=');

332

if (!p || p >= endp-2)

333

break;

334

*p++ = '\0';

335

quote = *p++;

336

value = p;

337

p = strchr(p, quote);

338

if (!p || p >= endp)

339

break;

340

*p++ = '\0';

341

PRINT(("NSV NSVf INFO: %s='%s'\n", token, value));

342

av_metadata_set2(&s->metadata, token, value, 0);

343

}

344

av_free(strings);

345

}

346

if (url_feof(pb))

347

return -1;

348

349

PRINT(("NSV got infos; filepos %"PRId64"\n", url_ftell(pb)));

350

351

if (table_entries_used > 0) {

352

int i;

353

nsv->index_entries = table_entries_used;

354

if((unsigned)table_entries_used >= UINT_MAX / sizeof(uint32_t))

355

return -1;

356

nsv->nsvs_file_offset = av_malloc((unsigned)table_entries_used * sizeof(uint32_t));

357

358

for(i=0;i<table_entries_used;i++)

359

nsv->nsvs_file_offset[i] = get_le32(pb) + size;

360

361

if(table_entries > table_entries_used &&

362

get_le32(pb) == MKTAG('T','O','C','2')) {

363

nsv->nsvs_timestamps = av_malloc((unsigned)table_entries_used*sizeof(uint32_t));

364

for(i=0;i<table_entries_used;i++) {

365

nsv->nsvs_timestamps[i] = get_le32(pb);

366

}

367

}

368

}

369

370

PRINT(("NSV got index; filepos %"PRId64"\n", url_ftell(pb)));

371

372

#ifdef DEBUG_DUMP_INDEX

373

#define V(v) ((v<0x20 || v > 127)?'.':v)

374

/* dump index */

375

PRINT(("NSV %d INDEX ENTRIES:\n", table_entries));

376

PRINT(("NSV [dataoffset][fileoffset]\n", table_entries));

377

for (i = 0; i < table_entries; i++) {

378

unsigned char b[8];

379

url_fseek(pb, size + nsv->nsvs_file_offset[i], SEEK_SET);

380

get_buffer(pb, b, 8);

381

PRINT(("NSV [0x%08lx][0x%08lx]: %02x %02x %02x %02x %02x %02x %02x %02x"

382

"%c%c%c%c%c%c%c%c\n",

383

nsv->nsvs_file_offset[i], size + nsv->nsvs_file_offset[i],

384

b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7],

385

V(b[0]), V(b[1]), V(b[2]), V(b[3]), V(b[4]), V(b[5]), V(b[6]), V(b[7]) ));

386

}

387

//url_fseek(pb, size, SEEK_SET); /* go back to end of header */

388

#undef V

389

#endif

390

391

url_fseek(pb, nsv->base_offset + size, SEEK_SET); /* required for dumbdriving-271.nsv (2 extra bytes) */

392

393

if (url_feof(pb))

394

return -1;

395

nsv->state = NSV_HAS_READ_NSVF;

396

return 0;

397

}

398

399

static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)

400

{

401

NSVContext *nsv = s->priv_data;

402

ByteIOContext *pb = s->pb;

403

uint32_t vtag, atag;

404

uint16_t vwidth, vheight;

405

AVRational framerate;

406

int i;

407

AVStream *st;

408

NSVStream *nst;

409

PRINT(("%s()\n", __FUNCTION__));

410

411

vtag = get_le32(pb);

412

atag = get_le32(pb);

413

vwidth = get_le16(pb);

414

vheight = get_le16(pb);

415

i = get_byte(pb);

416

417

PRINT(("NSV NSVs framerate code %2x\n", i));

418

if(i&0x80) { /* odd way of giving native framerates from docs */

419

int t=(i & 0x7F)>>2;

420

if(t<16) framerate = (AVRational){1, t+1};

421

else framerate = (AVRational){t-15, 1};

422

423

if(i&1){

424

framerate.num *= 1000;

425

framerate.den *= 1001;

426

}

427

428

if((i&3)==3) framerate.num *= 24;

429

else if((i&3)==2) framerate.num *= 25;

430

else framerate.num *= 30;

431

}

432

else

433

framerate= (AVRational){i, 1};

434

435

nsv->avsync = get_le16(pb);

436

nsv->framerate = framerate;

437

#ifdef DEBUG

438

print_tag("NSV NSVs vtag", vtag, 0);

439

print_tag("NSV NSVs atag", atag, 0);

440

PRINT(("NSV NSVs vsize %dx%d\n", vwidth, vheight));

441

#endif

442

443

/* XXX change to ap != NULL ? */

444

if (s->nb_streams == 0) { /* streams not yet published, let's do that */

445

nsv->vtag = vtag;

446

nsv->atag = atag;

447

nsv->vwidth = vwidth;

448

nsv->vheight = vwidth;

449

if (vtag != T_NONE) {

450

int i;

451

st = av_new_stream(s, NSV_ST_VIDEO);

452

if (!st)

453

goto fail;

454

455

nst = av_mallocz(sizeof(NSVStream));

456

if (!nst)

457

goto fail;

458

st->priv_data = nst;

459

st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

460

st->codec->codec_tag = vtag;

461

st->codec->codec_id = ff_codec_get_id(nsv_codec_video_tags, vtag);

462

st->codec->width = vwidth;

463

st->codec->height = vheight;

464

st->codec->bits_per_coded_sample = 24; /* depth XXX */

465

466

av_set_pts_info(st, 64, framerate.den, framerate.num);

467

st->start_time = 0;

468

st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den);

469

470

for(i=0;i<nsv->index_entries;i++) {

471

if(nsv->nsvs_timestamps) {

472

av_add_index_entry(st, nsv->nsvs_file_offset[i], nsv->nsvs_timestamps[i],

473

0, 0, AVINDEX_KEYFRAME);

474

} else {

475

int64_t ts = av_rescale(i*nsv->duration/nsv->index_entries, framerate.num, 1000*framerate.den);

476

av_add_index_entry(st, nsv->nsvs_file_offset[i], ts, 0, 0, AVINDEX_KEYFRAME);

477

}

478

}

479

}

480

if (atag != T_NONE) {

481

#ifndef DISABLE_AUDIO

482

st = av_new_stream(s, NSV_ST_AUDIO);

483

if (!st)

484

goto fail;

485

486

nst = av_mallocz(sizeof(NSVStream));

487

if (!nst)

488

goto fail;

489

st->priv_data = nst;

490

st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

491

st->codec->codec_tag = atag;

492

st->codec->codec_id = ff_codec_get_id(nsv_codec_audio_tags, atag);

493

494

st->need_parsing = AVSTREAM_PARSE_FULL; /* for PCM we will read a chunk later and put correct info */

495

496

/* set timebase to common denominator of ms and framerate */

497

av_set_pts_info(st, 64, 1, framerate.num*1000);

498

st->start_time = 0;

499

st->duration = (int64_t)nsv->duration * framerate.num;

500

#endif

501

}

502

#ifdef CHECK_SUBSEQUENT_NSVS

503

} else {

504

if (nsv->vtag != vtag || nsv->atag != atag || nsv->vwidth != vwidth || nsv->vheight != vwidth) {

505

PRINT(("NSV NSVs header values differ from the first one!!!\n"));

506

//return -1;

507

}

508

#endif /* CHECK_SUBSEQUENT_NSVS */

509

}

510

511

nsv->state = NSV_HAS_READ_NSVS;

512

return 0;

513

fail:

514

/* XXX */

515

nsv->state = NSV_UNSYNC;

516

return -1;

517

}

518

519

static int nsv_read_header(AVFormatContext *s, AVFormatParameters *ap)

520

{

521

NSVContext *nsv = s->priv_data;

522

int i, err;

523

524

PRINT(("%s()\n", __FUNCTION__));

525

PRINT(("filename '%s'\n", s->filename));

526

527

nsv->state = NSV_UNSYNC;

528

nsv->ahead[0].data = nsv->ahead[1].data = NULL;

529

530

for (i = 0; i < NSV_MAX_RESYNC_TRIES; i++) {

531

if (nsv_resync(s) < 0)

532

return -1;

533

if (nsv->state == NSV_FOUND_NSVF)

534

err = nsv_parse_NSVf_header(s, ap);

535

/* we need the first NSVs also... */

536

if (nsv->state == NSV_FOUND_NSVS) {

537

err = nsv_parse_NSVs_header(s, ap);

538

break; /* we just want the first one */

539

}

540

}

541

if (s->nb_streams < 1) /* no luck so far */

542

return -1;

543

/* now read the first chunk, so we can attempt to decode more info */

544

err = nsv_read_chunk(s, 1);

545

546

PRINT(("parsed header\n"));

547

return 0;

548

}

549

550

static int nsv_read_chunk(AVFormatContext *s, int fill_header)

551

{

552

NSVContext *nsv = s->priv_data;

553

ByteIOContext *pb = s->pb;

554

AVStream *st[2] = {NULL, NULL};

555

NSVStream *nst;

556

AVPacket *pkt;

557

int i, err = 0;

558

uint8_t auxcount; /* number of aux metadata, also 4 bits of vsize */

559

uint32_t vsize;

560

uint16_t asize;

561

uint16_t auxsize;

562

uint32_t auxtag;

563

564

PRINT(("%s(%d)\n", __FUNCTION__, fill_header));

565

566

if (nsv->ahead[0].data || nsv->ahead[1].data)

567

return 0; //-1; /* hey! eat what you've in your plate first! */

568

569

null_chunk_retry:

570

if (url_feof(pb))

571

return -1;

572

573

for (i = 0; i < NSV_MAX_RESYNC_TRIES && nsv->state < NSV_FOUND_NSVS && !err; i++)

574

err = nsv_resync(s);

575

if (err < 0)

576

return err;

577

if (nsv->state == NSV_FOUND_NSVS)

578

err = nsv_parse_NSVs_header(s, NULL);

579

if (err < 0)

580

return err;

581

if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF)

582

return -1;

583

584

auxcount = get_byte(pb);

585

vsize = get_le16(pb);

586

asize = get_le16(pb);

587

vsize = (vsize << 4) | (auxcount >> 4);

588

auxcount &= 0x0f;

589

PRINT(("NSV CHUNK %d aux, %u bytes video, %d bytes audio\n", auxcount, vsize, asize));

590

/* skip aux stuff */

591

for (i = 0; i < auxcount; i++) {

592

auxsize = get_le16(pb);

593

auxtag = get_le32(pb);

594

PRINT(("NSV aux data: '%c%c%c%c', %d bytes\n",

595

(auxtag & 0x0ff),

596

((auxtag >> 8) & 0x0ff),

597

((auxtag >> 16) & 0x0ff),

598

((auxtag >> 24) & 0x0ff),

599

auxsize));

600

url_fskip(pb, auxsize);

601

vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming braindead */

602

}

603

604

if (url_feof(pb))

605

return -1;

606

if (!vsize && !asize) {

607

nsv->state = NSV_UNSYNC;

608

goto null_chunk_retry;

609

}

610

611

/* map back streams to v,a */

612

if (s->streams[0])

613

st[s->streams[0]->id] = s->streams[0];

614

if (s->streams[1])

615

st[s->streams[1]->id] = s->streams[1];

616

617

if (vsize/* && st[NSV_ST_VIDEO]*/) {

618

nst = st[NSV_ST_VIDEO]->priv_data;

619

pkt = &nsv->ahead[NSV_ST_VIDEO];

620

av_get_packet(pb, pkt, vsize);

621

pkt->stream_index = st[NSV_ST_VIDEO]->index;//NSV_ST_VIDEO;

622

pkt->dts = nst->frame_offset;

623

pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */

624

625

for (i = 0; i < MIN(8, vsize); i++)

626

PRINT(("NSV video: [%d] = %02x\n", i, pkt->data[i]));

627

628

}

629

if(st[NSV_ST_VIDEO])

630

((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset++;

631

632

if (asize/*st[NSV_ST_AUDIO]*/) {

633

nst = st[NSV_ST_AUDIO]->priv_data;

634

pkt = &nsv->ahead[NSV_ST_AUDIO];

635

/* read raw audio specific header on the first audio chunk... */

636

/* on ALL audio chunks ?? seems so! */

637

if (asize && st[NSV_ST_AUDIO]->codec->codec_tag == MKTAG('P', 'C', 'M', ' ')/* && fill_header*/) {

638

uint8_t bps;

639

uint8_t channels;

640

uint16_t samplerate;

641

bps = get_byte(pb);

642

channels = get_byte(pb);

643

samplerate = get_le16(pb);

644

asize-=4;

645

PRINT(("NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate));

646

if (fill_header) {

647

st[NSV_ST_AUDIO]->need_parsing = AVSTREAM_PARSE_NONE; /* we know everything */

648

if (bps != 16) {

649

PRINT(("NSV AUDIO bit/sample != 16 (%d)!!!\n", bps));

650

}

651

bps /= channels; // ???

652

if (bps == 8)

653

st[NSV_ST_AUDIO]->codec->codec_id = CODEC_ID_PCM_U8;

654

samplerate /= 4;/* UGH ??? XXX */

655

channels = 1;

656

st[NSV_ST_AUDIO]->codec->channels = channels;

657

st[NSV_ST_AUDIO]->codec->sample_rate = samplerate;

658

PRINT(("NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate));

659

}

660

}

661

av_get_packet(pb, pkt, asize);

662

pkt->stream_index = st[NSV_ST_AUDIO]->index;//NSV_ST_AUDIO;

663

pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */

664

if( nsv->state == NSV_HAS_READ_NSVS && st[NSV_ST_VIDEO] ) {

665

/* on a nsvs frame we have new information on a/v sync */

666

pkt->dts = (((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset-1);

667

pkt->dts *= (int64_t)1000 * nsv->framerate.den;

668

pkt->dts += (int64_t)nsv->avsync * nsv->framerate.num;

669

PRINT(("NSV AUDIO: sync:%d, dts:%"PRId64, nsv->avsync, pkt->dts));

670

}

671

nst->frame_offset++;

672

}

673

674

nsv->state = NSV_UNSYNC;

675

return 0;

676

}

677

678

679

static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt)

680

{

681

NSVContext *nsv = s->priv_data;

682

int i, err = 0;

683

684

PRINT(("%s()\n", __FUNCTION__));

685

686

/* in case we don't already have something to eat ... */

687

if (nsv->ahead[0].data == NULL && nsv->ahead[1].data == NULL)

688

err = nsv_read_chunk(s, 0);

689

if (err < 0)

690

return err;

691

692

/* now pick one of the plates */

693

for (i = 0; i < 2; i++) {

694

if (nsv->ahead[i].data) {

695

PRINT(("%s: using cached packet[%d]\n", __FUNCTION__, i));

696

/* avoid the cost of new_packet + memcpy(->data) */

697

memcpy(pkt, &nsv->ahead[i], sizeof(AVPacket));

698

nsv->ahead[i].data = NULL; /* we ate that one */

699

return pkt->size;

700

}

701

}

702

703

/* this restaurant is not approvisionned :^] */

704

return -1;

705

}

706

707

static int nsv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

708

{

709

NSVContext *nsv = s->priv_data;

710

AVStream *st = s->streams[stream_index];

711

NSVStream *nst = st->priv_data;

712

int index;

713

714

index = av_index_search_timestamp(st, timestamp, flags);

715

if(index < 0)

716

return -1;

717

718

url_fseek(s->pb, st->index_entries[index].pos, SEEK_SET);

719

nst->frame_offset = st->index_entries[index].timestamp;

720

nsv->state = NSV_UNSYNC;

721

return 0;

722

}

723

724

static int nsv_read_close(AVFormatContext *s)

725

{

726

/* int i; */

727

NSVContext *nsv = s->priv_data;

728

729

av_freep(&nsv->nsvs_file_offset);

730

av_freep(&nsv->nsvs_timestamps);

731

if (nsv->ahead[0].data)

732

av_free_packet(&nsv->ahead[0]);

733

if (nsv->ahead[1].data)

734

av_free_packet(&nsv->ahead[1]);

735

736

#if 0

737

738

for(i=0;i<s->nb_streams;i++) {

739

AVStream *st = s->streams[i];

740

NSVStream *ast = st->priv_data;

741

if(ast){

742

av_free(ast->index_entries);

743

av_free(ast);

744

}

745

av_free(st->codec->palctrl);

746

}

747

748

#endif

749

return 0;

750

}

751

752

static int nsv_probe(AVProbeData *p)

753

{

754

int i;

755

// PRINT(("nsv_probe(), buf_size %d\n", p->buf_size));

756

/* check file header */

757

/* streamed files might not have any header */

758

if (p->buf[0] == 'N' && p->buf[1] == 'S' &&

759

p->buf[2] == 'V' && (p->buf[3] == 'f' || p->buf[3] == 's'))

760

return AVPROBE_SCORE_MAX;

761

/* XXX: do streamed files always start at chunk boundary ?? */

762

/* or do we need to search NSVs in the byte stream ? */

763

/* seems the servers don't bother starting clean chunks... */

764

/* sometimes even the first header is at 9KB or something :^) */

765

for (i = 1; i < p->buf_size - 3; i++) {

766

if (p->buf[i+0] == 'N' && p->buf[i+1] == 'S' &&

767

p->buf[i+2] == 'V' && p->buf[i+3] == 's')

768

return AVPROBE_SCORE_MAX-20;

769

}

770

/* so we'll have more luck on extension... */

771

if (av_match_ext(p->filename, "nsv"))

772

return AVPROBE_SCORE_MAX/2;

773

/* FIXME: add mime-type check */

774

return 0;

775

}

776

777

AVInputFormat nsv_demuxer = {

778

"nsv",

779

NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),

780

sizeof(NSVContext),

781

nsv_probe,

782

nsv_read_header,

783

nsv_read_packet,

784

nsv_read_close,

785

nsv_read_seek,

786

};

Older »