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

   1 /*****************************************************************************
   2  * dirac.c: Dirac decoder/encoder module making use of libdirac.
   3  *          (http://www.bbc.co.uk/rd/projects/dirac/index.shtml)
   4  *****************************************************************************
   5  * Copyright (C) 1999-2001 the VideoLAN team
   6  * $Id$
   7  *
   8  * Authors: Gildas Bazin <gbazin@videolan.org>
   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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <vlc/vlc.h>
  29 #include <vlc/decoder.h>
  30 #include <vlc/sout.h>
  31
  32 #include <libdirac_decoder/dirac_parser.h>
  33 #include <libdirac_encoder/dirac_encoder.h>
  34
  35 /*****************************************************************************
  36  * decoder_sys_t : theora decoder descriptor
  37  *****************************************************************************/
  38 struct decoder_sys_t
  39 {
  40     /*
  41      * Dirac properties
  42      */
  43     dirac_decoder_t *p_dirac;
  44 };
  45
  46 /*****************************************************************************
  47  * Local prototypes
  48  *****************************************************************************/
  49 static int        OpenDecoder  ( vlc_object_t * );
  50 static void       CloseDecoder ( vlc_object_t * );
  51 static picture_t *DecodeBlock  ( decoder_t *p_dec, block_t **pp_block );
  52
  53 static int  OpenEncoder( vlc_object_t *p_this );
  54 static void CloseEncoder( vlc_object_t *p_this );
  55 static block_t *Encode( encoder_t *p_enc, picture_t *p_pict );
  56
  57 #define ENC_CFG_PREFIX "sout-dirac-"
  58
  59 static const char *ppsz_enc_options[] = {
  60     "quality", NULL
  61 };
  62
  63 /*****************************************************************************
  64  * Module descriptor
  65  *****************************************************************************/
  66 #define ENC_QUALITY_TEXT N_("Encoding quality")
  67 #define ENC_QUALITY_LONGTEXT N_( \
  68   "Quality of the encoding between 1.0 (low) and 10.0 (high)." )
  69
  70 vlc_module_begin();
  71     set_category( CAT_INPUT );
  72     set_subcategory( SUBCAT_INPUT_VCODEC );
  73     set_description( _("Dirac video decoder") );
  74     set_capability( "decoder", 100 );
  75     set_callbacks( OpenDecoder, CloseDecoder );
  76     add_shortcut( "dirac" );
  77
  78     add_submodule();
  79     set_description( _("Dirac video encoder") );
  80     set_capability( "encoder", 100 );
  81     set_callbacks( OpenEncoder, CloseEncoder );
  82     add_shortcut( "dirac" );
  83     add_float( ENC_CFG_PREFIX "quality", 7.0, NULL, ENC_QUALITY_TEXT,
  84                ENC_QUALITY_LONGTEXT, VLC_FALSE );
  85
  86 vlc_module_end();
  87
  88 /*****************************************************************************
  89  * OpenDecoder: probe the decoder and return score
  90  *****************************************************************************/
  91 static int OpenDecoder( vlc_object_t *p_this )
  92 {
  93     decoder_t *p_dec = (decoder_t*)p_this;
  94     decoder_sys_t *p_sys;
  95     dirac_decoder_t *p_dirac;
  96
  97     if( p_dec->fmt_in.i_codec != VLC_FOURCC('d','r','a','c') )
  98     {
  99         return VLC_EGENERIC;
 100     }
 101
 102     /* Initialise the dirac decoder */
 103     if( !(p_dirac = dirac_decoder_init(0)) ) return VLC_EGENERIC;
 104
 105     /* Allocate the memory needed to store the decoder's structure */
 106     if( ( p_dec->p_sys = p_sys =
 107           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
 108     {
 109         msg_Err( p_dec, "out of memory" );
 110         return VLC_EGENERIC;
 111     }
 112
 113     p_sys->p_dirac = p_dirac;
 114
 115     /* Set output properties */
 116     p_dec->fmt_out.i_cat = VIDEO_ES;
 117     p_dec->fmt_out.i_codec = VLC_FOURCC('I','4','2','0');
 118
 119     /* Set callbacks */
 120     p_dec->pf_decode_video = DecodeBlock;
 121
 122     return VLC_SUCCESS;
 123 }
 124
 125 static void FreeFrameBuffer( dirac_decoder_t *p_dirac )
 126 {
 127     if( p_dirac->fbuf )
 128     {
 129         int i;
 130         for( i = 0; i < 3; i++ )
 131         {
 132             if( p_dirac->fbuf->buf[i] ) free( p_dirac->fbuf->buf[i] );
 133             p_dirac->fbuf->buf[i] = 0;
 134         }
 135     }
 136 }
 137
 138 /*****************************************************************************
 139  * GetNewPicture: Get a new picture from the vout and copy the decoder output
 140  *****************************************************************************/
 141 static picture_t *GetNewPicture( decoder_t *p_dec )
 142 {
 143     decoder_sys_t *p_sys = p_dec->p_sys;
 144     picture_t *p_pic;
 145     int i_plane;
 146
 147     p_dec->fmt_out.i_codec =
 148         p_sys->p_dirac->seq_params.chroma == format411 ?
 149         VLC_FOURCC('I','4','1','1') :
 150         p_sys->p_dirac->seq_params.chroma == format420 ?
 151         VLC_FOURCC('I','4','2','0') :
 152         p_sys->p_dirac->seq_params.chroma == format422 ?
 153         VLC_FOURCC('I','4','2','2') : 0;
 154
 155     p_dec->fmt_out.video.i_visible_width =
 156     p_dec->fmt_out.video.i_width = p_sys->p_dirac->seq_params.width;
 157     p_dec->fmt_out.video.i_visible_height =
 158     p_dec->fmt_out.video.i_height = p_sys->p_dirac->seq_params.height;
 159     p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * 4 / 3;
 160
 161     p_dec->fmt_out.video.i_frame_rate =
 162         p_sys->p_dirac->seq_params.frame_rate.numerator;
 163     p_dec->fmt_out.video.i_frame_rate_base =
 164         p_sys->p_dirac->seq_params.frame_rate.denominator;
 165
 166     /* Get a new picture */
 167     p_pic = p_dec->pf_vout_buffer_new( p_dec );
 168
 169     if( p_pic == NULL ) return NULL;
 170
 171     p_pic->b_progressive = !p_sys->p_dirac->seq_params.interlace;
 172     p_pic->b_top_field_first = p_sys->p_dirac->seq_params.topfieldfirst;
 173     p_pic->i_nb_fields = 2;
 174
 175     /* Copy picture stride by stride */
 176     for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 177     {
 178         int i_line, i_width, i_dst_stride;
 179         uint8_t *p_src = p_sys->p_dirac->fbuf->buf[i_plane];
 180         uint8_t *p_dst = p_pic->p[i_plane].p_pixels;
 181
 182         i_width = p_pic->p[i_plane].i_visible_pitch;
 183         i_dst_stride = p_pic->p[i_plane].i_pitch;
 184
 185         for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
 186         {
 187             p_dec->p_libvlc->pf_memcpy( p_dst, p_src, i_width );
 188             p_src += i_width;
 189             p_dst += i_dst_stride;
 190         }
 191     }
 192
 193     return p_pic;
 194 }
 195
 196 /*****************************************************************************
 197  * CloseDecoder: decoder destruction
 198  *****************************************************************************/
 199 static void CloseDecoder( vlc_object_t *p_this )
 200 {
 201     decoder_t *p_dec = (decoder_t *)p_this;
 202     decoder_sys_t *p_sys = p_dec->p_sys;
 203
 204     FreeFrameBuffer( p_sys->p_dirac );
 205     dirac_decoder_close( p_sys->p_dirac );
 206     free( p_sys );
 207 }
 208
 209 /****************************************************************************
 210  * DecodeBlock: the whole thing
 211  ****************************************************************************
 212  * This function must be fed with complete frames.
 213  ****************************************************************************/
 214 static picture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 215 {
 216     decoder_sys_t *p_sys = p_dec->p_sys;
 217     dirac_decoder_state_t state;
 218     picture_t *p_pic;
 219     block_t *p_block;
 220
 221     if( !pp_block || !*pp_block ) return NULL;
 222
 223     p_block = *pp_block;
 224
 225     while( 1 )
 226     {
 227         state = dirac_parse( p_sys->p_dirac );
 228
 229         switch( state )
 230         {
 231         case STATE_BUFFER:
 232             if( !p_block->i_buffer )
 233             {
 234                 block_Release( p_block );
 235                 return NULL;
 236             }
 237
 238             msg_Dbg( p_dec, "STATE_BUFFER" );
 239             dirac_buffer( p_sys->p_dirac, p_block->p_buffer,
 240                           p_block->p_buffer + p_block->i_buffer );
 241
 242             p_block->i_buffer = 0;
 243             break;
 244
 245         case STATE_SEQUENCE:
 246         {
 247             /* Initialize video output */
 248             uint8_t *buf[3];
 249
 250             msg_Dbg( p_dec, "%dx%d, chroma %i, %f fps",
 251                      p_sys->p_dirac->seq_params.width,
 252                      p_sys->p_dirac->seq_params.height,
 253                      p_sys->p_dirac->seq_params.chroma,
 254                      (float)p_sys->p_dirac->seq_params.frame_rate.numerator/
 255                      p_sys->p_dirac->seq_params.frame_rate.denominator );
 256
 257             FreeFrameBuffer( p_sys->p_dirac );
 258             buf[0] = malloc( p_sys->p_dirac->seq_params.width *
 259                              p_sys->p_dirac->seq_params.height );
 260             buf[1] = malloc( p_sys->p_dirac->seq_params.chroma_width *
 261                              p_sys->p_dirac->seq_params.chroma_height );
 262             buf[2] = malloc( p_sys->p_dirac->seq_params.chroma_width *
 263                              p_sys->p_dirac->seq_params.chroma_height );
 264
 265             dirac_set_buf( p_sys->p_dirac, buf, NULL );
 266             break;
 267         }
 268
 269         case STATE_SEQUENCE_END:
 270             msg_Dbg( p_dec, "SEQUENCE_END" );
 271             FreeFrameBuffer( p_sys->p_dirac );
 272             break;
 273
 274         case STATE_PICTURE_START:
 275             msg_Dbg( p_dec, "PICTURE_START: frame_type=%i frame_num=%d",
 276                      p_sys->p_dirac->frame_params.ftype,
 277                      p_sys->p_dirac->frame_params.fnum );
 278             break;
 279
 280         case STATE_PICTURE_AVAIL:
 281             msg_Dbg( p_dec, "PICTURE_AVAI : frame_type=%i frame_num=%d",
 282                      p_sys->p_dirac->frame_params.ftype,
 283                      p_sys->p_dirac->frame_params.fnum );
 284
 285             /* Picture available for display */
 286             p_pic = GetNewPicture( p_dec );
 287             p_pic->date = p_block->i_pts > 0 ? p_block->i_pts : p_block->i_dts;
 288             p_pic->b_force = 1; // HACK
 289             return p_pic;
 290             break;
 291
 292         case STATE_INVALID:
 293             msg_Dbg( p_dec, "STATE_INVALID" );
 294             break;
 295
 296         default:
 297             break;
 298         }
 299     }
 300
 301     /* Never reached */
 302     return NULL;
 303 }
 304
 305 /*****************************************************************************
 306  * encoder_sys_t : dirac encoder descriptor
 307  *****************************************************************************/
 308 #define ENC_BUFSIZE 1024*1024
 309 struct encoder_sys_t
 310 {
 311     /*
 312      * Dirac properties
 313      */
 314     dirac_encoder_t *p_dirac;
 315     dirac_encoder_context_t ctx;
 316
 317     uint8_t *p_buffer_in;
 318     int i_buffer_in;
 319
 320     uint8_t p_buffer_out[ENC_BUFSIZE];
 321 };
 322
 323 /*****************************************************************************
 324  * OpenEncoder: probe the encoder and return score
 325  *****************************************************************************/
 326 static int OpenEncoder( vlc_object_t *p_this )
 327 {
 328     encoder_t *p_enc = (encoder_t *)p_this;
 329     encoder_sys_t *p_sys = p_enc->p_sys;
 330     vlc_value_t val;
 331     float f_quality;
 332
 333     if( p_enc->fmt_out.i_codec != VLC_FOURCC('d','r','a','c') &&
 334         !p_enc->b_force )
 335     {
 336         return VLC_EGENERIC;
 337     }
 338
 339     /* Allocate the memory needed to store the decoder's structure */
 340     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
 341     {
 342         msg_Err( p_enc, "out of memory" );
 343         return VLC_EGENERIC;
 344     }
 345     memset( p_sys, 0, sizeof(encoder_sys_t) );
 346     p_enc->p_sys = p_sys;
 347
 348     p_enc->pf_encode_video = Encode;
 349     p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
 350     p_enc->fmt_in.video.i_bits_per_pixel = 12;
 351     p_enc->fmt_out.i_codec = VLC_FOURCC('d','r','a','c');
 352
 353     sout_CfgParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
 354
 355     /* Initialse the encoder context with the presets for SD576 - Standard
 356      * Definition Digital (some parameters will be overwritten later on) */
 357     dirac_encoder_context_init( &p_sys->ctx, SD576 );
 358
 359     /* Override parameters if required */
 360     p_sys->ctx.seq_params.width = p_enc->fmt_in.video.i_width;
 361     p_sys->ctx.seq_params.height = p_enc->fmt_in.video.i_height;
 362     p_sys->ctx.seq_params.chroma = format420;
 363     p_sys->ctx.seq_params.frame_rate.numerator =
 364         p_enc->fmt_in.video.i_frame_rate;
 365     p_sys->ctx.seq_params.frame_rate.denominator =
 366         p_enc->fmt_in.video.i_frame_rate_base;
 367     p_sys->ctx.seq_params.interlace = 0;
 368     p_sys->ctx.seq_params.topfieldfirst = 0;
 369
 370     var_Get( p_enc, ENC_CFG_PREFIX "quality", &val );
 371     f_quality = val.f_float;
 372     if( f_quality > 10 ) f_quality = 10;
 373     if( f_quality < 1 ) f_quality = 1;
 374     p_sys->ctx.enc_params.qf = f_quality;
 375
 376     /* Initialise the encoder with the encoder context */
 377     p_sys->p_dirac = dirac_encoder_init( &p_sys->ctx, 0 );
 378
 379     /* Set the buffer size for the encoded picture */
 380     p_sys->i_buffer_in = p_enc->fmt_in.video.i_width *
 381         p_enc->fmt_in.video.i_height * 3 / 2;
 382     p_sys->p_buffer_in = malloc( p_sys->i_buffer_in );
 383
 384     return VLC_SUCCESS;
 385 }
 386
 387 /****************************************************************************
 388  * Encode: the whole thing
 389  ****************************************************************************
 390  * This function spits out ogg packets.
 391  ****************************************************************************/
 392 static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
 393 {
 394     encoder_sys_t *p_sys = p_enc->p_sys;
 395     block_t *p_block, *p_chain = NULL;
 396     int i_plane, i_line, i_width, i_src_stride;
 397     uint8_t *p_dst;
 398
 399     /* Copy input picture in encoder input buffer (stride by stride) */
 400     p_dst = p_sys->p_buffer_in;
 401     for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 402     {
 403         uint8_t *p_src = p_pic->p[i_plane].p_pixels;
 404         i_width = p_pic->p[i_plane].i_visible_pitch;
 405         i_src_stride = p_pic->p[i_plane].i_pitch;
 406
 407         for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
 408         {
 409             p_enc->p_libvlc->pf_memcpy( p_dst, p_src, i_width );
 410             p_dst += i_width;
 411             p_src += i_src_stride;
 412         }
 413     }
 414
 415     /* Load one frame of data into encoder */
 416     if( dirac_encoder_load( p_sys->p_dirac, p_sys->p_buffer_in,
 417                             p_sys->i_buffer_in ) >= 0 )
 418     {
 419         dirac_encoder_state_t state;
 420
 421         msg_Dbg( p_enc, "dirac_encoder_load" );
 422
 423         /* Retrieve encoded frames from encoder */
 424         do
 425         {
 426             p_sys->p_dirac->enc_buf.buffer = p_sys->p_buffer_out;
 427             p_sys->p_dirac->enc_buf.size = ENC_BUFSIZE;
 428             state = dirac_encoder_output( p_sys->p_dirac );
 429             msg_Dbg( p_enc, "dirac_encoder_output: %i", state );
 430             switch( state )
 431             {
 432             case ENC_STATE_AVAIL:
 433                  // Encoded frame available in encoder->enc_buf
 434                  // Encoded frame params available in enccoder->enc_fparams
 435                  // Encoded frame stats available in enccoder->enc_fstats
 436                  p_block = block_New( p_enc, p_sys->p_dirac->enc_buf.size );
 437                  memcpy( p_block->p_buffer, p_sys->p_dirac->enc_buf.buffer,
 438                          p_sys->p_dirac->enc_buf.size );
 439                  p_block->i_dts = p_block->i_pts = p_pic->date;
 440                  block_ChainAppend( &p_chain, p_block );
 441
 442                  break;
 443             case ENC_STATE_BUFFER:
 444                 break;
 445             case ENC_STATE_INVALID:
 446             default:
 447                 break;
 448             }
 449             if( p_sys->p_dirac->decoded_frame_avail )
 450             {
 451                 //locally decoded frame is available in
 452                 //encoder->dec_buf
 453                 //locally decoded frame parameters available
 454                 //in encoder->dec_fparams
 455             }
 456             if( p_sys->p_dirac->instr_data_avail )
 457             {
 458                 //Instrumentation data (motion vectors etc.)
 459                 //available in encoder->instr
 460             }
 461
 462         } while( state == ENC_STATE_AVAIL );
 463     }
 464     else
 465     {
 466         msg_Dbg( p_enc, "dirac_encoder_load() error" );
 467     }
 468
 469     return p_chain;
 470 }
 471
 472 /*****************************************************************************
 473  * CloseEncoder: dirac encoder destruction
 474  *****************************************************************************/
 475 static void CloseEncoder( vlc_object_t *p_this )
 476 {
 477     encoder_t *p_enc = (encoder_t *)p_this;
 478     encoder_sys_t *p_sys = p_enc->p_sys;
 479
 480     msg_Dbg( p_enc, "resulting bit-rate: %i bits/sec",
 481              p_sys->p_dirac->enc_seqstats.bit_rate );
 482
 483     /* Free the encoder resources */
 484     dirac_encoder_close( p_sys->p_dirac );
 485
 486     free( p_sys->p_buffer_in );
 487     free( p_sys );
 488 }