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

   1 /*****************************************************************************
   2  * cvd.c : CVD Subtitle decoder
   3  *****************************************************************************
   4  * Copyright (C) 2003, 2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Rocky Bernstein
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *          Julio Sanchez Fernandez (http://subhandler.sourceforge.net)
  10  *          Laurent Aimar <fenrir@via.ecp.fr>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <vlc/vlc.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_vout.h>
  37 #include <vlc_codec.h>
  38
  39 #include "vlc_bits.h"
  40
  41 #define DEBUG_CVDSUB 1
  42
  43 /*****************************************************************************
  44  * Module descriptor.
  45  *****************************************************************************/
  46 static int  DecoderOpen   ( vlc_object_t * );
  47 static int  PacketizerOpen( vlc_object_t * );
  48 static void DecoderClose  ( vlc_object_t * );
  49
  50 vlc_module_begin();
  51     set_description( _("CVD subtitle decoder") );
  52     set_capability( "decoder", 50 );
  53     set_callbacks( DecoderOpen, DecoderClose );
  54
  55     add_submodule();
  56     set_description( _("Chaoji VCD subtitle packetizer") );
  57     set_capability( "packetizer", 50 );
  58     set_callbacks( PacketizerOpen, DecoderClose );
  59 vlc_module_end();
  60
  61 /*****************************************************************************
  62  * Local prototypes
  63  *****************************************************************************/
  64 static subpicture_t *Decode( decoder_t *, block_t ** );
  65 static block_t *Packetize  ( decoder_t *, block_t ** );
  66 static block_t *Reassemble ( decoder_t *, block_t * );
  67 static void ParseMetaInfo  ( decoder_t *, block_t * );
  68 static void ParseHeader    ( decoder_t *, block_t * );
  69 static subpicture_t *DecodePacket( decoder_t *, block_t * );
  70 static void RenderImage( decoder_t *, block_t *, subpicture_region_t * );
  71
  72 #define SUBTITLE_BLOCK_EMPTY 0
  73 #define SUBTITLE_BLOCK_PARTIAL 1
  74 #define SUBTITLE_BLOCK_COMPLETE 2
  75
  76 struct decoder_sys_t
  77 {
  78   int      b_packetizer;
  79
  80   int      i_state;    /* data-gathering state for this subtitle */
  81
  82   block_t  *p_spu;   /* Bytes of the packet. */
  83
  84   size_t   i_spu_size;     /* goal for subtitle_data_pos while gathering,
  85                              size of used subtitle_data later */
  86
  87   uint16_t i_image_offset;      /* offset from subtitle_data to compressed
  88                                    image data */
  89   size_t i_image_length;           /* size of the compressed image data */
  90   size_t first_field_offset;       /* offset of even raster lines */
  91   size_t second_field_offset;      /* offset of odd raster lines */
  92   size_t metadata_offset;          /* offset to data describing the image */
  93   size_t metadata_length;          /* length of metadata */
  94
  95   mtime_t i_duration;   /* how long to display the image, 0 stands
  96                            for "until next subtitle" */
  97
  98   uint16_t i_x_start, i_y_start; /* position of top leftmost pixel of
  99                                     image when displayed */
 100   uint16_t i_width, i_height;    /* dimensions in pixels of image */
 101
 102   uint8_t p_palette[4][4];       /* Palette of colors used in subtitle */
 103   uint8_t p_palette_highlight[4][4];
 104 };
 105
 106 /*****************************************************************************
 107  * DecoderOpen: open/initialize the cvdsub decoder.
 108  *****************************************************************************/
 109 static int DecoderOpen( vlc_object_t *p_this )
 110 {
 111     decoder_t     *p_dec = (decoder_t*)p_this;
 112     decoder_sys_t *p_sys;
 113
 114     if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'c','v','d',' ' ) )
 115     {
 116         return VLC_EGENERIC;
 117     }
 118
 119     p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );
 120
 121     p_sys->b_packetizer  = false;
 122
 123     p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
 124     p_sys->p_spu   = NULL;
 125
 126     es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_FOURCC( 'c','v','d',' ' ) );
 127
 128     p_dec->pf_decode_sub = Decode;
 129     p_dec->pf_packetize  = Packetize;
 130
 131     return VLC_SUCCESS;
 132 }
 133
 134 /*****************************************************************************
 135  * PacketizerOpen: open/initialize the cvdsub packetizer.
 136  *****************************************************************************/
 137 static int PacketizerOpen( vlc_object_t *p_this )
 138 {
 139     decoder_t *p_dec = (decoder_t*)p_this;
 140
 141     if( DecoderOpen( p_this ) != VLC_SUCCESS ) return VLC_EGENERIC;
 142
 143     p_dec->p_sys->b_packetizer = true;
 144
 145     return VLC_SUCCESS;
 146 }
 147
 148 /*****************************************************************************
 149  * DecoderClose: closes the cvdsub decoder/packetizer.
 150  *****************************************************************************/
 151 void DecoderClose( vlc_object_t *p_this )
 152 {
 153     decoder_t     *p_dec = (decoder_t*)p_this;
 154     decoder_sys_t *p_sys = p_dec->p_sys;
 155
 156     if( p_sys->p_spu ) block_ChainRelease( p_sys->p_spu );
 157     free( p_sys );
 158 }
 159
 160 /*****************************************************************************
 161  * Decode:
 162  *****************************************************************************/
 163 static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
 164 {
 165     block_t *p_block, *p_spu;
 166
 167     if( pp_block == NULL || *pp_block == NULL ) return NULL;
 168
 169     p_block = *pp_block;
 170     *pp_block = NULL;
 171
 172     if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
 173
 174     /* Parse and decode */
 175     return DecodePacket( p_dec, p_spu );
 176 }
 177
 178 /*****************************************************************************
 179  * Packetize:
 180  *****************************************************************************/
 181 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
 182 {
 183     block_t *p_block, *p_spu;
 184
 185     if( pp_block == NULL || *pp_block == NULL ) return NULL;
 186
 187     p_block = *pp_block;
 188     *pp_block = NULL;
 189
 190     if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
 191
 192     p_spu->i_dts = p_spu->i_pts;
 193     p_spu->i_length = 0;
 194
 195     return p_spu;
 196 }
 197
 198
 199 /*****************************************************************************
 200  Reassemble:
 201
 202  Data for single screen subtitle may come in several non-contiguous
 203  packets of a stream. This routine is called when the next packet in
 204  the stream comes in. The job of this routine is to parse the header,
 205  if this is the beginning, and combine the packets into one complete
 206  subtitle unit.
 207
 208  If everything is complete, we will return a block. Otherwise return
 209  NULL.
 210
 211  *****************************************************************************/
 212 #define SPU_HEADER_LEN 1
 213
 214 static block_t *Reassemble( decoder_t *p_dec, block_t *p_block )
 215 {
 216     decoder_sys_t *p_sys = p_dec->p_sys;
 217     uint8_t *p_buffer;
 218
 219     if( p_block->i_buffer < SPU_HEADER_LEN )
 220     {
 221         msg_Dbg( p_dec, "invalid packet header (size %d < %d)" ,
 222                  p_block->i_buffer, SPU_HEADER_LEN );
 223         block_Release( p_block );
 224         return NULL;
 225     }
 226
 227     p_buffer = p_block->p_buffer;
 228
 229     /* From the scant data on the format, there is only only way known
 230      * to detect the first packet in a subtitle.  The first packet
 231      * seems to have a valid PTS while later packets for the same
 232      * image don't. */
 233     if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY && p_block->i_pts == 0 )
 234     {
 235         msg_Warn( p_dec, "first packet expected but no PTS present");
 236         return NULL;
 237     }
 238
 239     p_block->p_buffer += SPU_HEADER_LEN;
 240     p_block->i_buffer -= SPU_HEADER_LEN;
 241
 242     /* First packet in the subtitle block */
 243     if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY ) ParseHeader( p_dec, p_block );
 244
 245     block_ChainAppend( &p_sys->p_spu, p_block );
 246     p_sys->p_spu = block_ChainGather( p_sys->p_spu );
 247
 248     if( p_sys->p_spu->i_buffer >= p_sys->i_spu_size )
 249     {
 250         block_t *p_spu = p_sys->p_spu;
 251
 252         if( p_spu->i_buffer != p_sys->i_spu_size )
 253         {
 254             msg_Warn( p_dec, "SPU packets size=%d should be %d",
 255                       p_spu->i_buffer, p_sys->i_spu_size );
 256         }
 257
 258         msg_Dbg( p_dec, "subtitle packet complete, size=%d", p_spu->i_buffer);
 259
 260         ParseMetaInfo( p_dec, p_spu );
 261
 262         p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
 263         p_sys->p_spu = 0;
 264         return p_spu;
 265     }
 266     else
 267     {
 268         /* Not last block in subtitle, so wait for another. */
 269         p_sys->i_state = SUBTITLE_BLOCK_PARTIAL;
 270     }
 271
 272     return NULL;
 273 }
 274
 275 /*
 276   We do not have information on the subtitle format used on CVD's
 277   except the submux sample code and a couple of samples of dubious
 278   origin. Thus, this is the result of reading some code whose
 279   correctness is not known and some experimentation.
 280
 281   CVD subtitles are different in several ways from SVCD OGT subtitles.
 282   Image comes first and metadata is at the end.  So that the metadata
 283   can be found easily, the subtitle packet starts with two bytes
 284   (everything is big-endian again) that give the total size of the
 285   subtitle data and the offset to the metadata - i.e. size of the
 286   image data plus the four bytes at the beginning.
 287
 288   Image data comes interlaced is run-length encoded.  Each field is a
 289   four-bit nibble. Each nibble contains a two-bit repeat count and a
 290   two-bit color number so that up to three pixels can be described in
 291   four bits.  The function of a 0 repeat count is unknown; it might be
 292   used for RLE extension.  However when the full nibble is zero, the
 293   rest of the line is filled with the color value in the next nibble.
 294   It is unknown what happens if the color value is greater than three.
 295   The rest seems to use a 4-entries palette.  It is not impossible
 296   that the fill-line complete case above is not as described and the
 297   zero repeat count means fill line.  The sample code never produces
 298   this, so it may be untested.
 299 */
 300
 301 static void ParseHeader( decoder_t *p_dec, block_t *p_block )
 302 {
 303     decoder_sys_t *p_sys = p_dec->p_sys;
 304     uint8_t *p = p_block->p_buffer;
 305
 306     p_sys->i_spu_size = (p[0] << 8) + p[1] + 4; p += 2;
 307
 308     /* FIXME: check data sanity */
 309     p_sys->metadata_offset = (p[0] <<  8) +   p[1]; p +=2;
 310     p_sys->metadata_length = p_sys->i_spu_size - p_sys->metadata_offset;
 311
 312     p_sys->i_image_offset = 4;
 313     p_sys->i_image_length = p_sys->metadata_offset - p_sys->i_image_offset;
 314
 315 #ifdef DEBUG_CVDSUB
 316     msg_Dbg( p_dec, "total size: %d  image size: %d",
 317              p_sys->i_spu_size, p_sys->i_image_length );
 318 #endif
 319 }
 320
 321 /*
 322   We parse the metadata information here.
 323
 324   Although metadata information does not have to come in a fixed field
 325   order, every metadata field consists of a tag byte followed by
 326   parameters. In all cases known, the size including tag byte is
 327   exactly four bytes in length.
 328 */
 329
 330 #define ExtractXY(x, y) x = ((p[1]&0x0f)<<6) + (p[2]>>2); \
 331                         y = ((p[2]&0x03)<<8) + p[3];
 332
 333 static void ParseMetaInfo( decoder_t *p_dec, block_t *p_spu  )
 334 {
 335     /* Last packet in subtitle block. */
 336
 337     decoder_sys_t *p_sys = p_dec->p_sys;
 338     uint8_t       *p     = p_spu->p_buffer + p_sys->metadata_offset;
 339     uint8_t       *p_end = p + p_sys->metadata_length;
 340
 341     for( ; p < p_end; p += 4 )
 342     {
 343         switch( p[0] )
 344         {
 345         case 0x04: /* subtitle duration in 1/90000ths of a second */
 346             p_sys->i_duration = (p[1]<<16) + (p[2]<<8) + p[3];
 347
 348 #ifdef DEBUG_CVDSUB
 349             msg_Dbg( p_dec, "subtitle display duration %lu secs",
 350                      (long unsigned int)(p_sys->i_duration / 90000) );
 351 #endif
 352             p_sys->i_duration *= 100 / 9;
 353             break;
 354
 355         case 0x0c: /* unknown */
 356 #ifdef DEBUG_CVDSUB
 357             msg_Dbg( p_dec, "subtitle command unknown 0x%0x 0x%0x 0x%0x 0x%0x",
 358                      (int)p[0], (int)p[1], (int)p[2], (int)p[3] );
 359 #endif
 360             break;
 361
 362         case 0x17: /* coordinates of subtitle upper left x, y position */
 363             ExtractXY(p_sys->i_x_start, p_sys->i_y_start);
 364
 365 #ifdef DEBUG_CVDSUB
 366             msg_Dbg( p_dec, "start position (%d,%d)",
 367                      p_sys->i_x_start, p_sys->i_y_start );
 368 #endif
 369             break;
 370
 371         case 0x1f: /* coordinates of subtitle bottom right x, y position */
 372         {
 373             int lastx;
 374             int lasty;
 375             ExtractXY(lastx, lasty);
 376             p_sys->i_width  = lastx - p_sys->i_x_start + 1;
 377             p_sys->i_height = lasty - p_sys->i_y_start + 1;
 378
 379 #ifdef DEBUG_CVDSUB
 380             msg_Dbg( p_dec, "end position (%d,%d), w x h: %dx%d",
 381                      lastx, lasty, p_sys->i_width, p_sys->i_height );
 382 #endif
 383             break;
 384         }
 385
 386         case 0x24:
 387         case 0x25:
 388         case 0x26:
 389         case 0x27:
 390         {
 391             uint8_t v = p[0] - 0x24;
 392
 393 #ifdef DEBUG_CVDSUB
 394             /* Primary Palette */
 395             msg_Dbg( p_dec, "primary palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
 396                      (int)v, (int)p[1], (int)p[2], (int)p[3] );
 397 #endif
 398
 399             p_sys->p_palette[v][0] = p[1]; /* Y */
 400             p_sys->p_palette[v][1] = p[3]; /* Cr / V */
 401             p_sys->p_palette[v][2] = p[2]; /* Cb / U */
 402             break;
 403         }
 404
 405         case 0x2c:
 406         case 0x2d:
 407         case 0x2e:
 408         case 0x2f:
 409         {
 410             uint8_t v = p[0] - 0x2c;
 411
 412 #ifdef DEBUG_CVDSUB
 413             msg_Dbg( p_dec,"highlight palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
 414                      (int)v, (int)p[1], (int)p[2], (int)p[3] );
 415 #endif
 416
 417             /* Highlight Palette */
 418             p_sys->p_palette_highlight[v][0] = p[1]; /* Y */
 419             p_sys->p_palette_highlight[v][1] = p[3]; /* Cr / V */
 420             p_sys->p_palette_highlight[v][2] = p[2]; /* Cb / U */
 421             break;
 422         }
 423
 424         case 0x37:
 425             /* transparency for primary palette */
 426             p_sys->p_palette[0][3] = (p[3] & 0x0f) << 4;
 427             p_sys->p_palette[1][3] = (p[3] >> 4) << 4;
 428             p_sys->p_palette[2][3] = (p[2] & 0x0f) << 4;
 429             p_sys->p_palette[3][3] = (p[2] >> 4) << 4;
 430
 431 #ifdef DEBUG_CVDSUB
 432             msg_Dbg( p_dec, "transparency for primary palette 0..3: "
 433                      "0x%0x 0x%0x 0x%0x 0x%0x",
 434                      (int)p_sys->p_palette[0][3], (int)p_sys->p_palette[1][3],
 435                      (int)p_sys->p_palette[2][3], (int)p_sys->p_palette[3][3]);
 436 #endif
 437             break;
 438
 439         case 0x3f:
 440             /* transparency for highlight palette */
 441             p_sys->p_palette_highlight[0][3] = (p[2] & 0x0f) << 4;
 442             p_sys->p_palette_highlight[1][3] = (p[2] >> 4) << 4;
 443             p_sys->p_palette_highlight[2][3] = (p[1] & 0x0f) << 4;
 444             p_sys->p_palette_highlight[3][3] = (p[1] >> 4) << 4;
 445
 446 #ifdef DEBUG_CVDSUB
 447             msg_Dbg( p_dec, "transparency for highlight palette 0..3: "
 448                      "0x%0x 0x%0x 0x%0x 0x%0x",
 449                      (int)p_sys->p_palette_highlight[0][3],
 450                      (int)p_sys->p_palette_highlight[1][3],
 451                      (int)p_sys->p_palette_highlight[2][3],
 452                      (int)p_sys->p_palette_highlight[3][3] );
 453 #endif
 454             break;
 455
 456         case 0x47:
 457             /* offset to start of even rows of interlaced image, we correct
 458              * to make it relative to i_image_offset (usually 4) */
 459             p_sys->first_field_offset =
 460                 (p[2] << 8) + p[3] - p_sys->i_image_offset;
 461 #ifdef DEBUG_CVDSUB
 462             msg_Dbg( p_dec, "1st_field_offset %d", p_sys->first_field_offset );
 463 #endif
 464             break;
 465
 466         case 0x4f:
 467             /* offset to start of odd rows of interlaced image, we correct
 468              * to make it relative to i_image_offset (usually 4) */
 469             p_sys->second_field_offset =
 470                 (p[2] << 8) + p[3] - p_sys->i_image_offset;
 471 #ifdef DEBUG_CVDSUB
 472             msg_Dbg( p_dec, "2nd_field_offset %d", p_sys->second_field_offset);
 473 #endif
 474             break;
 475
 476         default:
 477 #ifdef DEBUG_CVDSUB
 478             msg_Warn( p_dec, "unknown sequence in control header "
 479                       "0x%0x 0x%0x 0x%0x 0x%0x", p[0], p[1], p[2], p[3]);
 480 #endif
 481         }
 482     }
 483 }
 484
 485 /*****************************************************************************
 486  * DecodePacket: parse and decode an SPU packet
 487  *****************************************************************************
 488  * This function parses and decodes an SPU packet and, if valid, returns a
 489  * subpicture.
 490  *****************************************************************************/
 491 static subpicture_t *DecodePacket( decoder_t *p_dec, block_t *p_data )
 492 {
 493     decoder_sys_t *p_sys = p_dec->p_sys;
 494     subpicture_t  *p_spu;
 495     subpicture_region_t *p_region;
 496     video_format_t fmt;
 497     int i;
 498
 499     /* Allocate the subpicture internal data. */
 500     p_spu = p_dec->pf_spu_buffer_new( p_dec );
 501     if( !p_spu ) return NULL;
 502
 503     p_spu->b_pausable = true;
 504
 505     p_spu->i_x = p_sys->i_x_start;
 506     p_spu->i_x = p_spu->i_x * 3 / 4; /* FIXME: use aspect ratio for x? */
 507     p_spu->i_y = p_sys->i_y_start;
 508     p_spu->i_start = p_data->i_pts;
 509     p_spu->i_stop  = p_data->i_pts + p_sys->i_duration;
 510     p_spu->b_ephemer = true;
 511
 512     /* Create new SPU region */
 513     memset( &fmt, 0, sizeof(video_format_t) );
 514     fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
 515     fmt.i_aspect = VOUT_ASPECT_FACTOR;
 516     fmt.i_width = fmt.i_visible_width = p_sys->i_width;
 517     fmt.i_height = fmt.i_visible_height = p_sys->i_height;
 518     fmt.i_x_offset = fmt.i_y_offset = 0;
 519     p_region = p_spu->pf_create_region( VLC_OBJECT(p_dec), &fmt );
 520     if( !p_region )
 521     {
 522         msg_Err( p_dec, "cannot allocate SPU region" );
 523         //goto error;
 524     }
 525
 526     p_spu->p_region = p_region;
 527     p_region->i_x = p_region->i_y = 0;
 528
 529     /* Build palette */
 530     fmt.p_palette->i_entries = 4;
 531     for( i = 0; i < fmt.p_palette->i_entries; i++ )
 532     {
 533         fmt.p_palette->palette[i][0] = p_sys->p_palette[i][0];
 534         fmt.p_palette->palette[i][1] = p_sys->p_palette[i][1];
 535         fmt.p_palette->palette[i][2] = p_sys->p_palette[i][2];
 536         fmt.p_palette->palette[i][3] = p_sys->p_palette[i][3];
 537     }
 538
 539     RenderImage( p_dec, p_data, p_region );
 540
 541     return p_spu;
 542 }
 543
 544 /*****************************************************************************
 545  * ParseImage: parse and render the image part of the subtitle
 546  *****************************************************************************
 547  This part parses the subtitle graphical data and renders it.
 548
 549  Image data comes interlaced and is run-length encoded (RLE). Each
 550  field is a four-bit nibbles that is further subdivided in a two-bit
 551  repeat count and a two-bit color number - up to three pixels can be
 552  described in four bits.  What a 0 repeat count means is unknown.  It
 553  might be used for RLE extension.  There is a special case of a 0
 554  repeat count though.  When the full nibble is zero, the rest of the
 555  line is filled with the color value in the next nibble.  It is
 556  unknown what happens if the color value is greater than three.  The
 557  rest seems to use a 4-entries palette.  It is not impossible that the
 558  fill-line complete case above is not as described and the zero repeat
 559  count means fill line.  The sample code never produces this, so it
 560  may be untested.
 561
 562  However we'll transform this so that that the RLE is expanded and
 563  interlacing will also be removed. On output each pixel entry will by
 564  a 4-bit alpha (filling 8 bits), and 8-bit y, u, and v entry.
 565
 566  *****************************************************************************/
 567 static void RenderImage( decoder_t *p_dec, block_t *p_data,
 568                          subpicture_region_t *p_region )
 569 {
 570     decoder_sys_t *p_sys = p_dec->p_sys;
 571     uint8_t *p_dest = p_region->picture.Y_PIXELS;
 572     int i_field;            /* The subtitles are interlaced */
 573     int i_row, i_column;    /* scanline row/column number */
 574     uint8_t i_color, i_count;
 575     bs_t bs;
 576
 577     bs_init( &bs, p_data->p_buffer + p_sys->i_image_offset,
 578              p_data->i_buffer - p_sys->i_image_offset );
 579
 580     for( i_field = 0; i_field < 2; i_field++ )
 581     {
 582         for( i_row = i_field; i_row < p_sys->i_height; i_row += 2 )
 583         {
 584             for( i_column = 0; i_column < p_sys->i_width; i_column++ )
 585             {
 586                 uint8_t i_val = bs_read( &bs, 4 );
 587
 588                 if( i_val == 0 )
 589                 {
 590                     /* Fill the rest of the line with next color */
 591                     i_color = bs_read( &bs, 4 );
 592
 593                     memset( &p_dest[i_row * p_region->picture.Y_PITCH +
 594                                     i_column], i_color,
 595                             p_sys->i_width - i_column );
 596                     i_column = p_sys->i_width;
 597                     continue;
 598                 }
 599                 else
 600                 {
 601                     /* Normal case: get color and repeat count */
 602                     i_count = (i_val >> 2);
 603                     i_color = i_val & 0x3;
 604
 605                     i_count = __MIN( i_count, p_sys->i_width - i_column );
 606
 607                     memset( &p_dest[i_row * p_region->picture.Y_PITCH +
 608                                     i_column], i_color, i_count );
 609                     i_column += i_count - 1;
 610                     continue;
 611                 }
 612             }
 613
 614             bs_align( &bs );
 615         }
 616     }
 617 }