Added rudimentory error handling to HB. Instead of using hb_log() use hb_error()...

git-svn-id: svn://localhost/HandBrake/trunk@869 b64f7644-9d1e-0410-96f1-a4d463321fa5

diff --git a/libhb/common.c b/libhb/common.c
index d0b0155..45d207c 100644 (file)
--- a/libhb/common.c
+++ b/libhb/common.c
@@ -489,7 +489,7 @@ void hb_list_close( hb_list_t ** _l )
  * hb_log
  **********************************************************************
  * If verbose mode is one, print message with timestamp. Messages
- * longer than 80 characters are stripped ;p
+ * longer than 180 characters are stripped ;p
  *********************************************************************/
 void hb_log( char * log, ... )
 {
@@ -523,6 +523,31 @@ void hb_log( char * log, ... )
 }
 
 /**********************************************************************
+ * hb_error
+ **********************************************************************
+ * Using whatever output is available display this error. 
+ *********************************************************************/
+void hb_error( char * log, ... )
+{
+    char        string[181]; /* 180 chars + \0 */
+    time_t      _now;
+    struct tm * now;
+    va_list     args;
+
+    extern void hb_error_handler(const char *errmsg);
+
+    /* Convert the message to a string */
+    va_start( args, log );
+    vsnprintf( string, 180, log, args );
+    va_end( args );
+
+    /*
+     * Got the error in a single string, send it off to be dispatched.
+     */
+    hb_error_handler(string);
+}
+
+/**********************************************************************
  * hb_title_init
  **********************************************************************
  * 

diff --git a/libhb/dvd.c b/libhb/dvd.c
index c231b37..98d0690 100644 (file)
--- a/libhb/dvd.c
+++ b/libhb/dvd.c
@@ -79,14 +79,14 @@ hb_dvd_t * hb_dvd_init( char * path )
     /* Open device */
     if( !( d->reader = DVDOpen( path ) ) )
     {
-        hb_log( "dvd: DVDOpen failed (%s)", path );
+        hb_error( "dvd: DVDOpen failed (%s)", path );
         goto fail;
     }
 
     /* Open main IFO */
     if( !( d->vmg = ifoOpen( d->reader, 0 ) ) )
     {
-        hb_log( "dvd: ifoOpen failed" );
+        hb_error( "dvd: ifoOpen failed" );
         goto fail;
     }
 
@@ -147,7 +147,7 @@ hb_title_t * hb_dvd_title_scan( hb_dvd_t * d, int t )
     hb_log( "scan: opening IFO for VTS %d", title->vts );
     if( !( vts = ifoOpen( d->reader, title->vts ) ) )
     {
-        hb_log( "scan: ifoOpen failed" );
+        hb_error( "scan: ifoOpen failed" );
         goto fail;
     }
 
@@ -159,6 +159,14 @@ hb_title_t * hb_dvd_title_scan( hb_dvd_t * d, int t )
     pgn    = vts->vts_ptt_srpt->title[title->ttn-1].ptt[0].pgn;
     d->pgc = vts->vts_pgcit->pgci_srp[pgc_id-1].pgc;
 
+    hb_log("pgc_id: %d, pgn: %d: pgc: 0x%x", pgc_id, pgn, d->pgc);
+
+    if( !d->pgc )
+    {
+        hb_error( "scan: pgc not valid, skipping" );
+        goto fail;
+    }
+ 
     /* Start cell */
     title->cell_start  = d->pgc->program_map[pgn-1] - 1;
     title->block_start = d->pgc->cell_playback[title->cell_start].first_sector;
@@ -523,13 +531,13 @@ int hb_dvd_start( hb_dvd_t * d, int title, int chapter )
     d->ttn = d->vmg->tt_srpt->title[title-1].vts_ttn;
     if( !( d->ifo = ifoOpen( d->reader, d->vts ) ) )
     {
-        hb_log( "dvd: ifoOpen failed for VTS %d", d->vts );
+        hb_error( "dvd: ifoOpen failed for VTS %d", d->vts );
         return 0;
     }
     if( !( d->file = DVDOpenFile( d->reader, d->vts,
                                   DVD_READ_TITLE_VOBS ) ) )
     {
-        hb_log( "dvd: DVDOpenFile failed for VTS %d", d->vts );
+        hb_error( "dvd: DVDOpenFile failed for VTS %d", d->vts );
         return 0;
     }
 
