svcdsub.c 18.6 KB
Newer Older
1 2 3
/*****************************************************************************
 * svcdsub.c : Overlay Graphics Text (SVCD subtitles) decoder
 *****************************************************************************
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
4
 * Copyright (C) 2003, 2004 VLC authors and VideoLAN
5 6 7 8 9 10 11
 * $Id$
 *
 * Authors: Rocky Bernstein
 *          Gildas Bazin <gbazin@videolan.org>
 *          Julio Sanchez Fernandez (http://subhandler.sourceforge.net)
 *          Laurent Aimar <fenrir@via.ecp.fr>
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
12 13 14
 * This program 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
15 16 17 18
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
19 20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
21
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
22 23 24
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25 26 27 28 29
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
30 31 32 33
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

34
#include <vlc_common.h>
35
#include <vlc_plugin.h>
36
#include <vlc_codec.h>
37
#include <vlc_bits.h>
38 39 40 41 42 43 44 45

/*****************************************************************************
 * Module descriptor.
 *****************************************************************************/
static int  DecoderOpen   ( vlc_object_t * );
static int  PacketizerOpen( vlc_object_t * );
static void DecoderClose  ( vlc_object_t * );

46 47 48 49 50
vlc_module_begin ()
    set_description( N_("Philips OGT (SVCD subtitle) decoder") )
    set_shortname( N_("SVCD subtitles") )
    set_category( CAT_INPUT )
    set_subcategory( SUBCAT_INPUT_SCODEC )
51
    set_capability( "spu decoder", 50 )
52
    set_callbacks( DecoderOpen, DecoderClose )
53

54
    add_obsolete_integer ( MODULE_STRING "-debug" )
55

56 57 58 59 60
    add_submodule ()
    set_description( N_("Philips OGT (SVCD subtitle) packetizer") )
    set_capability( "packetizer", 50 )
    set_callbacks( PacketizerOpen, DecoderClose )
vlc_module_end ()
61 62 63 64

/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
65
static int      Decode( decoder_t *, block_t * );
66 67 68 69
static block_t *Packetize  ( decoder_t *, block_t ** );
static block_t *Reassemble ( decoder_t *, block_t * );
static void ParseHeader( decoder_t *, block_t * );
static subpicture_t *DecodePacket( decoder_t *, block_t * );
70 71
static void SVCDSubRenderImage( decoder_t *, block_t *, subpicture_region_t * );

72 73 74 75 76
#define GETINT16(p) ( (p[0] <<  8) +   p[1] )  ; p +=2;

#define GETINT32(p) ( (p[0] << 24) +  (p[1] << 16) +    \
                      (p[2] <<  8) +  (p[3]) ) ; p += 4;

77 78 79 80 81 82
typedef enum  {
  SUBTITLE_BLOCK_EMPTY    = 0,
  SUBTITLE_BLOCK_PARTIAL  = 1,
  SUBTITLE_BLOCK_COMPLETE = 2
} packet_state_t;

83 84
struct decoder_sys_t
{
85
  packet_state_t i_state; /* data-gathering state for this subtitle */
86

87
  block_t  *p_spu;        /* Bytes of the packet. */
88

89 90
  uint16_t i_image;       /* image number in the subtitle stream */
  uint8_t  i_packet;      /* packet number for above image number */
91

92
  size_t   i_spu_size;     /* goal for subtitle_data_pos while gathering,
93 94 95 96
                             size of used subtitle_data later */

  uint16_t i_image_offset;      /* offset from subtitle_data to compressed
                                   image data */
97 98 99 100
  size_t i_image_length;           /* size of the compressed image data */
  size_t second_field_offset;      /* offset of odd raster lines */
  size_t metadata_offset;          /* offset to data describing the image */
  size_t metadata_length;          /* length of metadata */
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119

  mtime_t i_duration;   /* how long to display the image, 0 stands
                           for "until next subtitle" */

  uint16_t i_x_start, i_y_start; /* position of top leftmost pixel of
                                    image when displayed */
  uint16_t i_width, i_height;    /* dimensions in pixels of image */

