First parallel version.

Known bugs: No longer gracefully handles files with long dependencies
            (dies with OutOfFrames)

            Needs optimization and benchmarks

Author: keithw

Makefile

@@ -1,5 +1,5 @@
-source = ahab.cpp es.cpp mpegheader.cpp bitreader.cpp startfinder.cpp sequence.cpp extensions.cpp exceptions.cpp picture.cpp slice.cpp file.cpp ogl.cpp slicedecode.cpp idct_mmx.cpp motion_comp_mmx.cpp framebuffer.cpp opq.cpp displayop.cpp controller.cpp displayopq.cpp decoder.cpp decoderop.cpp decoderopq.cpp xeventloop.cpp
-objects = es.o mpegheader.o bitreader.o startfinder.o sequence.o extensions.o exceptions.o picture.o slice.o file.o ogl.o slicedecode.o idct_mmx.o motion_comp_mmx.o framebuffer.o opq.o displayop.o controller.o displayopq.o decoder.o decoderop.o decoderopq.o xeventloop.o
+source = ahab.cpp es.cpp mpegheader.cpp bitreader.cpp startfinder.cpp sequence.cpp extensions.cpp exceptions.cpp picture.cpp slice.cpp file.cpp ogl.cpp slicedecode.cpp idct_mmx.cpp motion_comp_mmx.cpp framebuffer.cpp opq.cpp displayop.cpp controller.cpp displayopq.cpp decoder.cpp decoderop.cpp decoderopq.cpp xeventloop.cpp slicerow.cpp
+objects = es.o mpegheader.o bitreader.o startfinder.o sequence.o extensions.o exceptions.o picture.o slice.o file.o ogl.o slicedecode.o idct_mmx.o motion_comp_mmx.o framebuffer.o opq.o displayop.o controller.o displayopq.o decoder.o decoderop.o decoderopq.o xeventloop.o slicerow.o
 executables = ahab
 
 CPP = g++

controller.cpp

@@ -18,6 +18,7 @@ Controller::Controller( uint s_num_frames )
     opq( 0 ),
     num_frames( s_num_frames )
 {
+  unixassert( pthread_mutex_init( &mutex, NULL ) );
   pthread_create( &thread_handle, NULL, thread_helper, this );
 }
 
@@ -90,4 +91,5 @@ Controller::~Controller()
     }
   }
   unixassert( pthread_join( thread_handle, NULL ) );
+  unixassert( pthread_mutex_destroy( &mutex ) );
 }

decoder.cpp

@@ -33,7 +33,8 @@ Decoder::~Decoder() {}
 void Decoder::decode_and_display( void )
 {
   Picture *pic = stream->get_picture_displayed( state.current_picture );
-  pic->lock_and_decodeall();
+  pic->start_parallel_decode( true );
+  pic->get_framehandle()->wait_rendered();
   DrawAndUnlockFrame *op = new DrawAndUnlockFrame( pic->get_framehandle() );
   state.oglq->flush_type( op );
   state.oglq->enqueue( op );  
@@ -54,6 +55,16 @@ void Decoder::loop( void )
 
     if ( state.current_picture != picture_displayed ) {
       decode_and_display();
+
+      /* Also decode a window around current location
+      for ( int i = state.current_picture - 4;
+	    i < state.current_picture + 4;
+	    i++ ) {
+	if ( i >= 0 && i < stream->get_num_pictures() && i != state.current_picture ) {
+	  stream->get_picture_displayed( i )->start_parallel_decode( false );
+	}
+      }
+      */
     }
 
     picture_displayed = state.current_picture;

detachattr.hpp

@@ -0,0 +1,20 @@
+#ifndef DETACH_ATTR_HPP
+#define DETACH_ATTR_HPP
+
+#include <pthread.h>
+
+#include "exceptions.hpp"
+
+class DetachAttributes {
+public:
+  pthread_attr_t attr;
+
+  DetachAttributes( int detachstate ) {
+    unixassert( pthread_attr_init( &attr ) );
+    unixassert( pthread_attr_setdetachstate( &attr, detachstate ) );
+  }
+};
+
+static DetachAttributes DetachedThread( PTHREAD_CREATE_DETACHED );
+
+#endif

es.cpp

@@ -59,8 +59,8 @@ ES::ES( File *s_file, void (*progress)( off_t size, off_t location ) )
       hdr->link();
   }
 
-  pool = new BufferPool( pool_slots, 16 * seq->get_mb_width(),
-			 16 * seq->get_mb_height() );
+  pool = new BufferPool( pool_slots, seq->get_mb_width(),
+			 seq->get_mb_height() );
 
   /* Figure out the display order of each picture and link each
      from the coded_picture and displayed_picture arrays */

framebuffer.cpp

@@ -64,15 +64,15 @@ void FrameQueue::remove_specific( Frame *frame )
   frame->prev = frame->next = NULL;
 }
 
