libhb/hb.c

   1 /* $Id: hb.c,v 1.43 2005/04/27 21:05:24 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.m0k.org/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "hb.h"
   8
   9 #include "ffmpeg/avcodec.h"
  10
  11 struct hb_handle_s
  12 {
  13     /* The "Check for update" thread */
  14     int            build;
  15     char           version[16];
  16     hb_thread_t  * update_thread;
  17
  18     /* This thread's only purpose is to check other threads'
  19        states */
  20     volatile int   die;
  21     hb_thread_t  * main_thread;
  22     int            pid;
  23
  24     /* DVD/file scan thread */
  25     hb_list_t    * list_title;
  26     hb_thread_t  * scan_thread;
  27
  28     /* The thread which processes the jobs. Others threads are launched
  29        from this one (see work.c) */
  30     hb_list_t    * jobs;
  31     int            job_count;
  32     volatile int   work_die;
  33     int            work_error;
  34     hb_thread_t  * work_thread;
  35
  36     int            cpu_count;
  37
  38     hb_lock_t    * state_lock;
  39     hb_state_t     state;
  40
  41     int            paused;
  42     hb_lock_t    * pause_lock;
  43 };
  44
  45 hb_work_object_t * hb_objects = NULL;
  46
  47 static void thread_func( void * );
  48
  49 void hb_register( hb_work_object_t * w )
  50 {
  51     w->next    = hb_objects;
  52     hb_objects = w;
  53 }
  54
  55 hb_handle_t * hb_init_real( int verbose, int update_check )
  56 {
  57     hb_handle_t * h = calloc( sizeof( hb_handle_t ), 1 );
  58     uint64_t      date;
  59
  60     /* See hb_log() in common.c */
  61     if( verbose > HB_DEBUG_NONE )
  62     {
  63         putenv( "HB_DEBUG=1" );
  64     }
  65
  66     /* Check for an update on the website if asked to */
  67     h->build = -1;
  68
  69     if( update_check )
  70     {
  71         hb_log( "hb_init: checking for updates" );
  72         date             = hb_get_date();
  73         h->update_thread = hb_update_init( &h->build, h->version );
  74
  75         for( ;; )
  76         {
  77             if( hb_thread_has_exited( h->update_thread ) )
  78             {
  79                 /* Immediate success or failure */
  80                 hb_thread_close( &h->update_thread );
  81                 break;
  82             }
  83             if( hb_get_date() > date + 1000 )
  84             {
  85                 /* Still nothing after one second. Connection problem,
  86                    let the thread die */
  87                 hb_log( "hb_init: connection problem, not waiting for "
  88                         "update_thread" );
  89                 break;
  90             }
  91             hb_snooze( 50 );
  92         }
  93     }
  94
  95     /* CPU count detection */
  96     hb_log( "hb_init: checking cpu count" );
  97     h->cpu_count = hb_get_cpu_count();
  98
  99     h->list_title = hb_list_init();
 100     h->jobs       = hb_list_init();
 101
 102     h->state_lock  = hb_lock_init();
 103     h->state.state = HB_STATE_IDLE;
 104
 105     h->pause_lock = hb_lock_init();
 106
 107     /* libavcodec */
 108     avcodec_init();
 109     register_avcodec( &mpeg4_encoder );
 110     register_avcodec( &mp2_decoder );
 111     register_avcodec( &ac3_encoder );
 112
 113     /* Start library thread */
 114     hb_log( "hb_init: starting libhb thread" );
 115     h->die         = 0;
 116     h->main_thread = hb_thread_init( "libhb", thread_func, h,
 117                                      HB_NORMAL_PRIORITY );
 118
 119     return h;
 120 }
 121
 122 char * hb_get_version( hb_handle_t * h )
 123 {
 124     return HB_VERSION;
 125 }
 126
 127 int hb_get_build( hb_handle_t * h )
 128 {
 129     return HB_BUILD;
 130 }
 131
 132 int hb_check_update( hb_handle_t * h, char ** version )
 133 {
 134     *version = ( h->build < 0 ) ? NULL : h->version;
 135     return h->build;
 136 }
 137
 138 void hb_set_cpu_count( hb_handle_t * h, int cpu_count )
 139 {
 140     cpu_count    = MAX( 1, cpu_count );
 141     cpu_count    = MIN( cpu_count, 8 );
 142     h->cpu_count = cpu_count;
 143 }
 144
 145 void hb_scan( hb_handle_t * h, const char * path, int title_index )
 146 {
 147     hb_title_t * title;
 148
 149     /* Clean up from previous scan */
 150     while( ( title = hb_list_item( h->list_title, 0 ) ) )
 151     {
 152         hb_list_rem( h->list_title, title );
 153         hb_title_close( &title );
 154     }
 155
 156     hb_log( "hb_scan: path=%s, title_index=%d", path, title_index );
 157     h->scan_thread = hb_scan_init( h, path, title_index, h->list_title );
 158 }
 159
 160 hb_list_t * hb_get_titles( hb_handle_t * h )
 161 {
 162     return h->list_title;
 163 }
 164
 165 void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture,
 166                      uint8_t * buffer )
 167 {
 168     hb_job_t           * job = title->job;
 169     char                 filename[1024];
 170     FILE               * file;
 171     uint8_t            * buf1, * buf2, * buf3, * buf4, * pen;
 172     uint32_t           * p32;
 173     AVPicture            pic1, pic2, pic3, pic4;
 174     ImgReSampleContext * context;
 175     int                  i;
 176
 177     buf1 = malloc( title->width * title->height * 3 / 2 );
 178     buf2 = malloc( title->width * title->height * 3 / 2 );
 179     buf3 = malloc( title->width * title->height * 3 / 2 );
 180     buf4 = malloc( title->width * title->height * 4 );
 181     avpicture_fill( &pic1, buf1, PIX_FMT_YUV420P,
 182                     title->width, title->height );
 183     avpicture_fill( &pic2, buf2, PIX_FMT_YUV420P,
 184                     title->width, title->height );
 185     avpicture_fill( &pic3, buf3, PIX_FMT_YUV420P,
 186                     job->width, job->height );
 187     avpicture_fill( &pic4, buf4, PIX_FMT_RGBA32,
 188                     job->width, job->height );
 189
 190     memset( filename, 0, 1024 );
 191
 192     hb_get_tempory_filename( h, filename, "%x%d",
 193                              (int) title, picture );
 194
 195     file = fopen( filename, "r" );
 196     if( !file )
 197     {
 198         hb_log( "hb_get_preview: fopen failed" );
 199         return;
 200     }
 201
 202     fread( buf1, title->width * title->height * 3 / 2, 1, file );
 203     fclose( file );
 204
 205     context = img_resample_full_init(
 206             job->width, job->height, title->width, title->height,
 207             job->crop[0], job->crop[1], job->crop[2], job->crop[3],
 208             0, 0, 0, 0 );
 209
 210     if( job->deinterlace )
 211     {
 212         avpicture_deinterlace( &pic2, &pic1, PIX_FMT_YUV420P,
 213                                title->width, title->height );
 214         img_resample( context, &pic3, &pic2 );
 215     }
 216     else
 217     {
 218         img_resample( context, &pic3, &pic1 );
 219     }
 220     img_convert( &pic4, PIX_FMT_RGBA32, &pic3, PIX_FMT_YUV420P,
 221                  job->width, job->height );
 222
 223     /* Gray background */
 224     p32 = (uint32_t *) buffer;
 225     for( i = 0; i < ( title->width + 2 ) * ( title->height + 2 ); i++ )
 226     {
 227         p32[i] = 0xFF808080;
 228     }
 229
 230     /* Draw the picture, centered, and draw the cropping zone */
 231     pen = buffer + ( title->height - job->height ) *
 232         ( title->width + 2 ) * 2 + ( title->width - job->width ) * 2;
 233     memset( pen, 0xFF, 4 * ( job->width + 2 ) );
 234     pen += 4 * ( title->width + 2 );
 235     for( i = 0; i < job->height; i++ )
 236     {
 237         uint8_t * nextLine;
 238         nextLine = pen + 4 * ( title->width + 2 );
 239         memset( pen, 0xFF, 4 );
 240         pen += 4;
 241         memcpy( pen, buf4 + 4 * job->width * i, 4 * job->width );
 242         pen += 4 * job->width;
 243         memset( pen, 0xFF, 4 );
 244         pen = nextLine;
 245     }
 246     memset( pen, 0xFF, 4 * ( job->width + 2 ) );
 247
 248     free( buf1 );
 249     free( buf2 );
 250     free( buf3 );
 251     free( buf4 );
 252 }
 253
 254 int hb_count( hb_handle_t * h )
 255 {
 256     return hb_list_count( h->jobs );
 257 }
 258
 259 hb_job_t * hb_job( hb_handle_t * h, int i )
 260 {
 261     return hb_list_item( h->jobs, i );
 262 }
 263
 264 /* hb_add: memcpy() party. That's ugly, for if someone has a better
 265    idea... */
 266 void hb_add( hb_handle_t * h, hb_job_t * job )
 267 {
 268     hb_job_t      * job_copy;
 269     hb_title_t    * title,    * title_copy;
 270     hb_chapter_t  * chapter,  * chapter_copy;
 271     hb_audio_t    * audio,    * audio_copy;
 272     hb_subtitle_t * subtitle, * subtitle_copy;
 273     int             i;
 274
 275     /* Copy the title */
 276     title      = job->title;
 277     title_copy = malloc( sizeof( hb_title_t ) );
 278     memcpy( title_copy, title, sizeof( hb_title_t ) );
 279
 280     title_copy->list_chapter = hb_list_init();
 281     for( i = 0; i < hb_list_count( title->list_chapter ); i++ )
 282     {
 283         chapter      = hb_list_item( title->list_chapter, i );
 284         chapter_copy = malloc( sizeof( hb_chapter_t ) );
 285         memcpy( chapter_copy, chapter, sizeof( hb_chapter_t ) );
 286         hb_list_add( title_copy->list_chapter, chapter_copy );
 287     }
 288
 289     /* Copy the audio track(s) we want */
 290     title_copy->list_audio = hb_list_init();
 291
 292     /* Do nothing about audio during first pass */
 293     if( job->pass != 1 )
 294     {
 295         for( i = 0; i < 8; i++ )
 296         {
 297             if( job->audios[i] < 0 )
 298             {
 299                 break;
 300             }
 301             if( ( audio = hb_list_item( title->list_audio, job->audios[i] ) ) )
 302             {
 303                 audio_copy = malloc( sizeof( hb_audio_t ) );
 304                 memcpy( audio_copy, audio, sizeof( hb_audio_t ) );
 305                 hb_list_add( title_copy->list_audio, audio_copy );
 306             }
 307         }
 308     }
 309
 310     /* Copy the subtitle we want (or not) */
 311     title_copy->list_subtitle = hb_list_init();
 312     if( ( subtitle = hb_list_item( title->list_subtitle, job->subtitle ) ) )
 313     {
 314         subtitle_copy = malloc( sizeof( hb_subtitle_t ) );
 315         memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) );
 316         hb_list_add( title_copy->list_subtitle, subtitle_copy );
 317     }
 318
 319     /* Copy the job */
 320     job_copy        = calloc( sizeof( hb_job_t ), 1 );
 321     memcpy( job_copy, job, sizeof( hb_job_t ) );
 322     job_copy->title = title_copy;
 323     job_copy->file  = strdup( job->file );
 324     job_copy->h     = h;
 325     job_copy->pause = h->pause_lock;
 326
 327     /* Add the job to the list */
 328     hb_list_add( h->jobs, job_copy );
 329 }
 330
 331 void hb_rem( hb_handle_t * h, hb_job_t * job )
 332 {
 333     hb_list_rem( h->jobs, job );
 334
 335     /* XXX free everything XXX */
 336 }
 337
 338 void hb_start( hb_handle_t * h )
 339 {
 340     /* XXX Hack */
 341     h->job_count = hb_list_count( h->jobs );
 342
 343     hb_lock( h->state_lock );
 344     h->state.state = HB_STATE_WORKING;
 345 #define p h->state.param.working
 346     p.progress  = 0.0;
 347     p.job_cur   = 1;
 348     p.job_count = h->job_count;
 349     p.rate_cur  = 0.0;
 350     p.rate_avg  = 0.0;
 351     p.hours     = -1;
 352     p.minutes   = -1;
 353     p.seconds   = -1;
 354 #undef p
 355     hb_unlock( h->state_lock );
 356
 357     h->paused = 0;
 358
 359     h->work_die    = 0;
 360     h->work_thread = hb_work_init( h->jobs, h->cpu_count,
 361                                    &h->work_die, &h->work_error );
 362 }
 363
 364 void hb_pause( hb_handle_t * h )
 365 {
 366     if( !h->paused )
 367     {
 368         hb_lock( h->pause_lock );
 369         h->paused = 1;
 370
 371         hb_lock( h->state_lock );
 372         h->state.state = HB_STATE_PAUSED;
 373         hb_unlock( h->state_lock );
 374     }
 375 }
 376
 377 void hb_resume( hb_handle_t * h )
 378 {
 379     if( h->paused )
 380     {
 381         hb_unlock( h->pause_lock );
 382         h->paused = 0;
 383     }
 384 }
 385
 386 void hb_stop( hb_handle_t * h )
 387 {
 388     h->work_die = 1;
 389
 390     hb_resume( h );
 391 }
 392
 393 void hb_get_state( hb_handle_t * h, hb_state_t * s )
 394 {
 395     hb_lock( h->state_lock );
 396
 397     memcpy( s, &h->state, sizeof( hb_state_t ) );
 398     h->state.state = HB_STATE_IDLE;
 399
 400     hb_unlock( h->state_lock );
 401 }
 402
 403 void hb_close( hb_handle_t ** _h )
 404 {
 405     hb_handle_t * h = *_h;
 406     hb_title_t * title;
 407
 408     h->die = 1;
 409     hb_thread_close( &h->main_thread );
 410
 411     while( ( title = hb_list_item( h->list_title, 0 ) ) )
 412     {
 413         hb_list_rem( h->list_title, title );
 414         hb_title_close( &title );
 415     }
 416     hb_list_close( &h->list_title );
 417
 418     hb_list_close( &h->jobs );
 419     hb_lock_close( &h->state_lock );
 420     hb_lock_close( &h->pause_lock );
 421     free( h );
 422     *_h = NULL;
 423 }
 424
 425 static void thread_func( void * _h )
 426 {
 427     hb_handle_t * h = (hb_handle_t *) _h;
 428     char dirname[1024];
 429     DIR * dir;
 430     struct dirent * entry;
 431
 432     h->pid = getpid();
 433
 434     /* Create folder for temporary files */
 435     memset( dirname, 0, 1024 );
 436     hb_get_tempory_directory( h, dirname );
 437
 438     hb_mkdir( dirname );
 439
 440     while( !h->die )
 441     {
 442         /* In case the check_update thread hangs, it'll die sooner or
 443            later. Then, we join it here */
 444         if( h->update_thread &&
 445             hb_thread_has_exited( h->update_thread ) )
 446         {
 447             hb_thread_close( &h->update_thread );
 448         }
 449
 450         /* Check if the scan thread is done */
 451         if( h->scan_thread &&
 452             hb_thread_has_exited( h->scan_thread ) )
 453         {
 454             hb_thread_close( &h->scan_thread );
 455
 456             hb_log( "libhb: scan thread found %d valid title(s)",
 457                     hb_list_count( h->list_title ) );
 458             hb_lock( h->state_lock );
 459             h->state.state = HB_STATE_SCANDONE;
 460             hb_unlock( h->state_lock );
 461         }
 462
 463         /* Check if the work thread is done */
 464         if( h->work_thread &&
 465             hb_thread_has_exited( h->work_thread ) )
 466         {
 467             hb_thread_close( &h->work_thread );
 468
 469             hb_log( "libhb: work result = %d",
 470                     h->work_error );
 471             hb_lock( h->state_lock );
 472             h->state.state                = HB_STATE_WORKDONE;
 473             h->state.param.workdone.error = h->work_error;
 474             hb_unlock( h->state_lock );
 475         }
 476
 477         hb_snooze( 50 );
 478     }
 479
 480     if( h->work_thread )
 481     {
 482         hb_stop( h );
 483         hb_thread_close( &h->work_thread );
 484     }
 485
 486     /* Remove temp folder */
 487     dir = opendir( dirname );
 488     while( ( entry = readdir( dir ) ) )
 489     {
 490         char filename[1024];
 491         if( entry->d_name[0] == '.' )
 492         {
 493             continue;
 494         }
 495         memset( filename, 0, 1024 );
 496         snprintf( filename, 1023, "%s/%s", dirname, entry->d_name );
 497         unlink( filename );
 498     }
 499     closedir( dir );
 500     rmdir( dirname );
 501 }
 502
 503 int hb_get_pid( hb_handle_t * h )
 504 {
 505     return h->pid;
 506 }
 507
 508 void hb_set_state( hb_handle_t * h, hb_state_t * s )
 509 {
 510     hb_lock( h->pause_lock );
 511     hb_lock( h->state_lock );
 512     memcpy( &h->state, s, sizeof( hb_state_t ) );
 513     if( h->state.state == HB_STATE_WORKING )
 514     {
 515         /* XXX Hack */
 516         h->state.param.working.job_cur =
 517             h->job_count - hb_list_count( h->jobs );
 518         h->state.param.working.job_count = h->job_count;
 519     }
 520     hb_unlock( h->state_lock );
 521     hb_unlock( h->pause_lock );
 522 }