66f3110167f13180da29d92f5cba90d3e0edc070
[vlc.git] / modules / codec / spudec / parse.c
1 /*****************************************************************************
2  * parse.c: SPU parser
3  *****************************************************************************
4  * Copyright (C) 2000-2001 VideoLAN
5  * $Id: parse.c,v 1.12 2003/07/22 20:49:10 hartman Exp $
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  * 
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>                                      /* malloc(), free() */
28 #include <string.h>                                    /* memcpy(), memset() */
29
30 #include <vlc/vlc.h>
31 #include <vlc/vout.h>
32 #include <vlc/decoder.h>
33
34 #include "spudec.h"
35
36 /*****************************************************************************
37  * Local prototypes.
38  *****************************************************************************/
39 static int  ParseControlSeq  ( spudec_thread_t *, subpicture_t * );
40 static int  ParseRLE         ( spudec_thread_t *, subpicture_t *, uint8_t * );
41
42 static void DestroySPU       ( subpicture_t * );
43
44 static void UpdateSPU        ( subpicture_t *, vlc_object_t * );
45 static int  CropCallback     ( vlc_object_t *, char const *,
46                                vlc_value_t, vlc_value_t, void * );
47
48 /*****************************************************************************
49  * AddNibble: read a nibble from a source packet and add it to our integer.
50  *****************************************************************************/
51 static inline unsigned int AddNibble( unsigned int i_code,
52                                       uint8_t *p_src, int *pi_index )
53 {
54     if( *pi_index & 0x1 )
55     {
56         return( i_code << 4 | ( p_src[(*pi_index)++ >> 1] & 0xf ) );
57     }
58     else
59     {
60         return( i_code << 4 | p_src[(*pi_index)++ >> 1] >> 4 );
61     }
62 }
63
64 /*****************************************************************************
65  * SyncPacket: get in sync with the stream
66  *****************************************************************************
67  * This function makes a few sanity checks and returns 0 if it looks like we
68  * are at the beginning of a subpicture packet.
69  *****************************************************************************/
70 int E_(SyncPacket)( spudec_thread_t *p_spudec )
71 {
72     /* Re-align the buffer on an 8-bit boundary */
73     RealignBits( &p_spudec->bit_stream );
74
75     /* The total SPU packet size, often bigger than a PS packet */
76     p_spudec->i_spu_size = GetBits( &p_spudec->bit_stream, 16 );
77
78     /* The RLE stuff size (remove 4 because we just read 32 bits) */
79     p_spudec->i_rle_size = ShowBits( &p_spudec->bit_stream, 16 ) - 4;
80
81     /* If the values we got are a bit strange, skip packet */
82     if( !p_spudec->i_spu_size
83          || ( p_spudec->i_rle_size >= p_spudec->i_spu_size ) )
84     {
85         return VLC_EGENERIC;
86     }
87
88     RemoveBits( &p_spudec->bit_stream, 16 );
89
90     return VLC_SUCCESS;
91 }
92
93 /*****************************************************************************
94  * ParsePacket: parse an SPU packet and send it to the video output
95  *****************************************************************************
96  * This function parses the SPU packet and, if valid, sends it to the
97  * video output.
98  *****************************************************************************/
99 void E_(ParsePacket)( spudec_thread_t *p_spudec )
100 {
101     subpicture_t * p_spu;
102     uint8_t      * p_src;
103     unsigned int   i_offset;
104     mtime_t        i_pts;
105
106     msg_Dbg( p_spudec->p_fifo, "trying to gather a 0x%.2x long subtitle",
107                                p_spudec->i_spu_size );
108
109     /* We cannot display a subpicture with no date */
110     NextPTS( &p_spudec->bit_stream, &i_pts, NULL );
111     if( i_pts == 0 )
112     {
113         msg_Warn( p_spudec->p_fifo, "subtitle without a date" );
114         return;
115     }
116
117     /* Allocate the subpicture internal data. */
118     p_spu = vout_CreateSubPicture( p_spudec->p_vout, MEMORY_SUBPICTURE );
119
120     if( p_spu == NULL )
121     {
122         return;
123     }
124
125     /* Rationale for the "p_spudec->i_rle_size * 4": we are going to
126      * expand the RLE stuff so that we won't need to read nibbles later
127      * on. This will speed things up a lot. Plus, we'll only need to do
128      * this stupid interlacing stuff once. */
129     p_spu->p_sys = malloc( sizeof( subpicture_sys_t )
130                             + p_spudec->i_rle_size * 4 );
131
132     if( p_spu->p_sys == NULL )
133     {
134         vout_DestroySubPicture( p_spudec->p_vout, p_spu );
135         return;
136     }
137
138     /* Fill the p_spu structure */
139     vlc_mutex_init( p_spudec->p_fifo, &p_spu->p_sys->lock );
140
141     p_spu->pf_render = E_(RenderSPU);
142     p_spu->pf_destroy = DestroySPU;
143     p_spu->p_sys->p_data = (uint8_t*)p_spu->p_sys + sizeof( subpicture_sys_t );
144     p_spu->p_sys->b_palette = VLC_FALSE;
145
146     p_spu->p_sys->pi_alpha[0] = 0x00;
147     p_spu->p_sys->pi_alpha[1] = 0x0f;
148     p_spu->p_sys->pi_alpha[2] = 0x0f;
149     p_spu->p_sys->pi_alpha[3] = 0x0f;
150
151     p_spu->p_sys->b_crop = VLC_FALSE;
152
153     /* Get display time now. If we do it later, we may miss the PTS. */
154     p_spu->p_sys->i_pts = i_pts;
155
156     /* Attach to our input thread */
157     p_spu->p_sys->p_input = vlc_object_find( p_spudec->p_fifo,
158                                              VLC_OBJECT_INPUT, FIND_PARENT );
159     if( p_spu->p_sys->p_input )
160     {
161         vlc_value_t val;
162
163         if( !var_Get( p_spu->p_sys->p_input, "highlight-mutex", &val ) )
164         {
165             vlc_mutex_t *p_mutex = val.p_address;
166
167             vlc_mutex_lock( p_mutex );
168             UpdateSPU( p_spu, VLC_OBJECT(p_spu->p_sys->p_input) );
169
170             var_AddCallback( p_spu->p_sys->p_input,
171                              "highlight", CropCallback, p_spu );
172             vlc_mutex_unlock( p_mutex );
173         }
174     }
175
176     /* Allocate the temporary buffer we will parse */
177     p_src = malloc( p_spudec->i_rle_size );
178
179     if( p_src == NULL )
180     {
181         msg_Err( p_spudec->p_fifo, "out of memory" );
182         vout_DestroySubPicture( p_spudec->p_vout, p_spu );
183         return;
184     }
185
186     /* Get RLE data */
187     for( i_offset = 0; i_offset < p_spudec->i_rle_size;
188          i_offset += SPU_CHUNK_SIZE )
189     {
190         GetChunk( &p_spudec->bit_stream, p_src + i_offset,
191                   ( i_offset + SPU_CHUNK_SIZE < p_spudec->i_rle_size ) ?
192                   SPU_CHUNK_SIZE : p_spudec->i_rle_size - i_offset );
193
194         /* Abort subtitle parsing if we were requested to stop */
195         if( p_spudec->p_fifo->b_die )
196         {
197             free( p_src );
198             vout_DestroySubPicture( p_spudec->p_vout, p_spu );
199             return;
200         }
201     }
202
203 #if 0
204     /* Dump the subtitle info */
205     intf_WarnHexDump( 5, p_spu->p_sys->p_data, p_spudec->i_rle_size );
206 #endif
207
208     /* Getting the control part */
209     if( ParseControlSeq( p_spudec, p_spu ) )
210     {
211         /* There was a parse error, delete the subpicture */
212         free( p_src );
213         vout_DestroySubPicture( p_spudec->p_vout, p_spu );
214         return;
215     }
216
217     /* At this point, no more GetBit() command is needed, so we have all
218      * the data we need to tell whether the subtitle is valid. Thus we
219      * try to display it and we ignore b_die. */
220
221     if( ParseRLE( p_spudec, p_spu, p_src ) )
222     {
223         /* There was a parse error, delete the subpicture */
224         free( p_src );
225         vout_DestroySubPicture( p_spudec->p_vout, p_spu );
226         return;
227     }
228
229     msg_Dbg( p_spudec->p_fifo, "total size: 0x%x, RLE offsets: 0x%x 0x%x",
230              p_spudec->i_spu_size,
231              p_spu->p_sys->pi_offset[0], p_spu->p_sys->pi_offset[1] );
232
233     /* SPU is finished - we can ask the video output to display it */
234     vout_DisplaySubPicture( p_spudec->p_vout, p_spu );
235
236     /* TODO: do stuff! */
237
238     /* Clean up */
239     free( p_src );
240 }
241
242 /*****************************************************************************
243  * ParseControlSeq: parse all SPU control sequences
244  *****************************************************************************
245  * This is the most important part in SPU decoding. We get dates, palette
246  * information, coordinates, and so on. For more information on the
247  * subtitles format, see http://sam.zoy.org/doc/dvd/subtitles/index.html
248  *****************************************************************************/
249 static int ParseControlSeq( spudec_thread_t *p_spudec,
250                                   subpicture_t * p_spu )
251 {
252     /* Our current index in the SPU packet */
253     unsigned int i_index = p_spudec->i_rle_size + 4;
254
255     /* The next start-of-control-sequence index and the previous one */
256     unsigned int i_next_seq = 0, i_cur_seq = 0;
257
258     /* Command and date */
259     uint8_t i_command = SPU_CMD_END;
260     mtime_t date = 0;
261
262     unsigned int i, pi_alpha[4];
263
264     /* Initialize the structure */
265     p_spu->i_start = p_spu->i_stop = 0;
266     p_spu->b_ephemer = VLC_FALSE;
267
268     do
269     {
270         /* If we just read a command sequence, read the next one;
271          * otherwise, go on with the commands of the current sequence. */
272         if( i_command == SPU_CMD_END )
273         {
274             /* Get the control sequence date */
275             date = (mtime_t)GetBits( &p_spudec->bit_stream, 16 ) * 11000
276                     * p_spudec->bit_stream.p_pes->i_rate / DEFAULT_RATE;
277  
278             /* Next offset */
279             i_cur_seq = i_index;
280             i_next_seq = GetBits( &p_spudec->bit_stream, 16 );
281  
282             /* Skip what we just read */
283             i_index += 4;
284         }
285  
286         i_command = GetBits( &p_spudec->bit_stream, 8 );
287         i_index++;
288  
289         switch( i_command )
290         {
291         case SPU_CMD_FORCE_DISPLAY: /* 00 (force displaying) */
292             p_spu->i_start = p_spu->p_sys->i_pts + date;
293             p_spu->b_ephemer = VLC_TRUE;
294             break;
295
296         /* Convert the dates in seconds to PTS values */
297         case SPU_CMD_START_DISPLAY: /* 01 (start displaying) */
298             p_spu->i_start = p_spu->p_sys->i_pts + date;
299             break;
300
301         case SPU_CMD_STOP_DISPLAY: /* 02 (stop displaying) */
302             p_spu->i_stop = p_spu->p_sys->i_pts + date;
303             break;
304
305         case SPU_CMD_SET_PALETTE:
306
307             /* 03xxxx (palette) */
308             if( p_spudec->p_fifo->p_demux_data
309                  && *(int*)p_spudec->p_fifo->p_demux_data == 0xBeeF )
310             {
311                 uint32_t i_color;
312
313                 p_spu->p_sys->b_palette = VLC_TRUE;
314                 for( i = 0; i < 4 ; i++ )
315                 {
316                     i_color = ((uint32_t*)((char*)p_spudec->p_fifo->
317                                 p_demux_data + sizeof(int)))[
318                                   GetBits(&p_spudec->bit_stream, 4) ];
319
320                     /* FIXME: this job should be done sooner */
321                     p_spu->p_sys->pi_yuv[3-i][0] = (i_color>>16) & 0xff;
322                     p_spu->p_sys->pi_yuv[3-i][1] = (i_color>>0) & 0xff;
323                     p_spu->p_sys->pi_yuv[3-i][2] = (i_color>>8) & 0xff;
324                 }
325             }
326             else
327             {
328                 RemoveBits( &p_spudec->bit_stream, 16 );
329             }
330             i_index += 2;
331
332             break;
333
334         case SPU_CMD_SET_ALPHACHANNEL: /* 04xxxx (alpha channel) */
335             pi_alpha[3] = GetBits( &p_spudec->bit_stream, 4 );
336             pi_alpha[2] = GetBits( &p_spudec->bit_stream, 4 );
337             pi_alpha[1] = GetBits( &p_spudec->bit_stream, 4 );
338             pi_alpha[0] = GetBits( &p_spudec->bit_stream, 4 );
339
340             /* Ignore blank alpha palette. Sometimes spurious blank
341              * alpha palettes are present - dunno why. */
342             if( pi_alpha[0] | pi_alpha[1] | pi_alpha[2] | pi_alpha[3] )
343             {
344                 p_spu->p_sys->pi_alpha[0] = pi_alpha[0];
345                 p_spu->p_sys->pi_alpha[1] = pi_alpha[1];
346                 p_spu->p_sys->pi_alpha[2] = pi_alpha[2];
347                 p_spu->p_sys->pi_alpha[3] = pi_alpha[3];
348             }
349             else
350             {
351                 msg_Warn( p_spudec->p_fifo, "ignoring blank alpha palette" );
352             }
353
354             i_index += 2;
355             break;
356
357         case SPU_CMD_SET_COORDINATES: /* 05xxxyyyxxxyyy (coordinates) */
358             p_spu->i_x = GetBits( &p_spudec->bit_stream, 12 );
359             p_spu->i_width = GetBits( &p_spudec->bit_stream, 12 )
360                               - p_spu->i_x + 1;
361
362             p_spu->i_y = GetBits( &p_spudec->bit_stream, 12 );
363             p_spu->i_height = GetBits( &p_spudec->bit_stream, 12 )
364                                - p_spu->i_y + 1;
365
366             i_index += 6;
367             break;
368
369         case SPU_CMD_SET_OFFSETS: /* 06xxxxyyyy (byte offsets) */
370             p_spu->p_sys->pi_offset[0] =
371                 GetBits( &p_spudec->bit_stream, 16 ) - 4;
372
373             p_spu->p_sys->pi_offset[1] =
374                 GetBits( &p_spudec->bit_stream, 16 ) - 4;
375
376             i_index += 4;
377             break;
378
379         case SPU_CMD_END: /* ff (end) */
380             break;
381
382         default: /* xx (unknown command) */
383             msg_Err( p_spudec->p_fifo, "unknown command 0x%.2x",
384                                        i_command );
385             return VLC_EGENERIC;
386         }
387
388         /* We need to check for quit commands here */
389         if( p_spudec->p_fifo->b_die )
390         {
391             return VLC_EGENERIC;
392         }
393
394     } while( i_command != SPU_CMD_END || i_index == i_next_seq );
395
396     /* Check that the next sequence index matches the current one */
397     if( i_next_seq != i_cur_seq )
398     {
399         msg_Err( p_spudec->p_fifo, "index mismatch (0x%.4x != 0x%.4x)",
400                                    i_next_seq, i_cur_seq );
401         return VLC_EGENERIC;
402     }
403
404     if( i_index > p_spudec->i_spu_size )
405     {
406         msg_Err( p_spudec->p_fifo, "uh-oh, we went too far (0x%.4x > 0x%.4x)",
407                                    i_index, p_spudec->i_spu_size );
408         return VLC_EGENERIC;
409     }
410
411     if( !p_spu->i_start )
412     {
413         msg_Err( p_spudec->p_fifo, "no `start display' command" );
414     }
415
416     if( !p_spu->i_stop <= p_spu->i_start && !p_spu->b_ephemer )
417     {
418         /* This subtitle will live for 5 seconds or until the next subtitle */
419         p_spu->i_stop = p_spu->i_start + (mtime_t)500 * 11000
420                         * p_spudec->bit_stream.p_pes->i_rate / DEFAULT_RATE;
421         p_spu->b_ephemer = VLC_TRUE;
422     }
423
424     /* Get rid of padding bytes */
425     switch( p_spudec->i_spu_size - i_index )
426     {
427         /* Zero or one padding byte, quite usual */
428         case 1:
429             RemoveBits( &p_spudec->bit_stream, 8 );
430             i_index++;
431         case 0:
432             break;
433
434         /* More than one padding byte - this is very strange, but
435          * we can deal with it */
436         default:
437             msg_Warn( p_spudec->p_fifo,
438                       "%i padding bytes, we usually get 0 or 1 of them",
439                       p_spudec->i_spu_size - i_index );
440
441             while( i_index < p_spudec->i_spu_size )
442             {
443                 RemoveBits( &p_spudec->bit_stream, 8 );
444                 i_index++;
445             }
446
447             break;
448     }
449
450     /* Successfully parsed ! */
451     return VLC_SUCCESS;
452 }
453
454 /*****************************************************************************
455  * ParseRLE: parse the RLE part of the subtitle
456  *****************************************************************************
457  * This part parses the subtitle graphical data and stores it in a more
458  * convenient structure for later decoding. For more information on the
459  * subtitles format, see http://sam.zoy.org/doc/dvd/subtitles/index.html
460  *****************************************************************************/
461 static int ParseRLE( spudec_thread_t *p_spudec,
462                      subpicture_t * p_spu, uint8_t * p_src )
463 {
464     unsigned int i_code;
465
466     unsigned int i_width = p_spu->i_width;
467     unsigned int i_height = p_spu->i_height;
468     unsigned int i_x, i_y;
469
470     uint16_t *p_dest = (uint16_t *)p_spu->p_sys->p_data;
471
472     /* The subtitles are interlaced, we need two offsets */
473     unsigned int  i_id = 0;                   /* Start on the even SPU layer */
474     unsigned int  pi_table[ 2 ];
475     unsigned int *pi_offset;
476
477 #if 0 /* cropping */
478     vlc_bool_t b_empty_top = VLC_TRUE,
479                b_empty_bottom = VLC_FALSE;
480     unsigned int i_skipped_top = 0,
481                  i_skipped_bottom = 0;
482 #endif
483
484     /* Colormap statistics */
485     int i_border = -1;
486     int stats[4]; stats[0] = stats[1] = stats[2] = stats[3] = 0;
487
488     pi_table[ 0 ] = p_spu->p_sys->pi_offset[ 0 ] << 1;
489     pi_table[ 1 ] = p_spu->p_sys->pi_offset[ 1 ] << 1;
490
491     for( i_y = 0 ; i_y < i_height ; i_y++ )
492     {
493         pi_offset = pi_table + i_id;
494
495         for( i_x = 0 ; i_x < i_width ; i_x += i_code >> 2 )
496         {
497             i_code = AddNibble( 0, p_src, pi_offset );
498
499             if( i_code < 0x04 )
500             {
501                 i_code = AddNibble( i_code, p_src, pi_offset );
502
503                 if( i_code < 0x10 )
504                 {
505                     i_code = AddNibble( i_code, p_src, pi_offset );
506
507                     if( i_code < 0x040 )
508                     {
509                         i_code = AddNibble( i_code, p_src, pi_offset );
510
511                         if( i_code < 0x0100 )
512                         {
513                             /* If the 14 first bits are set to 0, then it's a
514                              * new line. We emulate it. */
515                             if( i_code < 0x0004 )
516                             {
517                                 i_code |= ( i_width - i_x ) << 2;
518                             }
519                             else
520                             {
521                                 /* We have a boo boo ! */
522                                 msg_Err( p_spudec->p_fifo, "unknown RLE code "
523                                          "0x%.4x", i_code );
524                                 return VLC_EGENERIC;
525                             }
526                         }
527                     }
528                 }
529             }
530
531             if( ( (i_code >> 2) + i_x + i_y * i_width ) > i_height * i_width )
532             {
533                 msg_Err( p_spudec->p_fifo,
534                          "out of bounds, %i at (%i,%i) is out of %ix%i",
535                          i_code >> 2, i_x, i_y, i_width, i_height );
536                 return VLC_EGENERIC;
537             }
538
539             /* Try to find the border color */
540             if( p_spu->p_sys->pi_alpha[ i_code & 0x3 ] != 0x00 )
541             {
542                 i_border = i_code & 0x3;
543                 stats[i_border] += i_code >> 2;
544             }
545
546 #if 0 /* cropping */
547             if( (i_code >> 2) == i_width
548                  && p_spu->p_sys->pi_alpha[ i_code & 0x3 ] == 0x00 )
549             {
550                 if( b_empty_top )
551                 {
552                     /* This is a blank top line, we skip it */
553                     i_skipped_top++;
554                 }
555                 else
556                 {
557                     /* We can't be sure the current lines will be skipped,
558                      * so we store the code just in case. */
559                     *p_dest++ = i_code;
560
561                     b_empty_bottom = VLC_TRUE;
562                     i_skipped_bottom++;
563                 }
564             }
565             else
566             {
567                 /* We got a valid code, store it */
568                 *p_dest++ = i_code;
569
570                 /* Valid code means no blank line */
571                 b_empty_top = VLC_FALSE;
572                 b_empty_bottom = VLC_FALSE;
573                 i_skipped_bottom = 0;
574             }
575 #else
576             *p_dest++ = i_code;
577 #endif
578         }
579
580         /* Check that we didn't go too far */
581         if( i_x > i_width )
582         {
583             msg_Err( p_spudec->p_fifo, "i_x overflowed, %i > %i",
584                                        i_x, i_width );
585             return VLC_EGENERIC;
586         }
587
588         /* Byte-align the stream */
589         if( *pi_offset & 0x1 )
590         {
591             (*pi_offset)++;
592         }
593
594         /* Swap fields */
595         i_id = ~i_id & 0x1;
596     }
597
598     /* We shouldn't get any padding bytes */
599     if( i_y < i_height )
600     {
601         msg_Err( p_spudec->p_fifo, "padding bytes found in RLE sequence" );
602         msg_Err( p_spudec->p_fifo, "send mail to <sam@zoy.org> if you "
603                                    "want to help debugging this" );
604
605         /* Skip them just in case */
606         while( i_y < i_height )
607         {
608             *p_dest++ = i_width << 2;
609             i_y++;
610         }
611
612         return VLC_EGENERIC;
613     }
614
615     msg_Dbg( p_spudec->p_fifo, "valid subtitle, size: %ix%i, position: %i,%i",
616              p_spu->i_width, p_spu->i_height, p_spu->i_x, p_spu->i_y );
617
618 #if 0 /* cropping */
619     /* Crop if necessary */
620     if( i_skipped_top || i_skipped_bottom )
621     {
622         p_spu->i_y += i_skipped_top;
623         p_spu->i_height -= i_skipped_top + i_skipped_bottom;
624
625         msg_Dbg( p_spudec->p_fifo, "cropped to: %ix%i, position: %i,%i",
626                  p_spu->i_width, p_spu->i_height, p_spu->i_x, p_spu->i_y );
627     }
628 #endif
629
630     /* Handle color if no palette was found */
631     if( !p_spu->p_sys->b_palette )
632     {
633         int i, i_inner = -1, i_shade = -1;
634
635         /* Set the border color */
636         p_spu->p_sys->pi_yuv[i_border][0] = 0x00;
637         p_spu->p_sys->pi_yuv[i_border][1] = 0x80;
638         p_spu->p_sys->pi_yuv[i_border][2] = 0x80;
639         stats[i_border] = 0;
640
641         /* Find the inner colors */
642         for( i = 0 ; i < 4 && i_inner == -1 ; i++ )
643         {
644             if( stats[i] )
645             {
646                 i_inner = i;
647             }
648         }
649
650         for(       ; i < 4 && i_shade == -1 ; i++ )
651         {
652             if( stats[i] )
653             {
654                 if( stats[i] > stats[i_inner] )
655                 {
656                     i_shade = i_inner;
657                     i_inner = i;
658                 }
659                 else
660                 {
661                     i_shade = i;
662                 }
663             }
664         }
665
666         /* Set the inner color */
667         if( i_inner != -1 )
668         {
669             p_spu->p_sys->pi_yuv[i_inner][0] = 0xff;
670             p_spu->p_sys->pi_yuv[i_inner][1] = 0x80;
671             p_spu->p_sys->pi_yuv[i_inner][2] = 0x80;
672         }
673
674         /* Set the anti-aliasing color */
675         if( i_shade != -1 )
676         {
677             p_spu->p_sys->pi_yuv[i_shade][0] = 0x80;
678             p_spu->p_sys->pi_yuv[i_shade][1] = 0x80;
679             p_spu->p_sys->pi_yuv[i_shade][2] = 0x80;
680         }
681
682         msg_Dbg( p_spudec->p_fifo,
683                  "using custom palette (border %i, inner %i, shade %i)",
684                  i_border, i_inner, i_shade );
685     }
686
687     return VLC_SUCCESS;
688 }
689
690 /*****************************************************************************
691  * DestroySPU: subpicture destructor
692  *****************************************************************************/
693 static void DestroySPU( subpicture_t *p_spu )
694 {
695     if( p_spu->p_sys->p_input )
696     {
697         /* Detach from our input thread */
698         var_DelCallback( p_spu->p_sys->p_input, "highlight",
699                          CropCallback, p_spu );
700         vlc_object_release( p_spu->p_sys->p_input );
701     }
702
703     vlc_mutex_destroy( &p_spu->p_sys->lock );
704     free( p_spu->p_sys );
705 }
706
707 /*****************************************************************************
708  * UpdateSPU: update subpicture settings
709  *****************************************************************************
710  * This function is called from CropCallback and at initialization time, to
711  * retrieve crop information from the input.
712  *****************************************************************************/
713 static void UpdateSPU( subpicture_t *p_spu, vlc_object_t *p_object )
714 {
715     vlc_value_t val;
716
717     if( var_Get( p_object, "highlight", &val ) )
718     {
719         return;
720     }
721
722     p_spu->p_sys->b_crop = val.b_bool;
723     if( !p_spu->p_sys->b_crop )
724     {
725         return;
726     }
727
728     var_Get( p_object, "x-start", &val );
729     p_spu->p_sys->i_x_start = val.i_int;
730     var_Get( p_object, "y-start", &val );
731     p_spu->p_sys->i_y_start = val.i_int;
732     var_Get( p_object, "x-end", &val );
733     p_spu->p_sys->i_x_end = val.i_int;
734     var_Get( p_object, "y-end", &val );
735     p_spu->p_sys->i_y_end = val.i_int;
736
737 #if 0
738     if( var_Get( p_object, "color", &val ) == VLC_SUCCESS )
739     {
740         p_spu->p_sys->pi_color[0] = ((uint8_t *)val.p_address)[0];
741         p_spu->p_sys->pi_color[1] = ((uint8_t *)val.p_address)[1];
742         p_spu->p_sys->pi_color[2] = ((uint8_t *)val.p_address)[2];
743         p_spu->p_sys->pi_color[3] = ((uint8_t *)val.p_address)[3];
744     }
745 #endif
746
747     if( var_Get( p_object, "contrast", &val ) == VLC_SUCCESS )
748     {
749         p_spu->p_sys->pi_alpha[0] = ((uint8_t *)val.p_address)[0];
750         p_spu->p_sys->pi_alpha[1] = ((uint8_t *)val.p_address)[1];
751         p_spu->p_sys->pi_alpha[2] = ((uint8_t *)val.p_address)[2];
752         p_spu->p_sys->pi_alpha[3] = ((uint8_t *)val.p_address)[3];
753     }
754 }
755
756 /*****************************************************************************
757  * CropCallback: called when the highlight properties are changed
758  *****************************************************************************
759  * This callback is called from the input thread when we need cropping
760  *****************************************************************************/
761 static int CropCallback( vlc_object_t *p_object, char const *psz_var,
762                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
763 {
764     UpdateSPU( (subpicture_t *)p_data, p_object );
765
766     return VLC_SUCCESS;
767 }
768