-BufferPool::BufferPool( uint s_num_frames, uint s_width, uint s_height )
+BufferPool::BufferPool( uint s_num_frames, uint mb_width, uint mb_height )
 {
   num_frames = s_num_frames;
-  width = s_width;
-  height = s_height;
+  width = 16 * mb_width;
+  height = 16 * mb_height;
 
   frames = new Frame *[ num_frames ];
   for ( uint i = 0; i < num_frames; i++ ) {
-    frames[ i ] = new Frame( width, height );
+    frames[ i ] = new Frame( mb_width, mb_height );
     free.add( frames[ i ] );
   }
 
@@ -90,30 +90,51 @@ BufferPool::~BufferPool()
   unixassert( pthread_mutex_destroy( &mutex ) );
 }
 
-Frame::Frame( uint s_width, uint s_height )
+Frame::Frame( uint mb_width, uint mb_height )
 {
-  width = s_width;
-  height = s_height;
+  width = 16 * mb_width;
+  height = 16 * mb_height;
   buf = new uint8_t[ sizeof( uint8_t ) * (3 * width * height / 2) ];
   state = FREE;
   handle = NULL;
   unixassert( pthread_mutex_init( &mutex, NULL ) );
+  unixassert( pthread_cond_init( &activity, NULL ) );
+
+  slicerow = new SliceRow *[ mb_height ];
+
+  for ( uint i = 0; i < mb_height; i++ ) {
+    slicerow[ i ] = new SliceRow( i, mb_height );
+  }
 }
 
 Frame::~Frame()
 {
   delete[] buf;
+
+  for ( uint i = 0; i < height / 16; i++ ) {
+    delete slicerow[ i ];
+  }
+
+  delete[] slicerow;
+
+  unixassert( pthread_cond_destroy( &activity ) );
   unixassert( pthread_mutex_destroy( &mutex ) );
 }
 
-void Frame::lock( FrameHandle *s_handle )
+void Frame::lock( FrameHandle *s_handle,
+		  int f_code_fv, int f_code_bv,
+		  Picture *forward, Picture *backward )
 {
   MutexLock x( &mutex );
 
   ahabassert( handle == NULL );
   ahabassert( state == FREE );
   handle = s_handle;
   state = LOCKED;
+
+  for ( uint i = 0; i < height / 16; i++ ) {
+    slicerow[ i ]->init( f_code_fv, f_code_bv, forward, backward );
+  }
 }
 
 void Frame::set_rendered( void )
@@ -122,6 +143,7 @@ void Frame::set_rendered( void )
 
   ahabassert( state == LOCKED );
   state = RENDERED;
+  pthread_cond_broadcast( &activity );
 }
 
 void Frame::relock( void )
@@ -130,6 +152,7 @@ void Frame::relock( void )
 
   ahabassert( state == FREEABLE );
   state = RENDERED;
+  pthread_cond_broadcast( &activity );
 }
 
 void Frame::set_freeable( void )
@@ -167,6 +190,13 @@ FrameHandle::FrameHandle( BufferPool *s_pool, Picture *s_pic )
   frame = NULL;
   locks = 0;
   unixassert( pthread_mutex_init( &mutex, NULL ) );
+  unixassert( pthread_cond_init( &activity, NULL ) );
+}
+
+FrameHandle::~FrameHandle()
+{
+  unixassert( pthread_cond_destroy( &activity ) );
+  unixassert( pthread_mutex_destroy( &mutex ) );
 }
 
 void FrameHandle::increment_lockcount( void )
@@ -183,8 +213,10 @@ void FrameHandle::increment_lockcount( void )
   } else {
     ahabassert( locks == 0 );
     frame = pool->get_free_frame();
-    frame->lock( this );
+    frame->lock( this, pic->get_f_code_fv(), pic->get_f_code_bv(),
+		 pic->get_forward(), pic->get_backward() );
     locks++;
+    pthread_cond_broadcast( &activity );
   }
 }
 
@@ -249,4 +281,25 @@ void FrameHandle::set_frame( Frame *s_frame )
   MutexLock x( &mutex );
   ahabassert( locks == 0 );
   frame = s_frame;
+  pthread_cond_broadcast( &activity );
+}
+
+void Frame::wait_rendered( void )
+{
+  MutexLock x( &mutex );
+  while ( state != RENDERED ) {
+    pthread_cond_wait( &activity, &mutex );
+  }
+}
+
+void FrameHandle::wait_rendered( void )
+{
+  MutexLock x( &mutex );
+
+  while ( !frame ) {
+    pthread_cond_wait( &activity, &mutex );
+  }
+  /* now we have a frame and our mutex is locked so it can't be taken away */
+
+  frame->wait_rendered();
 }

framebuffer.hpp