  uint8_t p_palette[4][4];       /* Palette of colors used in subtitle */
};

/*****************************************************************************
 * DecoderOpen: open/initialize the svcdsub decoder.
 *****************************************************************************/
static int DecoderOpen( vlc_object_t *p_this )
{
    decoder_t     *p_dec = (decoder_t*)p_this;
    decoder_sys_t *p_sys;

120
    if( p_dec->fmt_in.i_codec != VLC_CODEC_OGT )
121 122
        return VLC_EGENERIC;

123
    p_dec->p_sys = p_sys = calloc( 1, sizeof( decoder_sys_t ) );
124 125 126
    if( p_sys == NULL )
        return VLC_ENOMEM;

127

128
    p_sys->i_image = -1;
129 130 131 132

    p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
    p_sys->p_spu   = NULL;

133
    p_dec->fmt_out.i_codec = VLC_CODEC_OGT;
134

135 136
    p_dec->pf_decode    = Decode;
    p_dec->pf_packetize = Packetize;
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165

    return VLC_SUCCESS;
}

/*****************************************************************************
 * PacketizerOpen: open/initialize the svcdsub packetizer.
 *****************************************************************************/
static int PacketizerOpen( vlc_object_t *p_this )
{
    if( DecoderOpen( p_this ) != VLC_SUCCESS ) return VLC_EGENERIC;

    return VLC_SUCCESS;
}

/*****************************************************************************
 * DecoderClose: closes the svcdsub decoder/packetizer.
 *****************************************************************************/
void DecoderClose( vlc_object_t *p_this )
{
    decoder_t     *p_dec = (decoder_t*)p_this;
    decoder_sys_t *p_sys = p_dec->p_sys;

    if( p_sys->p_spu ) block_ChainRelease( p_sys->p_spu );
    free( p_sys );
}

/*****************************************************************************
 * Decode:
 *****************************************************************************/
166
static int Decode( decoder_t *p_dec, block_t *p_block )
167
{
168 169 170
#ifndef NDEBUG
    msg_Dbg( p_dec, "Decode" );
#endif
171

172 173
    if( p_block == NULL ) /* No Drain */
        return VLCDEC_SUCCESS;
174

175 176
    if( !(p_block = Reassemble( p_dec, p_block )) )
        return VLCDEC_SUCCESS;
177 178

    /* Parse and decode */
179 180 181 182
    subpicture_t *p_spu = DecodePacket( p_dec, p_block );
    if( p_spu != NULL )
        decoder_QueueSub( p_dec, p_spu );
    return VLCDEC_SUCCESS;
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
}

/*****************************************************************************
 * Packetize:
 *****************************************************************************/
static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
{
    block_t *p_block, *p_spu;

    if( pp_block == NULL || *pp_block == NULL ) return NULL;

    p_block = *pp_block;
    *pp_block = NULL;

    if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;

    p_spu->i_dts = p_spu->i_pts;
    p_spu->i_length = 0;

    return p_spu;
}

/*****************************************************************************
 Reassemble:

 The data for single screen subtitle may come in one of many
 non-contiguous packets of a stream. This routine is called when the
 next packet in the stream comes in. The job of this routine is to
 parse the header, if this is the beginning, and combine the packets
 into one complete subtitle unit.

 If everything is complete, we will return a block. Otherwise return
 NULL.


 The format of the beginning of the subtitle packet that is used here.

   size    description
   -------------------------------------------
   byte    subtitle channel (0..7) in bits 0-3
   byte    subtitle packet number of this subtitle image 0-N,
           if the subtitle packet is complete, the top bit of the byte is 1.
   uint16  subtitle image number

 *****************************************************************************/
#define SPU_HEADER_LEN 5

static block_t *Reassemble( decoder_t *p_dec, block_t *p_block )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    uint8_t *p_buffer;
    uint16_t i_expected_image;
    uint8_t  i_packet, i_expected_packet;

237
    if( p_block->i_flags & (BLOCK_FLAG_CORRUPTED) )
238 239 240 241 242
    {
        block_Release( p_block );
        return NULL;
    }

