modules/codec/cvdsub.c

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