@@ -750,7 +758,7 @@ int hb_dvd_read( hb_dvd_t * d, hb_buffer_t * b )
     {
         if( DVDReadBlocks( d->file, d->block, 1, b->data ) != 1 )
         {
-            hb_log( "reader: DVDReadBlocks failed (%d)", d->block );
+            hb_error( "reader: DVDReadBlocks failed (%d)", d->block );
             return 0;
         }
         d->pack_len--;

diff --git a/libhb/internal.h b/libhb/internal.h
index cf0f7fa..0b46059 100644 (file)
--- a/libhb/internal.h
+++ b/libhb/internal.h
@@ -8,6 +8,7 @@
  * common.c
  **********************************************************************/
 void hb_log( char * log, ... );
+void hb_error( char * fmt, ...);
 
 int  hb_list_bytes( hb_list_t * );
 void hb_list_seebytes( hb_list_t * l, uint8_t * dst, int size );

diff --git a/libhb/muxmkv.c b/libhb/muxmkv.c
index 0a78ac6..62a4dd9 100644 (file)
--- a/libhb/muxmkv.c
+++ b/libhb/muxmkv.c
@@ -100,7 +100,7 @@ static int MKVInit( hb_mux_object_t * m )
             break;
         default:
             *job->die = 1;
-            hb_log("muxmkv: Unknown video codec: %x", job->vcodec);
+            hb_error("muxmkv: Unknown video codec: %x", job->vcodec);
             return 0;
     }
 
@@ -171,7 +171,7 @@ static int MKVInit( hb_mux_object_t * m )
                 break;
             default:
                 *job->die = 1;
-                hb_log("muxmkv: Unknown audio codec: %x", job->acodec);
+                hb_error("muxmkv: Unknown audio codec: %x", job->acodec);
                 return 0;
         }
         
@@ -191,7 +191,11 @@ static int MKVInit( hb_mux_object_t * m )
           free(track->codecPrivate);
     }
 
-    mk_writeHeader( m->file, "HandBrake " HB_VERSION);
+    if( mk_writeHeader( m->file, "HandBrake " HB_VERSION) < 0 )
+    {
+        hb_error( "Failed to write to output file, disk full?");
+        *job->die = 1;
+    }
     if (track != NULL)
         free(track);
     if (avcC != NULL)
@@ -262,10 +266,22 @@ static int MKVMux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
         }
     }
 
-    mk_startFrame(m->file, mux_data->track);
-    mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
-    mk_setFrameFlags(m->file, mux_data->track, timecode,
-        ((job->vcodec == HB_VCODEC_X264 && mux_data == job->mux_data) ? (buf->frametype == HB_FRAME_IDR) : ((buf->frametype & HB_FRAME_KEY) != 0)) );
+    if( mk_startFrame(m->file, mux_data->track) < 0)
+    {
+        hb_error( "Failed to write start frame to output file, Disk Full?" );
+        *job->die = 1;
+    }
+    if( mk_addFrameData(m->file, mux_data->track, buf->data, buf->size) < 0 )
+    {
+        hb_error( "Failed to write frame data to output file, Disk Full?" );
+        *job->die = 1;
+    }
+    if( mk_setFrameFlags(m->file, mux_data->track, timecode,
+                         ((job->vcodec == HB_VCODEC_X264 && mux_data == job->mux_data) ? (buf->frametype == HB_FRAME_IDR) : ((buf->frametype & HB_FRAME_KEY) != 0)) ) < 0 )
+    {
+        hb_error( "Failed to write frame flags to output file, Disk Full?" );  
+        *job->die = 1; 
+    }
     return 0;
 }
 

diff --git a/libhb/muxmp4.c b/libhb/muxmp4.c
index c029487..4f7c4eb 100644 (file)
--- a/libhb/muxmp4.c
+++ b/libhb/muxmp4.c
@@ -157,7 +157,7 @@ static int MP4Init( hb_mux_object_t * m )
     
     if (m->file == MP4_INVALID_FILE_HANDLE)
     {
-        hb_log("muxmp4.c: MP4Create failed!");
+        hb_error("muxmp4.c: MP4Create failed!");
         *job->die = 1;
         return 0;
     }
@@ -172,7 +172,7 @@ static int MP4Init( hb_mux_object_t * m )
        timescale */
     if (!(MP4SetTimeScale( m->file, job->arate )))
     {
-        hb_log("muxmp4.c: MP4SetTimeScale failed!");
+        hb_error("muxmp4.c: MP4SetTimeScale failed!");
         *job->die = 1;
         return 0;
     }
@@ -182,7 +182,7 @@ static int MP4Init( hb_mux_object_t * m )
         /* Stolen from mp4creator */
         if(!(MP4SetVideoProfileLevel( m->file, 0x7F )))
         {
-            hb_log("muxmp4.c: MP4SetVideoProfileLevel failed!");
+            hb_error("muxmp4.c: MP4SetVideoProfileLevel failed!");
             *job->die = 1;
             return 0;
         }
@@ -211,7 +211,7 @@ static int MP4Init( hb_mux_object_t * m )
     {
         if(!(MP4SetVideoProfileLevel( m->file, MPEG4_SP_L3 )))
         {
-            hb_log("muxmp4.c: MP4SetVideoProfileLevel failed!");
+            hb_error("muxmp4.c: MP4SetVideoProfileLevel failed!");
             *job->die = 1;
             return 0;
         }
@@ -220,7 +220,7 @@ static int MP4Init( hb_mux_object_t * m )
                 MP4_MPEG4_VIDEO_TYPE );
         if (mux_data->track == MP4_INVALID_TRACK_ID)
         {
-            hb_log("muxmp4.c: MP4AddVideoTrack failed!");
+            hb_error("muxmp4.c: MP4AddVideoTrack failed!");
             *job->die = 1;
             return 0;
         }
