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

   1 /*****************************************************************************
   2  * tarkin.c: tarkin decoder module making use of libtarkin.
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VideoLAN
   5  * $Id: tarkin.c,v 1.7 2003/11/16 21:07:30 gbazin Exp $
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <vlc/vlc.h>
  28 #include <vlc/vout.h>
  29 #include <vlc/input.h>
  30 #include <vlc/decoder.h>
  31
  32 #include <stdlib.h>                                      /* malloc(), free() */
  33 #include <string.h>                                    /* memcpy(), memset() */
  34
  35 #include <ogg/ogg.h>
  36
  37 /* FIXME */
  38 // use 16 bit signed integers as wavelet coefficients
  39 #define TYPE int16_t
  40 // we'll actually use TYPE_BITS bits of type (e.g. 9 magnitude + 1 sign)
  41 #define TYPE_BITS 10
  42 // use the rle entropy coder
  43 #define RLECODER 1
  44
  45 #include <tarkin.h>
  46
  47 /*****************************************************************************
  48  * dec_thread_t : tarkin decoder thread descriptor
  49  *****************************************************************************/
  50 typedef struct dec_thread_t
  51 {
  52     /*
  53      * Thread properties
  54      */
  55     vlc_thread_t        thread_id;                /* id for thread functions */
  56
  57     /*
  58      * Tarkin properties
  59      */
  60     TarkinStream *tarkin_stream;
  61
  62     TarkinInfo       ti;                        /* tarkin bitstream settings */
  63     TarkinComment    tc;                   /* tarkin bitstream user comments */
  64     TarkinTime           tarkdate;
  65
  66     /*
  67      * Input properties
  68      */
  69     decoder_fifo_t         *p_fifo;            /* stores the PES stream data */
  70     pes_packet_t           *p_pes;            /* current PES we are decoding */
  71
  72     /*
  73      * Output properties
  74      */
  75     vout_thread_t *p_vout;
  76
  77 } dec_thread_t;
  78
  79 /*****************************************************************************
  80  * Local prototypes
  81  *****************************************************************************/
  82 static int  OpenDecoder  ( vlc_object_t * );
  83 static int  RunDecoder   ( decoder_fifo_t * );
  84 static void CloseDecoder ( dec_thread_t * );
  85
  86 static void DecodePacket ( dec_thread_t * );
  87 static int  GetOggPacket ( dec_thread_t *, ogg_packet *, mtime_t * );
  88
  89 static void tarkin_CopyPicture( dec_thread_t *, picture_t *, uint8_t *, int );
  90
  91 /*****************************************************************************
  92  * Module descriptor
  93  *****************************************************************************/
  94 vlc_module_begin();
  95     set_description( _("Tarkin decoder module") );
  96     set_capability( "decoder", 100 );
  97     set_callbacks( OpenDecoder, NULL );
  98     add_shortcut( "tarkin" );
  99 vlc_module_end();
 100
 101 /*****************************************************************************
 102  * OpenDecoder: probe the decoder and return score
 103  *****************************************************************************/
 104 static int OpenDecoder( vlc_object_t *p_this )
 105 {
 106     decoder_t *p_dec = (decoder_t*)p_this;
 107
 108     if( p_dec->fmt_in.i_codec != VLC_FOURCC('t','a','r','k') )
 109     {
 110         return VLC_EGENERIC;
 111     }
 112
 113     p_dec->pf_run = RunDecoder;
 114     return VLC_SUCCESS;
 115 }
 116
 117 /*****************************************************************************
 118  * RunDecoder: the tarkin decoder
 119  *****************************************************************************/
 120 static int RunDecoder( decoder_fifo_t *p_fifo )
 121 {
 122     dec_thread_t *p_dec;
 123     ogg_packet oggpacket;
 124     mtime_t i_pts;
 125
 126     /* Allocate the memory needed to store the thread's structure */
 127     if( (p_dec = (dec_thread_t *)malloc (sizeof(dec_thread_t)) )
 128             == NULL)
 129     {
 130         msg_Err( p_fifo, "out of memory" );
 131         goto error;
 132     }
 133
 134     /* Initialize the thread properties */
 135     memset( p_dec, 0, sizeof(dec_thread_t) );
 136     p_dec->p_fifo = p_fifo;
 137     p_dec->p_pes  = NULL;
 138     p_dec->p_vout = NULL;
 139
 140     /* Take care of the initial Tarkin header */
 141     p_dec->tarkin_stream = tarkin_stream_new();
 142     tarkin_info_init(&p_dec->ti);
 143     tarkin_comment_init(&p_dec->tc);
 144
 145     if( GetOggPacket( p_dec, &oggpacket, &i_pts ) != VLC_SUCCESS )
 146         goto error;
 147
 148     oggpacket.b_o_s = 1; /* yes this actually is a b_o_s packet :) */
 149     if( tarkin_synthesis_headerin( &p_dec->ti, &p_dec->tc, &oggpacket ) < 0 )
 150     {
 151         msg_Err( p_dec->p_fifo, "This bitstream does not contain Tarkin "
 152                  "video data");
 153         goto error;
 154     }
 155
 156     /* The next two packets in order are the comment and codebook headers.
 157        We need to watch out that these packets are not missing as a
 158        missing or corrupted header is fatal. */
 159     if( GetOggPacket( p_dec, &oggpacket, &i_pts ) != VLC_SUCCESS )
 160         goto error;
 161
 162     if( tarkin_synthesis_headerin( &p_dec->ti, &p_dec->tc, &oggpacket ) < 0 )
 163     {
 164         msg_Err( p_dec->p_fifo, "2nd Tarkin header is corrupted" );
 165         goto error;
 166     }
 167
 168     if( GetOggPacket( p_dec, &oggpacket, &i_pts ) != VLC_SUCCESS )
 169         goto error;
 170
 171     if( tarkin_synthesis_headerin( &p_dec->ti, &p_dec->tc, &oggpacket ) < 0 )
 172     {
 173         msg_Err( p_dec->p_fifo, "3rd Tarkin header is corrupted" );
 174         goto error;
 175     }
 176
 177     /* Initialize the tarkin decoder */
 178     tarkin_synthesis_init( p_dec->tarkin_stream, &p_dec->ti );
 179
 180     /* tarkin decoder thread's main loop */
 181     while( (!p_dec->p_fifo->b_die) && (!p_dec->p_fifo->b_error) )
 182     {
 183         DecodePacket( p_dec );
 184     }
 185
 186     /* If b_error is set, the tarkin decoder thread enters the error loop */
 187     if( p_dec->p_fifo->b_error )
 188     {
 189         DecoderError( p_dec->p_fifo );
 190     }
 191
 192     /* End of the tarkin decoder thread */
 193     CloseDecoder( p_dec );
 194
 195     return 0;
 196
 197  error:
 198     DecoderError( p_fifo );
 199     if( p_dec )
 200     {
 201         if( p_dec->p_fifo )
 202             p_dec->p_fifo->b_error = 1;
 203
 204         /* End of the tarkin decoder thread */
 205         CloseDecoder( p_dec );
 206     }
 207
 208     return -1;
 209 }
 210
 211 /*****************************************************************************
 212  * DecodePacket: decodes a Tarkin packet.
 213  *****************************************************************************/
 214 static void DecodePacket( dec_thread_t *p_dec )
 215 {
 216     ogg_packet oggpacket;
 217     picture_t *p_pic;
 218     mtime_t i_pts;
 219     int i_width, i_height, i_chroma, i_stride, i_aspect;
 220     uint8_t *rgb;
 221
 222     if( GetOggPacket( p_dec, &oggpacket, &i_pts ) != VLC_SUCCESS )
 223     {
 224         /* This should mean an eos */
 225         return;
 226     }
 227
 228     tarkin_synthesis_packetin( p_dec->tarkin_stream, &oggpacket );
 229
 230     while( tarkin_synthesis_frameout( p_dec->tarkin_stream,
 231                                       &rgb, 0, &p_dec->tarkdate ) == 0 )
 232     {
 233
 234         i_width = p_dec->tarkin_stream->layer->desc.width;
 235         i_height = p_dec->tarkin_stream->layer->desc.height;
 236         switch( p_dec->tarkin_stream->layer->desc.format )
 237         {
 238         case TARKIN_RGB24:
 239             /*i_chroma = VLC_FOURCC('R','G','B','A');*/
 240             i_chroma = VLC_FOURCC('R','V','2','4');
 241             i_stride = i_width * 3;
 242             break;
 243         case TARKIN_RGB32:
 244             i_chroma = VLC_FOURCC('R','V','3','2');
 245             i_stride = i_width * 4;
 246             break;
 247         case TARKIN_RGBA:
 248             i_chroma = VLC_FOURCC('R','G','B','A');
 249             i_stride = i_width * 4;
 250             break;
 251         default:
 252             i_chroma = VLC_FOURCC('Y','V','1','2');
 253             i_stride = i_width;
 254             break;
 255         }
 256         i_aspect = VOUT_ASPECT_FACTOR * i_width / i_height;
 257         p_dec->p_vout = vout_Request( p_dec->p_fifo, p_dec->p_vout,
 258                                       i_width, i_height, i_chroma, i_aspect );
 259
 260         /* Get a new picture */
 261         while( !(p_pic = vout_CreatePicture( p_dec->p_vout, 0, 0, 0 ) ) )
 262         {
 263             if( p_dec->p_fifo->b_die || p_dec->p_fifo->b_error )
 264             {
 265                 return;
 266             }
 267             msleep( VOUT_OUTMEM_SLEEP );
 268         }
 269         if( !p_pic )
 270             break;
 271
 272         tarkin_CopyPicture( p_dec, p_pic, rgb, i_stride );
 273
 274         tarkin_synthesis_freeframe( p_dec->tarkin_stream, rgb );
 275
 276         vout_DatePicture( p_dec->p_vout, p_pic, mdate()+DEFAULT_PTS_DELAY/*i_pts*/ );
 277         vout_DisplayPicture( p_dec->p_vout, p_pic );
 278
 279     }
 280 }
 281
 282 /*****************************************************************************
 283  * GetOggPacket: get the following tarkin packet from the stream and send back
 284  *               the result in an ogg packet (for easy decoding by libtarkin).
 285  *****************************************************************************
 286  * Returns VLC_EGENERIC in case of eof.
 287  *****************************************************************************/
 288 static int GetOggPacket( dec_thread_t *p_dec, ogg_packet *p_oggpacket,
 289                          mtime_t *p_pts )
 290 {
 291     if( p_dec->p_pes ) input_DeletePES( p_dec->p_fifo->p_packets_mgt,
 292                                         p_dec->p_pes );
 293
 294     input_ExtractPES( p_dec->p_fifo, &p_dec->p_pes );
 295     if( !p_dec->p_pes ) return VLC_EGENERIC;
 296
 297     p_oggpacket->packet = p_dec->p_pes->p_first->p_payload_start;
 298     p_oggpacket->bytes = p_dec->p_pes->i_pes_size;
 299     p_oggpacket->granulepos = p_dec->p_pes->i_dts;
 300     p_oggpacket->b_o_s = 0;
 301     p_oggpacket->e_o_s = 0;
 302     p_oggpacket->packetno = 0;
 303
 304     *p_pts = p_dec->p_pes->i_pts;
 305
 306     return VLC_SUCCESS;
 307 }
 308
 309 /*****************************************************************************
 310  * CloseDecoder: tarkin decoder destruction
 311  *****************************************************************************/
 312 static void CloseDecoder( dec_thread_t * p_dec )
 313 {
 314
 315     if( p_dec )
 316     {
 317         if( p_dec->p_pes )
 318             input_DeletePES( p_dec->p_fifo->p_packets_mgt, p_dec->p_pes );
 319
 320         vout_Request( p_dec->p_fifo, p_dec->p_vout, 0, 0, 0, 0 );
 321
 322         if( p_dec->tarkin_stream )
 323             tarkin_stream_destroy( p_dec->tarkin_stream );
 324
 325         free( p_dec );
 326     }
 327 }
 328
 329 /*****************************************************************************
 330  * tarkin_CopyPicture: copy a picture from tarkin internal buffers to a
 331  *                     picture_t structure.
 332  *****************************************************************************/
 333 static void tarkin_CopyPicture( dec_thread_t *p_dec, picture_t *p_pic,
 334                                 uint8_t *p_src, int i_pitch )
 335 {
 336     int i_plane, i_line, i_src_stride, i_dst_stride;
 337     uint8_t *p_dst;
 338
 339     for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 340     {
 341         p_dst = p_pic->p[i_plane].p_pixels;
 342         i_dst_stride = p_pic->p[i_plane].i_pitch;
 343         i_src_stride = i_pitch;
 344
 345         for( i_line = 0; i_line < p_pic->p[i_plane].i_lines; i_line++ )
 346         {
 347             p_dec->p_fifo->p_vlc->pf_memcpy( p_dst, p_src,
 348                                              i_src_stride );
 349
 350             p_src += i_src_stride;
 351             p_dst += i_dst_stride;
 352         }
 353     }
 354 }