@@ -3,6 +3,7 @@
 
 #include "mpegheader.hpp"
 #include "exceptions.hpp"
+#include "slicerow.hpp"
 
 #include <stdint.h>
 #include <pthread.h>
@@ -21,18 +22,21 @@ class FrameHandle
   int locks;
 
   pthread_mutex_t mutex;
+  pthread_cond_t activity;
 
   void set_frame( Frame *s_frame );
 
 public:
   void increment_lockcount( void );
   void decrement_lockcount( void );
 
-  Frame *get_frame( void ) { return frame; }
+  Frame *get_frame( void ) { ahabassert( frame ); return frame; }
   Picture *get_picture( void ) { return pic; }
 
   FrameHandle( BufferPool *s_pool, Picture *s_pic );
-  ~FrameHandle() { unixassert( pthread_mutex_destroy( &mutex ) ); }
+  ~FrameHandle();
+
+  void wait_rendered( void );
 };
 
 class FrameQueue
@@ -62,7 +66,7 @@ class BufferPool
   pthread_mutex_t mutex;
 
 public:
-  BufferPool( uint s_num_frames, uint s_width, uint s_height );
+  BufferPool( uint s_num_frames, uint mb_width, uint mb_height );
   ~BufferPool();
 
   FrameHandle *make_handle( Picture *pic ) { return new FrameHandle( this, pic ); }
@@ -88,24 +92,33 @@ class Frame
   Frame *prev, *next;
 
   pthread_mutex_t mutex;
+  pthread_cond_t activity;
+
+  SliceRow **slicerow;
 
 public:
-  Frame( uint s_width, uint s_height );
+  Frame( uint mb_width, uint mb_height );
   ~Frame();
 
   uint8_t *get_buf( void ) { return buf; }
   uint8_t *get_y( void ) { return buf; }
   uint8_t *get_cb( void ) { return buf + width * height; }
   uint8_t *get_cr( void ) { return buf + width * height + width * height / 4; }
 
-  void lock( FrameHandle *s_handle );
+  void lock( FrameHandle *s_handle,
+	     int f_code_fv, int f_code_bv,
+	     Picture *forward, Picture *backward );
   void set_rendered( void );
   void set_freeable( void );
   void relock( void );
   void free( void );
   void free_locked( void );
 
   FrameState get_state( void ) { return state; }
+
+  void wait_rendered( void );
+
+  SliceRow *get_slicerow( uint row ) { return slicerow[ row ]; }
 };
 
 #endif

mpegheader.hpp

@@ -8,6 +8,7 @@
 #include "bitreader.hpp"
 #include "exceptions.hpp"
 #include "file.hpp"
+#include "mutexobj.hpp"
 
 #include "libmpeg2.h"
 
@@ -168,9 +169,19 @@ class Slice : public MPEGHeader
 };
 
 enum PictureType { I = 1, P, B };
+enum DecodeDirection { TOPDOWN, BOTTOMUP };
 
+class Frame;
 class FrameHandle;
 
+struct picture_decoder_call_struct
+{
+  Picture *me;
+  DecodeDirection direction;
+  mpeg2_decoder_t decoder;
+  Frame *cur, *fwd, *back;
+};
+
 class Picture : public MPEGHeader
 {
 private:
@@ -194,7 +205,7 @@ class Picture : public MPEGHeader
   uint8_t *intra_quantiser_matrix,
     *non_intra_quantiser_matrix;
 
-  Slice **slicerow;
+  Slice **first_slice_in_row;
 
   Picture *forward_reference, *backward_reference;
 
@@ -207,6 +218,9 @@ class Picture : public MPEGHeader
 
   FrameHandle *fh;
 
+  pthread_mutex_t decoding_mutex;
+  bool decoding;
+
 public:
   int get_coded( void ) { return coded_order; }
   void set_coded( int s_coded ) { coded_order = s_coded; }
@@ -271,7 +285,10 @@ class Picture : public MPEGHeader
   Picture *get_forward( void ) { return forward_reference; }
   Picture *get_backward( void ) { return backward_reference; }
 
-  Slice *get_slicerow( uint row ) { return slicerow[ row ]; }
+  Slice *get_first_slice_in_row( uint row ) { return first_slice_in_row[ row ]; }
+
+  int get_f_code_fv( void ) { return get_extension()->f_code_fv; }
+  int get_f_code_bv( void ) { return get_extension()->f_code_bv; }
 
   FrameHandle *get_framehandle( void ) { return fh; }
 
@@ -284,6 +301,10 @@ class Picture : public MPEGHeader
   virtual void link( void );
 
   void lock_and_decodeall();
+  void start_parallel_decode( bool leave_locked );
+
+  void parallel_decode_internal( bool leave_locked );
+  void decoder_internal( picture_decoder_call_struct *args );
 };
 
 class SequenceEnd : public MPEGHeader