243 244
    if( p_block->i_buffer < SPU_HEADER_LEN )
    {
245
        msg_Dbg( p_dec, "invalid packet header (size %zu < %u)" ,
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
                 p_block->i_buffer, SPU_HEADER_LEN );
        block_Release( p_block );
        return NULL;
    }

    p_buffer = p_block->p_buffer;

    if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY )
    {
        i_expected_image  = p_sys->i_image + 1;
        i_expected_packet = 0;
    }
    else
    {
        i_expected_image  = p_sys->i_image;
        i_expected_packet = p_sys->i_packet + 1;
    }

264 265
    /* The dummy ES that the menu selection uses has an 0x70 at
       the head which we need to strip off. */
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
    p_buffer += 2;

    if( *p_buffer & 0x80 )
    {
        p_sys->i_state = SUBTITLE_BLOCK_COMPLETE;
        i_packet       = *p_buffer++ & 0x7F;
    }
    else
    {
        p_sys->i_state = SUBTITLE_BLOCK_PARTIAL;
        i_packet       = *p_buffer++;
    }

    p_sys->i_image = GETINT16(p_buffer);

    if( p_sys->i_image != i_expected_image )
    {
        msg_Warn( p_dec, "expected subtitle image %u but found %u",
                  i_expected_image, p_sys->i_image );
    }

    if( i_packet != i_expected_packet )
    {
        msg_Warn( p_dec, "expected subtitle image packet %u but found %u",
                  i_expected_packet, i_packet );
    }

    p_block->p_buffer += SPU_HEADER_LEN;
    p_block->i_buffer -= SPU_HEADER_LEN;

    p_sys->i_packet = i_packet;
    /* First packet in the subtitle block */
    if( !p_sys->i_packet ) ParseHeader( p_dec, p_block );

    block_ChainAppend( &p_sys->p_spu, p_block );

    if( p_sys->i_state == SUBTITLE_BLOCK_COMPLETE )
    {
        block_t *p_spu = block_ChainGather( p_sys->p_spu );

306 307 308 309 310 311 312 313 314 315
        if( unlikely( !p_spu ) )
        {
            block_ChainRelease( p_sys->p_spu );
            p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
            p_sys->p_spu = NULL;

            msg_Warn( p_dec, "unable to assemble blocks, discarding" );
            return NULL;
        }

316 317
        if( p_spu->i_buffer != p_sys->i_spu_size )
        {
318
            msg_Warn( p_dec, "subtitle packets size=%zu should be %zu",
319 320 321
                      p_spu->i_buffer, p_sys->i_spu_size );
        }

322
        msg_Dbg( p_dec, "subtitle packet complete, size=%zu", p_spu->i_buffer );
323 324

        p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
325
        p_sys->p_spu = NULL;
326 327 328 329 330 331 332 333 334 335 336
        return p_spu;
    }

    return NULL;
}

