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

   1 /* $Id$
   2  * decode.c
   3  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
   4  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
   5  *
   6  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
   7  * See http://libmpeg2.sourceforge.net/ for updates.
   8  *
   9  * mpeg2dec 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  * mpeg2dec 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-1307  USA
  22  */
  23
  24 #include <vlc/vlc.h>
  25 #include <vlc_vout.h>
  26
  27 #include "xxmc-config.h"
  28
  29 #include <string.h>     /* memcmp/memset, try to remove */
  30 #include <inttypes.h>
  31
  32 #include "mpeg2.h"
  33 #include "attributes.h"
  34 #include "mpeg2_internal.h"
  35 #include "xvmc_vld.h"
  36
  37 static int mpeg2_accels = 0;
  38
  39 #define BUFFER_SIZE (1194 * 1024)
  40
  41 const mpeg2_info_t *mpeg2_info( mpeg2dec_t * mpeg2dec )
  42 {
  43     return &(mpeg2dec->info);
  44 }
  45
  46 static inline int skip_chunk( mpeg2dec_t * mpeg2dec, int bytes )
  47 {
  48     uint8_t *current = NULL;
  49     uint32_t shift;
  50     uint8_t *limit = NULL;
  51     uint8_t byte;
  52
  53     if (!bytes)
  54         return 0;
  55
  56     current = mpeg2dec->buf_start;
  57     shift = mpeg2dec->shift;
  58     limit = current + bytes;
  59
  60     do {
  61         byte = *current++;
  62         if (shift == 0x00000100)
  63         {
  64             int skipped;
  65
  66             mpeg2dec->shift = 0xffffff00;
  67             skipped = current - mpeg2dec->buf_start;
  68             mpeg2dec->buf_start = current;
  69             return skipped;
  70         }
  71         shift = (shift | byte) << 8;
  72     } while (current < limit);
  73
  74     mpeg2dec->shift = shift;
  75     mpeg2dec->buf_start = current;
  76     return 0;
  77 }
  78
  79 static inline int copy_chunk( mpeg2dec_t * mpeg2dec, int bytes )
  80 {
  81     uint8_t *current = NULL;
  82     uint32_t shift;
  83     uint8_t *chunk_ptr = NULL;
  84     uint8_t *limit = NULL;
  85     uint8_t byte;
  86
  87     if (!bytes)
  88         return 0;
  89
  90     current = mpeg2dec->buf_start;
  91     shift = mpeg2dec->shift;
  92     chunk_ptr = mpeg2dec->chunk_ptr;
  93     limit = current + bytes;
  94
  95     do {
  96         byte = *current++;
  97         if (shift == 0x00000100)
  98         {
  99             int copied;
 100
 101             mpeg2dec->shift = 0xffffff00;
 102             mpeg2dec->chunk_size = chunk_ptr - mpeg2dec->chunk_start - 3;
 103             mpeg2dec->chunk_ptr = chunk_ptr + 1;
 104             copied = current - mpeg2dec->buf_start;
 105             mpeg2dec->buf_start = current;
 106             return copied;
 107         }
 108         shift = (shift | byte) << 8;
 109         *chunk_ptr++ = byte;
 110     } while (current < limit);
 111
 112     mpeg2dec->shift = shift;
 113     mpeg2dec->buf_start = current;
 114     return 0;
 115 }
 116
 117 void mpeg2_buffer( mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end )
 118 {
 119     mpeg2dec->buf_start = start;
 120     mpeg2dec->buf_end = end;
 121 }
 122
 123 int mpeg2_getpos( mpeg2dec_t * mpeg2dec )
 124 {
 125     return mpeg2dec->buf_end - mpeg2dec->buf_start;
 126 }
 127
 128 static inline mpeg2_state_t seek_chunk( mpeg2dec_t * mpeg2dec )
 129 {
 130     int size, skipped;
 131
 132     size = mpeg2dec->buf_end - mpeg2dec->buf_start;
 133     skipped = skip_chunk (mpeg2dec, size);
 134     if (!skipped)
 135     {
 136         mpeg2dec->bytes_since_tag += size;
 137         return STATE_BUFFER;
 138     }
 139     mpeg2dec->bytes_since_tag += skipped;
 140     mpeg2dec->code = mpeg2dec->buf_start[-1];
 141     return (mpeg2_state_t)-1;
 142 }
 143
 144 mpeg2_state_t mpeg2_seek_header( mpeg2dec_t * mpeg2dec )
 145 {
 146     while( (mpeg2dec->code != 0xb3) &&
 147            (((mpeg2dec->code != 0xb7) &&
 148              (mpeg2dec->code != 0xb8) &&
 149              mpeg2dec->code ) ||
 150              (mpeg2dec->sequence.width == (unsigned)-1)) )
 151     {
 152         if (seek_chunk (mpeg2dec) == STATE_BUFFER)
 153             return STATE_BUFFER;
 154     }
 155
 156     mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
 157     mpeg2dec->user_data_len = 0;
 158     return (mpeg2dec->code ? mpeg2_parse_header (mpeg2dec) :
 159                              mpeg2_header_picture_start (mpeg2dec));
 160 }
 161
 162 #define RECEIVED(code,state) (((state) << 8) + (code))
 163
 164 mpeg2_state_t mpeg2_parse( mpeg2dec_t * mpeg2dec )
 165 {
 166     int size_buffer, size_chunk, copied;
 167
 168     if (mpeg2dec->action)
 169     {
 170         mpeg2_state_t state;
 171
 172         state = mpeg2dec->action (mpeg2dec);
 173         if ((int)state >= 0)
 174             return state;
 175     }
 176
 177     while(1)
 178     {
 179         while( (unsigned int) (mpeg2dec->code - mpeg2dec->first_decode_slice)
 180                  < mpeg2dec->nb_decode_slices )
 181         {
 182             size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
 183             size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
 184                           mpeg2dec->chunk_ptr);
 185
 186             if (size_buffer <= size_chunk)
 187             {
 188                 copied = copy_chunk (mpeg2dec, size_buffer);
 189                 if (!copied)
 190                 {
 191                     mpeg2dec->bytes_since_tag += size_buffer;
 192                     mpeg2dec->chunk_ptr += size_buffer;
 193                     return STATE_BUFFER;
 194                 }
 195             }
 196             else
 197             {
 198                 copied = copy_chunk (mpeg2dec, size_chunk);
 199
 200                 if( !copied )
 201                 {
 202                     /* filled the chunk buffer without finding a start code */
 203                     mpeg2dec->bytes_since_tag += size_chunk;
 204                     mpeg2dec->action = seek_chunk;
 205                     return STATE_INVALID;
 206                 }
 207             }
 208             mpeg2dec->bytes_since_tag += copied;
 209             mpeg2_xxmc_slice( mpeg2dec, NULL,
 210                               mpeg2dec->code,mpeg2dec->chunk_start,
 211                               mpeg2dec->chunk_size);
 212             mpeg2dec->prev_code = mpeg2dec->code;
 213             mpeg2dec->code = mpeg2dec->buf_start[-1];
 214             mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
 215         }
 216
 217         if( (unsigned int) (mpeg2dec->code - 1) >= (0xb0 - 1) )
 218               break;
 219         if( seek_chunk (mpeg2dec) == STATE_BUFFER )
 220             return STATE_BUFFER;
 221     }
 222
 223     switch( mpeg2dec->code )
 224     {
 225         case 0x00:
 226             mpeg2dec->action = mpeg2_header_picture_start;
 227             return mpeg2dec->state;
 228         case 0xb7:
 229             mpeg2dec->action = mpeg2_header_end;
 230             break;
 231         case 0xb3:
 232         case 0xb8:
 233             mpeg2dec->action = mpeg2_parse_header;
 234             break;
 235         default:
 236             mpeg2dec->action = seek_chunk;
 237             return STATE_INVALID;
 238     }
 239     return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID;
 240 }
 241
 242 mpeg2_state_t mpeg2_parse_header( mpeg2dec_t * mpeg2dec )
 243 {
 244     static int (* process_header[]) (mpeg2dec_t * mpeg2dec) =
 245     {
 246         mpeg2_header_picture,
 247         mpeg2_header_extension,
 248         mpeg2_header_user_data,
 249         mpeg2_header_sequence,
 250         NULL,
 251         NULL,
 252         NULL,
 253         NULL,
 254         mpeg2_header_gop
 255     };
 256     int size_buffer, size_chunk, copied;
 257
 258     mpeg2dec->action = mpeg2_parse_header;
 259     mpeg2dec->info.user_data = NULL;
 260     mpeg2dec->info.user_data_len = 0;
 261
 262     while( 1 )
 263     {
 264         size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
 265         size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
 266                       mpeg2dec->chunk_ptr);
 267         if( size_buffer <= size_chunk )
 268         {
 269             copied = copy_chunk (mpeg2dec, size_buffer);
 270             if( !copied )
 271             {
 272                 mpeg2dec->bytes_since_tag += size_buffer;
 273                 mpeg2dec->chunk_ptr += size_buffer;
 274                 return STATE_BUFFER;
 275             }
 276         }
 277         else
 278         {
 279             copied = copy_chunk (mpeg2dec, size_chunk);
 280             if( !copied )
 281             {
 282                 /* filled the chunk buffer without finding a start code */
 283                 mpeg2dec->bytes_since_tag += size_chunk;
 284                 mpeg2dec->code = 0xb4;
 285                 mpeg2dec->action = mpeg2_seek_header;
 286                 return STATE_INVALID;
 287             }
 288         }
 289         mpeg2dec->bytes_since_tag += copied;
 290
 291         if( process_header[mpeg2dec->code & 0x0b](mpeg2dec) )
 292         {
 293             mpeg2dec->code = mpeg2dec->buf_start[-1];
 294             mpeg2dec->action = mpeg2_seek_header;
 295             return STATE_INVALID;
 296         }
 297         mpeg2dec->code = mpeg2dec->buf_start[-1];
 298
 299         switch( RECEIVED(mpeg2dec->code, mpeg2dec->state) )
 300         {
 301             /* state transition after a sequence header */
 302             case RECEIVED (0x00, STATE_SEQUENCE):
 303                 mpeg2dec->action = mpeg2_header_picture_start;
 304             case RECEIVED (0xb8, STATE_SEQUENCE):
 305                 mpeg2_header_sequence_finalize( mpeg2dec );
 306                 break;
 307             /* other legal state transitions */
 308             case RECEIVED (0x00, STATE_GOP):
 309                 mpeg2_header_gop_finalize( mpeg2dec );
 310                 mpeg2dec->action = mpeg2_header_picture_start;
 311                 break;
 312             case RECEIVED (0x01, STATE_PICTURE):
 313             case RECEIVED (0x01, STATE_PICTURE_2ND):
 314                 mpeg2_header_picture_finalize( mpeg2dec, mpeg2_accels );
 315                 mpeg2dec->action = mpeg2_header_slice_start;
 316                 break;
 317             /* legal headers within a given state */
 318             case RECEIVED (0xb2, STATE_SEQUENCE):
 319             case RECEIVED (0xb2, STATE_GOP):
 320             case RECEIVED (0xb2, STATE_PICTURE):
 321             case RECEIVED (0xb2, STATE_PICTURE_2ND):
 322             case RECEIVED (0xb5, STATE_SEQUENCE):
 323             case RECEIVED (0xb5, STATE_PICTURE):
 324             case RECEIVED (0xb5, STATE_PICTURE_2ND):
 325                 mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
 326                 continue;
 327             default:
 328                 mpeg2dec->action = mpeg2_seek_header;
 329                 return STATE_INVALID;
 330         }
 331         mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
 332         mpeg2dec->user_data_len = 0;
 333         return mpeg2dec->state;
 334     }
 335 }
 336
 337 int mpeg2_convert( mpeg2dec_t * mpeg2dec, mpeg2_convert_t convert, void * arg )
 338 {
 339     mpeg2_convert_init_t convert_init;
 340     int error;
 341
 342     error = convert( MPEG2_CONVERT_SET, NULL, &(mpeg2dec->sequence), 0,
 343                 mpeg2_accels, arg, &convert_init );
 344     if (!error)
 345     {
 346         mpeg2dec->convert = convert;
 347         mpeg2dec->convert_arg = arg;
 348         mpeg2dec->convert_id_size = convert_init.id_size;
 349         mpeg2dec->convert_stride = 0;
 350     }
 351     return error;
 352 }
 353
 354 int mpeg2_stride( mpeg2dec_t * mpeg2dec, int stride )
 355 {
 356     if (!mpeg2dec->convert)
 357     {
 358         if (stride < (int) mpeg2dec->sequence.width)
 359             stride = mpeg2dec->sequence.width;
 360         mpeg2dec->decoder.stride_frame = stride;
 361     }
 362     else
 363     {
 364         mpeg2_convert_init_t convert_init;
 365
 366         stride = mpeg2dec->convert( MPEG2_CONVERT_STRIDE, NULL,
 367                                     &(mpeg2dec->sequence), stride,
 368                                     mpeg2_accels, mpeg2dec->convert_arg,
 369                                     &convert_init );
 370         mpeg2dec->convert_id_size = convert_init.id_size;
 371         mpeg2dec->convert_stride = stride;
 372     }
 373     return stride;
 374 }
 375
 376 void mpeg2_set_buf( mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id )
 377 {
 378     mpeg2_fbuf_t * fbuf;
 379
 380     if (mpeg2dec->custom_fbuf)
 381     {
 382         if (mpeg2dec->state == STATE_SEQUENCE)
 383         {
 384             mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
 385             mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
 386         }
 387         mpeg2_set_fbuf( mpeg2dec,
 388                 (mpeg2dec->decoder.coding_type == PIC_FLAG_CODING_TYPE_B) );
 389         fbuf = mpeg2dec->fbuf[0];
 390     }
 391     else
 392     {
 393         fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf);
 394         mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index;
 395     }
 396     fbuf->buf[0] = buf[0];
 397     fbuf->buf[1] = buf[1];
 398     fbuf->buf[2] = buf[2];
 399     fbuf->id = id;
 400 }
 401
 402 void mpeg2_custom_fbuf( mpeg2dec_t * mpeg2dec, int custom_fbuf )
 403 {
 404     mpeg2dec->custom_fbuf = custom_fbuf;
 405 }
 406
 407 void mpeg2_skip( mpeg2dec_t * mpeg2dec, int skip )
 408 {
 409     mpeg2dec->first_decode_slice = 1;
 410     mpeg2dec->nb_decode_slices = skip ? 0 : (0xb0 - 1);
 411 }
 412
 413 void mpeg2_slice_region( mpeg2dec_t * mpeg2dec, int start, int end )
 414 {
 415     start = (start < 1) ? 1 : (start > 0xb0) ? 0xb0 : start;
 416     end = (end < start) ? start : (end > 0xb0) ? 0xb0 : end;
 417     mpeg2dec->first_decode_slice = start;
 418     mpeg2dec->nb_decode_slices = end - start;
 419 }
 420
 421 void mpeg2_tag_picture( mpeg2dec_t * mpeg2dec, uint32_t tag, uint32_t tag2 )
 422 {
 423     mpeg2dec->tag_previous = mpeg2dec->tag_current;
 424     mpeg2dec->tag2_previous = mpeg2dec->tag2_current;
 425     mpeg2dec->tag_current = tag;
 426     mpeg2dec->tag2_current = tag2;
 427     mpeg2dec->num_tags++;
 428     mpeg2dec->bytes_since_tag = 0;
 429 }
 430
 431 uint32_t mpeg2_accel( uint32_t accel )
 432 {
 433     if( !mpeg2_accels )
 434     {
 435         if( accel & MPEG2_ACCEL_DETECT )
 436             accel |= mpeg2_detect_accel ();
 437         mpeg2_accels = accel |= MPEG2_ACCEL_DETECT;
 438         mpeg2_cpu_state_init (accel);
 439         /* mpeg2_idct_init (accel); */
 440         mpeg2_mc_init (accel);
 441     }
 442     return mpeg2_accels & ~MPEG2_ACCEL_DETECT;
 443 }
 444
 445 void mpeg2_reset( mpeg2dec_t * mpeg2dec, int full_reset )
 446 {
 447     mpeg2dec->buf_start = mpeg2dec->buf_end = NULL;
 448     mpeg2dec->num_tags = 0;
 449     mpeg2dec->shift = 0xffffff00;
 450     mpeg2dec->code = 0xb4;
 451     mpeg2dec->action = mpeg2_seek_header;
 452     mpeg2dec->state = STATE_INVALID;
 453     mpeg2dec->first = 1;
 454     mpeg2dec->ptr_forward_ref_picture = NULL;
 455     mpeg2dec->ptr_backward_ref_picture = NULL;
 456
 457     mpeg2_reset_info(&(mpeg2dec->info));
 458     mpeg2dec->info.gop = NULL;
 459     mpeg2dec->info.user_data = NULL;
 460     mpeg2dec->info.user_data_len = 0;
 461     if( full_reset )
 462     {
 463         mpeg2dec->info.sequence = NULL;
 464         mpeg2_header_state_init (mpeg2dec);
 465     }
 466 }
 467
 468 mpeg2dec_t *mpeg2_init( void )
 469 {
 470     mpeg2dec_t *mpeg2dec = NULL;
 471
 472     mpeg2_accel( MPEG2_ACCEL_DETECT );
 473     mpeg2dec = (mpeg2dec_t *) mpeg2_malloc( sizeof (mpeg2dec_t),
 474                                             MPEG2_ALLOC_MPEG2DEC );
 475     if( mpeg2dec == NULL )
 476         return NULL;
 477
 478     memset( mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t) );
 479     memset( mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t) );
 480
 481     mpeg2dec->chunk_buffer = (uint8_t *) mpeg2_malloc( BUFFER_SIZE + 4,
 482                                                        MPEG2_ALLOC_CHUNK );
 483     mpeg2dec->sequence.width = (unsigned int)-1;
 484     mpeg2_reset (mpeg2dec, 1);
 485     return mpeg2dec;
 486 }
 487
 488 void mpeg2_close( mpeg2dec_t * mpeg2dec )
 489 {
 490     mpeg2_header_state_init( mpeg2dec );
 491     mpeg2_free( mpeg2dec->chunk_buffer );
 492     mpeg2_free( mpeg2dec );
 493 }