/* * DVD-Video demuxer, powered by libdvdnav and libdvdread * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* * See doc/demuxers.texi for a high-level overview. * * The tactical approach is as follows: * 1) Open the volume with dvdread * 2) Analyze the user-requested title and PGC coordinates in the IFO structures * 3) Request playback at the coordinates and chosen angle with dvdnav * 5) Begin the playback (reading and demuxing) of MPEG-PS blocks * 6) End playback if navigation goes backwards, to a menu, or a different PGC or angle * 7) Close the dvdnav VM, and free dvdread's IFO structures */ #include #include #include #include #include #include "libavutil/avstring.h" #include "libavutil/avutil.h" #include "libavutil/intreadwrite.h" #include "libavutil/mem.h" #include "libavutil/opt.h" #include "libavutil/samplefmt.h" #include "libavutil/time.h" #include "libavutil/timestamp.h" #include "avformat.h" #include "avio_internal.h" #include "avlanguage.h" #include "demux.h" #include "internal.h" #include "url.h" #define DVDVIDEO_MAX_PS_SEARCH_BLOCKS 128 #define DVDVIDEO_BLOCK_SIZE 2048 #define DVDVIDEO_TIME_BASE_Q (AVRational) { 1, 90000 } #define DVDVIDEO_PTS_WRAP_BITS 64 /* VOBUs use 32 (PES allows 33) */ #define DVDVIDEO_LIBDVDX_LOG_BUFFER_SIZE 1024 enum DVDVideoSubpictureViewport { DVDVIDEO_SUBP_VIEWPORT_FULLSCREEN, DVDVIDEO_SUBP_VIEWPORT_WIDESCREEN, DVDVIDEO_SUBP_VIEWPORT_LETTERBOX, DVDVIDEO_SUBP_VIEWPORT_PANSCAN }; static const char dvdvideo_subp_viewport_labels[4][13] = { "Fullscreen", "Widescreen", "Letterbox", "Pan and Scan" }; typedef struct DVDVideoVTSVideoStreamEntry { int startcode; enum AVCodecID codec_id; int width; int height; AVRational dar; AVRational framerate; int has_cc; } DVDVideoVTSVideoStreamEntry; typedef struct DVDVideoPGCAudioStreamEntry { int startcode; enum AVCodecID codec_id; int sample_fmt; int sample_rate; int bit_depth; int nb_channels; AVChannelLayout ch_layout; int disposition; const char *lang_iso; } DVDVideoPGCAudioStreamEntry; typedef struct DVDVideoPGCSubtitleStreamEntry { int startcode; enum DVDVideoSubpictureViewport viewport; int disposition; const char *lang_iso; } DVDVideoPGCSubtitleStreamEntry; typedef struct DVDVideoPlaybackState { int celln; /* ID of the active cell */ int entry_pgn; /* ID of the PG we are starting in */ int in_pgc; /* if our navigator is in the PGC */ int in_ps; /* if our navigator is in the program stream */ int in_vts; /* if our navigator is in the VTS */ int64_t nav_pts; /* PTS according to IFO, not frame-accurate */ int nb_cells_played; /* number of cells played back so far */ uint64_t pgc_duration_est; /* estimated duration as reported by IFO */ uint64_t pgc_elapsed; /* the elapsed time of the PGC, cell-relative */ int pgc_nb_pg_est; /* number of PGs as reported by IFOs */ int pgcn; /* ID of the PGC we are playing */ int pgn; /* ID of the PG we are in now */ int ptt; /* ID of the chapter we are in now */ int64_t ts_offset; /* PTS discontinuity offset (ex. VOB change) */ uint32_t vobu_duration; /* duration of the current VOBU */ uint32_t vobu_e_ptm; /* end PTM of the current VOBU */ int vtsn; /* ID of the active VTS (video title set) */ uint64_t *pgc_pg_times_est; /* PG start times as reported by IFO */ pgc_t *pgc; /* handle to the active PGC */ dvdnav_t *dvdnav; /* handle to the dvdnav VM */ } DVDVideoPlaybackState; typedef struct DVDVideoDemuxContext { const AVClass *class; /* options */ int opt_angle; /* the user-provided angle number (1-indexed) */ int opt_chapter_end; /* the user-provided exit PTT (0 for last) */ int opt_chapter_start; /* the user-provided entry PTT (1-indexed) */ int opt_pg; /* the user-provided PG number (1-indexed) */ int opt_pgc; /* the user-provided PGC number (1-indexed) */ int opt_preindex; /* pre-indexing mode (2-pass read) */ int opt_region; /* the user-provided region digit */ int opt_title; /* the user-provided title number (1-indexed) */ int opt_trim; /* trim padding cells at beginning */ /* subdemux */ AVFormatContext *mpeg_ctx; /* context for inner demuxer */ uint8_t *mpeg_buf; /* buffer for inner demuxer */ FFIOContext mpeg_pb; /* buffer context for inner demuxer */ /* volume */ dvd_reader_t *dvdread; /* handle to libdvdread */ ifo_handle_t *vmg_ifo; /* handle to the VMG (VIDEO_TS.IFO) */ ifo_handle_t *vts_ifo; /* handle to the active VTS (VTS_nn_n.IFO) */ /* playback control */ int64_t first_pts; /* the PTS of the first video keyframe */ int play_end; /* signal EOF to the parent demuxer */ DVDVideoPlaybackState play_state; /* the active playback state */ int play_started; /* signal that playback has started */ int segment_started; /* signal that subdemuxer is on a segment */ } DVDVideoDemuxContext; static void dvdvideo_libdvdread_log(void *opaque, dvd_logger_level_t level, const char *msg, va_list msg_va) { AVFormatContext *s = opaque; char msg_buf[DVDVIDEO_LIBDVDX_LOG_BUFFER_SIZE]; int lavu_level = AV_LOG_DEBUG; vsnprintf(msg_buf, sizeof(msg_buf), msg, msg_va); if (level == DVD_LOGGER_LEVEL_ERROR) lavu_level = AV_LOG_ERROR; else if (level == DVD_LOGGER_LEVEL_WARN) lavu_level = AV_LOG_WARNING; av_log(s, lavu_level, "libdvdread: %s\n", msg_buf); } static void dvdvideo_libdvdnav_log(void *opaque, dvdnav_logger_level_t level, const char *msg, va_list msg_va) { AVFormatContext *s = opaque; char msg_buf[DVDVIDEO_LIBDVDX_LOG_BUFFER_SIZE]; int lavu_level = AV_LOG_DEBUG; vsnprintf(msg_buf, sizeof(msg_buf), msg, msg_va); if (level == DVDNAV_LOGGER_LEVEL_ERROR) lavu_level = AV_LOG_ERROR; /* some discs have invalid language codes set for menus, which throws noisy warnings */ else if (level == DVDNAV_LOGGER_LEVEL_WARN && !av_strstart(msg, "Language", NULL)) lavu_level = AV_LOG_WARNING; av_log(s, lavu_level, "libdvdnav: %s\n", msg_buf); } static void dvdvideo_ifo_close(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; if (c->vts_ifo) ifoClose(c->vts_ifo); if (c->vmg_ifo) ifoClose(c->vmg_ifo); if (c->dvdread) DVDClose(c->dvdread); } static int dvdvideo_ifo_open(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; dvd_logger_cb dvdread_log_cb; title_info_t title_info; dvdread_log_cb = (dvd_logger_cb) { .pf_log = dvdvideo_libdvdread_log }; c->dvdread = DVDOpen2(s, &dvdread_log_cb, s->url); if (!c->dvdread) { av_log(s, AV_LOG_ERROR, "Unable to open the DVD-Video structure\n"); return AVERROR_EXTERNAL; } if (!(c->vmg_ifo = ifoOpen(c->dvdread, 0))) { av_log(s, AV_LOG_ERROR, "Unable to open the VMG (VIDEO_TS.IFO)\n"); return AVERROR_EXTERNAL; } if (c->opt_title > c->vmg_ifo->tt_srpt->nr_of_srpts) { av_log(s, AV_LOG_ERROR, "Title %d not found\n", c->opt_title); return AVERROR_STREAM_NOT_FOUND; } title_info = c->vmg_ifo->tt_srpt->title[c->opt_title - 1]; if (c->opt_angle > title_info.nr_of_angles) { av_log(s, AV_LOG_ERROR, "Angle %d not found\n", c->opt_angle); return AVERROR_STREAM_NOT_FOUND; } if (title_info.nr_of_ptts < 1) { av_log(s, AV_LOG_ERROR, "Title %d has invalid headers (no PTTs found)\n", c->opt_title); return AVERROR_INVALIDDATA; } if (c->opt_chapter_start > title_info.nr_of_ptts || (c->opt_chapter_end > 0 && c->opt_chapter_end > title_info.nr_of_ptts)) { av_log(s, AV_LOG_ERROR, "Chapter (PTT) range [%d, %d] is invalid\n", c->opt_chapter_start, c->opt_chapter_end); return AVERROR_INVALIDDATA; } if (!(c->vts_ifo = ifoOpen(c->dvdread, title_info.title_set_nr))) { av_log(s, AV_LOG_ERROR, "Unable to process IFO structure for VTS %d\n", title_info.title_set_nr); return AVERROR_EXTERNAL; } if (title_info.vts_ttn < 1 || title_info.vts_ttn > 99 || title_info.vts_ttn > c->vts_ifo->vts_ptt_srpt->nr_of_srpts || c->vts_ifo->vtsi_mat->nr_of_vts_audio_streams > 8 || c->vts_ifo->vtsi_mat->nr_of_vts_subp_streams > 32) { av_log(s, AV_LOG_ERROR, "Title %d has invalid headers in VTS\n", c->opt_title); return AVERROR_INVALIDDATA; } return 0; } static int dvdvideo_is_cell_promising(AVFormatContext *s, pgc_t *pgc, int celln) { dvd_time_t cell_duration = pgc->cell_playback[celln - 1].playback_time; return cell_duration.second >= 1 || cell_duration.minute >= 1 || cell_duration.hour >= 1; } static int dvdvideo_is_pgc_promising(AVFormatContext *s, pgc_t *pgc) { for (int i = 1; i <= pgc->nr_of_cells; i++) if (dvdvideo_is_cell_promising(s, pgc, i)) return 1; return 0; } static void dvdvideo_play_close(AVFormatContext *s, DVDVideoPlaybackState *state) { if (!state->dvdnav) return; /* not allocated by av_malloc() */ if (state->pgc_pg_times_est) free(state->pgc_pg_times_est); if (dvdnav_close(state->dvdnav) != DVDNAV_STATUS_OK) av_log(s, AV_LOG_ERROR, "Unable to close dvdnav successfully, dvdnav error: %s\n", dvdnav_err_to_string(state->dvdnav)); } static int dvdvideo_play_open(AVFormatContext *s, DVDVideoPlaybackState *state) { DVDVideoDemuxContext *c = s->priv_data; dvdnav_logger_cb dvdnav_log_cb; dvdnav_status_t dvdnav_open_status; int32_t disc_region_mask; int32_t player_region_mask; int cur_title, cur_pgcn, cur_pgn; pgc_t *pgc; dvdnav_log_cb = (dvdnav_logger_cb) { .pf_log = dvdvideo_libdvdnav_log }; dvdnav_open_status = dvdnav_open2(&state->dvdnav, s, &dvdnav_log_cb, s->url); if (!state->dvdnav || dvdnav_open_status != DVDNAV_STATUS_OK || dvdnav_set_readahead_flag(state->dvdnav, 0) != DVDNAV_STATUS_OK || dvdnav_set_PGC_positioning_flag(state->dvdnav, 1) != DVDNAV_STATUS_OK || dvdnav_get_region_mask(state->dvdnav, &disc_region_mask) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to open the DVD for playback\n"); goto end_dvdnav_error; } player_region_mask = c->opt_region > 0 ? (1 << (c->opt_region - 1)) : disc_region_mask; if (dvdnav_set_region_mask(state->dvdnav, player_region_mask) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to set the playback region code %d\n", c->opt_region); goto end_dvdnav_error; } if (c->opt_pgc > 0 && c->opt_pg > 0) { if (dvdnav_program_play(state->dvdnav, c->opt_title, c->opt_pgc, c->opt_pg) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to start playback at title %d, PGC %d, PG %d\n", c->opt_title, c->opt_pgc, c->opt_pg); goto end_dvdnav_error; } state->pgcn = c->opt_pgc; state->entry_pgn = c->opt_pg; } else { if (dvdnav_part_play(state->dvdnav, c->opt_title, c->opt_chapter_start) != DVDNAV_STATUS_OK || dvdnav_current_title_program(state->dvdnav, &cur_title, &cur_pgcn, &cur_pgn) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to start playback at title %d, chapter (PTT) %d\n", c->opt_title, c->opt_chapter_start); goto end_dvdnav_error; } state->pgcn = cur_pgcn; state->entry_pgn = cur_pgn; } pgc = c->vts_ifo->vts_pgcit->pgci_srp[state->pgcn - 1].pgc; if (pgc->pg_playback_mode != 0) { av_log(s, AV_LOG_ERROR, "Non-sequential PGCs, such as shuffles, are not supported\n"); return AVERROR_PATCHWELCOME; } if (c->opt_trim && !dvdvideo_is_pgc_promising(s, pgc)) { av_log(s, AV_LOG_ERROR, "Title %d, PGC %d looks empty (may consist of padding cells), " "if you want to try anyway, disable the -trim option\n", c->opt_title, state->pgcn); return AVERROR_INVALIDDATA; } if (dvdnav_angle_change(state->dvdnav, c->opt_angle) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to start playback at angle %d\n", c->opt_angle); goto end_dvdnav_error; } /* dvdnav_describe_title_chapters() performs several validations on the title structure */ /* take advantage of this side effect to increase chances of a safe navigation path */ state->pgc_nb_pg_est = dvdnav_describe_title_chapters(state->dvdnav, c->opt_title, &state->pgc_pg_times_est, &state->pgc_duration_est); /* dvdnav returning 0 PGs is documented as an error condition */ if (!state->pgc_nb_pg_est) { av_log(s, AV_LOG_ERROR, "Unable to read chapter information for title %d\n", c->opt_title); goto end_dvdnav_error; } state->nav_pts = dvdnav_get_current_time(state->dvdnav); state->vtsn = c->vmg_ifo->tt_srpt->title[c->opt_title - 1].title_set_nr; state->pgc = pgc; return 0; end_dvdnav_error: if (state->dvdnav) av_log(s, AV_LOG_ERROR, "dvdnav error: %s\n", dvdnav_err_to_string(state->dvdnav)); else av_log(s, AV_LOG_ERROR, "dvdnav could not be initialized\n"); return AVERROR_EXTERNAL; } static int dvdvideo_play_next_ps_block(AVFormatContext *s, DVDVideoPlaybackState *state, uint8_t *buf, int buf_size, int *p_nav_event, void (*flush_cb)(AVFormatContext *s)) { DVDVideoDemuxContext *c = s->priv_data; uint8_t nav_buf[DVDVIDEO_BLOCK_SIZE] = {0}; int nav_event; int nav_len; dvdnav_vts_change_event_t *e_vts; dvdnav_cell_change_event_t *e_cell; int cur_title, cur_pgcn, cur_pgn, cur_angle, cur_title_unused, cur_ptt, cur_nb_angles; int is_cell_promising = 0; pci_t *e_pci; dsi_t *e_dsi; if (buf_size != DVDVIDEO_BLOCK_SIZE) { av_log(s, AV_LOG_ERROR, "Invalid buffer size (expected=%d actual=%d)\n", DVDVIDEO_BLOCK_SIZE, buf_size); return AVERROR(EINVAL); } for (int i = 0; i < DVDVIDEO_MAX_PS_SEARCH_BLOCKS; i++) { if (ff_check_interrupt(&s->interrupt_callback)) return AVERROR_EXIT; if (dvdnav_get_next_block(state->dvdnav, nav_buf, &nav_event, &nav_len) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to read next block of PGC\n"); goto end_dvdnav_error; } /* STOP event can come at any time and should be honored */ if (nav_event == DVDNAV_STOP) return AVERROR_EOF; if (nav_len > DVDVIDEO_BLOCK_SIZE) { av_log(s, AV_LOG_ERROR, "Invalid block size (expected<=%d actual=%d)\n", DVDVIDEO_BLOCK_SIZE, nav_len); return AVERROR_INVALIDDATA; } if (dvdnav_current_title_info(state->dvdnav, &cur_title, &cur_ptt) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to determine current title coordinates\n"); goto end_dvdnav_error; } /* we somehow navigated to a menu */ if (cur_title == 0 || !dvdnav_is_domain_vts(state->dvdnav)) return AVERROR_EOF; if (dvdnav_current_title_program(state->dvdnav, &cur_title_unused, &cur_pgcn, &cur_pgn) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to determine current PGC coordinates\n"); goto end_dvdnav_error; } /* we somehow left the PGC */ if (state->in_pgc && cur_pgcn != state->pgcn) return AVERROR_EOF; if (dvdnav_get_angle_info(state->dvdnav, &cur_angle, &cur_nb_angles) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to determine current video angle\n"); goto end_dvdnav_error; } av_log(s, nav_event == DVDNAV_BLOCK_OK ? AV_LOG_TRACE : AV_LOG_DEBUG, "new block: i=%d nav_event=%d nav_len=%d cur_title=%d " "cur_ptt=%d cur_angle=%d cur_celln=%d cur_pgcn=%d cur_pgn=%d " "play_in_vts=%d play_in_pgc=%d play_in_ps=%d\n", i, nav_event, nav_len, cur_title, cur_ptt, cur_angle, state->celln, cur_pgcn, cur_pgn, state->in_vts, state->in_pgc, state->in_ps); switch (nav_event) { case DVDNAV_VTS_CHANGE: if (state->in_vts) return AVERROR_EOF; e_vts = (dvdnav_vts_change_event_t *) nav_buf; if (e_vts->new_vtsN == state->vtsn && e_vts->new_domain == DVD_DOMAIN_VTSTitle) state->in_vts = 1; continue; case DVDNAV_CELL_CHANGE: if (!state->in_vts) continue; e_cell = (dvdnav_cell_change_event_t *) nav_buf; is_cell_promising = !c->opt_trim || dvdvideo_is_cell_promising(s, state->pgc, e_cell->cellN); av_log(s, AV_LOG_DEBUG, "new cell: prev=%d new=%d promising=%d\n", state->celln, e_cell->cellN, is_cell_promising); if (!state->in_ps && !state->in_pgc) { if (cur_title == c->opt_title && (c->opt_pgc || cur_ptt == c->opt_chapter_start) && cur_pgcn == state->pgcn && cur_pgn == state->entry_pgn && is_cell_promising) { state->in_pgc = 1; } if (c->opt_trim && !is_cell_promising) av_log(s, AV_LOG_INFO, "Skipping padding cell #%d\n", e_cell->cellN); } else if (state->celln >= e_cell->cellN || state->pgn > cur_pgn) { return AVERROR_EOF; } state->celln = e_cell->cellN; state->ptt = cur_ptt; state->pgn = cur_pgn; state->nb_cells_played++; continue; case DVDNAV_NAV_PACKET: if (!state->in_pgc) continue; if ((state->ptt > 0 && state->ptt > cur_ptt) || (c->opt_chapter_end > 0 && cur_ptt > c->opt_chapter_end)) { return AVERROR_EOF; } e_pci = dvdnav_get_current_nav_pci(state->dvdnav); e_dsi = dvdnav_get_current_nav_dsi(state->dvdnav); if (e_pci == NULL || e_dsi == NULL || e_pci->pci_gi.vobu_s_ptm > e_pci->pci_gi.vobu_e_ptm) { av_log(s, AV_LOG_ERROR, "Invalid NAV packet\n"); return AVERROR_INVALIDDATA; } state->vobu_duration = e_pci->pci_gi.vobu_e_ptm - e_pci->pci_gi.vobu_s_ptm; state->pgc_elapsed += state->vobu_duration; state->nav_pts = dvdnav_get_current_time(state->dvdnav); state->ptt = cur_ptt; state->pgn = cur_pgn; av_log(s, AV_LOG_DEBUG, "NAV packet: s_ptm=%d e_ptm=%d " "scr=%d lbn=%d vobu_duration=%d nav_pts=%ld\n", e_pci->pci_gi.vobu_s_ptm, e_pci->pci_gi.vobu_e_ptm, e_dsi->dsi_gi.nv_pck_scr, e_pci->pci_gi.nv_pck_lbn, state->vobu_duration, state->nav_pts); if (!state->in_ps) { av_log(s, AV_LOG_DEBUG, "navigation: locked to program stream\n"); state->in_ps = 1; } else { if (state->vobu_e_ptm != e_pci->pci_gi.vobu_s_ptm) { if (flush_cb) flush_cb(s); state->ts_offset += state->vobu_e_ptm - e_pci->pci_gi.vobu_s_ptm; } } state->vobu_e_ptm = e_pci->pci_gi.vobu_e_ptm; (*p_nav_event) = nav_event; return nav_len; case DVDNAV_BLOCK_OK: if (!state->in_ps) { if (state->in_pgc) i = 0; /* necessary in case we are skipping junk cells at the beginning */ continue; } if (nav_len != DVDVIDEO_BLOCK_SIZE) { av_log(s, AV_LOG_ERROR, "Invalid MPEG block size (expected=%d actual=%d)\n", DVDVIDEO_BLOCK_SIZE, nav_len); return AVERROR_INVALIDDATA; } if (cur_angle != c->opt_angle) { av_log(s, AV_LOG_ERROR, "Unexpected angle change (expected=%d new=%d)\n", c->opt_angle, cur_angle); return AVERROR_INPUT_CHANGED; } memcpy(buf, &nav_buf, nav_len); if (state->pgn != cur_pgn) av_log(s, AV_LOG_WARNING, "Unexpected PG change (expected=%d actual=%d); " "this could be due to a missed NAV packet\n", state->pgn, cur_pgn); (*p_nav_event) = nav_event; return nav_len; case DVDNAV_STILL_FRAME: case DVDNAV_WAIT: case DVDNAV_HOP_CHANNEL: case DVDNAV_HIGHLIGHT: if (state->in_ps) return AVERROR_EOF; if (nav_event == DVDNAV_STILL_FRAME) { if (dvdnav_still_skip(state->dvdnav) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to skip still image\n"); goto end_dvdnav_error; } } if (nav_event == DVDNAV_WAIT) { if (dvdnav_wait_skip(state->dvdnav) != DVDNAV_STATUS_OK) { av_log(s, AV_LOG_ERROR, "Unable to skip WAIT event\n"); goto end_dvdnav_error; } } continue; default: continue; } } av_log(s, AV_LOG_ERROR, "Unable to find next program stream block\n"); return AVERROR_INVALIDDATA; end_dvdnav_error: av_log(s, AV_LOG_ERROR, "dvdnav error (title=%d pgc=%d pg=%d cell=%d): %s\n", cur_title, cur_pgcn, cur_pgn, state->celln, dvdnav_err_to_string(state->dvdnav)); return AVERROR_EXTERNAL; } static int dvdvideo_chapters_setup_simple(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; uint64_t time_prev = 0; int64_t total_duration = 0; int chapter_start = c->opt_chapter_start; int chapter_end = c->opt_chapter_end > 0 ? c->opt_chapter_end : c->play_state.pgc_nb_pg_est - 1; /* dvdnav_describe_title_chapters() describes PGs rather than PTTs, so validate our range */ if (chapter_start == chapter_end || c->play_state.pgc_nb_pg_est == 1 || chapter_start > c->play_state.pgc_nb_pg_est || chapter_end > c->play_state.pgc_nb_pg_est) { s->duration = av_rescale_q(c->play_state.pgc_duration_est, DVDVIDEO_TIME_BASE_Q, AV_TIME_BASE_Q); return 0; } for (int i = chapter_start - 1; i < chapter_end; i++) { uint64_t time_effective = c->play_state.pgc_pg_times_est[i] - c->play_state.nav_pts; if (!avpriv_new_chapter(s, i, DVDVIDEO_TIME_BASE_Q, time_prev, time_effective, NULL)) return AVERROR(ENOMEM); time_prev = time_effective; total_duration = time_effective; } if (c->opt_chapter_start == 1 && c->opt_chapter_end == 0) s->duration = av_rescale_q(c->play_state.pgc_duration_est, DVDVIDEO_TIME_BASE_Q, AV_TIME_BASE_Q); else s->duration = av_rescale_q(total_duration, DVDVIDEO_TIME_BASE_Q, AV_TIME_BASE_Q); return 0; } static int dvdvideo_chapters_setup_preindex(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; int ret = 0, interrupt = 0; int nb_chapters = 0, last_ptt = c->opt_chapter_start; uint64_t cur_chapter_offset = 0, cur_chapter_duration = 0; DVDVideoPlaybackState state = {0}; uint8_t nav_buf[DVDVIDEO_BLOCK_SIZE]; int nav_event; if (c->opt_chapter_start == c->opt_chapter_end) return ret; if ((ret = dvdvideo_play_open(s, &state)) < 0) return ret; if (state.pgc->nr_of_programs == 1) goto end_close; av_log(s, AV_LOG_INFO, "Indexing chapter markers, this will take a long time. Please wait...\n"); while (!(interrupt = ff_check_interrupt(&s->interrupt_callback))) { ret = dvdvideo_play_next_ps_block(s, &state, nav_buf, DVDVIDEO_BLOCK_SIZE, &nav_event, NULL); if (ret < 0 && ret != AVERROR_EOF) goto end_close; if (nav_event != DVDNAV_NAV_PACKET && ret != AVERROR_EOF) continue; if (state.ptt == last_ptt) { cur_chapter_duration += state.vobu_duration; /* ensure we add the last chapter */ if (ret != AVERROR_EOF) continue; } if (!avpriv_new_chapter(s, nb_chapters, DVDVIDEO_TIME_BASE_Q, cur_chapter_offset, cur_chapter_offset + cur_chapter_duration, NULL)) { ret = AVERROR(ENOMEM); goto end_close; } nb_chapters++; cur_chapter_offset += cur_chapter_duration; cur_chapter_duration = state.vobu_duration; last_ptt = state.ptt; if (ret == AVERROR_EOF) break; } if (interrupt) { ret = AVERROR_EXIT; goto end_close; } if (ret < 0 && ret != AVERROR_EOF) goto end_close; s->duration = av_rescale_q(state.pgc_elapsed, DVDVIDEO_TIME_BASE_Q, AV_TIME_BASE_Q); av_log(s, AV_LOG_INFO, "Chapter marker indexing complete\n"); ret = 0; end_close: dvdvideo_play_close(s, &state); return ret; } static int dvdvideo_video_stream_analyze(AVFormatContext *s, video_attr_t video_attr, DVDVideoVTSVideoStreamEntry *entry) { AVRational framerate; int height = 0; int width = 0; int is_pal = video_attr.video_format == 1; framerate = is_pal ? (AVRational) { 25, 1 } : (AVRational) { 30000, 1001 }; height = is_pal ? 576 : 480; if (height > 0) { switch (video_attr.picture_size) { case 0: /* D1 */ width = 720; break; case 1: /* 4CIF */ width = 704; break; case 2: /* Half D1 */ width = 352; break; case 3: /* CIF */ width = 352; height /= 2; break; } } if (!width || !height) { av_log(s, AV_LOG_ERROR, "Invalid video stream parameters in the IFO headers, " "this could be an authoring error or empty title " "(video_format=%d picture_size=%d)\n", video_attr.video_format, video_attr.picture_size); return AVERROR_INVALIDDATA; } entry->startcode = 0x1E0; entry->codec_id = !video_attr.mpeg_version ? AV_CODEC_ID_MPEG1VIDEO : AV_CODEC_ID_MPEG2VIDEO; entry->width = width; entry->height = height; entry->dar = video_attr.display_aspect_ratio ? (AVRational) { 16, 9 } : (AVRational) { 4, 3 }; entry->framerate = framerate; entry->has_cc = !is_pal && (video_attr.line21_cc_1 || video_attr.line21_cc_2); return 0; } static int dvdvideo_video_stream_add(AVFormatContext *s, DVDVideoVTSVideoStreamEntry *entry, enum AVStreamParseType need_parsing) { AVStream *st; FFStream *sti; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->id = entry->startcode; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_id = entry->codec_id; st->codecpar->width = entry->width; st->codecpar->height = entry->height; st->codecpar->format = AV_PIX_FMT_YUV420P; st->codecpar->color_range = AVCOL_RANGE_MPEG; #if FF_API_R_FRAME_RATE st->r_frame_rate = entry->framerate; #endif st->avg_frame_rate = entry->framerate; sti = ffstream(st); sti->request_probe = 0; sti->need_parsing = need_parsing; sti->display_aspect_ratio = entry->dar; avpriv_set_pts_info(st, DVDVIDEO_PTS_WRAP_BITS, DVDVIDEO_TIME_BASE_Q.num, DVDVIDEO_TIME_BASE_Q.den); return 0; } static int dvdvideo_video_stream_setup(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; int ret = 0; DVDVideoVTSVideoStreamEntry entry = {0}; if ((ret = dvdvideo_video_stream_analyze(s, c->vts_ifo->vtsi_mat->vts_video_attr, &entry)) < 0 || (ret = dvdvideo_video_stream_add(s, &entry, AVSTREAM_PARSE_HEADERS)) < 0) { av_log(s, AV_LOG_ERROR, "Unable to add video stream\n"); return ret; } return 0; } static int dvdvideo_audio_stream_analyze(AVFormatContext *s, audio_attr_t audio_attr, uint16_t audio_control, DVDVideoPGCAudioStreamEntry *entry) { int startcode = 0; enum AVCodecID codec_id = AV_CODEC_ID_NONE; int sample_fmt = AV_SAMPLE_FMT_NONE; int sample_rate = 0; int bit_depth = 0; int nb_channels = 0; AVChannelLayout ch_layout = (AVChannelLayout) {0}; char lang_dvd[3] = {0}; int position = (audio_control & 0x7F00) >> 8; /* XXX(PATCHWELCOME): SDDS is not supported due to lack of sample material */ switch (audio_attr.audio_format) { case 0: /* AC3 */ codec_id = AV_CODEC_ID_AC3; sample_fmt = AV_SAMPLE_FMT_FLTP; sample_rate = 48000; startcode = 0x80 + position; break; case 2: /* MP1 */ codec_id = AV_CODEC_ID_MP1; sample_fmt = audio_attr.quantization ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16; sample_rate = 48000; bit_depth = audio_attr.quantization ? 20 : 16; startcode = 0x1C0 + position; break; case 3: /* MP2 */ codec_id = AV_CODEC_ID_MP2; sample_fmt = audio_attr.quantization ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16; sample_rate = 48000; bit_depth = audio_attr.quantization ? 20 : 16; startcode = 0x1C0 + position; break; case 4: /* DVD PCM */ codec_id = AV_CODEC_ID_PCM_DVD; sample_fmt = audio_attr.quantization ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16; sample_rate = audio_attr.sample_frequency ? 96000 : 48000; bit_depth = audio_attr.quantization == 2 ? 24 : (audio_attr.quantization ? 20 : 16); startcode = 0xA0 + position; break; case 6: /* DCA */ codec_id = AV_CODEC_ID_DTS; sample_fmt = AV_SAMPLE_FMT_FLTP; sample_rate = 48000; bit_depth = audio_attr.quantization == 2 ? 24 : (audio_attr.quantization ? 20 : 16); startcode = 0x88 + position; break; } nb_channels = audio_attr.channels + 1; if (codec_id == AV_CODEC_ID_NONE || startcode == 0 || sample_fmt == AV_SAMPLE_FMT_NONE || sample_rate == 0 || nb_channels == 0) { av_log(s, AV_LOG_ERROR, "Invalid audio stream parameters in the IFO headers, " "this could be an authoring error or dummy title " "(stream position %d in IFO)\n", position); return AVERROR_INVALIDDATA; } if (nb_channels == 2) ch_layout = (AVChannelLayout) AV_CHANNEL_LAYOUT_STEREO; else if (nb_channels == 6) ch_layout = (AVChannelLayout) AV_CHANNEL_LAYOUT_5POINT1; else if (nb_channels == 7) ch_layout = (AVChannelLayout) AV_CHANNEL_LAYOUT_6POINT1; else if (nb_channels == 8) ch_layout = (AVChannelLayout) AV_CHANNEL_LAYOUT_7POINT1; /* XXX(PATCHWELCOME): IFO structures have metadata on karaoke tracks for additional features */ if (audio_attr.application_mode == 1) { entry->disposition |= AV_DISPOSITION_KARAOKE; av_log(s, AV_LOG_WARNING, "Extended karaoke metadata is not supported at this time " "(stream id=%d)\n", startcode); } if (audio_attr.code_extension == 2) entry->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; if (audio_attr.code_extension == 3 || audio_attr.code_extension == 4) entry->disposition |= AV_DISPOSITION_COMMENT; AV_WB16(lang_dvd, audio_attr.lang_code); entry->startcode = startcode; entry->codec_id = codec_id; entry->sample_rate = sample_rate; entry->bit_depth = bit_depth; entry->nb_channels = nb_channels; entry->ch_layout = ch_layout; entry->lang_iso = ff_convert_lang_to(lang_dvd, AV_LANG_ISO639_2_BIBL); return 0; } static int dvdvideo_audio_stream_add(AVFormatContext *s, DVDVideoPGCAudioStreamEntry *entry, enum AVStreamParseType need_parsing) { AVStream *st; FFStream *sti; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->id = entry->startcode; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_id = entry->codec_id; st->codecpar->format = entry->sample_fmt; st->codecpar->sample_rate = entry->sample_rate; st->codecpar->bits_per_coded_sample = entry->bit_depth; st->codecpar->bits_per_raw_sample = entry->bit_depth; st->codecpar->ch_layout = entry->ch_layout; st->codecpar->ch_layout.nb_channels = entry->nb_channels; st->disposition = entry->disposition; if (entry->lang_iso) av_dict_set(&st->metadata, "language", entry->lang_iso, 0); sti = ffstream(st); sti->request_probe = 0; sti->need_parsing = need_parsing; avpriv_set_pts_info(st, DVDVIDEO_PTS_WRAP_BITS, DVDVIDEO_TIME_BASE_Q.num, DVDVIDEO_TIME_BASE_Q.den); return 0; } static int dvdvideo_audio_stream_add_all(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; int ret = 0; for (int i = 0; i < c->vts_ifo->vtsi_mat->nr_of_vts_audio_streams; i++) { DVDVideoPGCAudioStreamEntry entry = {0}; if (!(c->play_state.pgc->audio_control[i] & 0x8000)) continue; if ((ret = dvdvideo_audio_stream_analyze(s, c->vts_ifo->vtsi_mat->vts_audio_attr[i], c->play_state.pgc->audio_control[i], &entry)) < 0) goto break_error; /* IFO structures can declare duplicate entries for the same startcode */ for (int j = 0; j < s->nb_streams; j++) if (s->streams[j]->id == entry.startcode) continue; if ((ret = dvdvideo_audio_stream_add(s, &entry, AVSTREAM_PARSE_HEADERS)) < 0) goto break_error; continue; break_error: av_log(s, AV_LOG_ERROR, "Unable to add audio stream at position %d\n", i); return ret; } return 0; } static int dvdvideo_subp_stream_analyze(AVFormatContext *s, uint32_t offset, subp_attr_t subp_attr, DVDVideoPGCSubtitleStreamEntry *entry) { char lang_dvd[3] = {0}; entry->startcode = 0x20 + (offset & 0x1F); if (subp_attr.lang_extension == 9) entry->disposition |= AV_DISPOSITION_FORCED; AV_WB16(lang_dvd, subp_attr.lang_code); entry->lang_iso = ff_convert_lang_to(lang_dvd, AV_LANG_ISO639_2_BIBL); return 0; } static int dvdvideo_subp_stream_add(AVFormatContext *s, DVDVideoPGCSubtitleStreamEntry *entry, enum AVStreamParseType need_parsing) { AVStream *st; FFStream *sti; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->id = entry->startcode; st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codecpar->codec_id = AV_CODEC_ID_DVD_SUBTITLE; if (entry->lang_iso) av_dict_set(&st->metadata, "language", entry->lang_iso, 0); av_dict_set(&st->metadata, "VIEWPORT", dvdvideo_subp_viewport_labels[entry->viewport], 0); st->disposition = entry->disposition; sti = ffstream(st); sti->request_probe = 0; sti->need_parsing = need_parsing; avpriv_set_pts_info(st, DVDVIDEO_PTS_WRAP_BITS, DVDVIDEO_TIME_BASE_Q.num, DVDVIDEO_TIME_BASE_Q.den); return 0; } static int dvdvideo_subp_stream_add_internal(AVFormatContext *s, uint32_t offset, subp_attr_t subp_attr, enum DVDVideoSubpictureViewport viewport) { int ret = 0; DVDVideoPGCSubtitleStreamEntry entry = {0}; entry.viewport = viewport; if ((ret = dvdvideo_subp_stream_analyze(s, offset, subp_attr, &entry)) < 0) goto end_error; /* IFO structures can declare duplicate entries for the same startcode */ for (int i = 0; i < s->nb_streams; i++) if (s->streams[i]->id == entry.startcode) return 0; if ((ret = dvdvideo_subp_stream_add(s, &entry, AVSTREAM_PARSE_HEADERS)) < 0) goto end_error; return 0; end_error: av_log(s, AV_LOG_ERROR, "Unable to add subtitle stream\n"); return ret; } static int dvdvideo_subp_stream_add_all(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; for (int i = 0; i < c->vts_ifo->vtsi_mat->nr_of_vts_subp_streams; i++) { int ret = 0; uint32_t subp_control; subp_attr_t subp_attr; video_attr_t video_attr; subp_control = c->play_state.pgc->subp_control[i]; if (!(subp_control & 0x80000000)) continue; /* there can be several presentations for one SPU */ /* the DAR check is flexible in order to support weird authoring */ video_attr = c->vts_ifo->vtsi_mat->vts_video_attr; subp_attr = c->vts_ifo->vtsi_mat->vts_subp_attr[i]; /* 4:3 */ if (!video_attr.display_aspect_ratio) { if ((ret = dvdvideo_subp_stream_add_internal(s, subp_control >> 24, subp_attr, DVDVIDEO_SUBP_VIEWPORT_FULLSCREEN)) < 0) return ret; continue; } /* 16:9 */ if (( ret = dvdvideo_subp_stream_add_internal(s, subp_control >> 16, subp_attr, DVDVIDEO_SUBP_VIEWPORT_WIDESCREEN)) < 0) return ret; /* 16:9 letterbox */ if (video_attr.permitted_df == 2 || video_attr.permitted_df == 0) if ((ret = dvdvideo_subp_stream_add_internal(s, subp_control >> 8, subp_attr, DVDVIDEO_SUBP_VIEWPORT_LETTERBOX)) < 0) return ret; /* 16:9 pan-and-scan */ if (video_attr.permitted_df == 1 || video_attr.permitted_df == 0) if ((ret = dvdvideo_subp_stream_add_internal(s, subp_control, subp_attr, DVDVIDEO_SUBP_VIEWPORT_PANSCAN)) < 0) return ret; } return 0; } static void dvdvideo_subdemux_flush(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; if (!c->segment_started) return; av_log(s, AV_LOG_DEBUG, "flushing sub-demuxer\n"); avio_flush(&c->mpeg_pb.pub); ff_read_frame_flush(c->mpeg_ctx); c->segment_started = 0; } static int dvdvideo_subdemux_read_data(void *opaque, uint8_t *buf, int buf_size) { AVFormatContext *s = opaque; DVDVideoDemuxContext *c = s->priv_data; int ret = 0; int nav_event; if (c->play_end) return AVERROR_EOF; ret = dvdvideo_play_next_ps_block(opaque, &c->play_state, buf, buf_size, &nav_event, dvdvideo_subdemux_flush); if (ret == AVERROR_EOF) { c->mpeg_pb.pub.eof_reached = 1; c->play_end = 1; return AVERROR_EOF; } if (ret >= 0 && nav_event == DVDNAV_NAV_PACKET) return FFERROR_REDO; return ret; } static void dvdvideo_subdemux_close(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; av_freep(&c->mpeg_pb.pub.buffer); avformat_close_input(&c->mpeg_ctx); } static int dvdvideo_subdemux_open(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; extern const AVInputFormat ff_mpegps_demuxer; int ret = 0; if (!(c->mpeg_buf = av_mallocz(DVDVIDEO_BLOCK_SIZE))) return AVERROR(ENOMEM); ffio_init_context(&c->mpeg_pb, c->mpeg_buf, DVDVIDEO_BLOCK_SIZE, 0, s, dvdvideo_subdemux_read_data, NULL, NULL); c->mpeg_pb.pub.seekable = 0; if (!(c->mpeg_ctx = avformat_alloc_context())) return AVERROR(ENOMEM); if ((ret = ff_copy_whiteblacklists(c->mpeg_ctx, s)) < 0) { avformat_free_context(c->mpeg_ctx); c->mpeg_ctx = NULL; return ret; } c->mpeg_ctx->flags = AVFMT_FLAG_CUSTOM_IO | AVFMT_FLAG_GENPTS; c->mpeg_ctx->ctx_flags |= AVFMTCTX_UNSEEKABLE; c->mpeg_ctx->probesize = 0; c->mpeg_ctx->max_analyze_duration = 0; c->mpeg_ctx->interrupt_callback = s->interrupt_callback; c->mpeg_ctx->pb = &c->mpeg_pb.pub; c->mpeg_ctx->correct_ts_overflow = 0; c->mpeg_ctx->io_open = NULL; return avformat_open_input(&c->mpeg_ctx, "", &ff_mpegps_demuxer, NULL); } static int dvdvideo_read_header(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; int ret = 0; if (c->opt_title == 0) { av_log(s, AV_LOG_INFO, "Defaulting to title #1. " "This is not always the main feature, validation suggested.\n"); c->opt_title = 1; } if (c->opt_pgc) { if (c->opt_pg == 0) { av_log(s, AV_LOG_ERROR, "Invalid coordinates. If -pgc is set, -pg must be set too.\n"); return AVERROR(EINVAL); } else if (c->opt_chapter_start > 1 || c->opt_chapter_end > 0 || c->opt_preindex) { av_log(s, AV_LOG_ERROR, "-pgc is not compatible with the -preindex or " "-chapter_start/-chapter_end options\n"); return AVERROR(EINVAL); } } if ((ret = dvdvideo_ifo_open(s)) < 0) return ret; if (!c->opt_pgc && c->opt_preindex && (ret = dvdvideo_chapters_setup_preindex(s)) < 0) return ret; if ((ret = dvdvideo_play_open(s, &c->play_state)) < 0 || (ret = dvdvideo_subdemux_open(s)) < 0 || (ret = dvdvideo_video_stream_setup(s)) < 0 || (ret = dvdvideo_audio_stream_add_all(s)) < 0 || (ret = dvdvideo_subp_stream_add_all(s)) < 0) return ret; if (!c->opt_pgc && !c->opt_preindex) return dvdvideo_chapters_setup_simple(s); return 0; } static int dvdvideo_read_packet(AVFormatContext *s, AVPacket *pkt) { DVDVideoDemuxContext *c = s->priv_data; int ret; enum AVMediaType st_type; int found_stream = 0; if (c->play_end) return AVERROR_EOF; ret = av_read_frame(c->mpeg_ctx, pkt); if (ret < 0) return ret; if (!c->segment_started) c->segment_started = 1; st_type = c->mpeg_ctx->streams[pkt->stream_index]->codecpar->codec_type; /* map the subdemuxer stream to the parent demuxer's stream (by startcode) */ for (int i = 0; i < s->nb_streams; i++) { if (s->streams[i]->id == c->mpeg_ctx->streams[pkt->stream_index]->id) { pkt->stream_index = s->streams[i]->index; found_stream = 1; break; } } if (!found_stream) { av_log(s, AV_LOG_DEBUG, "discarding frame with stream that was not in IFO headers " "(stream id=%d)\n", c->mpeg_ctx->streams[pkt->stream_index]->id); return FFERROR_REDO; } if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE) { if (!c->play_started) { /* try to start at the beginning of a GOP */ if (st_type != AVMEDIA_TYPE_VIDEO || !(pkt->flags & AV_PKT_FLAG_KEY)) { av_log(s, AV_LOG_VERBOSE, "Discarding packet which is not a video keyframe or " "with unset PTS/DTS at start\n"); return FFERROR_REDO; } c->first_pts = pkt->pts; c->play_started = 1; } pkt->pts += c->play_state.ts_offset - c->first_pts; pkt->dts += c->play_state.ts_offset - c->first_pts; if (pkt->pts < 0) { av_log(s, AV_LOG_VERBOSE, "Discarding packet with negative PTS (st=%d pts=%ld), " "this is OK at start of playback\n", pkt->stream_index, pkt->pts); return FFERROR_REDO; } } else { av_log(s, AV_LOG_WARNING, "Unset PTS or DTS @ st=%d pts=%ld dts=%ld\n", pkt->stream_index, pkt->pts, pkt->dts); } av_log(s, AV_LOG_TRACE, "st=%d pts=%ld dts=%ld ts_offset=%ld first_pts=%ld\n", pkt->stream_index, pkt->pts, pkt->dts, c->play_state.ts_offset, c->first_pts); return c->play_end ? AVERROR_EOF : 0; } static int dvdvideo_close(AVFormatContext *s) { DVDVideoDemuxContext *c = s->priv_data; dvdvideo_subdemux_close(s); dvdvideo_play_close(s, &c->play_state); dvdvideo_ifo_close(s); return 0; } #define OFFSET(x) offsetof(DVDVideoDemuxContext, x) static const AVOption dvdvideo_options[] = { {"angle", "playback angle number", OFFSET(opt_angle), AV_OPT_TYPE_INT, { .i64=1 }, 1, 9, AV_OPT_FLAG_DECODING_PARAM }, {"chapter_end", "exit chapter (PTT) number (0=end)", OFFSET(opt_chapter_end), AV_OPT_TYPE_INT, { .i64=0 }, 0, 99, AV_OPT_FLAG_DECODING_PARAM }, {"chapter_start", "entry chapter (PTT) number", OFFSET(opt_chapter_start), AV_OPT_TYPE_INT, { .i64=1 }, 1, 99, AV_OPT_FLAG_DECODING_PARAM }, {"pg", "entry PG number (0=auto)", OFFSET(opt_pg), AV_OPT_TYPE_INT, { .i64=0 }, 0, 255, AV_OPT_FLAG_DECODING_PARAM }, {"pgc", "entry PGC number (0=auto)", OFFSET(opt_pgc), AV_OPT_TYPE_INT, { .i64=0 }, 0, 999, AV_OPT_FLAG_DECODING_PARAM }, {"preindex", "enable for accurate chapter markers, slow (2-pass read)", OFFSET(opt_preindex), AV_OPT_TYPE_BOOL, { .i64=0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, {"region", "playback region number (0=free)", OFFSET(opt_region), AV_OPT_TYPE_INT, { .i64=0 }, 0, 8, AV_OPT_FLAG_DECODING_PARAM }, {"title", "title number (0=auto)", OFFSET(opt_title), AV_OPT_TYPE_INT, { .i64=0 }, 0, 99, AV_OPT_FLAG_DECODING_PARAM }, {"trim", "trim padding cells from start", OFFSET(opt_trim), AV_OPT_TYPE_BOOL, { .i64=1 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, {NULL} }; static const AVClass dvdvideo_class = { .class_name = "DVD-Video demuxer", .item_name = av_default_item_name, .option = dvdvideo_options, .version = LIBAVUTIL_VERSION_INT }; const AVInputFormat ff_dvdvideo_demuxer = { .name = "dvdvideo", .long_name = NULL_IF_CONFIG_SMALL("DVD-Video"), .priv_class = &dvdvideo_class, .priv_data_size = sizeof(DVDVideoDemuxContext), .flags = AVFMT_NOFILE | AVFMT_SHOW_IDS | AVFMT_TS_DISCONT | AVFMT_NO_BYTE_SEEK | AVFMT_NOGENSEARCH | AVFMT_NOBINSEARCH, .flags_internal = FF_FMT_INIT_CLEANUP, .read_close = dvdvideo_close, .read_header = dvdvideo_read_header, .read_packet = dvdvideo_read_packet };