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 void hb_set_size( hb_job_t * job, int aspect, int pixels )
 255 {
 256     hb_title_t * title = job->title;
 257
 258     int croppedWidth  = title->width - title->crop[2] - title->crop[3];
 259     int croppedHeight = title->height - title->crop[0] - title->crop[1];
 260     int croppedAspect = title->aspect * title->height * croppedWidth /
 261                             croppedHeight / title->width;
 262     int addCrop;
 263
 264     if( aspect <= 0 )
 265     {
 266         /* Keep the best possible aspect ratio */
 267         aspect = croppedAspect;
 268     }
 269
 270     /* Crop if necessary to obtain the desired ratio */
 271     memcpy( job->crop, title->crop, 4 * sizeof( int ) );
 272     if( aspect < croppedAspect )
 273     {
 274         /* Need to crop on the left and right */
 275         addCrop = croppedWidth - aspect * croppedHeight * title->width /
 276                     title->aspect / title->height;
 277         if( addCrop & 3 )
 278         {
 279             addCrop = ( addCrop + 1 ) / 2;
 280             job->crop[2] += addCrop;
 281             job->crop[3] += addCrop;
 282         }
 283         else if( addCrop & 2 )
 284         {
 285             addCrop /= 2;
 286             job->crop[2] += addCrop - 1;
 287             job->crop[3] += addCrop + 1;
 288         }
 289         else
 290         {
 291             addCrop /= 2;
 292             job->crop[2] += addCrop;
 293             job->crop[3] += addCrop;
 294         }
 295     }
 296     else if( aspect > croppedAspect )
 297     {
 298         /* Need to crop on the top and bottom */
 299         /* TODO */
 300     }
 301
 302     /* Compute a resolution from the number of pixels and aspect */
 303     int i, w, h;
 304     for( i = 0;; i++ )
 305     {
 306         w = 16 * i;
 307         h = MULTIPLE_16( w * HB_ASPECT_BASE / aspect );
 308         if( w * h > pixels )
 309         {
 310             break;
 311         }
 312     }
 313     i--;
 314     job->width  = 16 * i;
 315     job->height = MULTIPLE_16( 16 * i * HB_ASPECT_BASE / aspect );
 316 }
 317
 318 int hb_count( hb_handle_t * h )
 319 {
 320     return hb_list_count( h->jobs );
 321 }
 322
 323 hb_job_t * hb_job( hb_handle_t * h, int i )
 324 {
 325     return hb_list_item( h->jobs, i );
 326 }
 327
 328 /* hb_add: memcpy() party. That's ugly, for if someone has a better
 329    idea... */
 330 void hb_add( hb_handle_t * h, hb_job_t * job )
 331 {
 332     hb_job_t      * job_copy;
 333     hb_title_t    * title,    * title_copy;
 334     hb_chapter_t  * chapter,  * chapter_copy;
 335     hb_audio_t    * audio,    * audio_copy;
 336     hb_subtitle_t * subtitle, * subtitle_copy;
 337     int             i;
 338
 339     /* Copy the title */
 340     title      = job->title;
 341     title_copy = malloc( sizeof( hb_title_t ) );
 342     memcpy( title_copy, title, sizeof( hb_title_t ) );
 343
 344     title_copy->list_chapter = hb_list_init();
 345     for( i = 0; i < hb_list_count( title->list_chapter ); i++ )
 346     {
 347         chapter      = hb_list_item( title->list_chapter, i );
 348         chapter_copy = malloc( sizeof( hb_chapter_t ) );
 349         memcpy( chapter_copy, chapter, sizeof( hb_chapter_t ) );
 350         hb_list_add( title_copy->list_chapter, chapter_copy );
 351     }
 352
 353     /* Copy the audio track(s) we want */
 354     title_copy->list_audio = hb_list_init();
 355
 356     /* Do nothing about audio during first pass */
 357     if( job->pass != 1 )
 358     {
 359         for( i = 0; i < 8; i++ )
 360         {
 361             if( job->audios[i] < 0 )
 362             {
 363                 break;
 364             }
 365             if( ( audio = hb_list_item( title->list_audio, job->audios[i] ) ) )
 366             {
 367                 audio_copy = malloc( sizeof( hb_audio_t ) );
 368                 memcpy( audio_copy, audio, sizeof( hb_audio_t ) );
 369                 hb_list_add( title_copy->list_audio, audio_copy );
 370             }
 371         }
 372     }
 373
 374     /* Copy the subtitle we want (or not) */
 375     title_copy->list_subtitle = hb_list_init();
 376     if( ( subtitle = hb_list_item( title->list_subtitle, job->subtitle ) ) )
 377     {
 378         subtitle_copy = malloc( sizeof( hb_subtitle_t ) );
 379         memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) );
 380         hb_list_add( title_copy->list_subtitle, subtitle_copy );
 381     }
 382
 383     /* Copy the job */
 384     job_copy        = calloc( sizeof( hb_job_t ), 1 );
 385     memcpy( job_copy, job, sizeof( hb_job_t ) );
 386     job_copy->title = title_copy;
 387     job_copy->file  = strdup( job->file );
 388     job_copy->h     = h;
 389     job_copy->pause = h->pause_lock;
 390
 391     /* Add the job to the list */
 392     hb_list_add( h->jobs, job_copy );
 393 }
 394
 395 void hb_rem( hb_handle_t * h, hb_job_t * job )
 396 {
 397     hb_list_rem( h->jobs, job );
 398
 399     /* XXX free everything XXX */
 400 }
 401
 402 void hb_start( hb_handle_t * h )
 403 {
 404     /* XXX Hack */
 405     h->job_count = hb_list_count( h->jobs );
 406
 407     hb_lock( h->state_lock );
 408     h->state.state = HB_STATE_WORKING;
 409 #define p h->state.param.working
 410     p.progress  = 0.0;
 411     p.job_cur   = 1;
 412     p.job_count = h->job_count;
 413     p.rate_cur  = 0.0;
 414     p.rate_avg  = 0.0;
 415     p.hours     = -1;
 416     p.minutes   = -1;
 417     p.seconds   = -1;
 418 #undef p
 419     hb_unlock( h->state_lock );
 420
 421     h->paused = 0;
 422
 423     h->work_die    = 0;
 424     h->work_thread = hb_work_init( h->jobs, h->cpu_count,
 425                                    &h->work_die, &h->work_error );
 426 }
 427
 428 void hb_pause( hb_handle_t * h )
 429 {
 430     if( !h->paused )
 431     {
 432         hb_lock( h->pause_lock );
 433         h->paused = 1;
 434
 435         hb_lock( h->state_lock );
 436         h->state.state = HB_STATE_PAUSED;
 437         hb_unlock( h->state_lock );
 438     }
 439 }
 440
 441 void hb_resume( hb_handle_t * h )
 442 {
 443     if( h->paused )
 444     {
 445         hb_unlock( h->pause_lock );
 446         h->paused = 0;
 447     }
 448 }
 449
 450 void hb_stop( hb_handle_t * h )
 451 {
 452     h->work_die = 1;
 453
 454     hb_resume( h );
 455 }
 456
 457 void hb_get_state( hb_handle_t * h, hb_state_t * s )
 458 {
 459     hb_lock( h->state_lock );
 460
 461     memcpy( s, &h->state, sizeof( hb_state_t ) );
 462     h->state.state = HB_STATE_IDLE;
 463
 464     hb_unlock( h->state_lock );
 465 }
 466
 467 void hb_close( hb_handle_t ** _h )
 468 {
 469     hb_handle_t * h = *_h;
 470     hb_title_t * title;
 471
 472     h->die = 1;
 473     hb_thread_close( &h->main_thread );
 474
 475     while( ( title = hb_list_item( h->list_title, 0 ) ) )
 476     {
 477         hb_list_rem( h->list_title, title );
 478         hb_title_close( &title );
 479     }
 480     hb_list_close( &h->list_title );
 481
 482     hb_list_close( &h->jobs );
 483     hb_lock_close( &h->state_lock );
 484     hb_lock_close( &h->pause_lock );
 485     free( h );
 486     *_h = NULL;
 487 }
 488
 489 static void thread_func( void * _h )
 490 {
 491     hb_handle_t * h = (hb_handle_t *) _h;
 492     char dirname[1024];
 493     DIR * dir;
 494     struct dirent * entry;
 495
 496     h->pid = getpid();
 497
 498     /* Create folder for temporary files */
 499     memset( dirname, 0, 1024 );
 500     hb_get_tempory_directory( h, dirname );
 501
 502     hb_mkdir( dirname );
 503
 504     while( !h->die )
 505     {
 506         /* In case the check_update thread hangs, it'll die sooner or
 507            later. Then, we join it here */
 508         if( h->update_thread &&
 509             hb_thread_has_exited( h->update_thread ) )
 510         {
 511             hb_thread_close( &h->update_thread );
 512         }
 513
 514         /* Check if the scan thread is done */
 515         if( h->scan_thread &&
 516             hb_thread_has_exited( h->scan_thread ) )
 517         {
 518             hb_thread_close( &h->scan_thread );
 519
 520             hb_log( "libhb: scan thread found %d valid title(s)",
 521                     hb_list_count( h->list_title ) );
 522             hb_lock( h->state_lock );
 523             h->state.state = HB_STATE_SCANDONE;
 524             hb_unlock( h->state_lock );
 525         }
 526
 527         /* Check if the work thread is done */
 528         if( h->work_thread &&
 529             hb_thread_has_exited( h->work_thread ) )
 530         {
 531             hb_thread_close( &h->work_thread );
 532
 533             hb_log( "libhb: work result = %d",
 534                     h->work_error );
 535             hb_lock( h->state_lock );
 536             h->state.state                = HB_STATE_WORKDONE;
 537             h->state.param.workdone.error = h->work_error;
 538             hb_unlock( h->state_lock );
 539         }
 540
 541         hb_snooze( 50 );
 542     }
 543
 544     if( h->work_thread )
 545     {
 546         hb_stop( h );
 547         hb_thread_close( &h->work_thread );
 548     }
 549
 550     /* Remove temp folder */
 551     dir = opendir( dirname );
 552     while( ( entry = readdir( dir ) ) )
 553     {
 554         char filename[1024];
 555         if( entry->d_name[0] == '.' )
 556         {
 557             continue;
 558         }
 559         memset( filename, 0, 1024 );
 560         snprintf( filename, 1023, "%s/%s", dirname, entry->d_name );
 561         unlink( filename );
 562     }
 563     closedir( dir );
 564     rmdir( dirname );
 565 }
 566
 567 int hb_get_pid( hb_handle_t * h )
 568 {
 569     return h->pid;
 570 }
 571
 572 void hb_set_state( hb_handle_t * h, hb_state_t * s )
 573 {
 574     hb_lock( h->pause_lock );
 575     hb_lock( h->state_lock );
 576     memcpy( &h->state, s, sizeof( hb_state_t ) );
 577     if( h->state.state == HB_STATE_WORKING )
 578     {
 579         /* XXX Hack */
 580         h->state.param.working.job_cur =
 581             h->job_count - hb_list_count( h->jobs );
 582         h->state.param.working.job_count = h->job_count;
 583     }
 584     hb_unlock( h->state_lock );
 585     hb_unlock( h->pause_lock );
 586 }