git.sesse.net Git - vlc/blob - modules/codec/kate.c

   1 /*****************************************************************************
   2  * kate.c : a decoder for the kate bitstream format
   3  *****************************************************************************
   4  * Copyright (C) 2000-2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Vincent Penquerc'h <ogg.k.ogg.k@googlemail.com>
   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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32 #include <vlc_plugin.h>
  33 #include <vlc_input.h>
  34 #include <vlc_codec.h>
  35
  36 #include <kate/kate.h>
  37
  38 #include "vlc_osd.h"
  39
  40 /* #define ENABLE_PACKETIZER */
  41 /* #define ENABLE_FORMATTING */
  42 #define ENABLE_BITMAPS
  43
  44 /*****************************************************************************
  45  * decoder_sys_t : decoder descriptor
  46  *****************************************************************************/
  47 struct decoder_sys_t
  48 {
  49 #ifdef ENABLE_PACKETIZER
  50     /* Module mode */
  51     bool b_packetizer;
  52 #endif
  53
  54     /*
  55      * Input properties
  56      */
  57     int i_num_headers;
  58     int i_headers;
  59
  60     /*
  61      * Kate properties
  62      */
  63     bool           b_ready;
  64     kate_info      ki;
  65     kate_comment   kc;
  66     kate_state     k;
  67
  68     /*
  69      * Common properties
  70      */
  71     mtime_t i_pts;
  72
  73     /*
  74      * Options
  75      */
  76 #ifdef ENABLE_FORMATTING
  77     bool   b_formatted;
  78 #endif
  79 };
  80
  81 /*****************************************************************************
  82  * Local prototypes
  83  *****************************************************************************/
  84 static int  OpenDecoder   ( vlc_object_t * );
  85 static void CloseDecoder  ( vlc_object_t * );
  86 #ifdef ENABLE_PACKETIZER
  87 static int OpenPacketizer( vlc_object_t *p_this );
  88 #endif
  89
  90 static subpicture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block );
  91 static int ProcessHeaders( decoder_t *p_dec );
  92 static subpicture_t *ProcessPacket( decoder_t *p_dec, kate_packet *p_kp,
  93                             block_t **pp_block );
  94 static subpicture_t *DecodePacket( decoder_t *p_dec, kate_packet *p_kp,
  95                             block_t *p_block );
  96 static void ParseKateComments( decoder_t * );
  97
  98 #define DEFAULT_NAME "Default"
  99 #define MAX_LINE 8192
 100
 101 /*****************************************************************************
 102  * Module descriptor.
 103  *****************************************************************************/
 104
 105 #ifdef ENABLE_FORMATTING
 106 #define FORMAT_TEXT N_("Formatted Subtitles")
 107 #define FORMAT_LONGTEXT N_("Kate streams allow for text formatting. " \
 108  "VLC partly implements this, but you can choose to disable all formatting.")
 109 #endif
 110
 111
 112 vlc_module_begin();
 113     set_shortname( N_("Kate"));
 114     set_description( N_("Kate text subtitles decoder") );
 115     set_capability( "decoder", 50 );
 116     set_callbacks( OpenDecoder, CloseDecoder );
 117     set_category( CAT_INPUT );
 118     set_subcategory( SUBCAT_INPUT_SCODEC );
 119     add_shortcut( "kate" );
 120
 121 #ifdef ENABLE_PACKETIZER
 122     add_submodule();
 123     set_description( N_("Kate text subtitles packetizer") );
 124     set_capability( "packetizer", 100 );
 125     set_callbacks( OpenPacketizer, CloseDecoder );
 126     add_shortcut( "kate" );
 127 #endif
 128
 129 #ifdef ENABLE_FORMATTING
 130     add_bool( "kate-formatted", true, NULL, FORMAT_TEXT, FORMAT_LONGTEXT,
 131                  false );
 132 #endif
 133 vlc_module_end();
 134
 135 /*****************************************************************************
 136  * OpenDecoder: probe the decoder and return score
 137  *****************************************************************************
 138  * Tries to launch a decoder and return score so that the interface is able
 139  * to chose.
 140  *****************************************************************************/
 141 static int OpenDecoder( vlc_object_t *p_this )
 142 {
 143     decoder_t     *p_dec = (decoder_t*)p_this;
 144     decoder_sys_t *p_sys;
 145
 146     msg_Dbg( p_dec, "kate: OpenDecoder");
 147
 148     if( p_dec->fmt_in.i_codec != VLC_FOURCC('k','a','t','e') )
 149     {
 150         return VLC_EGENERIC;
 151     }
 152
 153     /* Set callbacks */
 154     p_dec->pf_decode_sub = (subpicture_t *(*)(decoder_t *, block_t **))
 155         DecodeBlock;
 156     p_dec->pf_packetize    = (block_t *(*)(decoder_t *, block_t **))
 157         DecodeBlock;
 158
 159     /* Allocate the memory needed to store the decoder's structure */
 160     if( ( p_dec->p_sys = p_sys =
 161           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
 162         return VLC_ENOMEM;
 163
 164     /* init of p_sys */
 165 #ifdef ENABLE_PACKETIZER
 166     p_sys->b_packetizer = false;
 167 #endif
 168     p_sys->b_ready = false;
 169     p_sys->i_pts = 0;
 170
 171     kate_comment_init( &p_sys->kc );
 172     kate_info_init( &p_sys->ki );
 173
 174     p_sys->i_num_headers = 0;
 175     p_sys->i_headers = 0;
 176
 177     /* retrieve options */
 178 #ifdef ENABLE_FORMATTING
 179     p_sys->b_formatted = var_CreateGetBool( p_dec, "kate-formatted" );
 180 #endif
 181
 182     return VLC_SUCCESS;
 183 }
 184
 185 #ifdef ENABLE_PACKETIZER
 186 static int OpenPacketizer( vlc_object_t *p_this )
 187 {
 188     decoder_t *p_dec = (decoder_t*)p_this;
 189
 190     int i_ret = OpenDecoder( p_this );
 191
 192     if( i_ret == VLC_SUCCESS )
 193     {
 194         p_dec->p_sys->b_packetizer = true;
 195         p_dec->fmt_out.i_codec = VLC_FOURCC( 'k', 'a', 't', 'e' );
 196     }
 197
 198     return i_ret;
 199 }
 200 #endif
 201
 202 /****************************************************************************
 203  * DecodeBlock: the whole thing
 204  ****************************************************************************
 205  * This function must be fed with kate packets.
 206  ****************************************************************************/
 207 static subpicture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 208 {
 209     decoder_sys_t *p_sys = p_dec->p_sys;
 210     block_t *p_block;
 211     kate_packet kp;
 212
 213     if( !pp_block || !*pp_block )
 214         return NULL;
 215
 216     p_block = *pp_block;
 217     if( p_block->i_rate != 0 )
 218         p_block->i_length = p_block->i_length * p_block->i_rate / INPUT_RATE_DEFAULT;
 219
 220     /* Block to Kate packet */
 221     kate_packet_wrap(&kp, p_block->i_buffer, p_block->p_buffer);
 222
 223     if( p_sys->i_headers == 0 && p_dec->fmt_in.i_extra )
 224     {
 225         /* Headers already available as extra data */
 226         p_sys->i_num_headers = ((unsigned char*)p_dec->fmt_in.p_extra)[0];
 227         p_sys->i_headers = p_sys->i_num_headers;
 228     }
 229     else if( kp.nbytes && (p_sys->i_headers==0 || p_sys->i_headers < p_sys->ki.num_headers ))
 230     {
 231         /* Backup headers as extra data */
 232         uint8_t *p_extra;
 233
 234         p_dec->fmt_in.p_extra =
 235             realloc( p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra + kp.nbytes + 2 );
 236         p_extra = (void*)(((unsigned char*)p_dec->fmt_in.p_extra) + p_dec->fmt_in.i_extra);
 237         *(p_extra++) = kp.nbytes >> 8;
 238         *(p_extra++) = kp.nbytes & 0xFF;
 239
 240         memcpy( p_extra, kp.data, kp.nbytes );
 241         p_dec->fmt_in.i_extra += kp.nbytes + 2;
 242
 243         block_Release( *pp_block );
 244         p_sys->i_num_headers = ((unsigned char*)p_dec->fmt_in.p_extra)[0];
 245         p_sys->i_headers++;
 246         return NULL;
 247     }
 248
 249     if( p_sys->i_headers == p_sys->i_num_headers && p_sys->i_num_headers>0 )
 250     {
 251         if( ProcessHeaders( p_dec ) != VLC_SUCCESS )
 252         {
 253             p_sys->i_headers = 0;
 254             p_dec->fmt_in.i_extra = 0;
 255             block_Release( *pp_block );
 256             return NULL;
 257         }
 258         else p_sys->i_headers++;
 259     }
 260
 261     return ProcessPacket( p_dec, &kp, pp_block );
 262 }
 263
 264 /*****************************************************************************
 265  * ProcessHeaders: process Kate headers.
 266  *****************************************************************************/
 267 static int ProcessHeaders( decoder_t *p_dec )
 268 {
 269     decoder_sys_t *p_sys = p_dec->p_sys;
 270     kate_packet kp;
 271     uint8_t *p_extra;
 272     int i_extra;
 273     int headeridx;
 274     int ret;
 275
 276     if( !p_dec->fmt_in.i_extra ) return VLC_EGENERIC;
 277
 278     p_extra = p_dec->fmt_in.p_extra;
 279     i_extra = p_dec->fmt_in.i_extra;
 280
 281     /* skip number of headers */
 282     ++p_extra;
 283     --i_extra;
 284
 285     /* Take care of the initial Kate header */
 286     kp.nbytes = *(p_extra++) << 8;
 287     kp.nbytes |= (*(p_extra++) & 0xFF);
 288     kp.data = p_extra;
 289     p_extra += kp.nbytes;
 290     i_extra -= (kp.nbytes + 2);
 291     if( i_extra < 0 )
 292     {
 293         msg_Err( p_dec, "header data corrupted");
 294         return VLC_EGENERIC;
 295     }
 296
 297     ret = kate_decode_headerin( &p_sys->ki, &p_sys->kc, &kp );
 298     if( ret < 0 )
 299     {
 300         msg_Err( p_dec, "this bitstream does not contain Kate data (%d)", ret );
 301         return VLC_EGENERIC;
 302     }
 303
 304     msg_Dbg( p_dec, "%s %s text, granule rate %f, granule shift %d",
 305              p_sys->ki.language, p_sys->ki.category,
 306              (double)p_sys->ki.gps_numerator/p_sys->ki.gps_denominator,
 307              p_sys->ki.granule_shift);
 308
 309     /* we want markup to be removed for now */
 310     kate_info_remove_markup( &p_sys->ki, 1 );
 311
 312     /* parse all remaining header packets */
 313     for (headeridx=1; headeridx<p_sys->ki.num_headers; ++headeridx)
 314     {
 315         kp.nbytes = *(p_extra++) << 8;
 316         kp.nbytes |= (*(p_extra++) & 0xFF);
 317         kp.data = p_extra;
 318         p_extra += kp.nbytes;
 319         i_extra -= (kp.nbytes + 2);
 320         if( i_extra < 0 )
 321         {
 322             msg_Err( p_dec, "header %d data corrupted", headeridx);
 323             return VLC_EGENERIC;
 324         }
 325
 326         ret = kate_decode_headerin( &p_sys->ki, &p_sys->kc, &kp );
 327         if( ret < 0 )
 328         {
 329             msg_Err( p_dec, "Kate header %d is corrupted: %d", headeridx, ret);
 330             return VLC_EGENERIC;
 331         }
 332
 333         /* header 1 is comments */
 334         if( headeridx == 1 )
 335         {
 336             ParseKateComments( p_dec );
 337         }
 338     }
 339
 340 #ifdef ENABLE_PACKETIZER
 341     if( !p_sys->b_packetizer )
 342 #endif
 343     {
 344         /* We have all the headers, initialize decoder */
 345         msg_Dbg( p_dec, "we have all headers, initialize libkate for decoding" );
 346         ret = kate_decode_init( &p_sys->k, &p_sys->ki );
 347         if (ret < 0)
 348         {
 349             msg_Err( p_dec, "Kate failed to initialize for decoding: %d", ret );
 350             return VLC_EGENERIC;
 351         }
 352         p_sys->b_ready = true;
 353     }
 354 #ifdef ENABLE_PACKETIZER
 355     else
 356     {
 357         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
 358         p_dec->fmt_out.p_extra =
 359             realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
 360         memcpy( p_dec->fmt_out.p_extra,
 361                 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
 362     }
 363 #endif
 364
 365     return VLC_SUCCESS;
 366 }
 367
 368 /*****************************************************************************
 369  * ProcessPacket: processes a kate packet.
 370  *****************************************************************************/
 371 static subpicture_t *ProcessPacket( decoder_t *p_dec, kate_packet *p_kp,
 372                             block_t **pp_block )
 373 {
 374     decoder_sys_t *p_sys = p_dec->p_sys;
 375     block_t *p_block = *pp_block;
 376     subpicture_t *p_buf = NULL;
 377
 378     /* Date management */
 379     if( p_block->i_pts > 0 && p_block->i_pts != p_sys->i_pts )
 380     {
 381         p_sys->i_pts = p_block->i_pts;
 382     }
 383
 384     *pp_block = NULL; /* To avoid being fed the same packet again */
 385
 386 #ifdef ENABLE_PACKETIZER
 387     if( p_sys->b_packetizer )
 388     {
 389         /* Date management */
 390         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
 391
 392         if( p_sys->i_headers >= p_sys->i_num_headers )
 393             p_block->i_length = p_sys->i_pts - p_block->i_pts;
 394         else
 395             p_block->i_length = 0;
 396
 397         p_buf = p_block;
 398     }
 399     else
 400 #endif
 401     {
 402         if( p_sys->i_headers >= p_sys->i_num_headers )
 403             p_buf = DecodePacket( p_dec, p_kp, p_block );
 404         else
 405             p_buf = NULL;
 406
 407         if( p_block ) block_Release( p_block );
 408     }
 409
 410     return p_buf;
 411 }
 412
 413 #ifdef ENABLE_BITMAPS
 414 /* nicked off blend.c */
 415 static inline void rgb_to_yuv( uint8_t *y, uint8_t *u, uint8_t *v,
 416                                int r, int g, int b )
 417 {
 418     *y = ( ( (  66 * r + 129 * g +  25 * b + 128 ) >> 8 ) + 16 );
 419     *u =   ( ( -38 * r -  74 * g + 112 * b + 128 ) >> 8 ) + 128 ;
 420     *v =   ( ( 112 * r -  94 * g -  18 * b + 128 ) >> 8 ) + 128 ;
 421 }
 422 #endif
 423
 424 /*****************************************************************************
 425  * DecodePacket: decodes a Kate packet.
 426  *****************************************************************************/
 427 static subpicture_t *DecodePacket( decoder_t *p_dec, kate_packet *p_kp, block_t *p_block )
 428 {
 429     decoder_sys_t *p_sys = p_dec->p_sys;
 430     const kate_event *ev=NULL;
 431     subpicture_t *p_spu = NULL;
 432     subpicture_region_t *p_bitmap_region = NULL;
 433     int ret;
 434 #ifdef ENABLE_BITMAPS
 435     size_t n, y;
 436     picture_t *pic = NULL;
 437 #endif
 438     video_format_t fmt;
 439     kate_tracker kin;
 440     bool tracker_valid = false;
 441
 442     ret = kate_decode_packetin( &p_sys->k, p_kp );
 443     if( ret < 0 )
 444     {
 445         msg_Err( p_dec, "Kate failed to decode packet: %d", ret );
 446         return NULL;
 447     }
 448
 449     ret = kate_decode_eventout( &p_sys->k, &ev );
 450     if( ret < 0 )
 451     {
 452         msg_Err( p_dec, "Kate failed to retrieve event: %d", ret );
 453         return NULL;
 454     }
 455     if( ret > 0 )
 456     {
 457         /* no event to go with this packet, this is normal */
 458         return NULL;
 459     }
 460
 461     /* we have an event */
 462
 463     /* Get a new spu */
 464     p_spu = p_dec->pf_spu_buffer_new( p_dec );
 465     if( !p_spu )
 466     {
 467         msg_Err( p_dec, "Failed to allocate spu buffer" );
 468         return NULL;
 469     }
 470
 471     p_spu->b_pausable = true;
 472
 473 #ifdef ENABLE_BITMAPS
 474     if (ev->bitmap && ev->bitmap->type==kate_bitmap_type_paletted && ev->palette) {
 475         /* create a separate region for the bitmap */
 476         memset( &fmt, 0, sizeof(video_format_t) );
 477         fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
 478         fmt.i_aspect = 0;
 479         fmt.i_width = fmt.i_visible_width = ev->bitmap->width;
 480         fmt.i_height = fmt.i_visible_height = ev->bitmap->height;
 481         fmt.i_x_offset = fmt.i_y_offset = 0;
 482
 483         p_bitmap_region = p_spu->pf_create_region( VLC_OBJECT(p_dec), &fmt );
 484         if( !p_bitmap_region )
 485         {
 486             msg_Err( p_dec, "cannot allocate SPU region" );
 487             p_dec->pf_spu_buffer_del( p_dec, p_spu );
 488             return NULL;
 489         }
 490
 491         /* create the palette */
 492         fmt.p_palette->i_entries = ev->palette->ncolors;
 493         for (n=0; n<ev->palette->ncolors; ++n)
 494         {
 495             rgb_to_yuv(
 496                 &fmt.p_palette->palette[n][0], &fmt.p_palette->palette[n][1], &fmt.p_palette->palette[n][2],
 497                 ev->palette->colors[n].r, ev->palette->colors[n].g, ev->palette->colors[n].b
 498             );
 499             fmt.p_palette->palette[n][3] = ev->palette->colors[n].a;
 500         }
 501
 502         /* create the bitmap */
 503         pic = &p_bitmap_region->picture;
 504         for (y=0; y<ev->bitmap->height; ++y) {
 505           uint8_t *dest=pic->Y_PIXELS+pic->Y_PITCH*y;
 506           const uint8_t *src=ev->bitmap->pixels+y*ev->bitmap->width;
 507           memcpy(dest, src, ev->bitmap->width);
 508         }
 509
 510         msg_Dbg(p_dec, "Created bitmap, %zux%zu, %zu colors\n", ev->bitmap->width, ev->bitmap->height, ev->palette->ncolors);
 511     }
 512 #endif
 513
 514     /* Create a new subpicture region */
 515     memset( &fmt, 0, sizeof(video_format_t) );
 516     fmt.i_chroma = VLC_FOURCC('T','E','X','T');
 517     fmt.i_aspect = 0;
 518     fmt.i_width = fmt.i_height = 0;
 519     fmt.i_x_offset = fmt.i_y_offset = 0;
 520
 521 #ifdef ENABLE_FORMATTING
 522     if (p_sys->b_formatted)
 523     {
 524         ret = kate_tracker_init( &kin, &p_sys->ki, ev);
 525         if( ret < 0)
 526         {
 527             msg_Err( p_dec, "failed to initialize kate tracker, event will be unformatted: %d", ret );
 528         }
 529         else
 530         {
 531             // TODO: get window/video sizes/pos - can't find where to get those !
 532             int w = 640;
 533             int h = 480;
 534             ret = kate_tracker_update(&kin, 0, w, h, 0, 0, w, h);
 535             if( ret < 0)
 536             {
 537                 kate_tracker_clear(&kin);
 538                 msg_Err( p_dec, "failed to update kate tracker, event will be unformatted: %d", ret );
 539             }
 540             else
 541             {
 542                 if (kin.has.region)
 543                 {
 544                     fmt.i_width = kin.region_w;
 545                     fmt.i_height = kin.region_h;
 546                 }
 547
 548                 // TODO: parse tracker and set style, init fmt
 549                 tracker_valid = true;
 550             }
 551         }
 552     }
 553 #endif
 554
 555
 556
 557     p_spu->p_region = p_spu->pf_create_region( VLC_OBJECT(p_dec), &fmt );
 558     if( !p_spu->p_region )
 559     {
 560         msg_Err( p_dec, "cannot allocate SPU region" );
 561         p_dec->pf_spu_buffer_del( p_dec, p_spu );
 562         return NULL;
 563     }
 564
 565     p_spu->p_region->psz_text = strdup(ev->text); /* no leak, this actually gets killed by the core */
 566     p_spu->i_start = p_block->i_pts;
 567     p_spu->i_stop = p_block->i_pts + INT64_C(1000000)*ev->duration*p_sys->ki.gps_denominator/p_sys->ki.gps_numerator;
 568     p_spu->b_ephemer = (p_block->i_length == 0);
 569     p_spu->b_absolute = false;
 570
 571     if (tracker_valid)
 572     {
 573         p_spu->i_flags = 0;
 574         if (kin.has.region)
 575         {
 576             p_spu->p_region->i_x = kin.region_x;
 577             p_spu->p_region->i_y = kin.region_y;
 578             if (p_bitmap_region) {
 579                 p_bitmap_region->i_x = kin.region_x;
 580                 p_bitmap_region->i_y = kin.region_y;
 581             }
 582         }
 583
 584         kate_tracker_clear(&kin);
 585     }
 586     else
 587     {
 588         /* Normal text subs, easy markup */
 589         p_spu->p_region->i_align = SUBPICTURE_ALIGN_BOTTOM;
 590         if (p_bitmap_region) {
 591             p_bitmap_region->i_align = SUBPICTURE_ALIGN_BOTTOM;
 592         }
 593         p_spu->i_x = 0;
 594         p_spu->i_y = 10;
 595     }
 596
 597 #ifdef ENABLE_BITMAPS
 598     /* if we have a bitmap, chain it before the text */
 599     if (p_bitmap_region)
 600     {
 601         p_bitmap_region->p_next = p_spu->p_region;
 602         p_spu->p_region = p_bitmap_region;
 603     }
 604 #endif
 605
 606     return p_spu;
 607 }
 608
 609 /*****************************************************************************
 610  * ParseKateComments: FIXME should be done in demuxer
 611  *****************************************************************************/
 612 static void ParseKateComments( decoder_t *p_dec )
 613 {
 614     input_thread_t *p_input = (input_thread_t *)p_dec->p_parent;
 615     char *psz_name, *psz_value, *psz_comment;
 616     int i = 0;
 617
 618     if( p_input->i_object_type != VLC_OBJECT_INPUT ) return;
 619
 620     while ( i < p_dec->p_sys->kc.comments )
 621     {
 622         psz_comment = strdup( p_dec->p_sys->kc.user_comments[i] );
 623         if( !psz_comment )
 624         {
 625             msg_Warn( p_dec, "out of memory" );
 626             break;
 627         }
 628         psz_name = psz_comment;
 629         psz_value = strchr( psz_comment, '=' );
 630         if( psz_value )
 631         {
 632             *psz_value = '\0';
 633             psz_value++;
 634             input_Control( p_input, INPUT_ADD_INFO, _("Kate comment"),
 635                            psz_name, "%s", psz_value );
 636         }
 637         free( psz_comment );
 638         i++;
 639     }
 640 }
 641
 642 /*****************************************************************************
 643  * CloseDecoder: clean up the decoder
 644  *****************************************************************************/
 645 static void CloseDecoder( vlc_object_t *p_this )
 646 {
 647     decoder_t *p_dec = (decoder_t *)p_this;
 648     decoder_sys_t *p_sys = p_dec->p_sys;
 649
 650     if (p_sys->b_ready)
 651         kate_clear( &p_sys->k );
 652     kate_info_clear( &p_sys->ki );
 653     kate_comment_clear( &p_sys->kc );
 654
 655     free( p_sys );
 656 }
 657