/******************************************************************************
  The format is roughly as follows (everything is big-endian):
 
   size     description
   -------------------------------------------
337
   byte     subtitle channel (0..7) in bits 0-3
338 339 340 341 342 343
   byte     subtitle packet number of this subtitle image 0-N,
            if the subtitle packet is complete, the top bit of the byte is 1.
   u_int16  subtitle image number
   u_int16  length in bytes of the rest
   byte     option flags, unknown meaning except bit 3 (0x08) indicates
            presence of the duration field
344
   byte     unknown
345 346 347 348 349 350 351 352 353 354 355 356
   u_int32  duration in 1/90000ths of a second (optional), start time
            is as indicated by the PTS in the PES header
   u_int32  xpos
   u_int32  ypos
   u_int32  width (must be even)
   u_int32  height (must be even)
   byte[16] palette, 4 palette entries, each contains values for
            Y, U, V and transparency, 0 standing for transparent
   byte     command,
            cmd>>6==1 indicates shift
            (cmd>>4)&3 is direction from, (0=top,1=left,2=right,3=bottom)
   u_int32  shift duration in 1/90000ths of a second
357
   u_int16  offset of odd-numbered scanlines - subtitle images are
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
            given in interlace order
   byte[]   limited RLE image data in interlace order (0,2,4... 1,3,5) with
            2-bits per palette number
******************************************************************************/
static void ParseHeader( decoder_t *p_dec, block_t *p_block )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    uint8_t *p = p_block->p_buffer;
    uint8_t i_options, i_options2, i_cmd, i_cmd_arg;
    int i;

    p_sys->i_spu_size = GETINT16(p);
    i_options  = *p++;
    i_options2 = *p++;

    if( i_options & 0x08 ) { p_sys->i_duration = GETINT32(p); }
    else p_sys->i_duration = 0; /* Ephemer subtitle */
    p_sys->i_duration *= 100 / 9;

    p_sys->i_x_start = GETINT16(p);
    p_sys->i_y_start = GETINT16(p);
    p_sys->i_width   = GETINT16(p);
    p_sys->i_height  = GETINT16(p);

    for( i = 0; i < 4; i++ )
    {
384 385 386 387
        p_sys->p_palette[i][0] = *p++; /* Y */
        p_sys->p_palette[i][2] = *p++; /* Cr / V */
        p_sys->p_palette[i][1] = *p++; /* Cb / U */
        p_sys->p_palette[i][3] = *p++; /* T */
388 389 390 391 392 393 394 395 396 397 398 399 400
    }

    i_cmd = *p++;
    /* We do not really know this, FIXME */
    if( i_cmd ) {i_cmd_arg = GETINT32(p);}

    /* Actually, this is measured against a different origin, so we have to
     * adjust it */
    p_sys->second_field_offset = GETINT16(p);
    p_sys->i_image_offset  = p - p_block->p_buffer;
    p_sys->i_image_length  = p_sys->i_spu_size - p_sys->i_image_offset;
    p_sys->metadata_length = p_sys->i_image_offset;

401
#ifndef NDEBUG
402 403 404 405 406 407 408 409
    msg_Dbg( p_dec, "x-start: %d, y-start: %d, width: %d, height %d, "
             "spu size: %zu, duration: %"PRIu64" (d:%zu p:%"PRIu16")",
             p_sys->i_x_start, p_sys->i_y_start,
             p_sys->i_width, p_sys->i_height,
             p_sys->i_spu_size, p_sys->i_duration,
             p_sys->i_image_length, p_sys->i_image_offset);

    for( i = 0; i < 4; i++ )
410
    {
411 412 413
        msg_Dbg( p_dec, "palette[%d]= T: %2x, Y: %2x, u: %2x, v: %2x", i,
                 p_sys->p_palette[i][3], p_sys->p_palette[i][0],
                 p_sys->p_palette[i][1], p_sys->p_palette[i][2] );
414 415
    }
#endif
416 417 418
}

/*****************************************************************************
419
 * DecodePacket: parse and decode an subtitle packet
420 421 422 423 424 425 426 427 428 429
 *****************************************************************************
 * This function parses and decodes an SPU packet and, if valid, returns a
 * subpicture.
 *****************************************************************************/
static subpicture_t *DecodePacket( decoder_t *p_dec, block_t *p_data )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    subpicture_t  *p_spu;
    subpicture_region_t *p_region;
    video_format_t fmt;
430
    video_palette_t palette;
431 432 433
    int i;

    /* Allocate the subpicture internal data. */
434
    p_spu = decoder_NewSubpicture( p_dec, NULL );
435 436 437 438
    if( !p_spu ) return NULL;

    p_spu->i_start = p_data->i_pts;
    p_spu->i_stop  = p_data->i_pts + p_sys->i_duration;
439
    p_spu->b_ephemer = true;
440

441
    /* Create new subtitle region */
442
    video_format_Init( &fmt, VLC_CODEC_YUVP );
443 444 445 446 447 448 449 450 451

    /**
       The video on which the subtitle sits, is scaled, probably
       4:3. However subtitle bitmaps assume an 1:1 aspect ratio.

       FIXME: We should get the video aspect ratio from somewhere.
       Two candidates are the video and the other possibility would be
       the access module.
    */
