libhb/decmpeg2.c

   1 /* $Id: decmpeg2.c,v 1.12 2005/03/03 16:30:42 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.fr/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "hb.h"
   8
   9 #include "mpeg2dec/mpeg2.h"
  10
  11 /* Cadence tracking */
  12 #ifndef PIC_FLAG_REPEAT_FIRST_FIELD
  13 #define PIC_FLAG_REPEAT_FIRST_FIELD 256
  14 #endif
  15 #define TOP_FIRST PIC_FLAG_TOP_FIELD_FIRST
  16 #define PROGRESSIVE PIC_FLAG_PROGRESSIVE_FRAME
  17 #define COMPOSITE PIC_FLAG_COMPOSITE_DISPLAY
  18 #define SKIP PIC_FLAG_SKIP
  19 #define TAGS PIC_FLAG_TAGS
  20 #define REPEAT_FIRST PIC_FLAG_REPEAT_FIRST_FIELD
  21 #define COMPOSITE_MASK PIC_MASK_COMPOSITE_DISPLAY
  22 #define TB 8
  23 #define BT 16
  24 #define BT_PROG 32
  25 #define BTB_PROG 64
  26 #define TB_PROG 128
  27 #define TBT_PROG 256
  28 static int cadence[12];
  29 static int flag = 0;
  30
  31 /**********************************************************************
  32  * hb_libmpeg2_t
  33  *********************************************************************/
  34 typedef struct hb_libmpeg2_s
  35 {
  36     mpeg2dec_t         * libmpeg2;
  37     const mpeg2_info_t * info;
  38     hb_job_t           * job;
  39     int                  width;
  40     int                  height;
  41     int                  rate;
  42     int                  aspect_ratio;
  43     int                  got_iframe;        /* set when we get our first iframe */
  44     int                  look_for_iframe;   /* need an iframe to add chap break */
  45     int                  look_for_break;    /* need gop start to add chap break */
  46     uint32_t             nframes;           /* number of frames we've decoded */
  47     int64_t              last_pts;
  48 } hb_libmpeg2_t;
  49
  50 /**********************************************************************
  51  * hb_libmpeg2_init
  52  **********************************************************************
  53  *
  54  *********************************************************************/
  55 static hb_libmpeg2_t * hb_libmpeg2_init()
  56 {
  57     hb_libmpeg2_t * m = calloc( sizeof( hb_libmpeg2_t ), 1 );
  58
  59     m->libmpeg2 = mpeg2_init();
  60     m->info     = mpeg2_info( m->libmpeg2 );
  61     m->last_pts = -1;
  62
  63     return m;
  64 }
  65
  66 /**********************************************************************
  67  * hb_libmpeg2_decode
  68  **********************************************************************
  69  *
  70  *********************************************************************/
  71 static int hb_libmpeg2_decode( hb_libmpeg2_t * m, hb_buffer_t * buf_es,
  72                         hb_list_t * list_raw )
  73 {
  74     mpeg2_state_t   state;
  75     hb_buffer_t   * buf;
  76     uint8_t       * data;
  77
  78     if ( buf_es->size )
  79     {
  80         /* Feed libmpeg2 */
  81         if( buf_es->start > -1 )
  82         {
  83             mpeg2_tag_picture( m->libmpeg2, buf_es->start >> 32,
  84                                buf_es->start & 0xFFFFFFFF );
  85         }
  86         mpeg2_buffer( m->libmpeg2, buf_es->data,
  87                       buf_es->data + buf_es->size );
  88     }
  89
  90     for( ;; )
  91     {
  92         state = mpeg2_parse( m->libmpeg2 );
  93         if( state == STATE_BUFFER )
  94         {
  95             /* Require some more data */
  96             break;
  97         }
  98         else if( state == STATE_SEQUENCE )
  99         {
 100             if( !( m->width && m->height && m->rate ) )
 101             {
 102                 m->width  = m->info->sequence->width;
 103                 m->height = m->info->sequence->height;
 104                 m->rate   = m->info->sequence->frame_period;
 105                 if ( m->aspect_ratio <= 0 && m->height &&
 106                      m->info->sequence->pixel_height )
 107                 {
 108                     /* mpeg2_parse doesn't store the aspect ratio. Instead
 109                      * it keeps the pixel width & height that would cause
 110                      * the storage width & height to come out in the correct
 111                      * aspect ratio. Convert these back to aspect ratio.
 112                      * We do the calc in floating point to get the rounding right.
 113                      * We round in the second decimal digit because we scale
 114                      * the (integer) aspect by 9 to preserve the 1st digit.
 115                      */
 116                     double ar_numer = m->width * m->info->sequence->pixel_width;
 117                     double ar_denom = m->height * m->info->sequence->pixel_height;
 118                     m->aspect_ratio = ( ar_numer / ar_denom + .05 ) * HB_ASPECT_BASE;
 119                 }
 120             }
 121         }
 122         else if( state == STATE_GOP && m->look_for_break)
 123         {
 124             // we were looking for a gop to add a chapter break - we found it
 125             // so now start looking for an iframe.
 126             m->look_for_iframe = m->look_for_break;
 127             m->look_for_break = 0;
 128         }
 129         else if( ( state == STATE_SLICE || state == STATE_END ) &&
 130                  m->info->display_fbuf )
 131         {
 132             if( ( m->info->display_picture->flags &
 133                   PIC_MASK_CODING_TYPE ) == PIC_FLAG_CODING_TYPE_I )
 134             {
 135                 // we got an iframe so we can start decoding video now
 136                 m->got_iframe = 1;
 137             }
 138
 139             if( m->got_iframe )
 140             {
 141                 buf  = hb_buffer_init( m->width * m->height * 3 / 2 );
 142                 data = buf->data;
 143
 144                 buf->sequence = buf_es->sequence;
 145
 146                 memcpy( data, m->info->display_fbuf->buf[0],
 147                         m->width * m->height );
 148                 data += m->width * m->height;
 149                 memcpy( data, m->info->display_fbuf->buf[1],
 150                         m->width * m->height / 4 );
 151                 data += m->width * m->height / 4;
 152                 memcpy( data, m->info->display_fbuf->buf[2],
 153                         m->width * m->height / 4 );
 154
 155                 if( m->info->display_picture->flags & PIC_FLAG_TAGS )
 156                 {
 157                     buf->start =
 158                         ( (uint64_t) m->info->display_picture->tag << 32 ) |
 159                         ( (uint64_t) m->info->display_picture->tag2 );
 160                     /*
 161                       * Add back in again to track PTS of MPEG2 frames
 162                       * hb_log("MPEG2: Normal buf->start = %lld", buf->start);
 163                     */
 164                 }
 165                 else if( m->last_pts > -1 )
 166                 {
 167                     /* For some reason nb_fields is sometimes 1 while it
 168                        should be 2 */
 169                     buf->start = m->last_pts +
 170                         MAX( 2, m->info->display_picture->nb_fields ) *
 171                         m->info->sequence->frame_period / 600;
 172                 }
 173                 else
 174                 {
 175                     buf->start = -1;
 176                 }
 177                 m->last_pts = buf->start;
 178
 179                 if( m->look_for_iframe && ( m->info->display_picture->flags &
 180                       PIC_MASK_CODING_TYPE ) == PIC_FLAG_CODING_TYPE_I )
 181                 {
 182                     // we were waiting for an iframe to insert a chapter mark
 183                     // and we have one.
 184                     buf->new_chap = m->look_for_iframe;
 185                     m->look_for_iframe = 0;
 186                     const char *chap_name = "";
 187                     if ( m->job && buf->new_chap > 0 &&
 188                          hb_list_item( m->job->title->list_chapter,
 189                                        buf->new_chap - 1 ) )
 190                     {
 191                         hb_chapter_t * c = hb_list_item( m->job->title->list_chapter,
 192                                                          buf->new_chap - 1 );
 193                         chap_name = c->title;
 194                     }
 195                     hb_log( "mpeg2: \"%s\" (%d) at frame %u time %lld",
 196                             chap_name, buf->new_chap, m->nframes, buf->start );
 197                 } else if ( m->nframes == 0 && m->job &&
 198                             hb_list_item( m->job->title->list_chapter,
 199                                           m->job->chapter_start - 1 ) )
 200                 {
 201                     hb_chapter_t * c = hb_list_item( m->job->title->list_chapter,
 202                                                      m->job->chapter_start - 1 );
 203                     hb_log( "mpeg2: \"%s\" (%d) at frame %u time %lld", c->title,
 204                             m->job->chapter_start, m->nframes, buf->start );
 205                 }
 206                 ++m->nframes;
 207
 208                 flag = m->info->display_picture->flags;
 209
 210 /*  Uncomment this block to see frame-by-frame picture flags, as the video encodes.
 211                hb_log("***** MPEG 2 Picture Info for PTS %lld *****", buf->start);
 212                 if( flag & TOP_FIRST )
 213                     hb_log("MPEG2 Flag: Top field first");
 214                 if( flag & PROGRESSIVE )
 215                     hb_log("MPEG2 Flag: Progressive");
 216                 if( flag & COMPOSITE )
 217                     hb_log("MPEG2 Flag: Composite");
 218                 if( flag & SKIP )
 219                     hb_log("MPEG2 Flag: Skip!");
 220                 if( flag & TAGS )
 221                     hb_log("MPEG2 Flag: TAGS");
 222                 if(flag & REPEAT_FIRST )
 223                     hb_log("MPEG2 Flag: Repeat first field");
 224                 if( flag & COMPOSITE_MASK )
 225                     hb_log("MPEG2 Flag: Composite mask");
 226                 hb_log("fields: %d", m->info->display_picture->nb_fields);
 227 */
 228                 /*  Rotate the cadence tracking. */
 229                 int i = 0;
 230                 for(i=11; i > 0; i--)
 231                 {
 232                     cadence[i] = cadence[i-1];
 233                 }
 234
 235                 if ( !(flag & PROGRESSIVE) && !(flag & TOP_FIRST) )
 236                 {
 237                     /* Not progressive, not top first...
 238                        That means it's probably bottom
 239                        first, 2 fields displayed.
 240                     */
 241                     //hb_log("MPEG2 Flag: Bottom field first, 2 fields displayed.");
 242                     cadence[0] = BT;
 243                 }
 244                 else if ( !(flag & PROGRESSIVE) && (flag & TOP_FIRST) )
 245                 {
 246                     /* Not progressive, top is first,
 247                        Two fields displayed.
 248                     */
 249                     //hb_log("MPEG2 Flag: Top field first, 2 fields displayed.");
 250                     cadence[0] = TB;
 251                 }
 252                 else if ( (flag & PROGRESSIVE) && !(flag & TOP_FIRST) && !( flag & REPEAT_FIRST )  )
 253                 {
 254                     /* Progressive, but noting else.
 255                        That means Bottom first,
 256                        2 fields displayed.
 257                     */
 258                     //hb_log("MPEG2 Flag: Progressive. Bottom field first, 2 fields displayed.");
 259                     cadence[0] = BT_PROG;
 260                 }
 261                 else if ( (flag & PROGRESSIVE) && !(flag & TOP_FIRST) && ( flag & REPEAT_FIRST )  )
 262                 {
 263                     /* Progressive, and repeat. .
 264                        That means Bottom first,
 265                        3 fields displayed.
 266                     */
 267                     //hb_log("MPEG2 Flag: Progressive repeat. Bottom field first, 3 fields displayed.");
 268                     cadence[0] = BTB_PROG;
 269                 }
 270                 else if ( (flag & PROGRESSIVE) && (flag & TOP_FIRST) && !( flag & REPEAT_FIRST )  )
 271                 {
 272                     /* Progressive, top first.
 273                        That means top first,
 274                        2 fields displayed.
 275                     */
 276                     //hb_log("MPEG2 Flag: Progressive. Top field first, 2 fields displayed.");
 277                     cadence[0] = TB_PROG;
 278                 }
 279                 else if ( (flag & PROGRESSIVE) && (flag & TOP_FIRST) && ( flag & REPEAT_FIRST )  )
 280                 {
 281                     /* Progressive, top, repeat.
 282                        That means top first,
 283                        3 fields displayed.
 284                     */
 285                     //hb_log("MPEG2 Flag: Progressive repeat. Top field first, 3 fields displayed.");
 286                     cadence[0] = TBT_PROG;
 287                 }
 288
 289                 if ( (cadence[2] <= TB) && (cadence[1] <= TB) && (cadence[0] > TB) && (cadence[11]) )
 290                     hb_log("%fs: Video -> Film", (float)buf->start / 90000);
 291                 if ( (cadence[2] > TB) && (cadence[1] <= TB) && (cadence[0] <= TB) && (cadence[11]) )
 292                     hb_log("%fs: Film -> Video", (float)buf->start / 90000);
 293
 294                 /* Store picture flags for later use by filters */
 295                 buf->flags = m->info->display_picture->flags;
 296
 297                 hb_list_add( list_raw, buf );
 298             }
 299         }
 300         else if( state == STATE_INVALID )
 301         {
 302             mpeg2_reset( m->libmpeg2, 0 );
 303         }
 304     }
 305     return 1;
 306 }
 307
 308 /**********************************************************************
 309  * hb_libmpeg2_close
 310  **********************************************************************
 311  *
 312  *********************************************************************/
 313 static void hb_libmpeg2_close( hb_libmpeg2_t ** _m )
 314 {
 315     hb_libmpeg2_t * m = *_m;
 316
 317     mpeg2_close( m->libmpeg2 );
 318
 319     free( m );
 320     *_m = NULL;
 321 }
 322
 323 /**********************************************************************
 324  * The decmpeg2 work object
 325  **********************************************************************
 326  *
 327  *********************************************************************/
 328 struct hb_work_private_s
 329 {
 330     hb_libmpeg2_t * libmpeg2;
 331     hb_list_t     * list;
 332 };
 333
 334 /**********************************************************************
 335  * hb_work_decmpeg2_init
 336  **********************************************************************
 337  *
 338  *********************************************************************/
 339 static int decmpeg2Init( hb_work_object_t * w, hb_job_t * job )
 340 {
 341     hb_work_private_t * pv;
 342
 343     pv              = calloc( 1, sizeof( hb_work_private_t ) );
 344     w->private_data = pv;
 345
 346     pv->libmpeg2 = hb_libmpeg2_init();
 347     pv->list     = hb_list_init();
 348
 349     pv->libmpeg2->job = job;
 350
 351     return 0;
 352 }
 353
 354 /**********************************************************************
 355  * Work
 356  **********************************************************************
 357  *
 358  *********************************************************************/
 359 static int decmpeg2Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
 360                    hb_buffer_t ** buf_out )
 361 {
 362     hb_work_private_t * pv = w->private_data;
 363     hb_buffer_t * buf, * last = NULL;
 364     int status = HB_WORK_OK;
 365
 366     // The reader found a chapter break, consume it completely, and remove it from the
 367     // stream. We need to shift it.
 368     if( (*buf_in)->new_chap )
 369     {
 370         pv->libmpeg2->look_for_break = (*buf_in)->new_chap;
 371         (*buf_in)->new_chap = 0;
 372     }
 373
 374     hb_libmpeg2_decode( pv->libmpeg2, *buf_in, pv->list );
 375
 376     /* if we got an empty buffer signaling end-of-stream send it downstream */
 377     if ( (*buf_in)->size == 0 )
 378     {
 379         hb_list_add( pv->list, *buf_in );
 380         *buf_in = NULL;
 381         status = HB_WORK_DONE;
 382     }
 383
 384     *buf_out = NULL;
 385     while( ( buf = hb_list_item( pv->list, 0 ) ) )
 386     {
 387         hb_list_rem( pv->list, buf );
 388         if( last )
 389         {
 390             last->next = buf;
 391             last       = buf;
 392         }
 393         else
 394         {
 395             *buf_out = buf;
 396             last     = buf;
 397         }
 398     }
 399
 400     return status;
 401 }
 402
 403 /**********************************************************************
 404  * Close
 405  **********************************************************************
 406  *
 407  *********************************************************************/
 408 static void decmpeg2Close( hb_work_object_t * w )
 409 {
 410     hb_work_private_t * pv = w->private_data;
 411
 412     // don't log during scan
 413     if ( pv->libmpeg2->job )
 414     {
 415         hb_log( "mpeg2 done: %d frames", pv->libmpeg2->nframes );
 416     }
 417     hb_list_close( &pv->list );
 418     hb_libmpeg2_close( &pv->libmpeg2 );
 419     free( pv );
 420 }
 421
 422 static int decmpeg2Info( hb_work_object_t *w, hb_work_info_t *info )
 423 {
 424     hb_work_private_t *pv = w->private_data;
 425
 426     if ( pv && pv->libmpeg2 && pv->libmpeg2->info && pv->libmpeg2->info->sequence )
 427     {
 428         hb_libmpeg2_t *m = pv->libmpeg2;
 429
 430         info->width = m->width;
 431         info->height = m->height;
 432         info->pixel_aspect_width = m->info->sequence->pixel_width;
 433         info->pixel_aspect_height = m->info->sequence->pixel_height;
 434         info->aspect = (double)m->aspect_ratio;
 435
 436         // if the frame is progressive & NTSC DVD height report it as 23.976 FPS
 437         // so that scan can autodetect NTSC film
 438         info->rate = 27000000;
 439         info->rate_base = ( m->info->display_fbuf && m->info->display_picture &&
 440                             (m->info->display_picture->flags & PROGRESSIVE) &&
 441                             (m->height == 480 ) ) ?  1126125 : m->rate;
 442
 443         info->bitrate = m->info->sequence->byte_rate * 8;
 444         info->profile = m->info->sequence->profile_level_id >> 4;
 445         info->level = m->info->sequence->profile_level_id & 0xf;
 446         info->name = "mpeg2";
 447         return 1;
 448     }
 449     return 0;
 450 }
 451
 452 hb_work_object_t hb_decmpeg2 =
 453 {
 454     WORK_DECMPEG2,
 455     "MPEG-2 decoder (libmpeg2)",
 456     decmpeg2Init,
 457     decmpeg2Work,
 458     decmpeg2Close,
 459     decmpeg2Info
 460 };
 461