git.sesse.net Git - vlc/blob - modules/codec/ogt/ogt_parse.c

   1 /*****************************************************************************
   2  * Philips OGT (SVCD subtitle) packet parser
   3  *****************************************************************************
   4  * Copyright (C) 2003 VideoLAN
   5  * $Id: ogt_parse.c,v 1.4 2003/12/30 04:43:52 rocky Exp $
   6  *
   7  * Author: Rocky Bernstein
   8  *   based on code from:
   9  *       Julio Sanchez Fernandez (http://subhandler.sourceforge.net)
  10  *       Sam Hocevar <sam@zoy.org>
  11  *       Laurent Aimar <fenrir@via.ecp.fr>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  26  *****************************************************************************/
  27
  28 /*****************************************************************************
  29  * Preamble
  30  *****************************************************************************/
  31 #include <vlc/vlc.h>
  32 #include <vlc/vout.h>
  33 #include <vlc/decoder.h>
  34
  35 #include "subtitle.h"
  36 #include "common.h"
  37 #include "render.h"
  38 #include "ogt.h"
  39
  40 /* An image color is a two-bit palette entry: 0..3 */
  41 typedef uint8_t ogt_color_t;
  42
  43 /*****************************************************************************
  44  * Local prototypes.
  45  *****************************************************************************/
  46 static int  ParseImage         ( decoder_t *, subpicture_t * );
  47
  48 /*
  49   The format is roughly as follows (everything is big-endian):
  50
  51    size     description
  52    -------------------------------------------
  53    byte     subtitle channel (0..7) in bits 0-3
  54    byte     subtitle packet number of this subtitle image 0-N,
  55             if the subtitle packet is complete, the top bit of the byte is 1.
  56    u_int16  subtitle image number
  57    u_int16  length in bytes of the rest
  58    byte     option flags, unknown meaning except bit 3 (0x08) indicates
  59             presence of the duration field
  60    byte     unknown
  61    u_int32  duration in 1/90000ths of a second (optional), start time
  62             is as indicated by the PTS in the PES header
  63    u_int32  xpos
  64    u_int32  ypos
  65    u_int32  width (must be even)
  66    u_int32  height (must be even)
  67    byte[16] palette, 4 palette entries, each contains values for
  68             Y, U, V and transparency, 0 standing for transparent
  69    byte     command,
  70             cmd>>6==1 indicates shift
  71             (cmd>>4)&3 is direction from, (0=top,1=left,2=right,3=bottom)
  72    u_int32  shift duration in 1/90000ths of a second
  73    u_int16  offset of odd-numbered scanlines - subtitle images are
  74             given in interlace order
  75    byte[]   limited RLE image data in interlace order (0,2,4... 1,3,5) with
  76             2-bits per palette number
  77 */
  78
  79 /* FIXME: do we really need p_buffer and p?
  80    Can't all of thes _offset's and _lengths's get removed?
  81 */
  82 void E_(ParseHeader)( decoder_t *p_dec, uint8_t *p_buffer, block_t *p_block )
  83 {
  84   decoder_sys_t *p_sys = p_dec->p_sys;
  85   u_int8_t *p = p_buffer;
  86   int i;
  87
  88   dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
  89
  90   p_sys->i_pts    = p_block->i_pts;
  91   p_sys->i_spu_size = GETINT16(p);
  92   p_sys->i_options  = *p++;
  93   p_sys->i_options2 = *p++;
  94
  95   if ( p_sys->i_options & 0x08 ) {
  96     p_sys->i_duration = GETINT32(p);
  97   } else {
  98     /* 0 means display until next subtitle comes in. */
  99     p_sys->i_duration = 0;
 100   }
 101   p_sys->i_x_start= GETINT16(p);
 102   p_sys->i_y_start= GETINT16(p);
 103   p_sys->i_width  = GETINT16(p);
 104   p_sys->i_height = GETINT16(p);
 105
 106   for (i=0; i<4; i++) {
 107     p_sys->pi_palette[i].s.y = *p++;
 108     p_sys->pi_palette[i].s.u = *p++;
 109     p_sys->pi_palette[i].s.v = *p++;
 110     /* OGT has 8-bit resolution for alpha, but DVD's and CVDS use 4-bits.
 111        Since we want to use the same render routine, rather than scale up
 112        CVD (and DVD) subtitles, we'll scale down ours.
 113     */
 114     p_sys->pi_palette[i].s.t = (*p++) >> 4;
 115   }
 116   p_sys->i_cmd = *p++;
 117       /* We do not really know this, FIXME */
 118   if ( p_sys->i_cmd ) {
 119     p_sys->i_cmd_arg = GETINT32(p);
 120   }
 121
 122   /* Actually, this is measured against a different origin, so we have to
 123      adjust it */
 124   p_sys->second_field_offset = GETINT16(p);
 125   p_sys->comp_image_offset = p - p_buffer;
 126   p_sys->comp_image_length = p_sys->i_spu_size - p_sys->comp_image_offset;
 127   p_sys->metadata_length   = p_sys->comp_image_offset;
 128
 129   if (p_sys && p_sys->i_debug & DECODE_DBG_PACKET) {
 130     msg_Dbg( p_dec, "x-start: %d, y-start: %d, width: %d, height %d, "
 131              "spu size: %d, duration: %u (d:%d p:%d)",
 132              p_sys->i_x_start, p_sys->i_y_start,
 133              p_sys->i_width, p_sys->i_height,
 134              p_sys->i_spu_size, p_sys->i_duration,
 135              p_sys->comp_image_length, p_sys->comp_image_offset);
 136
 137     for (i=0; i<4; i++) {
 138       msg_Dbg( p_dec, "palette[%d]= T: %2x, Y: %2x, u: %2x, v: %2x", i,
 139                p_sys->pi_palette[i].s.t, p_sys->pi_palette[i].s.y,
 140                p_sys->pi_palette[i].s.u, p_sys->pi_palette[i].s.v );
 141     }
 142   }
 143 }
 144
 145
 146 /*****************************************************************************
 147  * ParsePacket: parse an SPU packet and send it to the video output
 148  *****************************************************************************
 149  * This function parses the SPU packet and, if valid, sends it to the
 150  * video output.
 151  *****************************************************************************/
 152 void
 153 E_(ParsePacket)( decoder_t *p_dec)
 154 {
 155     decoder_sys_t *p_sys = p_dec->p_sys;
 156
 157     subpicture_t  *p_spu;
 158
 159     dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
 160
 161     /* Allocate the subpicture internal data. */
 162     p_spu = vout_CreateSubPicture( p_sys->p_vout, MEMORY_SUBPICTURE );
 163     if( p_spu == NULL )
 164     {
 165         return;
 166     }
 167
 168     /* In ParseImage we expand the run-length encoded color 0's; also
 169        we expand pixels and remove the color palette. This should
 170        facilitate scaling and antialiasing and speed up rendering.
 171     */
 172     p_spu->p_sys = malloc( sizeof( subpicture_sys_t )
 173                            + PIXEL_SIZE * (p_sys->i_width * p_sys->i_height) );
 174
 175     /* Fill the p_spu structure */
 176     vlc_mutex_init( p_dec, &p_spu->p_sys->lock );
 177
 178     p_spu->pf_render  = VCDSubRender;
 179     p_spu->pf_destroy = VCDSubDestroySPU;
 180     p_spu->p_sys->p_data = (uint8_t*)p_spu->p_sys + sizeof( subpicture_sys_t );
 181
 182     p_spu->p_sys->i_x_end        = p_sys->i_x_start + p_sys->i_width - 1;
 183     p_spu->p_sys->i_y_end        = p_sys->i_y_start + p_sys->i_height - 1;
 184
 185     /* FIXME: use aspect ratio for x? */
 186     p_spu->i_x        = p_sys->i_x_start * 3 / 4;
 187     p_spu->i_y        = p_sys->i_y_start;
 188     p_spu->i_width    = p_sys->i_width;
 189     p_spu->i_height   = p_sys->i_height;
 190
 191     p_spu->i_start    = p_sys->i_pts;
 192     p_spu->i_stop     = p_sys->i_pts + (p_sys->i_duration * 10);
 193
 194     p_spu->p_sys->b_crop  = VLC_FALSE;
 195     p_spu->p_sys->i_debug = p_sys->i_debug;
 196
 197     /* Get display time now. If we do it later, we may miss the PTS. */
 198     p_spu->p_sys->i_pts = p_sys->i_pts;
 199
 200     /* Attach to our input thread */
 201     p_spu->p_sys->p_input = vlc_object_find( p_dec,
 202                                              VLC_OBJECT_INPUT, FIND_PARENT );
 203
 204     /* We try to display it */
 205     if( ParseImage( p_dec, p_spu ) )
 206     {
 207         /* There was a parse error, delete the subpicture */
 208         vout_DestroySubPicture( p_sys->p_vout, p_spu );
 209         return;
 210     }
 211
 212     /* SPU is finished - we can ask the video output to display it */
 213     vout_DisplaySubPicture( p_sys->p_vout, p_spu );
 214
 215 }
 216
 217 /* Advance pointer to image pointer, update internal i_2bit_field counter
 218    and check that we haven't goine too far  in the image data. */
 219 #define advance_color_pointer_byte                                      \
 220   p++;                                                                  \
 221   i_2bit_field=4;                                                       \
 222   if (p >= maxp) {                                                      \
 223     msg_Warn( p_dec,                                                    \
 224               "broken subtitle - tried to access beyond end "           \
 225               "in image extraction");                                   \
 226     return VLC_EGENERIC;                                                \
 227   }                                                                     \
 228
 229 #define advance_color_pointer                                           \
 230   i_2bit_field--;                                                       \
 231   if ( i_2bit_field == 0 ) {                                            \
 232     advance_color_pointer_byte;                                         \
 233   }
 234
 235 #define OGT_FIELD_BITS (2)
 236 #define OGT_FIELD_MASK  ((1<<OGT_FIELD_BITS) - 1)
 237
 238 /* Get the next field - either a palette index or a RLE count for
 239    color 0.  To do this we use byte image pointer p, and i_2bit_field
 240    which indicates where we are in the byte.
 241 */
 242 static inline ogt_color_t
 243 ExtractField(uint8_t *p, unsigned int i_2bit_field)
 244 {
 245   return ( ( *p >> (OGT_FIELD_BITS*(i_2bit_field-1)) ) & OGT_FIELD_MASK );
 246 }
 247
 248 /*****************************************************************************
 249  * ParseImage: parse the image part of the subtitle
 250  *****************************************************************************
 251  This part parses the subtitle graphical data and stores it in a more
 252  convenient structure for later rendering.
 253
 254  The image is encoded using two bits per pixel that select a palette
 255  entry except that value 0 starts a limited run-length encoding for
 256  color 0.  When 0 is seen, the next two bits encode one less than the
 257  number of pixels, so we can encode run lengths from 1 to 4. These get
 258  filled with the color in palette entry 0.
 259
 260  The encoding of each line is padded to a whole number of bytes.  The
 261  first field is padded to an even byte length and the complete subtitle
 262  is padded to a 4-byte multiple that always include one zero byte at
 263  the end.
 264
 265  However we'll transform this so that that the RLE is expanded and
 266  interlacing will also be removed. On output each pixel entry will by
 267  an 4-bit alpha (filling 8 bits), and 8-bit y, u, and v entry.
 268
 269  *****************************************************************************/
 270 static int
 271 ParseImage( decoder_t *p_dec, subpicture_t * p_spu )
 272 {
 273     decoder_sys_t *p_sys = p_dec->p_sys;
 274
 275     unsigned int i_field;  /* The subtitles are interlaced, are we on an
 276                               even or odd scanline?  */
 277
 278     unsigned int i_row;    /* scanline row number */
 279     unsigned int i_column; /* scanline column number */
 280
 281     unsigned int i_width  = p_sys->i_width;
 282     unsigned int i_height = p_sys->i_height;
 283
 284     uint8_t *p_dest = (uint8_t *)p_spu->p_sys->p_data;
 285
 286     uint8_t i_2bit_field;           /* The 2-bit field to sue in byte of *p.
 287                                        Has value 0..4. */
 288     uint8_t i_pending_zero = 0;    /* number of pixels to fill with
 289                                       color zero 0..3 */
 290     ogt_color_t i_color;           /* current pixel color: 0..3 */
 291     uint8_t *p = p_sys->subtitle_data  + p_sys->comp_image_offset;
 292     uint8_t *maxp = p + p_sys->comp_image_length;
 293
 294     dbg_print( (DECODE_DBG_CALL) , "width x height: %dx%d ",
 295                i_width, i_height);
 296
 297     if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)
 298       printf("\n");
 299
 300     for ( i_field=0; i_field < 2; i_field++ ) {
 301       i_2bit_field = 4;
 302       for ( i_row=i_field; i_row < i_height; i_row += 2 ) {
 303         for ( i_column=0; i_column<i_width; i_column++ ) {
 304
 305           if ( i_pending_zero ) {
 306             /* We are in the middle of a RLE expansion, just decrement and
 307                fall through with current color value */
 308             i_pending_zero--;
 309             i_color = 0;
 310           } else {
 311             i_color = ExtractField( p, i_2bit_field );
 312             advance_color_pointer;
 313             if ( i_color == 0 ) {
 314               i_pending_zero = ExtractField( p, i_2bit_field );
 315               advance_color_pointer;
 316               /* Fall through with i_color == 0 to output the first cell */
 317             }
 318           }
 319
 320           /* Color is 0-3. */
 321           p_dest[i_row*i_width+i_column] = i_color;
 322
 323           if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)
 324             printf("%1d", i_color);
 325
 326         }
 327
 328         if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)
 329           printf("\n");
 330
 331         if ( i_2bit_field != 4 ) {
 332           /* Lines are padded to complete bytes, ignore padding */
 333           advance_color_pointer_byte;
 334         }
 335       }
 336       p = p_sys->subtitle_data + p_sys->comp_image_offset
 337         + p_sys->second_field_offset;
 338     }
 339
 340     /* Dump out image not interlaced... */
 341     if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE) {
 342       uint8_t *p = p_dest;
 343       printf("-------------------------------------\n++");
 344       for ( i_row=0; i_row < i_height; i_row ++ ) {
 345         for ( i_column=0; i_column<i_width; i_column++ ) {
 346           printf("%1d", *p++ & 0x03);
 347         }
 348         printf("\n++");
 349       }
 350       printf("\n-------------------------------------\n");
 351     }
 352
 353     VCDInlinePalette( p_dest, p_sys, i_height, i_width );
 354
 355     /* The video is automatically scaled. However subtitle bitmaps
 356        assume a 1:1 aspect ratio. So we need to scale to compensate for
 357        or undo the effects of video output scaling.
 358     */
 359     /* FIXME do the right scaling depending on vout. It may not be 4:3 */
 360     VCDSubScaleX( p_dec, p_spu, 3, 4 );
 361
 362     return VLC_SUCCESS;
 363 }
 364