static uint64_t align_to_next_packet(BLURAY *bd, uint8_t *pkt)
{
uint8_t buf[MAX_HOLE];
uint64_t pos = 0;
uint64_t start = bd_tell(bd);
uint64_t orig;
uint64_t off = 192;
memcpy(buf, pkt, 192);
if ( start >= 192 ) {
start -= 192;
}
orig = start;
while (1)
{
if (bd_read(bd, buf+off, sizeof(buf)-off) == sizeof(buf)-off)
{
const uint8_t *bp = buf;
int i;
for ( i = sizeof(buf) - 8 * 192; --i >= 0; ++bp )
{
if ( have_ts_sync( bp, 192 ) )
{
break;
}
}
if ( i >= 0 )
{
pos = ( bp - buf );
break;
}
off = 8 * 192;
memcpy(buf, buf + sizeof(buf) - off, off);
start += sizeof(buf) - off;
}
else
{
return 0;
}
}
off = start + pos - 4;
// bd_seek seeks to the nearest access unit *before* the requested position
// we don't want to seek backwards, so we need to read until we get
// past that position.
bd_seek(bd, off);
while (off > bd_tell(bd))
{
if (bd_read(bd, buf, 192) != 192)
{
break;
}
}
return start - orig + pos;
}
int BDRingBuffer::safe_read(void *data, uint sz)
{
int result = 0;
if (m_isHDMVNavigation)
{
HandleBDEvents();
while (result == 0)
{
BD_EVENT event;
result = bd_read_ext(bdnav,
(unsigned char *)data,
sz, &event);
HandleBDEvent(event);
if (result == 0)
HandleBDEvents();
}
}
else
{
result = bd_read(bdnav, (unsigned char *)data, sz);
}
m_currentTime = bd_tell(bdnav);
return result;
}
static int next_packet( BLURAY *bd, uint8_t *pkt )
{
int result;
while ( 1 )
{
result = bd_read( bd, pkt, 192 );
if ( result < 0 )
{
return -1;
}
if ( result < 192 )
{
return 0;
}
// Sync byte is byte 4. 0-3 are timestamp.
if (pkt[4] == 0x47)
{
return 1;
}
// lost sync - back up to where we started then try to re-establish.
uint64_t pos = bd_tell(bd);
uint64_t pos2 = align_to_next_packet(bd, pkt);
if ( pos2 == 0 )
{
hb_log( "next_packet: eof while re-establishing sync @ %"PRId64, pos );
return 0;
}
hb_log( "next_packet: sync lost @ %"PRId64", regained after %"PRId64" bytes",
pos, pos2 );
}
}
int64_t CBDDemuxer::BDByteStreamSeek(void *opaque, int64_t offset, int whence)
{
CBDDemuxer *demux = (CBDDemuxer *)opaque;
BLURAY *bd = demux->m_pBD;
int64_t pos = 0;
if (whence == SEEK_SET) {
pos = offset;
} else if (whence == SEEK_CUR) {
if (offset == 0)
return bd_tell(bd);
pos = bd_tell(bd) + offset;
} else if (whence == SEEK_END) {
pos = bd_get_title_size(bd) - offset;
} else if (whence == AVSEEK_SIZE) {
return bd_get_title_size(bd);
} else
return -1;
if (pos < 0)
pos = 0;
int64_t achieved = bd_seek(bd, pos);
if (pos > achieved) {
offset = pos - achieved;
DbgLog((LOG_TRACE, 10, L"BD Seek to %I64d, achieved %I64d, correcting target by %I64d", pos, achieved, offset));
uint8_t *dump_buffer = (uint8_t *)CoTaskMemAlloc(6144);
while (offset > 0) {
bd_read(bd, dump_buffer, min(offset, 6144));
offset -= 6144;
}
CoTaskMemFree(dump_buffer);
achieved = bd_tell(bd);
}
return achieved;
}
/*
* Print out each valid partition in the disklabel of a FreeBSD slice.
* For size calculations, we assume a 512 byte sector size.
*/
static int
bd_printbsdslice(struct open_disk *od, daddr_t offset, char *prefix,
int verbose)
{
char line[80];
char buf[BIOSDISK_SECSIZE];
struct disklabel *lp;
int i;
/* read disklabel */
if (bd_read(od, offset + LABELSECTOR, 1, buf))
return (0);
lp =(struct disklabel *)(&buf[0]);
if (lp->d_magic != DISKMAGIC) {
sprintf(line, "%s: FFS bad disklabel\n", prefix);
return (pager_output(line));
}
/* Print partitions */
for (i = 0; i < lp->d_npartitions; i++) {
/*
* For each partition, make sure we know what type of fs it is. If
* not, then skip it. However, since floppies often have bogus
* fstypes, print the 'a' partition on a floppy even if it is marked
* unused.
*/
if ((lp->d_partitions[i].p_fstype == FS_BSDFFS) ||
(lp->d_partitions[i].p_fstype == FS_SWAP) ||
(lp->d_partitions[i].p_fstype == FS_VINUM) ||
((lp->d_partitions[i].p_fstype == FS_UNUSED) &&
(od->od_flags & BD_FLOPPY) && (i == 0))) {
/* Only print out statistics in verbose mode */
if (verbose)
sprintf(line, " %s%c: %s %s (%d - %d)\n", prefix, 'a' + i,
(lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap " :
(lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
"FFS ",
display_size(lp->d_partitions[i].p_size),
lp->d_partitions[i].p_offset,
lp->d_partitions[i].p_offset + lp->d_partitions[i].p_size);
else
sprintf(line, " %s%c: %s\n", prefix, 'a' + i,
(lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap" :
(lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
"FFS");
if (pager_output(line))
return (1);
}
}
return (0);
}
int bd_readlink(const char *pPathLien, char *pBuffer, int sizeBuffer) {
int iNode = find_iNode(pPathLien);
if (iNode == -1) {
return iNode;
}
int isSymlink = is_symlink(iNode);
if (isSymlink == -1) {
return -1;
}
int linesRead = bd_read(pPathLien, pBuffer, 0, sizeBuffer);
return linesRead;
}
static int
bd_realstrategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
{
struct open_disk *od = (struct open_disk *)(((struct i386_devdesc *)devdata)->d_kind.biosdisk.data);
int blks;
#ifdef BD_SUPPORT_FRAGS
char fragbuf[BIOSDISK_SECSIZE];
size_t fragsize;
fragsize = size % BIOSDISK_SECSIZE;
#else
if (size % BIOSDISK_SECSIZE)
panic("bd_strategy: %d bytes I/O not multiple of block size", size);
#endif
DEBUG("open_disk %p", od);
blks = size / BIOSDISK_SECSIZE;
if (rsize)
*rsize = 0;
switch(rw){
case F_READ:
DEBUG("read %d from %d to %p", blks, dblk, buf);
if (blks && bd_read(od, dblk, blks, buf)) {
DEBUG("read error");
return (EIO);
}
#ifdef BD_SUPPORT_FRAGS
DEBUG("bd_strategy: frag read %d from %d+%d to %p",
fragsize, dblk, blks, buf + (blks * BIOSDISK_SECSIZE));
if (fragsize && bd_read(od, dblk + blks, 1, fragsize)) {
DEBUG("frag read error");
return(EIO);
}
bcopy(fragbuf, buf + (blks * BIOSDISK_SECSIZE), fragsize);
#endif
break;
case F_WRITE :
DEBUG("write %d from %d to %p", blks, dblk, buf);
if (blks && bd_write(od, dblk, blks, buf)) {
DEBUG("write error");
return (EIO);
}
#ifdef BD_SUPPORT_FRAGS
if(fragsize) {
DEBUG("Attempted to write a frag");
return (EIO);
}
#endif
break;
default:
/* DO NOTHING */
return (EROFS);
}
if (rsize)
*rsize = size;
return (0);
}
static int
bd_open_pc98(struct open_disk *od, struct i386_devdesc *dev)
{
struct pc98_partition *dptr;
struct disklabel *lp;
int sector, slice, i;
char buf[BUFSIZE];
/*
* Following calculations attempt to determine the correct value
* for d->od_boff by looking for the slice and partition specified,
* or searching for reasonable defaults.
*/
/*
* Find the slice in the DOS slice table.
*/
od->od_nslices = 0;
if (od->od_flags & BD_FLOPPY) {
sector = 0;
goto unsliced;
}
if (bd_read(od, 0, 1, buf)) {
DEBUG("error reading MBR");
return (EIO);
}
/*
* Check the slice table magic.
*/
if (((u_char)buf[0x1fe] != 0x55) || ((u_char)buf[0x1ff] != 0xaa)) {
/* If a slice number was explicitly supplied, this is an error */
if (dev->d_kind.biosdisk.slice > 0) {
DEBUG("no slice table/MBR (no magic)");
return (ENOENT);
}
sector = 0;
goto unsliced; /* may be a floppy */
}
if (bd_read(od, 1, 1, buf)) {
DEBUG("error reading MBR");
return (EIO);
}
/*
* copy the partition table, then pick up any extended partitions.
*/
bcopy(buf + DOSPARTOFF, &od->od_slicetab,
sizeof(struct pc98_partition) * NDOSPART);
od->od_nslices = NDOSPART; /* extended slices start here */
od->od_flags |= BD_PARTTABOK;
dptr = &od->od_slicetab[0];
/* Is this a request for the whole disk? */
if (dev->d_kind.biosdisk.slice == -1) {
sector = 0;
goto unsliced;
}
/*
* if a slice number was supplied but not found, this is an error.
*/
if (dev->d_kind.biosdisk.slice > 0) {
slice = dev->d_kind.biosdisk.slice - 1;
if (slice >= od->od_nslices) {
DEBUG("slice %d not found", slice);
return (ENOENT);
}
}
/* Try to auto-detect the best slice; this should always give a slice number */
if (dev->d_kind.biosdisk.slice == 0) {
slice = bd_bestslice(od);
if (slice == -1) {
return (ENOENT);
}
dev->d_kind.biosdisk.slice = slice;
}
dptr = &od->od_slicetab[0];
/*
* Accept the supplied slice number unequivocally (we may be looking
* at a DOS partition).
*/
dptr += (dev->d_kind.biosdisk.slice - 1); /* we number 1-4, offsets are 0-3 */
sector = dptr->dp_scyl * od->od_hds * od->od_sec +
dptr->dp_shd * od->od_sec + dptr->dp_ssect;
{
int end = dptr->dp_ecyl * od->od_hds * od->od_sec +
dptr->dp_ehd * od->od_sec + dptr->dp_esect;
DEBUG("slice entry %d at %d, %d sectors",
dev->d_kind.biosdisk.slice - 1, sector, end-sector);
}
/*
* If we are looking at a BSD slice, and the partition is < 0, assume the 'a' partition
*/
if ((dptr->dp_mid == DOSMID_386BSD) && (dev->d_kind.biosdisk.partition < 0))
dev->d_kind.biosdisk.partition = 0;
unsliced:
/*
* Now we have the slice offset, look for the partition in the disklabel if we have
* a partition to start with.
*
* XXX we might want to check the label checksum.
*/
if (dev->d_kind.biosdisk.partition < 0) {
od->od_boff = sector; /* no partition, must be after the slice */
DEBUG("opening raw slice");
} else {
if (bd_read(od, sector + LABELSECTOR, 1, buf)) {
DEBUG("error reading disklabel");
return (EIO);
}
DEBUG("copy %d bytes of label from %p to %p", sizeof(struct disklabel), buf + LABELOFFSET, &od->od_disklabel);
bcopy(buf + LABELOFFSET, &od->od_disklabel, sizeof(struct disklabel));
lp = &od->od_disklabel;
od->od_flags |= BD_LABELOK;
if (lp->d_magic != DISKMAGIC) {
DEBUG("no disklabel");
return (ENOENT);
}
if (dev->d_kind.biosdisk.partition >= lp->d_npartitions) {
DEBUG("partition '%c' exceeds partitions in table (a-'%c')",
'a' + dev->d_kind.biosdisk.partition, 'a' + lp->d_npartitions);
return (EPART);
}
#ifdef DISK_DEBUG
/* Complain if the partition is unused unless this is a floppy. */
if ((lp->d_partitions[dev->d_kind.biosdisk.partition].p_fstype == FS_UNUSED) &&
!(od->od_flags & BD_FLOPPY))
DEBUG("warning, partition marked as unused");
#endif
od->od_boff =
lp->d_partitions[dev->d_kind.biosdisk.partition].p_offset -
lp->d_partitions[RAW_PART].p_offset +
sector;
}
return (0);
}
int CBDDemuxer::BDByteStreamRead(void *opaque, uint8_t *buf, int buf_size)
{
CBDDemuxer *demux = (CBDDemuxer *)opaque;
return bd_read(demux->m_pBD, buf, buf_size);
}
int main(int argc, char **argv) {
int index;
int RetVal = -99;
if ((argc < 2) || (argc > 5)) {
printf("On doit fournir entre 2 et 5 arguments a ufs!\n");
return -1;
}
printf("\n");
// Imprimer la commande a l'ecran
for (index=1; index<argc; index++) {
printf("%s ",argv[index]);
}
printf("\n");
// ========== commande truncate() =============
if (strcmp(argv[1],"truncate")==0) {
if (argc!=4) {
printf("La commande truncate demande 2 arguments!\n");
printf(" ufs truncate nom_fichier taille\n");
return 1;
}
RetVal = bd_truncate(argv[2], atoi(argv[3]));
} // ========== commande blockfree() =============
else if (strcmp(argv[1],"blockfree")==0) {
if (argc!=2) {
printf("La commande blockfree demande 0 arguments!\n");
printf(" ufs blockfree\n");
return 1;
}
RetVal = bd_countfreeblocks(argv[2], argv[3]);
} // ========== commande read() =============
else if (strcmp(argv[1],"read")==0) {
if (argc!=5) {
printf("La commande read demande 3 arguments!\n");
printf(" ufs read nom_fichier offset numbytes\n");
return 1;
}
char Donnees[65536];
RetVal = bd_read(argv[2],Donnees,atoi(argv[3]),atoi(argv[4]));
for (index=0; index<RetVal; index++) { printf("%c",Donnees[index]); }
printf("\n");
} // ========== commande write() =============
else if (strcmp(argv[1],"write")==0) {
if (argc!=5) {
printf("La commande write demande 3 arguments!\n");
printf(" ufs write nom_fichier \"Chaine de caractere\" offset\n");
return 1;
}
RetVal = bd_write(argv[2],argv[3],atoi(argv[4]),strlen(argv[3]));
} // ========== commande bd_stat() =============
else if (strcmp(argv[1],"stat")==0) {
if (argc!=3) {
printf("La commande stat demande 1 arguments!\n");
printf(" ufs stat nom_fichier\n");
return 1;
}
stat MyStat;
RetVal = bd_stat(argv[2], &MyStat);
printf("inode:%d size:%d blocks:%d\n",MyStat.st_ino, MyStat.st_size, MyStat.st_blocks);
} // ========== commande bd_ls() =============
else if (strcmp(argv[1],"ls")==0) {
if (argc!=3) {
printf("La commande ls demande 1 arguments!\n");
printf(" ufs ls nom_repertoire\n");
return 1;
}
RetVal = bd_ls(argv[2]);
}
else {
printf("Impossible de trouver la commande %s\n",argv[1]);
return -1;
}
printf("RetVal:%d\n",RetVal);
return 0;
}
int
main(int argc, char *argv[])
{
int title_no = -1;
int playlist = -1;
int angle = 0;
char *bdpath = NULL, *dest = NULL;
FILE *out;
int opt;
int verbose = 0;
int64_t total = 0;
int64_t pos, end_pos = -1;
size_t size, wrote;
int bytes;
int title_count;
BLURAY *bd;
int chapter_start = 0;
int chapter_end = -1;
uint8_t buf[BUF_SIZE];
char *keyfile = NULL;
BLURAY_TITLE_INFO *ti;
do {
opt = getopt(argc, argv, OPTS);
switch (opt) {
case -1:
if (optind < argc && bdpath == NULL) {
bdpath = argv[optind];
optind++;
opt = 1;
}
else if (optind < argc && dest == NULL) {
dest = argv[optind];
optind++;
opt = 1;
}
break;
case 'c': {
int match;
match = sscanf(optarg, "%d-%d", &chapter_start, &chapter_end);
if (match == 1) {
chapter_end = chapter_start + 1;
}
chapter_start--;
chapter_end--;
} break;
case 'k':
keyfile = optarg;
break;
case 'a':
angle = atoi(optarg);
angle--;
break;
case 't':
if (playlist >= 0) {
_usage(argv[0]);
}
title_no = atoi(optarg);
title_no--;
break;
case 'p':
if (title_no >= 0) {
_usage(argv[0]);
}
playlist = atoi(optarg);
break;
case 'v':
verbose = 1;
break;
default:
_usage(argv[0]);
break;
}
} while (opt != -1);
if (title_no < 0 && playlist < 0) {
_usage(argv[0]);
}
if (optind < argc) {
_usage(argv[0]);
}
bd = bd_open(bdpath, keyfile);
if (bd == NULL) {
fprintf(stderr, "Failed to open disc: %s\n", bdpath);
return 1;
}
title_count = bd_get_titles(bd, TITLES_RELEVANT, 0);
if (title_count <= 0) {
fprintf(stderr, "No titles found: %s\n", bdpath);
return 1;
}
if (title_no >= 0) {
if (!bd_select_title(bd, title_no)) {
fprintf(stderr, "Failed to open title: %d\n", title_no);
return 1;
}
ti = bd_get_title_info(bd, title_no, angle);
} else {
if (!bd_select_playlist(bd, playlist)) {
fprintf(stderr, "Failed to open playlist: %d\n", playlist);
return 1;
}
ti = bd_get_playlist_info(bd, playlist, angle);
}
if (dest) {
out = fopen(dest, "wb");
if (out == NULL) {
fprintf(stderr, "Failed to open destination: %s\n", dest);
return 1;
}
} else {
out = stdout;
}
if (angle >= (int)ti->angle_count) {
fprintf(stderr, "Invalid angle %d > angle count %d. Using angle 1.\n",
angle+1, ti->angle_count);
angle = 0;
}
bd_select_angle(bd, angle);
if (chapter_start >= (int)ti->chapter_count) {
fprintf(stderr, "First chapter %d > chapter count %d\n",
chapter_start+1, ti->chapter_count);
return 1;
}
if (chapter_end >= (int)ti->chapter_count) {
chapter_end = -1;
}
if (chapter_end >= 0) {
end_pos = bd_chapter_pos(bd, chapter_end);
}
bd_free_title_info(ti);
bd_seek_chapter(bd, chapter_start);
pos = bd_tell(bd);
while (end_pos < 0 || pos < end_pos) {
size = BUF_SIZE;
if (size > (size_t)(end_pos - pos)) {
size = end_pos - pos;
}
bytes = bd_read(bd, buf, size);
if (bytes <= 0) {
break;
}
pos = bd_tell(bd);
wrote = fwrite(buf, 1, bytes, out);
if (wrote != (size_t)bytes) {
fprintf(stderr, "read/write sizes do not match: %d/%zu\n", bytes, wrote);
}
if (wrote == 0) {
if (ferror(out)) {
perror("Write error");
}
break;
}
total += wrote;
}
if (verbose) {
fprintf(stderr, "Wrote %"PRId64" bytes\n", total);
}
bd_close(bd);
fclose(out);
return 0;
}
static int bluray_stream_fill_buffer(stream_t *s, char *buf, int len)
{
struct bluray_priv_s *b = s->priv;
return bd_read(b->bd, buf, len);
}
int BDByteStreamRead(void *opaque, uint8_t *buf, int buf_size)
{
return bd_read((BLURAY *)opaque, buf, buf_size);
}
int CBDDemuxer::BDByteStreamRead(void *opaque, uint8_t *buf, int buf_size)
{
CBDDemuxer *demux = (CBDDemuxer *)opaque;
int ret = bd_read(demux->m_pBD, buf, buf_size);
return (ret != 0) ? ret : AVERROR_EOF;
}