@@ -230,7 +230,7 @@ static int MP4Init( hb_mux_object_t * m )
         if (!(MP4SetTrackESConfiguration( m->file, mux_data->track,
                 job->config.mpeg4.bytes, job->config.mpeg4.length )))
         {
-            hb_log("muxmp4.c: MP4SetTrackESConfiguration failed!");
+            hb_error("muxmp4.c: MP4SetTrackESConfiguration failed!");
             *job->die = 1;
             return 0;
         }
@@ -360,8 +360,17 @@ static int MP4Mux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
         if( job->chapter_markers && buf->new_chap )
         {
             struct hb_text_sample_s *sample = MP4GenerateChapterSample( m, (m->sum_dur - m->chapter_duration) );
-        
-            MP4WriteSample(m->file, m->chapter_track, sample->sample, sample->length, sample->duration, 0, true);
+            
+            if( !MP4WriteSample(m->file, 
+                                m->chapter_track, 
+                                sample->sample, 
+                                sample->length, 
+                                sample->duration, 
+                                0, true) )
+            {
+                hb_error("Failed to write to output file, disk full?");
+                *job->die = 1;
+            }
             free(sample);
             m->current_chapter++;
             m->chapter_duration = m->sum_dur;
@@ -396,21 +405,42 @@ static int MP4Mux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
        If there are b-frames, offset by the initDelay plus the
        difference between the presentation time stamp x264 gives
        and the decoding time stamp from the buffer data. */
-       MP4WriteSample( m->file, mux_data->track, buf->data, buf->size,
-            duration, ((mux_data->track != 1) || (job->areBframes==0) || (job->vcodec != HB_VCODEC_X264)) ? 0 : (  buf->renderOffset * job->arate / 90000),
-            ((buf->frametype & HB_FRAME_KEY) != 0) );
+    if( !MP4WriteSample( m->file, 
+                         mux_data->track, 
+                         buf->data, 
+                         buf->size,
+                         duration, 
+                         ((mux_data->track != 1) || 
+                          (job->areBframes==0) || 
+                          (job->vcodec != HB_VCODEC_X264)) ? 0 : (  buf->renderOffset * job->arate / 90000),
+                         ((buf->frametype & HB_FRAME_KEY) != 0) ) )
+    {
+        hb_error("Failed to write to output file, disk full?");   
+        *job->die = 1;
+    }
                                 
     return 0;
 }
 
 static int MP4End( hb_mux_object_t * m )
-{
+{ 
+    hb_job_t   * job   = m->job;
+
     /* Write our final chapter marker */
     if( m->job->chapter_markers )
     {
         struct hb_text_sample_s *sample = MP4GenerateChapterSample( m, (m->sum_dur - m->chapter_duration) );
     
-        MP4WriteSample(m->file, m->chapter_track, sample->sample, sample->length, sample->duration, 0, true);
+        if( !MP4WriteSample(m->file, 
+                            m->chapter_track, 
+                            sample->sample, 
+                            sample->length, 
+                            sample->duration, 
+                            0, true) )
+        {
+            hb_error("Failed to write to output file, disk full?");      
+            *job->die = 1;
+        }
         free(sample);
     }
     
@@ -419,8 +449,6 @@ static int MP4End( hb_mux_object_t * m )
     char filename[1024]; memset( filename, 0, 1024 );
 #endif
 
-    hb_job_t * job = m->job;
-    
     if (job->areBframes)
     /* Walk the entire video sample table and find the minumum ctts value. */
     {

diff --git a/macosx/main.mm b/macosx/main.mm
index b07c7f1..7880214 100644 (file)
--- a/macosx/main.mm
+++ b/macosx/main.mm
@@ -11,6 +11,19 @@ void SigHandler( int signal )
     [NSApp terminate: NULL];
 } 
 
+/****************************************************************************
+ * hb_error_handler
+ * 
+ * Change this to display a dialog box - and maybe move it somewhere else,
+ * this is the only place I could find that looked like C :)
+****************************************************************************/
+extern "C" {
+void hb_error_handler( const char *errmsg )
+{
+    fprintf(stderr, "ERROR: %s\n", errmsg );
+}
+}
+
 int main( int argc, const char ** argv )
 {
     signal( SIGINT, SigHandler );

diff --git a/test/test.c b/test/test.c
index 85d506f..49b787a 100644 (file)
--- a/test/test.c
+++ b/test/test.c
@@ -1345,3 +1345,13 @@ static int CheckOptions( int argc, char ** argv )
     return 0;
 }
 
+/****************************************************************************
+ * hb_error_handler
+ * 
+ * When using the CLI just display using hb_log as we always did in the past
+ * make sure that we prefix with a nice ERROR message to catch peoples eyes.
+ ****************************************************************************/
+void hb_error_handler ( const char *errmsg )
+{
+    hb_log( "ERROR: %s", errmsg );
+}