452 453
    fmt.i_sar_num = p_sys->i_height;
    fmt.i_sar_den = p_sys->i_width;
454

455 456 457
    fmt.i_width = fmt.i_visible_width = p_sys->i_width;
    fmt.i_height = fmt.i_visible_height = p_sys->i_height;
    fmt.i_x_offset = fmt.i_y_offset = 0;
458
    fmt.p_palette = &palette;
459 460 461 462 463 464 465 466 467
    fmt.p_palette->i_entries = 4;
    for( i = 0; i < fmt.p_palette->i_entries; i++ )
    {
        fmt.p_palette->palette[i][0] = p_sys->p_palette[i][0];
        fmt.p_palette->palette[i][1] = p_sys->p_palette[i][1];
        fmt.p_palette->palette[i][2] = p_sys->p_palette[i][2];
        fmt.p_palette->palette[i][3] = p_sys->p_palette[i][3];
    }

468
    p_region = subpicture_region_New( &fmt );
469 470
    fmt.p_palette = NULL;
    video_format_Clean( &fmt );
471 472 473
    if( !p_region )
    {
        msg_Err( p_dec, "cannot allocate SVCD subtitle region" );
474
        subpicture_Delete( p_spu );
475 476 477 478 479 480 481
        return NULL;
    }

    p_spu->p_region = p_region;
    p_region->i_x = p_sys->i_x_start;
    p_region->i_y = p_sys->i_y_start;

482
    SVCDSubRenderImage( p_dec, p_data, p_region );
483 484 485 486 487

    return p_spu;
}

/*****************************************************************************
488
 * SVCDSubRenderImage: reorders bytes of image data in subpicture region.
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
 *****************************************************************************

 The image is encoded using two bits per pixel that select a palette
 entry except that value 0 starts a limited run-length encoding for
 color 0.  When 0 is seen, the next two bits encode one less than the
 number of pixels, so we can encode run lengths from 1 to 4. These get
 filled with the color in palette entry 0.

 The encoding of each line is padded to a whole number of bytes.  The
 first field is padded to an even byte length and the complete subtitle
 is padded to a 4-byte multiple that always include one zero byte at
 the end.

 However we'll transform this so that that the RLE is expanded and
 interlacing will also be removed.
 *****************************************************************************/
505
static void SVCDSubRenderImage( decoder_t *p_dec, block_t *p_data,
506
                subpicture_region_t *p_region )
507 508
{
    decoder_sys_t *p_sys = p_dec->p_sys;
509
    uint8_t *p_dest = p_region->p_picture->Y_PIXELS;
510 511 512
    int i_field;            /* The subtitles are interlaced */
    int i_row, i_column;    /* scanline row/column number */
    uint8_t i_color, i_count;
513
    bs_t bs;
514

515
    bs_init( &bs, p_data->p_buffer + p_sys->i_image_offset,
516 517 518 519 520 521 522 523
             p_data->i_buffer - p_sys->i_image_offset );

    for( i_field = 0; i_field < 2; i_field++ )
    {
        for( i_row = i_field; i_row < p_sys->i_height; i_row += 2 )
        {
            for( i_column = 0; i_column < p_sys->i_width; i_column++ )
            {
524 525
                i_color = bs_read( &bs, 2 );
                if( i_color == 0 && (i_count = bs_read( &bs, 2 )) )
526 527
                {
                    i_count = __MIN( i_count, p_sys->i_width - i_column );
528
                    memset( &p_dest[i_row * p_region->p_picture->Y_PITCH +
529 530 531 532 533
                                    i_column], 0, i_count + 1 );
                    i_column += i_count;
                    continue;
                }

534
                p_dest[i_row * p_region->p_picture->Y_PITCH + i_column] = i_color;
535 536
            }

537
            bs_align( &bs );
538 539 540
        }

        /* odd field */
541
        bs_init( &bs, p_data->p_buffer + p_sys->i_image_offset +
542 543 544 545 546
                 p_sys->second_field_offset,
                 p_data->i_buffer - p_sys->i_image_offset -
                 p_sys->second_field_offset );
    }
}