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