ac68502651bead054eff8c6a10334229fecbe41d
[vlc.git] / plugins / spudec / spu_decoder.c
1 /*****************************************************************************
2  * spu_decoder.c : spu decoder thread
3  *****************************************************************************
4  * Copyright (C) 2000-2001 VideoLAN
5  * $Id: spu_decoder.c,v 1.29 2002/06/27 19:46:32 sam Exp $
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *          Rudolf Cornelissen <rag.cornelissen@inter.nl.net>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  * 
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>                                      /* malloc(), free() */
29 #include <string.h>                                    /* memcpy(), memset() */
30
31 #include <vlc/vlc.h>
32 #include <vlc/vout.h>
33 #include <vlc/decoder.h>
34
35 #ifdef HAVE_UNISTD_H
36 #   include <unistd.h>                                           /* getpid() */
37 #endif
38
39 #ifdef WIN32                   /* getpid() for win32 is located in process.h */
40 #   include <process.h>
41 #endif
42
43 #include "spu_decoder.h"
44
45 /*****************************************************************************
46  * Local prototypes
47  *****************************************************************************/
48 static int  decoder_Probe ( u8 * );
49 static int  decoder_Run   ( decoder_fifo_t * );
50 static int  InitThread    ( spudec_thread_t * );
51 static void EndThread     ( spudec_thread_t * );
52
53 static int  SyncPacket           ( spudec_thread_t * );
54 static void ParsePacket          ( spudec_thread_t * );
55 static int  ParseControlSequences( spudec_thread_t *, subpicture_t * );
56 static int  ParseRLE             ( spudec_thread_t *, subpicture_t *, u8 * );
57 static void RenderSPU            ( vout_thread_t *, picture_t *,
58                                    const subpicture_t * );
59
60 /*****************************************************************************
61  * Capabilities
62  *****************************************************************************/
63 void _M( spudec_getfunctions )( function_list_t * p_function_list )
64 {
65     p_function_list->functions.dec.pf_probe = decoder_Probe;
66     p_function_list->functions.dec.pf_run   = decoder_Run;
67 }
68
69 /*****************************************************************************
70  * Build configuration tree.
71  *****************************************************************************/
72 MODULE_CONFIG_START
73 MODULE_CONFIG_STOP
74
75 MODULE_INIT_START
76     SET_DESCRIPTION( _("DVD subtitles decoder module") )
77     ADD_CAPABILITY( DECODER, 50 )
78 MODULE_INIT_STOP
79
80 MODULE_ACTIVATE_START
81     _M( spudec_getfunctions )( &p_module->p_functions->dec );
82 MODULE_ACTIVATE_STOP
83
84 MODULE_DEACTIVATE_START
85 MODULE_DEACTIVATE_STOP
86
87 /*****************************************************************************
88  * decoder_Probe: probe the decoder and return score
89  *****************************************************************************
90  * Tries to launch a decoder and return score so that the interface is able 
91  * to chose.
92  *****************************************************************************/
93 static int decoder_Probe( u8 *pi_type )
94 {
95     return ( *pi_type == DVD_SPU_ES ) ? 0 : -1;
96 }
97
98 /*****************************************************************************
99  * decoder_Run: this function is called just after the thread is created
100  *****************************************************************************/
101 static int decoder_Run( decoder_fifo_t * p_fifo )
102 {
103     spudec_thread_t *     p_spudec;
104    
105     /* Allocate the memory needed to store the thread's structure */
106     p_spudec = (spudec_thread_t *)malloc( sizeof(spudec_thread_t) );
107
108     if ( p_spudec == NULL )
109     {
110         msg_Err( p_fifo, "out of memory" );
111         DecoderError( p_fifo );
112         return( -1 );
113     }
114     
115     /*
116      * Initialize the thread properties
117      */
118     p_spudec->p_vout = NULL;
119     p_spudec->p_fifo = p_fifo;
120         
121     /*
122      * Initialize thread and free configuration
123      */
124     p_spudec->p_fifo->b_error = InitThread( p_spudec );
125
126     /*
127      * Main loop - it is not executed if an error occured during
128      * initialization
129      */
130     while( (!p_spudec->p_fifo->b_die) && (!p_spudec->p_fifo->b_error) )
131     {
132         if( !SyncPacket( p_spudec ) )
133         {
134             ParsePacket( p_spudec );
135         }
136     }
137
138     /*
139      * Error loop
140      */
141     if( p_spudec->p_fifo->b_error )
142     {
143         DecoderError( p_spudec->p_fifo );
144
145         /* End of thread */
146         EndThread( p_spudec );
147         return -1;
148     }
149
150     /* End of thread */
151     EndThread( p_spudec );
152     return 0;
153 }
154
155 /* following functions are local */
156
157 /*****************************************************************************
158  * InitThread: initialize spu decoder thread
159  *****************************************************************************
160  * This function is called from RunThread and performs the second step of the
161  * initialization. It returns 0 on success. Note that the thread's flag are not
162  * modified inside this function.
163  *****************************************************************************/
164 static int InitThread( spudec_thread_t *p_spudec )
165 {
166     /* Find an available video output */
167     do
168     {
169         if( p_spudec->p_fifo->b_die || p_spudec->p_fifo->b_error )
170         {
171             return -1;
172         }
173
174         p_spudec->p_vout = vlc_object_find( p_spudec->p_fifo, VLC_OBJECT_VOUT,
175                                                               FIND_ANYWHERE );
176
177         if( p_spudec->p_vout )
178         {
179             break;
180         }
181
182         msleep( VOUT_OUTMEM_SLEEP );
183     }
184     while( 1 );
185
186     InitBitstream( &p_spudec->bit_stream, p_spudec->p_fifo, NULL, NULL );
187
188     /* Mark thread as running and return */
189     return 0;
190 }
191
192 /*****************************************************************************
193  * EndThread: thread destruction
194  *****************************************************************************
195  * This function is called when the thread ends after a sucessful
196  * initialization.
197  *****************************************************************************/
198 static void EndThread( spudec_thread_t *p_spudec )
199 {
200     if( p_spudec->p_vout != NULL 
201      && p_spudec->p_vout->p_subpicture != NULL )
202     {
203         subpicture_t *  p_subpic;
204         int             i_subpic;
205     
206         for( i_subpic = 0; i_subpic < VOUT_MAX_SUBPICTURES; i_subpic++ )
207         {
208             p_subpic = &p_spudec->p_vout->p_subpicture[i_subpic];
209
210             if( p_subpic != NULL &&
211               ( ( p_subpic->i_status == RESERVED_SUBPICTURE )
212              || ( p_subpic->i_status == READY_SUBPICTURE ) ) )
213             {
214                 vout_DestroySubPicture( p_spudec->p_vout, p_subpic );
215             }
216         }
217
218         vlc_object_release( p_spudec->p_vout );
219     }
220     
221     free( p_spudec );
222 }
223
224 /*****************************************************************************
225  * SyncPacket: get in sync with the stream
226  *****************************************************************************
227  * This function makes a few sanity checks and returns 0 if it looks like we
228  * are at the beginning of a subpicture packet.
229  *****************************************************************************/
230 static int SyncPacket( spudec_thread_t *p_spudec )
231 {
232     /* Re-align the buffer on an 8-bit boundary */
233     RealignBits( &p_spudec->bit_stream );
234
235     /* The total SPU packet size, often bigger than a PS packet */
236     p_spudec->i_spu_size = GetBits( &p_spudec->bit_stream, 16 );
237
238     /* The RLE stuff size (remove 4 because we just read 32 bits) */
239     p_spudec->i_rle_size = ShowBits( &p_spudec->bit_stream, 16 ) - 4;
240
241     /* If the values we got are a bit strange, skip packet */
242     if( !p_spudec->i_spu_size
243          || ( p_spudec->i_rle_size >= p_spudec->i_spu_size ) )
244     {
245         return( 1 );
246     }
247
248     RemoveBits( &p_spudec->bit_stream, 16 );
249
250     return( 0 );
251 }
252
253 /*****************************************************************************
254  * ParsePacket: parse an SPU packet and send it to the video output
255  *****************************************************************************
256  * This function parses the SPU packet and, if valid, sends it to the
257  * video output.
258  *****************************************************************************/
259 static void ParsePacket( spudec_thread_t *p_spudec )
260 {
261     subpicture_t * p_spu;
262     u8           * p_src;
263     unsigned int   i_offset;
264
265     msg_Dbg( p_spudec->p_fifo, "trying to gather a 0x%.2x long subtitle",
266                                p_spudec->i_spu_size );
267
268     /* We cannot display a subpicture with no date */
269     if( p_spudec->p_fifo->p_first->i_pts == 0 )
270     {
271         msg_Warn( p_spudec->p_fifo, "subtitle without a date" );
272         return;
273     }
274
275     /* Allocate the subpicture internal data. */
276     p_spu = vout_CreateSubPicture( p_spudec->p_vout, MEMORY_SUBPICTURE,
277                                    sizeof( subpicture_sys_t )
278                                     + p_spudec->i_rle_size * 4 );
279     /* Rationale for the "p_spudec->i_rle_size * 4": we are going to
280      * expand the RLE stuff so that we won't need to read nibbles later
281      * on. This will speed things up a lot. Plus, we'll only need to do
282      * this stupid interlacing stuff once. */
283
284     if( p_spu == NULL )
285     {
286         return;
287     }
288
289     /* Fill the p_spu structure */
290     p_spu->pf_render = RenderSPU;
291     p_spu->p_sys->p_data = (u8*)p_spu->p_sys + sizeof( subpicture_sys_t );
292     p_spu->p_sys->b_palette = 0;
293
294     /* Get display time now. If we do it later, we may miss the PTS. */
295     p_spu->p_sys->i_pts = p_spudec->p_fifo->p_first->i_pts;
296
297     /* Allocate the temporary buffer we will parse */
298     p_src = malloc( p_spudec->i_rle_size );
299
300     if( p_src == NULL )
301     {
302         msg_Err( p_spudec->p_fifo, "out of memory" );
303         vout_DestroySubPicture( p_spudec->p_vout, p_spu );
304         return;
305     }
306
307     /* Get RLE data */
308     for( i_offset = 0; i_offset < p_spudec->i_rle_size;
309          i_offset += SPU_CHUNK_SIZE )
310     {
311         GetChunk( &p_spudec->bit_stream, p_src + i_offset,
312                   ( i_offset + SPU_CHUNK_SIZE < p_spudec->i_rle_size ) ?
313                   SPU_CHUNK_SIZE : p_spudec->i_rle_size - i_offset );
314
315         /* Abort subtitle parsing if we were requested to stop */
316         if( p_spudec->p_fifo->b_die )
317         {
318             free( p_src );
319             vout_DestroySubPicture( p_spudec->p_vout, p_spu );
320             return;
321         }
322     }
323
324 #if 0
325     /* Dump the subtitle info */
326     intf_WarnHexDump( 5, p_spu->p_sys->p_data, p_spudec->i_rle_size );
327 #endif
328
329     /* Getting the control part */
330     if( ParseControlSequences( p_spudec, p_spu ) )
331     {
332         /* There was a parse error, delete the subpicture */
333         free( p_src );
334         vout_DestroySubPicture( p_spudec->p_vout, p_spu );
335         return;
336     }
337
338     /* At this point, no more GetBit() command is needed, so we have all
339      * the data we need to tell whether the subtitle is valid. Thus we
340      * try to display it and we ignore b_die. */
341
342     if( ParseRLE( p_spudec, p_spu, p_src ) )
343     {
344         /* There was a parse error, delete the subpicture */
345         free( p_src );
346         vout_DestroySubPicture( p_spudec->p_vout, p_spu );
347         return;
348     }
349
350     msg_Dbg( p_spudec->p_fifo, "total size: 0x%x, RLE offsets: 0x%x 0x%x",
351              p_spudec->i_spu_size,
352              p_spu->p_sys->pi_offset[0], p_spu->p_sys->pi_offset[1] );
353
354     /* SPU is finished - we can ask the video output to display it */
355     vout_DisplaySubPicture( p_spudec->p_vout, p_spu );
356
357     /* Clean up */
358     free( p_src );
359 }
360
361 /*****************************************************************************
362  * ParseControlSequences: parse all SPU control sequences
363  *****************************************************************************
364  * This is the most important part in SPU decoding. We get dates, palette
365  * information, coordinates, and so on. For more information on the
366  * subtitles format, see http://sam.zoy.org/doc/dvd/subtitles/index.html
367  *****************************************************************************/
368 static int ParseControlSequences( spudec_thread_t *p_spudec,
369                                   subpicture_t * p_spu )
370 {
371     /* Our current index in the SPU packet */
372     int i_index = p_spudec->i_rle_size + 4;
373
374     /* The next start-of-control-sequence index and the previous one */
375     int i_next_seq, i_cur_seq;
376
377     /* Command time and date */
378     u8  i_command;
379     int i_date;
380
381     int i, pi_alpha[4];
382
383     /* XXX: temporary variables */
384     vlc_bool_t b_force_display = 0;
385
386     /* Initialize the structure */
387     p_spu->i_start = p_spu->i_stop = 0;
388     p_spu->b_ephemer = 0;
389
390     do
391     {
392         /* Get the control sequence date */
393         i_date = GetBits( &p_spudec->bit_stream, 16 );
394  
395         /* Next offset */
396         i_cur_seq = i_index;
397         i_next_seq = GetBits( &p_spudec->bit_stream, 16 );
398  
399         /* Skip what we just read */
400         i_index += 4;
401  
402         do
403         {
404             i_command = GetBits( &p_spudec->bit_stream, 8 );
405             i_index++;
406  
407             switch( i_command )
408             {
409                 case SPU_CMD_FORCE_DISPLAY:
410
411                     /* 00 (force displaying) */
412                     p_spu->i_start = p_spu->p_sys->i_pts + ( i_date * 11000 );
413                     b_force_display = 1;
414  
415                     break;
416  
417                 /* Convert the dates in seconds to PTS values */
418                 case SPU_CMD_START_DISPLAY:
419  
420                     /* 01 (start displaying) */
421                     p_spu->i_start = p_spu->p_sys->i_pts + ( i_date * 11000 );
422  
423                     break;
424  
425                 case SPU_CMD_STOP_DISPLAY:
426  
427                     /* 02 (stop displaying) */
428                     p_spu->i_stop = p_spu->p_sys->i_pts + ( i_date * 11000 );
429  
430                     break;
431  
432                 case SPU_CMD_SET_PALETTE:
433  
434                     /* 03xxxx (palette) */
435                     if( p_spudec->p_fifo->p_demux_data &&
436                          *(int*)p_spudec->p_fifo->p_demux_data == 0xBeeF )
437                     {
438                         u32 i_color;
439
440                         p_spu->p_sys->b_palette = 1;
441                         for( i = 0; i < 4 ; i++ )
442                         {
443                             i_color = ((u32*)((char*)p_spudec->p_fifo->
444                                         p_demux_data + sizeof(int)))[
445                                           GetBits(&p_spudec->bit_stream, 4) ];
446
447                             /* FIXME: this job should be done sooner */
448 #ifndef WORDS_BIGENDIAN
449                             p_spu->p_sys->pi_yuv[3-i][0] = (i_color>>16) & 0xff;
450                             p_spu->p_sys->pi_yuv[3-i][1] = (i_color>>0) & 0xff;
451                             p_spu->p_sys->pi_yuv[3-i][2] = (i_color>>8) & 0xff;
452 #else
453                             p_spu->p_sys->pi_yuv[3-i][0] = (i_color>>8) & 0xff;
454                             p_spu->p_sys->pi_yuv[3-i][1] = (i_color>>24) & 0xff;
455                             p_spu->p_sys->pi_yuv[3-i][2] = (i_color>>16) & 0xff;
456 #endif
457                         }
458                     }
459                     else
460                     {
461                         RemoveBits( &p_spudec->bit_stream, 16 );
462                     }
463                     i_index += 2;
464  
465                     break;
466  
467                 case SPU_CMD_SET_ALPHACHANNEL:
468  
469                     /* 04xxxx (alpha channel) */
470                     pi_alpha[3] = GetBits( &p_spudec->bit_stream, 4 );
471                     pi_alpha[2] = GetBits( &p_spudec->bit_stream, 4 );
472                     pi_alpha[1] = GetBits( &p_spudec->bit_stream, 4 );
473                     pi_alpha[0] = GetBits( &p_spudec->bit_stream, 4 );
474
475                     /* Ignore blank alpha palette. Sometimes spurious blank
476                      * alpha palettes are present - dunno why. */
477                     if( pi_alpha[0] | pi_alpha[1] | pi_alpha[2] | pi_alpha[3] )
478                     {
479                         p_spu->p_sys->pi_alpha[0] = pi_alpha[0];
480                         p_spu->p_sys->pi_alpha[1] = pi_alpha[1];
481                         p_spu->p_sys->pi_alpha[2] = pi_alpha[2];
482                         p_spu->p_sys->pi_alpha[3] = pi_alpha[3];
483                     }
484                     else
485                     {
486                         msg_Warn( p_spudec->p_fifo,
487                                   "ignoring blank alpha palette" );
488                     }
489
490                     i_index += 2;
491  
492                     break;
493  
494                 case SPU_CMD_SET_COORDINATES:
495  
496                     /* 05xxxyyyxxxyyy (coordinates) */
497                     p_spu->i_x = GetBits( &p_spudec->bit_stream, 12 );
498                     p_spu->i_width = GetBits( &p_spudec->bit_stream, 12 )
499                                       - p_spu->i_x + 1;
500  
501                     p_spu->i_y = GetBits( &p_spudec->bit_stream, 12 );
502                     p_spu->i_height = GetBits( &p_spudec->bit_stream, 12 )
503                                        - p_spu->i_y + 1;
504  
505                     i_index += 6;
506  
507                     break;
508  
509                 case SPU_CMD_SET_OFFSETS:
510  
511                     /* 06xxxxyyyy (byte offsets) */
512                     p_spu->p_sys->pi_offset[0] =
513                         GetBits( &p_spudec->bit_stream, 16 ) - 4;
514  
515                     p_spu->p_sys->pi_offset[1] =
516                         GetBits( &p_spudec->bit_stream, 16 ) - 4;
517  
518                     i_index += 4;
519  
520                     break;
521  
522                 case SPU_CMD_END:
523  
524                     /* ff (end) */
525                     break;
526  
527                 default:
528  
529                     /* xx (unknown command) */
530                     msg_Err( p_spudec->p_fifo, "unknown command 0x%.2x",
531                                                i_command );
532                     return( 1 );
533             }
534
535             /* We need to check for quit commands here */
536             if( p_spudec->p_fifo->b_die )
537             {
538                 return( 1 );
539             }
540
541         } while( i_command != SPU_CMD_END );
542
543     } while( i_index == i_next_seq );
544
545     /* Check that the next sequence index matches the current one */
546     if( i_next_seq != i_cur_seq )
547     {
548         msg_Err( p_spudec->p_fifo, "index mismatch (0x%.4x != 0x%.4x)",
549                                    i_next_seq, i_cur_seq );
550         return( 1 );
551     }
552
553     if( i_index > p_spudec->i_spu_size )
554     {
555         msg_Err( p_spudec->p_fifo, "uh-oh, we went too far (0x%.4x > 0x%.4x)",
556                                    i_index, p_spudec->i_spu_size );
557         return( 1 );
558     }
559
560     if( !p_spu->i_start )
561     {
562         msg_Err( p_spudec->p_fifo, "no `start display' command" );
563     }
564
565     if( !p_spu->i_stop )
566     {
567         /* This subtitle will live for 5 seconds or until the next subtitle */
568         p_spu->i_stop = p_spu->i_start + 500 * 11000;
569         p_spu->b_ephemer = 1;
570     }
571
572     /* Get rid of padding bytes */
573     switch( p_spudec->i_spu_size - i_index )
574     {
575         /* Zero or one padding byte, quite usual */
576         case 1:
577             RemoveBits( &p_spudec->bit_stream, 8 );
578             i_index++;
579         case 0:
580             break;
581
582         /* More than one padding byte - this is very strange, but
583          * we can deal with it */
584         default:
585             msg_Warn( p_spudec->p_fifo,
586                       "%i padding bytes, we usually get 0 or 1 of them",
587                       p_spudec->i_spu_size - i_index );
588
589             while( i_index < p_spudec->i_spu_size )
590             {
591                 RemoveBits( &p_spudec->bit_stream, 8 );
592                 i_index++;
593             }
594
595             break;
596     }
597
598     if( b_force_display )
599     {
600         msg_Err( p_spudec->p_fifo, "\"force display\" command" );
601         msg_Err( p_spudec->p_fifo, "send mail to <sam@zoy.org> if you "
602                                    "want to help debugging this" );
603     }
604
605     /* Successfully parsed ! */
606     return( 0 );
607 }
608
609 /*****************************************************************************
610  * ParseRLE: parse the RLE part of the subtitle
611  *****************************************************************************
612  * This part parses the subtitle graphical data and stores it in a more
613  * convenient structure for later decoding. For more information on the
614  * subtitles format, see http://sam.zoy.org/doc/dvd/subtitles/index.html
615  *****************************************************************************/
616 static int ParseRLE( spudec_thread_t *p_spudec,
617                      subpicture_t * p_spu, u8 * p_src )
618 {
619     unsigned int i_code;
620
621     unsigned int i_width = p_spu->i_width;
622     unsigned int i_height = p_spu->i_height;
623     unsigned int i_x, i_y;
624
625     u16 *p_dest = (u16 *)p_spu->p_sys->p_data;
626
627     /* The subtitles are interlaced, we need two offsets */
628     unsigned int  i_id = 0;                   /* Start on the even SPU layer */
629     unsigned int  pi_table[ 2 ];
630     unsigned int *pi_offset;
631
632     vlc_bool_t b_empty_top = 1,
633                b_empty_bottom = 0;
634     unsigned int i_skipped_top = 0,
635                  i_skipped_bottom = 0;
636
637     /* Colormap statistics */
638     int i_border = -1;
639     int stats[4]; stats[0] = stats[1] = stats[2] = stats[3] = 0;
640
641     pi_table[ 0 ] = p_spu->p_sys->pi_offset[ 0 ] << 1;
642     pi_table[ 1 ] = p_spu->p_sys->pi_offset[ 1 ] << 1;
643
644     for( i_y = 0 ; i_y < i_height ; i_y++ )
645     {
646         pi_offset = pi_table + i_id;
647
648         for( i_x = 0 ; i_x < i_width ; i_x += i_code >> 2 )
649         {
650             i_code = AddNibble( 0, p_src, pi_offset );
651
652             if( i_code < 0x04 )
653             {
654                 i_code = AddNibble( i_code, p_src, pi_offset );
655
656                 if( i_code < 0x10 )
657                 {
658                     i_code = AddNibble( i_code, p_src, pi_offset );
659
660                     if( i_code < 0x040 )
661                     {
662                         i_code = AddNibble( i_code, p_src, pi_offset );
663
664                         if( i_code < 0x0100 )
665                         {
666                             /* If the 14 first bits are set to 0, then it's a
667                              * new line. We emulate it. */
668                             if( i_code < 0x0004 )
669                             {
670                                 i_code |= ( i_width - i_x ) << 2;
671                             }
672                             else
673                             {
674                                 /* We have a boo boo ! */
675                                 msg_Err( p_spudec->p_fifo, "unknown RLE code "
676                                          "0x%.4x", i_code );
677                                 return( 1 );
678                             }
679                         }
680                     }
681                 }
682             }
683
684             if( ( (i_code >> 2) + i_x + i_y * i_width ) > i_height * i_width )
685             {
686                 msg_Err( p_spudec->p_fifo,
687                          "out of bounds, %i at (%i,%i) is out of %ix%i",
688                          i_code >> 2, i_x, i_y, i_width, i_height );
689                 return( 1 );
690             }
691
692             /* Try to find the border color */
693             if( p_spu->p_sys->pi_alpha[ i_code & 0x3 ] != 0x00 )
694             {
695                 i_border = i_code & 0x3;
696                 stats[i_border] += i_code >> 2;
697             }
698
699             if( (i_code >> 2) == i_width
700                  && p_spu->p_sys->pi_alpha[ i_code & 0x3 ] == 0x00 )
701             {
702                 if( b_empty_top )
703                 {
704                     /* This is a blank top line, we skip it */
705                     i_skipped_top++;
706                 }
707                 else
708                 {
709                     /* We can't be sure the current lines will be skipped,
710                      * so we store the code just in case. */
711                     *p_dest++ = i_code;
712
713                     b_empty_bottom = 1;
714                     i_skipped_bottom++;
715                 }
716             }
717             else
718             {
719                 /* We got a valid code, store it */
720                 *p_dest++ = i_code;
721
722                 /* Valid code means no blank line */
723                 b_empty_top = 0;
724                 b_empty_bottom = 0;
725                 i_skipped_bottom = 0;
726             }
727         }
728
729         /* Check that we didn't go too far */
730         if( i_x > i_width )
731         {
732             msg_Err( p_spudec->p_fifo, "i_x overflowed, %i > %i",
733                                        i_x, i_width );
734             return( 1 );
735         }
736
737         /* Byte-align the stream */
738         if( *pi_offset & 0x1 )
739         {
740             (*pi_offset)++;
741         }
742
743         /* Swap fields */
744         i_id = ~i_id & 0x1;
745     }
746
747     /* We shouldn't get any padding bytes */
748     if( i_y < i_height )
749     {
750         msg_Err( p_spudec->p_fifo, "padding bytes found in RLE sequence" );
751         msg_Err( p_spudec->p_fifo, "send mail to <sam@zoy.org> if you "
752                                    "want to help debugging this" );
753
754         /* Skip them just in case */
755         while( i_y < i_height )
756         {
757             *p_dest++ = i_width << 2;
758             i_y++;
759         }
760
761         return( 1 );
762     }
763
764     msg_Dbg( p_spudec->p_fifo, "valid subtitle, size: %ix%i, position: %i,%i",
765              p_spu->i_width, p_spu->i_height, p_spu->i_x, p_spu->i_y );
766
767     /* Crop if necessary */
768     if( i_skipped_top || i_skipped_bottom )
769     {
770         p_spu->i_y += i_skipped_top;
771         p_spu->i_height -= i_skipped_top + i_skipped_bottom;
772
773         msg_Dbg( p_spudec->p_fifo, "cropped to: %ix%i, position: %i,%i",
774                  p_spu->i_width, p_spu->i_height, p_spu->i_x, p_spu->i_y );
775     }
776
777     /* Handle color if no palette was found */
778     if( !p_spu->p_sys->b_palette )
779     {
780         int i, i_inner = -1, i_shade = -1;
781
782         /* Set the border color */
783         p_spu->p_sys->pi_yuv[i_border][0] = 0x00;
784         p_spu->p_sys->pi_yuv[i_border][1] = 0x80;
785         p_spu->p_sys->pi_yuv[i_border][2] = 0x80;
786         stats[i_border] = 0;
787
788         /* Find the inner colors */
789         for( i = 0 ; i < 4 && i_inner == -1 ; i++ )
790         {
791             if( stats[i] )
792             {
793                 i_inner = i;
794             }
795         }
796
797         for(       ; i < 4 && i_shade == -1 ; i++ )
798         {
799             if( stats[i] )
800             {
801                 if( stats[i] > stats[i_inner] )
802                 {
803                     i_shade = i_inner;
804                     i_inner = i;
805                 }
806                 else
807                 {
808                     i_shade = i;
809                 }
810             }
811         }
812
813         /* Set the inner color */
814         if( i_inner != -1 )
815         {
816             p_spu->p_sys->pi_yuv[i_inner][0] = 0xff;
817             p_spu->p_sys->pi_yuv[i_inner][1] = 0x80;
818             p_spu->p_sys->pi_yuv[i_inner][2] = 0x80;
819         }
820
821         /* Set the anti-aliasing color */
822         if( i_shade != -1 )
823         {
824             p_spu->p_sys->pi_yuv[i_shade][0] = 0x80;
825             p_spu->p_sys->pi_yuv[i_shade][1] = 0x80;
826             p_spu->p_sys->pi_yuv[i_shade][2] = 0x80;
827         }
828
829         msg_Dbg( p_spudec->p_fifo,
830                  "using custom palette (border %i, inner %i, shade %i)",
831                  i_border, i_inner, i_shade );
832     }
833
834     return( 0 );
835 }
836
837 /*****************************************************************************
838  * RenderSPU: draw an SPU on a picture
839  *****************************************************************************
840  * This is a fast implementation of the subpicture drawing code. The data
841  * has been preprocessed once, so we don't need to parse the RLE buffer again
842  * and again. Most sanity checks are already done so that this routine can be
843  * as fast as possible.
844  *****************************************************************************/
845 static void RenderSPU( vout_thread_t *p_vout, picture_t *p_pic,
846                        const subpicture_t *p_spu )
847 {
848     /* Common variables */
849     u16  p_clut16[4];
850     u32  p_clut32[4];
851     u8  *p_dest;
852     u8  *p_destptr = (u8 *)p_dest;
853     u16 *p_source = (u16 *)p_spu->p_sys->p_data;
854
855     int i_x, i_y;
856     int i_len, i_color, i_colprecomp, i_destalpha;
857     u8  i_cnt;
858
859     /* RGB-specific */
860     int i_xscale, i_yscale, i_width, i_height, i_ytmp, i_yreal, i_ynext;
861
862     switch( p_vout->output.i_chroma )
863     {
864     /* I420 target, no scaling */
865     case FOURCC_I420:
866     case FOURCC_IYUV:
867     case FOURCC_YV12:
868
869     p_dest = p_pic->Y_PIXELS + p_spu->i_x + p_spu->i_width
870               + p_pic->Y_PITCH * ( p_spu->i_y + p_spu->i_height );
871
872     /* Draw until we reach the bottom of the subtitle */
873     for( i_y = p_spu->i_height * p_pic->Y_PITCH ;
874          i_y ;
875          i_y -= p_pic->Y_PITCH )
876     {
877         /* Draw until we reach the end of the line */
878         for( i_x = p_spu->i_width ; i_x ; )
879         {
880             /* Get the RLE part, then draw the line */
881             i_color = *p_source & 0x3;
882             i_len = *p_source++ >> 2;
883
884             switch( p_spu->p_sys->pi_alpha[ i_color ] )
885             {
886                 case 0x00:
887                     break;
888
889                 case 0x0f:
890                     memset( p_dest - i_x - i_y,
891                             p_spu->p_sys->pi_yuv[i_color][0], i_len );
892                     break;
893
894                 default:
895                     /* To be able to divide by 16 (>>4) we add 1 to the alpha.
896                      * This means Alpha 0 won't be completely transparent, but
897                      * that's handled in a special case above anyway. */
898                     i_colprecomp = p_spu->p_sys->pi_yuv[i_color][0]
899                                     * (p_spu->p_sys->pi_alpha[ i_color ] + 1);
900                     i_destalpha = 15 - p_spu->p_sys->pi_alpha[ i_color ];
901
902                     for ( p_destptr = p_dest - i_x - i_y;
903                           p_destptr < p_dest - i_x - i_y + i_len;
904                           p_destptr++ )
905                     {
906                         *p_destptr = ( i_colprecomp +
907                                         *p_destptr * i_destalpha ) >> 4;
908                     }
909                     break;
910
911             }
912             i_x -= i_len;
913         }
914     }
915
916     break;
917
918     /* RV16 target, scaling */
919     case FOURCC_RV16:
920
921     /* XXX: this is a COMPLETE HACK, memcpy is unable to do u16s anyway */
922     /* FIXME: get this from the DVD */
923     for( i_color = 0; i_color < 4; i_color++ )
924     {
925         p_clut16[i_color] = 0x1111
926                              * ( (u16)p_spu->p_sys->pi_yuv[i_color][0] >> 4 );
927     }
928
929     i_xscale = ( p_vout->output.i_width << 6 ) / p_vout->render.i_width;
930     i_yscale = ( p_vout->output.i_height << 6 ) / p_vout->render.i_height;
931
932     i_width  = p_spu->i_width  * i_xscale;
933     i_height = p_spu->i_height * i_yscale;
934
935     p_dest = p_pic->p->p_pixels + ( i_width >> 6 ) * 2
936               /* Add the picture coordinates and the SPU coordinates */
937               + ( (p_spu->i_x * i_xscale) >> 6 ) * 2
938               + ( (p_spu->i_y * i_yscale) >> 6 ) * p_pic->p->i_pitch;
939
940     /* Draw until we reach the bottom of the subtitle */
941     for( i_y = 0 ; i_y < i_height ; )
942     {
943         i_ytmp = i_y >> 6;
944         i_y += i_yscale;
945
946         /* Check whether we need to draw one line or more than one */
947         if( i_ytmp + 1 >= ( i_y >> 6 ) )
948         {
949             /* Just one line : we precalculate i_y >> 6 */
950             i_yreal = p_pic->p->i_pitch * i_ytmp;
951
952             /* Draw until we reach the end of the line */
953             for( i_x = i_width ; i_x ; )
954             {
955                 /* Get the RLE part, then draw the line */
956                 i_color = *p_source & 0x3;
957
958                 switch( p_spu->p_sys->pi_alpha[ i_color ] )
959                 {
960                 case 0x00:
961                     i_x -= i_xscale * ( *p_source++ >> 2 );
962                     break;
963
964                 case 0x0f:
965                     i_len = i_xscale * ( *p_source++ >> 2 );
966                     memset( p_dest - 2 * ( i_x >> 6 ) + i_yreal,
967                             p_clut16[ i_color ],
968                             2 * ( ( i_len >> 6 ) + 1 ) );
969                     i_x -= i_len;
970                     break;
971
972                 default:
973                     /* FIXME: we should do transparency */
974                     i_len = i_xscale * ( *p_source++ >> 2 );
975                     memset( p_dest - 2 * ( i_x >> 6 ) + i_yreal,
976                             p_clut16[ i_color ],
977                             2 * ( ( i_len >> 6 ) + 1 ) );
978                     i_x -= i_len;
979                     break;
980                 }
981
982             }
983         }
984         else
985         {
986             i_yreal = p_pic->p->i_pitch * i_ytmp;
987             i_ynext = p_pic->p->i_pitch * i_y >> 6;
988
989             /* Draw until we reach the end of the line */
990             for( i_x = i_width ; i_x ; )
991             {
992                 /* Get the RLE part, then draw as many lines as needed */
993                 i_color = *p_source & 0x3;
994
995                 switch( p_spu->p_sys->pi_alpha[ i_color ] )
996                 {
997                 case 0x00:
998                     i_x -= i_xscale * ( *p_source++ >> 2 );
999                     break;
1000
1001                 case 0x0f:
1002                     i_len = i_xscale * ( *p_source++ >> 2 );
1003                     for( i_ytmp = i_yreal ; i_ytmp < i_ynext ;
1004                          i_ytmp += p_pic->p->i_pitch )
1005                     {
1006                         memset( p_dest - 2 * ( i_x >> 6 ) + i_ytmp,
1007                                 p_clut16[ i_color ],
1008                                 2 * ( ( i_len >> 6 ) + 1 ) );
1009                     }
1010                     i_x -= i_len;
1011                     break;
1012
1013                 default:
1014                     /* FIXME: we should do transparency */
1015                     i_len = i_xscale * ( *p_source++ >> 2 );
1016                     for( i_ytmp = i_yreal ; i_ytmp < i_ynext ;
1017                          i_ytmp += p_pic->p->i_pitch )
1018                     {
1019                         memset( p_dest - 2 * ( i_x >> 6 ) + i_ytmp,
1020                                 p_clut16[ i_color ],
1021                                 2 * ( ( i_len >> 6 ) + 1 ) );
1022                     }
1023                     i_x -= i_len;
1024                     break;
1025                 }
1026             }
1027         }
1028     }
1029
1030     break;
1031
1032     /* RV32 target, scaling */
1033     case FOURCC_RV24:
1034     case FOURCC_RV32:
1035
1036     /* XXX: this is a COMPLETE HACK, memcpy is unable to do u32s anyway */
1037     /* FIXME: get this from the DVD */
1038     for( i_color = 0; i_color < 4; i_color++ )
1039     {
1040         p_clut32[i_color] = 0x11111111
1041                              * ( (u16)p_spu->p_sys->pi_yuv[i_color][0] >> 4 );
1042     }
1043
1044     i_xscale = ( p_vout->output.i_width << 6 ) / p_vout->render.i_width;
1045     i_yscale = ( p_vout->output.i_height << 6 ) / p_vout->render.i_height;
1046
1047     i_width  = p_spu->i_width  * i_xscale;
1048     i_height = p_spu->i_height * i_yscale;
1049
1050     p_dest = p_pic->p->p_pixels + ( i_width >> 6 ) * 4
1051               /* Add the picture coordinates and the SPU coordinates */
1052               + ( (p_spu->i_x * i_xscale) >> 6 ) * 4
1053               + ( (p_spu->i_y * i_yscale) >> 6 ) * p_pic->p->i_pitch;
1054
1055     /* Draw until we reach the bottom of the subtitle */
1056     for( i_y = 0 ; i_y < i_height ; )
1057     {
1058         i_ytmp = i_y >> 6;
1059         i_y += i_yscale;
1060
1061         /* Check whether we need to draw one line or more than one */
1062         if( i_ytmp + 1 >= ( i_y >> 6 ) )
1063         {
1064             /* Just one line : we precalculate i_y >> 6 */
1065             i_yreal = p_pic->p->i_pitch * i_ytmp;
1066
1067             /* Draw until we reach the end of the line */
1068             for( i_x = i_width ; i_x ; )
1069             {
1070                 /* Get the RLE part, then draw the line */
1071                 i_color = *p_source & 0x3;
1072
1073                 switch( p_spu->p_sys->pi_alpha[ i_color ] )
1074                 {
1075                 case 0x00:
1076                     i_x -= i_xscale * ( *p_source++ >> 2 );
1077                     break;
1078
1079                 case 0x0f:
1080                     i_len = i_xscale * ( *p_source++ >> 2 );
1081                     memset( p_dest - 4 * ( i_x >> 6 ) + i_yreal,
1082                             p_clut32[ i_color ], 4 * ( ( i_len >> 6 ) + 1 ) );
1083                     i_x -= i_len;
1084                     break;
1085
1086                 default:
1087                     /* FIXME: we should do transparency */
1088                     i_len = i_xscale * ( *p_source++ >> 2 );
1089                     memset( p_dest - 4 * ( i_x >> 6 ) + i_yreal,
1090                             p_clut32[ i_color ], 4 * ( ( i_len >> 6 ) + 1 ) );
1091                     i_x -= i_len;
1092                     break;
1093                 }
1094
1095             }
1096         }
1097         else
1098         {
1099             i_yreal = p_pic->p->i_pitch * i_ytmp;
1100             i_ynext = p_pic->p->i_pitch * i_y >> 6;
1101
1102             /* Draw until we reach the end of the line */
1103             for( i_x = i_width ; i_x ; )
1104             {
1105                 /* Get the RLE part, then draw as many lines as needed */
1106                 i_color = *p_source & 0x3;
1107
1108                 switch( p_spu->p_sys->pi_alpha[ i_color ] )
1109                 {
1110                 case 0x00:
1111                     i_x -= i_xscale * ( *p_source++ >> 2 );
1112                     break;
1113
1114                 case 0x0f:
1115                     i_len = i_xscale * ( *p_source++ >> 2 );
1116                     for( i_ytmp = i_yreal ; i_ytmp < i_ynext ;
1117                          i_ytmp += p_pic->p->i_pitch )
1118                     {
1119                         memset( p_dest - 4 * ( i_x >> 6 ) + i_ytmp,
1120                                 p_clut32[ i_color ],
1121                                 4 * ( ( i_len >> 6 ) + 1 ) );
1122                     }
1123                     i_x -= i_len;
1124                     break;
1125
1126                 default:
1127                     /* FIXME: we should do transparency */
1128                     i_len = i_xscale * ( *p_source++ >> 2 );
1129                     for( i_ytmp = i_yreal ; i_ytmp < i_ynext ;
1130                          i_ytmp += p_pic->p->i_pitch )
1131                     {
1132                         memset( p_dest - 4 * ( i_x >> 6 ) + i_ytmp,
1133                                 p_clut32[ i_color ],
1134                                 4 * ( ( i_len >> 6 ) + 1 ) );
1135                     }
1136                     i_x -= i_len;
1137                     break;
1138                 }
1139             }
1140         }
1141     }
1142
1143     break;
1144
1145     /* NVidia overlay, no scaling */
1146     case FOURCC_YUY2:
1147
1148     p_dest = p_pic->p->p_pixels +
1149               (p_spu->i_x + p_spu->i_width +
1150                p_vout->output.i_width * ( p_spu->i_y + p_spu->i_height )) * 2;
1151     /* Draw until we reach the bottom of the subtitle */
1152     for( i_y = p_spu->i_height * p_vout->output.i_width;
1153          i_y ;
1154          i_y -= p_vout->output.i_width )
1155     {
1156         /* Draw until we reach the end of the line */
1157         for( i_x = p_spu->i_width ; i_x ; )
1158         {
1159             /* Get the RLE part, then draw the line */
1160             i_color = *p_source & 0x3;
1161
1162             switch( p_spu->p_sys->pi_alpha[ i_color ] )
1163             {
1164             case 0x00:
1165                 i_x -= *p_source++ >> 2;
1166                 break;
1167
1168             case 0x0f:
1169                 i_len = *p_source++ >> 2;
1170                 for( i_cnt = 0; i_cnt < i_len; i_cnt++ )
1171                 {
1172                     /* draw a pixel */
1173                     /* Y */
1174                     memset( p_dest - i_x * 2 - i_y * 2 + i_cnt * 2,
1175                             p_spu->p_sys->pi_yuv[i_color][0], 1);
1176
1177                     if (!(i_cnt & 0x01))
1178                     {
1179                         /* U and V */
1180                         memset( p_dest - i_x * 2 - i_y * 2 + i_cnt * 2 + 1,
1181                                 0x80, 1);
1182                         memset( p_dest - i_x * 2 - i_y * 2 + i_cnt * 2 + 3,
1183                                 0x80, 1);
1184                     }
1185                 }
1186                 i_x -= i_len;
1187                 break;
1188
1189             default:
1190                 /* FIXME: we should do transparency */
1191                 i_len = *p_source++ >> 2;
1192                 for( i_cnt = 0; i_cnt < i_len; i_cnt++ )
1193                 {
1194                     /* draw a pixel */
1195                     /* Y */
1196                     memset( p_dest - i_x * 2 - i_y * 2 + i_cnt * 2,
1197                             p_spu->p_sys->pi_yuv[i_color][0], 1);
1198
1199                     if (!(i_cnt & 0x01))
1200                     {
1201                         /* U and V */
1202                         memset( p_dest - i_x * 2 - i_y * 2 + i_cnt * 2 + 1,
1203                                 0x80, 1);
1204                         memset( p_dest - i_x * 2 - i_y * 2 + i_cnt * 2 + 3,
1205                                 0x80, 1);
1206                     }
1207                 }
1208                 i_x -= i_len;
1209                 break;
1210             }
1211         }
1212     }
1213
1214     break;
1215
1216
1217     default:
1218         msg_Err( p_vout, "unknown chroma, can't render SPU" );
1219         break;
1220     }
1221 }