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_control(stream_t *s, int cmd, void *arg)
{
struct bluray_priv_s *b = s->priv;
switch (cmd) {
case STREAM_CTRL_GET_NUM_CHAPTERS: {
BLURAY_TITLE_INFO *ti;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
*((unsigned int *) arg) = ti->chapter_count;
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_CURRENT_TITLE: {
*((unsigned int *) arg) = b->current_title;
return 1;
}
case STREAM_CTRL_GET_CURRENT_CHAPTER: {
*((unsigned int *) arg) = bd_get_current_chapter(b->bd);
return 1;
}
case STREAM_CTRL_SEEK_TO_CHAPTER: {
BLURAY_TITLE_INFO *ti;
int chapter = *((unsigned int *) arg);
int64_t pos;
int r;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
if (chapter < 0 || chapter > ti->chapter_count) {
bd_free_title_info(ti);
return STREAM_UNSUPPORTED;
}
pos = bd_chapter_pos(b->bd, chapter);
r = bluray_stream_seek(s, pos);
bd_free_title_info(ti);
return r ? 1 : STREAM_UNSUPPORTED;
}
case STREAM_CTRL_GET_TIME_LENGTH: {
BLURAY_TITLE_INFO *ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
*(double *)arg = ti->duration / 90000.0;
return STREAM_OK;
}
case STREAM_CTRL_GET_SIZE:
*(uint64_t*)arg = bd_get_title_size(b->bd);
return STREAM_OK;
case STREAM_CTRL_GET_CURRENT_TIME:
*(double *)arg = bd_tell_time(b->bd) / 90000.0;
return STREAM_OK;
case STREAM_CTRL_SEEK_TO_TIME: {
int64_t res;
double target = *(double*)arg * 90000.0;
BLURAY_TITLE_INFO *ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
// clamp to ensure that out-of-bounds seeks do not simply do nothing.
target = FFMAX(target, 0);
if (ti && ti->duration > 1)
target = FFMIN(target, ti->duration - 1);
res = bd_seek_time(b->bd, target);
if (res < 0)
return STREAM_ERROR;
s->pos = res;
return 1;
}
case STREAM_CTRL_GET_NUM_ANGLES: {
BLURAY_TITLE_INFO *ti;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
*((int *) arg) = ti->angle_count;
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_ANGLE: {
*((int *) arg) = b->current_angle;
return 1;
}
case STREAM_CTRL_SET_ANGLE: {
BLURAY_TITLE_INFO *ti;
int angle = *((int *) arg);
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
if (angle < 0 || angle > ti->angle_count) {
bd_free_title_info(ti);
return STREAM_UNSUPPORTED;
}
b->current_angle = angle;
bd_seamless_angle_change(b->bd, angle);
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_LANG: {
struct stream_lang_req *req = arg;
const BLURAY_STREAM_INFO *si;
int count;
BLURAY_TITLE_INFO *ti = get_langs(b, req->type, &si, &count);
while (count-- > 0) {
if (si->pid == req->id) {
memcpy(req->buf, si->lang, 4);
req->buf[4] = 0;
bd_free_title_info(ti);
return STREAM_OK;
}
si++;
}
if (ti)
bd_free_title_info(ti);
return STREAM_ERROR;
}
default:
break;
}
return STREAM_UNSUPPORTED;
}
static int bluray_stream_control(stream_t *s, int cmd, void *arg)
{
struct bluray_priv_s *b = s->priv;
switch (cmd) {
case STREAM_CTRL_GET_NUM_CHAPTERS: {
BLURAY_TITLE_INFO *ti;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
*((unsigned int *) arg) = ti->chapter_count;
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_CURRENT_TITLE: {
*((unsigned int *) arg) = b->current_title;
return 1;
}
case STREAM_CTRL_GET_CURRENT_CHAPTER: {
*((unsigned int *) arg) = bd_get_current_chapter(b->bd);
return 1;
}
case STREAM_CTRL_SEEK_TO_CHAPTER: {
BLURAY_TITLE_INFO *ti;
int chapter = *((unsigned int *) arg);
int64_t pos;
int r;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
if (chapter < 0 || chapter > ti->chapter_count) {
bd_free_title_info(ti);
return STREAM_UNSUPPORTED;
}
pos = bd_chapter_pos(b->bd, chapter);
r = bluray_stream_seek(s, pos);
bd_free_title_info(ti);
return r ? 1 : STREAM_UNSUPPORTED;
}
case STREAM_CTRL_GET_NUM_ANGLES: {
BLURAY_TITLE_INFO *ti;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
*((int *) arg) = ti->angle_count;
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_ANGLE: {
*((int *) arg) = b->current_angle;
return 1;
}
case STREAM_CTRL_SET_ANGLE: {
BLURAY_TITLE_INFO *ti;
int angle = *((int *) arg);
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
if (angle < 0 || angle > ti->angle_count) {
bd_free_title_info(ti);
return STREAM_UNSUPPORTED;
}
b->current_angle = angle;
bd_seamless_angle_change(b->bd, angle);
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_LANG: {
struct stream_lang_req *req = arg;
BLURAY_TITLE_INFO *ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (ti->clip_count) {
BLURAY_STREAM_INFO *si = NULL;
int count = 0;
switch (req->type) {
case stream_ctrl_audio:
count = ti->clips[0].audio_stream_count;
si = ti->clips[0].audio_streams;
break;
case stream_ctrl_sub:
count = ti->clips[0].pg_stream_count;
si = ti->clips[0].pg_streams;
break;
}
while (count-- > 0) {
if (si->pid == req->id) {
memcpy(req->buf, si->lang, 4);
req->buf[4] = 0;
bd_free_title_info(ti);
return STREAM_OK;
}
si++;
}
}
bd_free_title_info(ti);
return STREAM_ERROR;
}
default:
break;
}
return STREAM_UNSUPPORTED;
}
JNIEXPORT jlong JNICALL Java_org_videolan_Libbluray_chapterPosN(JNIEnv * env,
jclass cls, jlong np, jint chapter) {
BDJAVA* bdj = (BDJAVA*)(intptr_t)np;
return bd_chapter_pos(bdj->bd, chapter);
}
static int bluray_stream_open(stream_t *s, int mode,
void *opts, int *file_format)
{
struct stream_priv_s *p = opts;
struct bluray_priv_s *b;
BLURAY_TITLE_INFO *info = NULL;
BLURAY *bd;
int title, title_guess, title_count;
uint64_t title_size;
unsigned int chapter = 0, angle = 0;
uint64_t max_duration = 0;
int64_t chapter_pos = 0;
char *device = NULL;
int i;
/* find the requested device */
if (p->device)
device = p->device;
else if (bluray_device)
device = bluray_device;
if (!device) {
mp_tmsg(MSGT_OPEN, MSGL_ERR,
"No Blu-ray device/location was specified ...\n");
return STREAM_UNSUPPORTED;
}
/* open device */
bd = bd_open(device, NULL);
if (!bd) {
mp_tmsg(MSGT_OPEN, MSGL_ERR, "Couldn't open Blu-ray device: %s\n",
device);
return STREAM_UNSUPPORTED;
}
/* check for available titles on disc */
title_count = bd_get_titles(bd, TITLES_RELEVANT, angle);
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_BLURAY_TITLES=%d\n", title_count);
if (!title_count) {
mp_msg(MSGT_OPEN, MSGL_ERR,
"Can't find any Blu-ray-compatible title here.\n");
bd_close(bd);
return STREAM_UNSUPPORTED;
}
/* parse titles information */
title_guess = BLURAY_DEFAULT_TITLE;
for (i = 0; i < title_count; i++) {
BLURAY_TITLE_INFO *ti;
int sec, msec;
ti = bd_get_title_info(bd, i, angle);
if (!ti)
continue;
sec = ti->duration / 90000;
msec = (ti->duration - sec) % 1000;
mp_msg(MSGT_IDENTIFY, MSGL_INFO,
"ID_BLURAY_TITLE_%d_CHAPTERS=%d\n", i + 1, ti->chapter_count);
mp_msg(MSGT_IDENTIFY, MSGL_INFO,
"ID_BLURAY_TITLE_%d_ANGLE=%d\n", i + 1, ti->angle_count);
mp_msg(MSGT_IDENTIFY, MSGL_V,
"ID_BLURAY_TITLE_%d_LENGTH=%d.%03d\n", i + 1, sec, msec);
/* try to guess which title may contain the main movie */
if (ti->duration > max_duration) {
max_duration = ti->duration;
title_guess = i;
}
bd_free_title_info(ti);
}
/* Select current title */
title = p->title ? p->title - 1: title_guess;
title = FFMIN(title, title_count - 1);
bd_select_title(bd, title);
title_size = bd_get_title_size(bd);
mp_msg(MSGT_IDENTIFY, MSGL_INFO,
"ID_BLURAY_CURRENT_TITLE=%d\n", title + 1);
/* Get current title information */
info = bd_get_title_info(bd, title, angle);
if (!info)
goto err_no_info;
/* Select chapter */
chapter = bluray_chapter ? bluray_chapter : BLURAY_DEFAULT_CHAPTER;
chapter = FFMIN(chapter, info->chapter_count);
if (chapter)
chapter_pos = bd_chapter_pos(bd, chapter);
mp_msg(MSGT_IDENTIFY, MSGL_INFO,
"ID_BLURAY_CURRENT_CHAPTER=%d\n", chapter + 1);
/* Select angle */
angle = bluray_angle ? bluray_angle : BLURAY_DEFAULT_ANGLE;
angle = FFMIN(angle, info->angle_count);
if (angle)
bd_select_angle(bd, angle);
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_BLURAY_CURRENT_ANGLE=%d\n", angle + 1);
bd_free_title_info(info);
err_no_info:
s->fill_buffer = bluray_stream_fill_buffer;
s->seek = bluray_stream_seek;
s->close = bluray_stream_close;
s->control = bluray_stream_control;
b = calloc(1, sizeof(struct bluray_priv_s));
b->bd = bd;
b->current_angle = angle;
b->current_chapter = chapter;
b->current_title = title;
s->start_pos = chapter_pos;
s->end_pos = title_size;
s->sector_size = BLURAY_SECTOR_SIZE;
s->flags = mode | MP_STREAM_SEEK;
s->priv = b;
s->type = STREAMTYPE_BLURAY;
s->url = strdup("br://");
mp_tmsg(MSGT_OPEN, MSGL_V, "Blu-ray successfully opened.\n");
return STREAM_OK;
}
static int bluray_stream_control(stream_t *s, int cmd, void *arg)
{
struct bluray_priv_s *b = s->priv;
switch (cmd) {
case STREAM_CTRL_GET_NUM_CHAPTERS: {
BLURAY_TITLE_INFO *ti;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
*((unsigned int *) arg) = ti->chapter_count;
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_CURRENT_CHAPTER: {
*((unsigned int *) arg) = b->current_chapter;
return 1;
}
case STREAM_CTRL_SEEK_TO_CHAPTER: {
BLURAY_TITLE_INFO *ti;
int chapter = *((unsigned int *) arg);
int64_t pos;
int r;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
if (chapter < 0 || chapter > ti->chapter_count) {
bd_free_title_info(ti);
return STREAM_UNSUPPORTED;
}
pos = bd_chapter_pos(b->bd, chapter);
r = bluray_stream_seek(s, pos);
bd_free_title_info(ti);
return r ? 1 : STREAM_UNSUPPORTED;
}
case STREAM_CTRL_GET_NUM_ANGLES: {
BLURAY_TITLE_INFO *ti;
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
*((int *) arg) = ti->angle_count;
bd_free_title_info(ti);
return 1;
}
case STREAM_CTRL_GET_ANGLE: {
*((int *) arg) = b->current_angle;
return 1;
}
case STREAM_CTRL_SET_ANGLE: {
BLURAY_TITLE_INFO *ti;
int angle = *((int *) arg);
ti = bd_get_title_info(b->bd, b->current_title, b->current_angle);
if (!ti)
return STREAM_UNSUPPORTED;
if (angle < 0 || angle > ti->angle_count) {
bd_free_title_info(ti);
return STREAM_UNSUPPORTED;
}
b->current_angle = angle;
bd_seamless_angle_change(b->bd, angle);
bd_free_title_info(ti);
return 1;
}
default:
break;
}
return STREAM_UNSUPPORTED;
}
