/* GStreamer Sub-Picture Unit - VobSub/DVD handling * Copyright (C) 2009 Jan Schmidt <thaytan@noraisin.net> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifdef HAVE_CONFIG_H # include <config.h> #endif #include <string.h> #include <gst/gst.h> #include "gstdvdspu.h" #include "gstspu-vobsub.h" GST_DEBUG_CATEGORY_EXTERN (dvdspu_debug); #define GST_CAT_DEFAULT dvdspu_debug /* Define to dump out a text description of the incoming SPU commands */ #define DUMP_DCSQ 0 /* Convert an STM offset in the SPU sequence to a GStreamer timestamp */ #define STM_TO_GST(stm) ((GST_MSECOND * 1024 * (stm)) / 90) typedef enum SpuVobsubCmd SpuVobsubCmd; enum SpuVobsubCmd { SPU_CMD_FSTA_DSP = 0x00, /* Forced Display */ SPU_CMD_DSP = 0x01, /* Display Start */ SPU_CMD_STP_DSP = 0x02, /* Display Off */ SPU_CMD_SET_COLOR = 0x03, /* Set the color indexes for the palette */ SPU_CMD_SET_ALPHA = 0x04, /* Set the alpha indexes for the palette */ SPU_CMD_SET_DAREA = 0x05, /* Set the display area for the SPU */ SPU_CMD_DSPXA = 0x06, /* Pixel data addresses */ SPU_CMD_CHG_COLCON = 0x07, /* Change Color & Contrast */ SPU_CMD_END = 0xff }; static void gst_dvd_spu_parse_chg_colcon (GstDVDSpu * dvdspu, guint8 * data, guint8 * end) { SpuState *state = &dvdspu->spu_state; guint8 *cur; gint16 n_entries; gint16 i; /* Clear any existing chg colcon info */ state->vobsub.n_line_ctrl_i = 0; if (state->vobsub.line_ctrl_i != NULL) { g_free (state->vobsub.line_ctrl_i); state->vobsub.line_ctrl_i = NULL; } GST_DEBUG_OBJECT (dvdspu, "Change Color & Contrast. Pixel data = %d bytes", (gint16) (end - data)); /* Count the number of entries we'll need */ n_entries = 0; for (cur = data; cur < end;) { guint8 n_changes; guint32 code; if (cur + 4 > end) break; code = GST_READ_UINT32_BE (cur); if (code == 0x0fffffff) break; /* Termination code */ n_changes = CLAMP ((cur[2] >> 4), 1, 8); cur += 4 + (6 * n_changes); if (cur > end) break; /* Invalid entry overrunning buffer */ n_entries++; } state->vobsub.n_line_ctrl_i = n_entries; state->vobsub.line_ctrl_i = g_new (SpuVobsubLineCtrlI, n_entries); cur = data; for (i = 0; i < n_entries; i++) { SpuVobsubLineCtrlI *cur_line_ctrl = state->vobsub.line_ctrl_i + i; guint8 n_changes = CLAMP ((cur[2] >> 4), 1, 8); guint8 c; cur_line_ctrl->n_changes = n_changes; cur_line_ctrl->top = ((cur[0] << 8) & 0x300) | cur[1]; cur_line_ctrl->bottom = ((cur[2] << 8) & 0x300) | cur[3]; GST_LOG_OBJECT (dvdspu, "ChgColcon Entry %d Top: %d Bottom: %d Changes: %d", i, cur_line_ctrl->top, cur_line_ctrl->bottom, n_changes); cur += 4; for (c = 0; c < n_changes; c++) { SpuVobsubPixCtrlI *cur_pix_ctrl = cur_line_ctrl->pix_ctrl_i + c; cur_pix_ctrl->left = ((cur[0] << 8) & 0x300) | cur[1]; cur_pix_ctrl->palette = GST_READ_UINT32_BE (cur + 2); GST_LOG_OBJECT (dvdspu, " %d: left: %d palette 0x%x", c, cur_pix_ctrl->left, cur_pix_ctrl->palette); cur += 6; } } } static void gst_dvd_spu_exec_cmd_blk (GstDVDSpu * dvdspu, guint8 * data, guint8 * end) { SpuState *state = &dvdspu->spu_state; while (data < end) { guint8 cmd; cmd = data[0]; switch (cmd) { case SPU_CMD_FSTA_DSP: GST_DEBUG_OBJECT (dvdspu, " Forced Display"); state->flags |= SPU_STATE_FORCED_DSP; data += 1; break; case SPU_CMD_DSP: GST_DEBUG_OBJECT (dvdspu, " Display On"); state->flags |= SPU_STATE_DISPLAY; data += 1; break; case SPU_CMD_STP_DSP: GST_DEBUG_OBJECT (dvdspu, " Display Off"); state->flags &= ~(SPU_STATE_FORCED_DSP | SPU_STATE_DISPLAY); data += 1; break; case SPU_CMD_SET_COLOR:{ if (G_UNLIKELY (data + 3 >= end)) return; /* Invalid SET_COLOR cmd at the end of the blk */ state->vobsub.main_idx[3] = data[1] >> 4; state->vobsub.main_idx[2] = data[1] & 0x0f; state->vobsub.main_idx[1] = data[2] >> 4; state->vobsub.main_idx[0] = data[2] & 0x0f; state->vobsub.main_pal_dirty = TRUE; GST_DEBUG_OBJECT (dvdspu, " Set Color bg %u pattern %u emph-1 %u emph-2 %u", state->vobsub.main_idx[0], state->vobsub.main_idx[1], state->vobsub.main_idx[2], state->vobsub.main_idx[3]); data += 3; break; } case SPU_CMD_SET_ALPHA:{ if (G_UNLIKELY (data + 3 >= end)) return; /* Invalid SET_ALPHA cmd at the end of the blk */ state->vobsub.main_alpha[3] = data[1] >> 4; state->vobsub.main_alpha[2] = data[1] & 0x0f; state->vobsub.main_alpha[1] = data[2] >> 4; state->vobsub.main_alpha[0] = data[2] & 0x0f; state->vobsub.main_pal_dirty = TRUE; GST_DEBUG_OBJECT (dvdspu, " Set Alpha bg %u pattern %u emph-1 %u emph-2 %u", state->vobsub.main_alpha[0], state->vobsub.main_alpha[1], state->vobsub.main_alpha[2], state->vobsub.main_alpha[3]); data += 3; break; } case SPU_CMD_SET_DAREA:{ SpuRect *r = &state->vobsub.disp_rect; if (G_UNLIKELY (data + 7 >= end)) return; /* Invalid SET_DAREA cmd at the end of the blk */ r->top = ((data[4] & 0xff) << 4) | ((data[5] & 0xf0) >> 4); r->left = ((data[1] & 0xff) << 4) | ((data[2] & 0xf0) >> 4); r->right = ((data[2] & 0x0f) << 8) | data[3]; r->bottom = ((data[5] & 0x0f) << 8) | data[6]; GST_DEBUG_OBJECT (dvdspu, " Set Display Area top %u left %u bottom %u right %u", r->top, r->left, r->bottom, r->right); data += 7; break; } case SPU_CMD_DSPXA:{ if (G_UNLIKELY (data + 5 >= end)) return; /* Invalid SET_DSPXE cmd at the end of the blk */ state->vobsub.pix_data[0] = GST_READ_UINT16_BE (data + 1); state->vobsub.pix_data[1] = GST_READ_UINT16_BE (data + 3); /* Store a reference to the current command buffer, as that's where * we'll need to take our pixel data from */ gst_buffer_replace (&state->vobsub.pix_buf, state->vobsub.buf); GST_DEBUG_OBJECT (dvdspu, " Set Pixel Data Offsets top: %u bot: %u", state->vobsub.pix_data[0], state->vobsub.pix_data[1]); data += 5; break; } case SPU_CMD_CHG_COLCON:{ guint16 field_size; GST_DEBUG_OBJECT (dvdspu, " Set Color & Contrast Change"); if (G_UNLIKELY (data + 3 >= end)) return; /* Invalid CHG_COLCON cmd at the end of the blk */ data++; field_size = GST_READ_UINT16_BE (data); if (G_UNLIKELY (data + field_size >= end)) return; /* Invalid CHG_COLCON cmd at the end of the blk */ gst_dvd_spu_parse_chg_colcon (dvdspu, data + 2, data + field_size); state->vobsub.line_ctrl_i_pal_dirty = TRUE; data += field_size; break; } case SPU_CMD_END: default: GST_DEBUG_OBJECT (dvdspu, " END"); data = end; break; } } } static void gst_dvd_spu_finish_spu_buf (GstDVDSpu * dvdspu) { SpuState *state = &dvdspu->spu_state; state->next_ts = state->vobsub.base_ts = GST_CLOCK_TIME_NONE; gst_buffer_replace (&state->vobsub.buf, NULL); GST_DEBUG_OBJECT (dvdspu, "Finished SPU buffer"); } static gboolean gst_dvd_spu_setup_cmd_blk (GstDVDSpu * dvdspu, guint16 cmd_blk_offset, guint8 * start, guint8 * end) { SpuState *state = &dvdspu->spu_state; guint16 delay; guint8 *cmd_blk = start + cmd_blk_offset; if (G_UNLIKELY (cmd_blk + 5 >= end)) { GST_DEBUG_OBJECT (dvdspu, "No valid command block"); return FALSE; /* No valid command block to read */ } delay = GST_READ_UINT16_BE (cmd_blk); state->next_ts = state->vobsub.base_ts + STM_TO_GST (delay); state->vobsub.cur_cmd_blk = cmd_blk_offset; GST_DEBUG_OBJECT (dvdspu, "Setup CMD Block @ %u with TS %" GST_TIME_FORMAT, state->vobsub.cur_cmd_blk, GST_TIME_ARGS (state->next_ts)); return TRUE; } #if DUMP_DCSQ static void gst_dvd_spu_dump_dcsq (GstDVDSpu * dvdspu, GstClockTime start_ts, GstBuffer * spu_buf) { guint16 cmd_blk_offset; guint16 next_blk; guint8 *start, *end; start = GST_BUFFER_DATA (spu_buf); end = start + GST_BUFFER_SIZE (spu_buf); g_return_if_fail (start != NULL); /* First command */ next_blk = GST_READ_UINT16_BE (start + 2); cmd_blk_offset = 0; /* Loop through all commands */ g_print ("SPU begins @ %" GST_TIME_FORMAT " offset %u\n", GST_TIME_ARGS (start_ts), next_blk); while (cmd_blk_offset != next_blk) { guint8 *data; GstClockTime cmd_blk_ts; cmd_blk_offset = next_blk; if (G_UNLIKELY (start + cmd_blk_offset + 5 >= end)) break; /* No valid command to read */ data = start + cmd_blk_offset; cmd_blk_ts = start_ts + STM_TO_GST (GST_READ_UINT16_BE (data)); next_blk = GST_READ_UINT16_BE (data + 2); g_print ("Cmd Blk @ offset %u next %u ts %" GST_TIME_FORMAT "\n", cmd_blk_offset, next_blk, GST_TIME_ARGS (cmd_blk_ts)); data += 4; gst_dvd_spu_exec_cmd_blk (dvdspu, data, end); } } #endif void gstspu_vobsub_handle_new_buf (GstDVDSpu * dvdspu, GstClockTime event_ts, GstBuffer * buf) { GstMapInfo map; guint8 *start, *end; SpuState *state = &dvdspu->spu_state; #if DUMP_DCSQ gst_dvd_spu_dump_dcsq (dvdspu, event_ts, buf); #endif if (G_UNLIKELY (gst_buffer_get_size (buf) < 4)) goto invalid; if (state->vobsub.buf != NULL) { gst_buffer_unref (state->vobsub.buf); state->vobsub.buf = NULL; } state->vobsub.buf = buf; state->vobsub.base_ts = event_ts; gst_buffer_map (state->vobsub.buf, &map, GST_MAP_READ); start = map.data; end = start + map.size; /* Configure the first command block in this buffer as our initial blk */ state->vobsub.cur_cmd_blk = GST_READ_UINT16_BE (start + 2); gst_dvd_spu_setup_cmd_blk (dvdspu, state->vobsub.cur_cmd_blk, start, end); /* Clear existing chg-colcon info */ state->vobsub.n_line_ctrl_i = 0; if (state->vobsub.line_ctrl_i != NULL) { g_free (state->vobsub.line_ctrl_i); state->vobsub.line_ctrl_i = NULL; } gst_buffer_unmap (state->vobsub.buf, &map); return; invalid: /* Invalid buffer */ gst_dvd_spu_finish_spu_buf (dvdspu); } gboolean gstspu_vobsub_execute_event (GstDVDSpu * dvdspu) { GstMapInfo map; guint8 *start, *cmd_blk, *end; guint16 next_blk; SpuState *state = &dvdspu->spu_state; gboolean ret = TRUE; if (state->vobsub.buf == NULL) return FALSE; GST_DEBUG_OBJECT (dvdspu, "Executing cmd blk with TS %" GST_TIME_FORMAT " @ offset %u", GST_TIME_ARGS (state->next_ts), state->vobsub.cur_cmd_blk); gst_buffer_map (state->vobsub.buf, &map, GST_MAP_READ); start = map.data; end = start + map.size; cmd_blk = start + state->vobsub.cur_cmd_blk; if (G_UNLIKELY (cmd_blk + 5 >= end)) { gst_buffer_unmap (state->vobsub.buf, &map); /* Invalid. Finish the buffer and loop again */ gst_dvd_spu_finish_spu_buf (dvdspu); return FALSE; } gst_dvd_spu_exec_cmd_blk (dvdspu, cmd_blk + 4, end); next_blk = GST_READ_UINT16_BE (cmd_blk + 2); if (next_blk != state->vobsub.cur_cmd_blk) { /* Advance to the next block of commands */ ret = gst_dvd_spu_setup_cmd_blk (dvdspu, next_blk, start, end); gst_buffer_unmap (state->vobsub.buf, &map); } else { /* Next Block points to the current block, so we're finished with this * SPU buffer */ gst_buffer_unmap (state->vobsub.buf, &map); gst_dvd_spu_finish_spu_buf (dvdspu); ret = FALSE; } return ret; } gboolean gstspu_vobsub_handle_dvd_event (GstDVDSpu * dvdspu, GstEvent * event) { const gchar *event_type; const GstStructure *structure = gst_event_get_structure (event); SpuState *state = &dvdspu->spu_state; gboolean hl_change = FALSE; event_type = gst_structure_get_string (structure, "event"); if (strcmp (event_type, "dvd-spu-clut-change") == 0) { gchar prop_name[32]; gint i; gint entry; for (i = 0; i < 16; i++) { g_snprintf (prop_name, 32, "clut%02d", i); if (!gst_structure_get_int (structure, prop_name, &entry)) entry = 0; state->vobsub.current_clut[i] = (guint32) entry; } state->vobsub.main_pal_dirty = TRUE; state->vobsub.hl_pal_dirty = TRUE; state->vobsub.line_ctrl_i_pal_dirty = TRUE; hl_change = TRUE; } else if (strcmp (event_type, "dvd-spu-highlight") == 0) { gint val; if (gst_structure_get_int (structure, "palette", &val)) { state->vobsub.hl_idx[3] = ((guint32) (val) >> 28) & 0x0f; state->vobsub.hl_idx[2] = ((guint32) (val) >> 24) & 0x0f; state->vobsub.hl_idx[1] = ((guint32) (val) >> 20) & 0x0f; state->vobsub.hl_idx[0] = ((guint32) (val) >> 16) & 0x0f; state->vobsub.hl_alpha[3] = ((guint32) (val) >> 12) & 0x0f; state->vobsub.hl_alpha[2] = ((guint32) (val) >> 8) & 0x0f; state->vobsub.hl_alpha[1] = ((guint32) (val) >> 4) & 0x0f; state->vobsub.hl_alpha[0] = ((guint32) (val) >> 0) & 0x0f; state->vobsub.hl_pal_dirty = TRUE; } if (gst_structure_get_int (structure, "sx", &val)) state->vobsub.hl_rect.left = (gint16) val; if (gst_structure_get_int (structure, "sy", &val)) state->vobsub.hl_rect.top = (gint16) val; if (gst_structure_get_int (structure, "ex", &val)) state->vobsub.hl_rect.right = (gint16) val; if (gst_structure_get_int (structure, "ey", &val)) state->vobsub.hl_rect.bottom = (gint16) val; GST_INFO_OBJECT (dvdspu, "Highlight rect is now (%d,%d) to (%d,%d)", state->vobsub.hl_rect.left, state->vobsub.hl_rect.top, state->vobsub.hl_rect.right, state->vobsub.hl_rect.bottom); hl_change = TRUE; } else if (strcmp (event_type, "dvd-spu-reset-highlight") == 0) { if (state->vobsub.hl_rect.top != -1 || state->vobsub.hl_rect.bottom != -1) hl_change = TRUE; state->vobsub.hl_rect.top = -1; state->vobsub.hl_rect.bottom = -1; GST_INFO_OBJECT (dvdspu, "Highlight off"); } else if (strcmp (event_type, "dvd-set-subpicture-track") == 0) { gboolean forced_only; if (gst_structure_get_boolean (structure, "forced-only", &forced_only)) { gboolean was_forced = (state->flags & SPU_STATE_FORCED_ONLY); if (forced_only) state->flags |= SPU_STATE_FORCED_ONLY; else state->flags &= ~(SPU_STATE_FORCED_ONLY); if (was_forced != forced_only) hl_change = TRUE; } } gst_event_unref (event); return hl_change; } void gstspu_vobsub_flush (GstDVDSpu * dvdspu) { SpuState *state = &dvdspu->spu_state; if (state->vobsub.buf) { gst_buffer_unref (state->vobsub.buf); state->vobsub.buf = NULL; } if (state->vobsub.pix_buf) { gst_buffer_unref (state->vobsub.pix_buf); state->vobsub.pix_buf = NULL; } state->vobsub.base_ts = GST_CLOCK_TIME_NONE; state->vobsub.pix_data[0] = 0; state->vobsub.pix_data[1] = 0; state->vobsub.hl_rect.top = -1; state->vobsub.hl_rect.bottom = -1; state->vobsub.disp_rect.top = -1; state->vobsub.disp_rect.bottom = -1; state->vobsub.n_line_ctrl_i = 0; if (state->vobsub.line_ctrl_i != NULL) { g_free (state->vobsub.line_ctrl_i); state->vobsub.line_ctrl_i = NULL; } }