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_common.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( N_("CVD subtitle decoder") )
  52     set_capability( "decoder", 50 )
  53     set_callbacks( DecoderOpen, DecoderClose )
  54
  55     add_submodule ()
  56     set_description( N_("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_CODEC_CVD )
 115         return VLC_EGENERIC;
 116
 117     p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );
 118     if( !p_sys )
 119         return VLC_ENOMEM;
 120
 121     p_sys->b_packetizer  = false;
 122
 123     p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
 124     p_sys->p_spu   = NULL;
 125
 126     p_dec->pf_decode_sub = Decode;
 127     p_dec->pf_packetize  = Packetize;
 128
 129     p_dec->fmt_out.i_cat = SPU_ES;
 130     p_dec->fmt_out.i_codec = VLC_CODEC_YUVP;
 131
 132     return VLC_SUCCESS;
 133 }
 134
 135 /*****************************************************************************
 136  * PacketizerOpen: open/initialize the cvdsub packetizer.
 137  *****************************************************************************/
 138 static int PacketizerOpen( vlc_object_t *p_this )
 139 {
 140     decoder_t *p_dec = (decoder_t*)p_this;
 141
 142     if( DecoderOpen( p_this ) != VLC_SUCCESS ) return VLC_EGENERIC;
 143
 144     p_dec->p_sys->b_packetizer = true;
 145
 146     return VLC_SUCCESS;
 147 }
 148
 149 /*****************************************************************************
 150  * DecoderClose: closes the cvdsub decoder/packetizer.
 151  *****************************************************************************/
 152 void DecoderClose( vlc_object_t *p_this )
 153 {
 154     decoder_t     *p_dec = (decoder_t*)p_this;
 155     decoder_sys_t *p_sys = p_dec->p_sys;
 156
 157     if( p_sys->p_spu ) block_ChainRelease( p_sys->p_spu );
 158     free( p_sys );
 159 }
 160
 161 /*****************************************************************************
 162  * Decode:
 163  *****************************************************************************/
 164 static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
 165 {
 166     block_t *p_block, *p_spu;
 167
 168     if( pp_block == NULL || *pp_block == NULL ) return NULL;
 169
 170     p_block = *pp_block;
 171     *pp_block = NULL;
 172
 173     if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
 174
 175     /* Parse and decode */
 176     return DecodePacket( p_dec, p_spu );
 177 }
 178
 179 /*****************************************************************************
 180  * Packetize:
 181  *****************************************************************************/
 182 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
 183 {
 184     block_t *p_block, *p_spu;
 185
 186     if( pp_block == NULL || *pp_block == NULL ) return NULL;
 187
 188     p_block = *pp_block;
 189     *pp_block = NULL;
 190
 191     if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
 192
 193     p_spu->i_dts = p_spu->i_pts;
 194     p_spu->i_length = 0;
 195
 196     return p_spu;
 197 }
 198
 199
 200 /*****************************************************************************
 201  Reassemble:
 202
 203  Data for single screen subtitle may come in several non-contiguous
 204  packets of a stream. This routine is called when the next packet in
 205  the stream comes in. The job of this routine is to parse the header,
 206  if this is the beginning, and combine the packets into one complete
 207  subtitle unit.
 208
 209  If everything is complete, we will return a block. Otherwise return
 210  NULL.
 211
 212  *****************************************************************************/
 213 #define SPU_HEADER_LEN 1
 214
 215 static block_t *Reassemble( decoder_t *p_dec, block_t *p_block )
 216 {
 217     decoder_sys_t *p_sys = p_dec->p_sys;
 218     uint8_t *p_buffer;
 219
 220     if( p_block->i_buffer < SPU_HEADER_LEN )
 221     {
 222         msg_Dbg( p_dec, "invalid packet header (size %zu < %u)" ,
 223                  p_block->i_buffer, SPU_HEADER_LEN );
 224         block_Release( p_block );
 225         return NULL;
 226     }
 227
 228     p_buffer = p_block->p_buffer;
 229
 230     /* From the scant data on the format, there is only only way known
 231      * to detect the first packet in a subtitle.  The first packet
 232      * seems to have a valid PTS while later packets for the same
 233      * image don't. */
 234     if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY && p_block->i_pts == 0 )
 235     {
 236         msg_Warn( p_dec, "first packet expected but no PTS present");
 237         return NULL;
 238     }
 239
 240     p_block->p_buffer += SPU_HEADER_LEN;
 241     p_block->i_buffer -= SPU_HEADER_LEN;
 242
 243     /* First packet in the subtitle block */
 244     if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY ) ParseHeader( p_dec, p_block );
 245
 246     block_ChainAppend( &p_sys->p_spu, p_block );
 247     p_sys->p_spu = block_ChainGather( p_sys->p_spu );
 248
 249     if( p_sys->p_spu->i_buffer >= p_sys->i_spu_size )
 250     {
 251         block_t *p_spu = p_sys->p_spu;
 252
 253         if( p_spu->i_buffer != p_sys->i_spu_size )
 254         {
 255             msg_Warn( p_dec, "SPU packets size=%zu should be %zu",
 256                       p_spu->i_buffer, p_sys->i_spu_size );
 257         }
 258
 259         msg_Dbg( p_dec, "subtitle packet complete, size=%zuu", p_spu->i_buffer);
 260
 261         ParseMetaInfo( p_dec, p_spu );
 262
 263         p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
 264         p_sys->p_spu = 0;
 265         return p_spu;
 266     }
 267     else
 268     {
 269         /* Not last block in subtitle, so wait for another. */
 270         p_sys->i_state = SUBTITLE_BLOCK_PARTIAL;
 271     }
 272
 273     return NULL;
 274 }
 275
 276 /*
 277   We do not have information on the subtitle format used on CVD's
 278   except the submux sample code and a couple of samples of dubious
 279   origin. Thus, this is the result of reading some code whose
 280   correctness is not known and some experimentation.
 281
 282   CVD subtitles are different in several ways from SVCD OGT subtitles.
 283   Image comes first and metadata is at the end.  So that the metadata
 284   can be found easily, the subtitle packet starts with two bytes
 285   (everything is big-endian again) that give the total size of the
 286   subtitle data and the offset to the metadata - i.e. size of the
 287   image data plus the four bytes at the beginning.
 288
 289   Image data comes interlaced is run-length encoded.  Each field is a
 290   four-bit nibble. Each nibble contains a two-bit repeat count and a
 291   two-bit color number so that up to three pixels can be described in
 292   four bits.  The function of a 0 repeat count is unknown; it might be
 293   used for RLE extension.  However when the full nibble is zero, the
 294   rest of the line is filled with the color value in the next nibble.
 295   It is unknown what happens if the color value is greater than three.
 296   The rest seems to use a 4-entries palette.  It is not impossible
 297   that the fill-line complete case above is not as described and the
 298   zero repeat count means fill line.  The sample code never produces
 299   this, so it may be untested.
 300 */
 301
 302 static void ParseHeader( decoder_t *p_dec, block_t *p_block )
 303 {
 304     decoder_sys_t *p_sys = p_dec->p_sys;
 305     uint8_t *p = p_block->p_buffer;
 306
 307     p_sys->i_spu_size = (p[0] << 8) + p[1] + 4; p += 2;
 308
 309     /* FIXME: check data sanity */
 310     p_sys->metadata_offset = (p[0] <<  8) +   p[1]; p +=2;
 311     p_sys->metadata_length = p_sys->i_spu_size - p_sys->metadata_offset;
 312
 313     p_sys->i_image_offset = 4;
 314     p_sys->i_image_length = p_sys->metadata_offset - p_sys->i_image_offset;
 315
 316 #ifdef DEBUG_CVDSUB
 317     msg_Dbg( p_dec, "total size: %zu  image size: %zu",
 318              p_sys->i_spu_size, p_sys->i_image_length );
 319 #endif
 320 }
 321
 322 /*
 323   We parse the metadata information here.
 324
 325   Although metadata information does not have to come in a fixed field
 326   order, every metadata field consists of a tag byte followed by
 327   parameters. In all cases known, the size including tag byte is
 328   exactly four bytes in length.
 329 */
 330
 331 #define ExtractXY(x, y) x = ((p[1]&0x0f)<<6) + (p[2]>>2); \
 332                         y = ((p[2]&0x03)<<8) + p[3];
 333
 334 static void ParseMetaInfo( decoder_t *p_dec, block_t *p_spu  )
 335 {
 336     /* Last packet in subtitle block. */
 337
 338     decoder_sys_t *p_sys = p_dec->p_sys;
 339     uint8_t       *p     = p_spu->p_buffer + p_sys->metadata_offset;
 340     uint8_t       *p_end = p + p_sys->metadata_length;
 341
 342     for( ; p < p_end; p += 4 )
 343     {
 344         switch( p[0] )
 345         {
 346         case 0x04: /* subtitle duration in 1/90000ths of a second */
 347             p_sys->i_duration = (p[1]<<16) + (p[2]<<8) + p[3];
 348
 349 #ifdef DEBUG_CVDSUB
 350             msg_Dbg( p_dec, "subtitle display duration %lu secs",
 351                      (long unsigned int)(p_sys->i_duration / 90000) );
 352 #endif
 353             p_sys->i_duration *= 100 / 9;
 354             break;
 355
 356         case 0x0c: /* unknown */
 357 #ifdef DEBUG_CVDSUB
 358             msg_Dbg( p_dec, "subtitle command unknown 0x%0x 0x%0x 0x%0x 0x%0x",
 359                      (int)p[0], (int)p[1], (int)p[2], (int)p[3] );
 360 #endif
 361             break;
 362
 363         case 0x17: /* coordinates of subtitle upper left x, y position */
 364             ExtractXY(p_sys->i_x_start, p_sys->i_y_start);
 365
 366 #ifdef DEBUG_CVDSUB
 367             msg_Dbg( p_dec, "start position (%d,%d)",
 368                      p_sys->i_x_start, p_sys->i_y_start );
 369 #endif
 370             break;
 371
 372         case 0x1f: /* coordinates of subtitle bottom right x, y position */
 373         {
 374             int lastx;
 375             int lasty;
 376             ExtractXY(lastx, lasty);
 377             p_sys->i_width  = lastx - p_sys->i_x_start + 1;
 378             p_sys->i_height = lasty - p_sys->i_y_start + 1;
 379
 380 #ifdef DEBUG_CVDSUB
 381             msg_Dbg( p_dec, "end position (%d,%d), w x h: %dx%d",
 382                      lastx, lasty, p_sys->i_width, p_sys->i_height );
 383 #endif
 384             break;
 385         }
 386
 387         case 0x24:
 388         case 0x25:
 389         case 0x26:
 390         case 0x27:
 391         {
 392             uint8_t v = p[0] - 0x24;
 393
 394 #ifdef DEBUG_CVDSUB
 395             /* Primary Palette */
 396             msg_Dbg( p_dec, "primary palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
 397                      (int)v, (int)p[1], (int)p[2], (int)p[3] );
 398 #endif
 399
 400             p_sys->p_palette[v][0] = p[1]; /* Y */
 401             p_sys->p_palette[v][1] = p[3]; /* Cr / V */
 402             p_sys->p_palette[v][2] = p[2]; /* Cb / U */
 403             break;
 404         }
 405
 406         case 0x2c:
 407         case 0x2d:
 408         case 0x2e:
 409         case 0x2f:
 410         {
 411             uint8_t v = p[0] - 0x2c;
 412
 413 #ifdef DEBUG_CVDSUB
 414             msg_Dbg( p_dec,"highlight palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
 415                      (int)v, (int)p[1], (int)p[2], (int)p[3] );
 416 #endif
 417
 418             /* Highlight Palette */
 419             p_sys->p_palette_highlight[v][0] = p[1]; /* Y */
 420             p_sys->p_palette_highlight[v][1] = p[3]; /* Cr / V */
 421             p_sys->p_palette_highlight[v][2] = p[2]; /* Cb / U */
 422             break;
 423         }
 424
 425         case 0x37:
 426             /* transparency for primary palette */
 427             p_sys->p_palette[0][3] = (p[3] & 0x0f) << 4;
 428             p_sys->p_palette[1][3] = (p[3] >> 4) << 4;
 429             p_sys->p_palette[2][3] = (p[2] & 0x0f) << 4;
 430             p_sys->p_palette[3][3] = (p[2] >> 4) << 4;
 431
 432 #ifdef DEBUG_CVDSUB
 433             msg_Dbg( p_dec, "transparency for primary palette 0..3: "
 434                      "0x%0x 0x%0x 0x%0x 0x%0x",
 435                      (int)p_sys->p_palette[0][3], (int)p_sys->p_palette[1][3],
 436                      (int)p_sys->p_palette[2][3], (int)p_sys->p_palette[3][3]);
 437 #endif
 438             break;
 439
 440         case 0x3f:
 441             /* transparency for highlight palette */
 442             p_sys->p_palette_highlight[0][3] = (p[2] & 0x0f) << 4;
 443             p_sys->p_palette_highlight[1][3] = (p[2] >> 4) << 4;
 444             p_sys->p_palette_highlight[2][3] = (p[1] & 0x0f) << 4;
 445             p_sys->p_palette_highlight[3][3] = (p[1] >> 4) << 4;
 446
 447 #ifdef DEBUG_CVDSUB
 448             msg_Dbg( p_dec, "transparency for highlight palette 0..3: "
 449                      "0x%0x 0x%0x 0x%0x 0x%0x",
 450                      (int)p_sys->p_palette_highlight[0][3],
 451                      (int)p_sys->p_palette_highlight[1][3],
 452                      (int)p_sys->p_palette_highlight[2][3],
 453                      (int)p_sys->p_palette_highlight[3][3] );
 454 #endif
 455             break;
 456
 457         case 0x47:
 458             /* offset to start of even rows of interlaced image, we correct
 459              * to make it relative to i_image_offset (usually 4) */
 460             p_sys->first_field_offset =
 461                 (p[2] << 8) + p[3] - p_sys->i_image_offset;
 462 #ifdef DEBUG_CVDSUB
 463             msg_Dbg( p_dec, "1st_field_offset %zu",
 464                      p_sys->first_field_offset );
 465 #endif
 466             break;
 467
 468         case 0x4f:
 469             /* offset to start of odd rows of interlaced image, we correct
 470              * to make it relative to i_image_offset (usually 4) */
 471             p_sys->second_field_offset =
 472                 (p[2] << 8) + p[3] - p_sys->i_image_offset;
 473 #ifdef DEBUG_CVDSUB
 474             msg_Dbg( p_dec, "2nd_field_offset %zu",
 475                      p_sys->second_field_offset);
 476 #endif
 477             break;
 478
 479         default:
 480 #ifdef DEBUG_CVDSUB
 481             msg_Warn( p_dec, "unknown sequence in control header "
 482                       "0x%0x 0x%0x 0x%0x 0x%0x", p[0], p[1], p[2], p[3]);
 483 #endif
 484         }
 485     }
 486 }
 487
 488 /*****************************************************************************
 489  * DecodePacket: parse and decode an SPU packet
 490  *****************************************************************************
 491  * This function parses and decodes an SPU packet and, if valid, returns a
 492  * subpicture.
 493  *****************************************************************************/
 494 static subpicture_t *DecodePacket( decoder_t *p_dec, block_t *p_data )
 495 {
 496     decoder_sys_t *p_sys = p_dec->p_sys;
 497     subpicture_t  *p_spu;
 498     subpicture_region_t *p_region;
 499     video_format_t fmt;
 500     video_palette_t palette;
 501     int i;
 502
 503     /* Allocate the subpicture internal data. */
 504     p_spu = decoder_NewSubpicture( p_dec );
 505     if( !p_spu ) return NULL;
 506
 507     p_spu->i_start = p_data->i_pts;
 508     p_spu->i_stop  = p_data->i_pts + p_sys->i_duration;
 509     p_spu->b_ephemer = true;
 510
 511     /* Create new SPU region */
 512     memset( &fmt, 0, sizeof(video_format_t) );
 513     fmt.i_chroma = VLC_CODEC_YUVP;
 514     fmt.i_aspect = VOUT_ASPECT_FACTOR;
 515     fmt.i_width = fmt.i_visible_width = p_sys->i_width;
 516     fmt.i_height = fmt.i_visible_height = p_sys->i_height;
 517     fmt.i_x_offset = fmt.i_y_offset = 0;
 518     fmt.p_palette = &palette;
 519     fmt.p_palette->i_entries = 4;
 520     for( i = 0; i < fmt.p_palette->i_entries; i++ )
 521     {
 522         fmt.p_palette->palette[i][0] = p_sys->p_palette[i][0];
 523         fmt.p_palette->palette[i][1] = p_sys->p_palette[i][1];
 524         fmt.p_palette->palette[i][2] = p_sys->p_palette[i][2];
 525         fmt.p_palette->palette[i][3] = p_sys->p_palette[i][3];
 526     }
 527
 528     p_region = subpicture_region_New( &fmt );
 529     if( !p_region )
 530     {
 531         msg_Err( p_dec, "cannot allocate SPU region" );
 532         decoder_DeleteSubpicture( p_dec, p_spu );
 533         return NULL;
 534     }
 535
 536     p_spu->p_region = p_region;
 537     p_region->i_x = p_sys->i_x_start;
 538     p_region->i_x = p_region->i_x * 3 / 4; /* FIXME: use aspect ratio for x? */
 539     p_region->i_y = p_sys->i_y_start;
 540
 541     RenderImage( p_dec, p_data, p_region );
 542
 543     return p_spu;
 544 }
 545
 546 /*****************************************************************************
 547  * ParseImage: parse and render the image part of the subtitle
 548  *****************************************************************************
 549  This part parses the subtitle graphical data and renders it.
 550
 551  Image data comes interlaced and is run-length encoded (RLE). Each
 552  field is a four-bit nibbles that is further subdivided in a two-bit
 553  repeat count and a two-bit color number - up to three pixels can be
 554  described in four bits.  What a 0 repeat count means is unknown.  It
 555  might be used for RLE extension.  There is a special case of a 0
 556  repeat count though.  When the full nibble is zero, the rest of the
 557  line is filled with the color value in the next nibble.  It is
 558  unknown what happens if the color value is greater than three.  The
 559  rest seems to use a 4-entries palette.  It is not impossible that the
 560  fill-line complete case above is not as described and the zero repeat
 561  count means fill line.  The sample code never produces this, so it
 562  may be untested.
 563
 564  However we'll transform this so that that the RLE is expanded and
 565  interlacing will also be removed. On output each pixel entry will by
 566  a 4-bit alpha (filling 8 bits), and 8-bit y, u, and v entry.
 567
 568  *****************************************************************************/
 569 static void RenderImage( decoder_t *p_dec, block_t *p_data,
 570                          subpicture_region_t *p_region )
 571 {
 572     decoder_sys_t *p_sys = p_dec->p_sys;
 573     uint8_t *p_dest = p_region->p_picture->Y_PIXELS;
 574     int i_field;            /* The subtitles are interlaced */
 575     int i_row, i_column;    /* scanline row/column number */
 576     uint8_t i_color, i_count;
 577     bs_t bs;
 578
 579     bs_init( &bs, p_data->p_buffer + p_sys->i_image_offset,
 580              p_data->i_buffer - p_sys->i_image_offset );
 581
 582     for( i_field = 0; i_field < 2; i_field++ )
 583     {
 584         for( i_row = i_field; i_row < p_sys->i_height; i_row += 2 )
 585         {
 586             for( i_column = 0; i_column < p_sys->i_width; i_column++ )
 587             {
 588                 uint8_t i_val = bs_read( &bs, 4 );
 589
 590                 if( i_val == 0 )
 591                 {
 592                     /* Fill the rest of the line with next color */
 593                     i_color = bs_read( &bs, 4 );
 594
 595                     memset( &p_dest[i_row * p_region->p_picture->Y_PITCH +
 596                                     i_column], i_color,
 597                             p_sys->i_width - i_column );
 598                     i_column = p_sys->i_width;
 599                     continue;
 600                 }
 601                 else
 602                 {
 603                     /* Normal case: get color and repeat count */
 604                     i_count = (i_val >> 2);
 605                     i_color = i_val & 0x3;
 606
 607                     i_count = __MIN( i_count, p_sys->i_width - i_column );
 608
 609                     memset( &p_dest[i_row * p_region->p_picture->Y_PITCH +
 610                                     i_column], i_color, i_count );
 611                     i_column += i_count - 1;
 612                     continue;
 613                 }
 614             }
 615
 616             bs_align( &bs );
 617         }
 618     }
 619 }