OSDN Git Service

A big batch of patches from eddyg.
[handbrake-jp/handbrake-jp-git.git] / libhb / hb.c
1 #include "hb.h"
2
3 #include "ffmpeg/avcodec.h"
4
5 struct hb_handle_s
6 {
7     /* The "Check for update" thread */
8     int            build;
9     char           version[16];
10     hb_thread_t  * update_thread;
11
12     /* This thread's only purpose is to check other threads'
13        states */
14     volatile int   die;
15     hb_thread_t  * main_thread;
16     int            pid;
17
18     /* DVD/file scan thread */
19     hb_list_t    * list_title;
20     hb_thread_t  * scan_thread;
21
22     /* The thread which processes the jobs. Others threads are launched
23        from this one (see work.c) */
24     hb_list_t    * jobs;
25     int            job_count;
26     volatile int   work_die;
27     int            work_error;
28     hb_thread_t  * work_thread;
29
30     int            cpu_count;
31
32     hb_lock_t    * state_lock;
33     hb_state_t     state;
34
35     int            paused;
36     hb_lock_t    * pause_lock;
37 };
38
39 hb_work_object_t * hb_objects = NULL;
40
41 static void thread_func( void * );
42
43 /**
44  * Registers work objects, by adding the work object to a liked list.
45  * @param w Handle to hb_work_object_t to register.
46  */
47 void hb_register( hb_work_object_t * w )
48 {
49     w->next    = hb_objects;
50     hb_objects = w;
51 }
52
53 /**
54  * libhb initialization routine.
55  * @param verbose HB_DEBUG_NONE or HB_DEBUG_ALL.
56  * @param update_check signals libhb to check for updated version from HandBrake website.
57  * @return Handle to hb_handle_t for use on all subsequent calls to libhb.
58  */
59 hb_handle_t * hb_init_real( int verbose, int update_check )
60 {
61     hb_handle_t * h = calloc( sizeof( hb_handle_t ), 1 );
62     uint64_t      date;
63
64     /* See hb_log() in common.c */
65     if( verbose > HB_DEBUG_NONE )
66     {
67         putenv( "HB_DEBUG=1" );
68                 av_log_set_level(AV_LOG_DEBUG);
69     }
70
71     /* Check for an update on the website if asked to */
72     h->build = -1;
73
74     if( update_check )
75     {
76         hb_log( "hb_init: checking for updates" );
77         date             = hb_get_date();
78         h->update_thread = hb_update_init( &h->build, h->version );
79
80         for( ;; )
81         {
82             if( hb_thread_has_exited( h->update_thread ) )
83             {
84                 /* Immediate success or failure */
85                 hb_thread_close( &h->update_thread );
86                 break;
87             }
88             if( hb_get_date() > date + 1000 )
89             {
90                 /* Still nothing after one second. Connection problem,
91                    let the thread die */
92                 hb_log( "hb_init: connection problem, not waiting for "
93                         "update_thread" );
94                 break;
95             }
96             hb_snooze( 500 );
97         }
98     }
99
100     /* CPU count detection */
101     hb_log( "hb_init: checking cpu count" );
102     h->cpu_count = hb_get_cpu_count();
103
104     h->list_title = hb_list_init();
105     h->jobs       = hb_list_init();
106
107     h->state_lock  = hb_lock_init();
108     h->state.state = HB_STATE_IDLE;
109
110     h->pause_lock = hb_lock_init();
111
112     /* libavcodec */
113     avcodec_init();
114     register_avcodec( &mpeg4_encoder );
115     register_avcodec( &mp2_decoder );
116     register_avcodec( &ac3_encoder );
117     av_register_codec_parser( &mpegaudio_parser);
118     
119     /* Start library thread */
120     hb_log( "hb_init: starting libhb thread" );
121     h->die         = 0;
122     h->main_thread = hb_thread_init( "libhb", thread_func, h,
123                                      HB_NORMAL_PRIORITY );
124
125     return h;
126 }
127
128 /**
129  * libhb initialization routine.
130  * This version is to use when calling the dylib, the macro hb_init isn't available from a dylib call!
131  * @param verbose HB_DEBUG_NONE or HB_DEBUG_ALL.
132  * @param update_check signals libhb to check for updated version from HandBrake website.
133  * @return Handle to hb_handle_t for use on all subsequent calls to libhb.
134  */
135 hb_handle_t * hb_init_dl( int verbose, int update_check )
136 {
137     hb_handle_t * h = calloc( sizeof( hb_handle_t ), 1 );
138     uint64_t      date;
139
140     /* See hb_log() in common.c */
141     if( verbose > HB_DEBUG_NONE )
142     {
143         putenv( "HB_DEBUG=1" );
144                 av_log_set_level(AV_LOG_DEBUG);
145     }
146
147     /* Check for an update on the website if asked to */
148     h->build = -1;
149
150     if( update_check )
151     {
152         hb_log( "hb_init: checking for updates" );
153         date             = hb_get_date();
154         h->update_thread = hb_update_init( &h->build, h->version );
155
156         for( ;; )
157         {
158             if( hb_thread_has_exited( h->update_thread ) )
159             {
160                 /* Immediate success or failure */
161                 hb_thread_close( &h->update_thread );
162                 break;
163             }
164             if( hb_get_date() > date + 1000 )
165             {
166                 /* Still nothing after one second. Connection problem,
167                    let the thread die */
168                 hb_log( "hb_init: connection problem, not waiting for "
169                         "update_thread" );
170                 break;
171             }
172             hb_snooze( 500 );
173         }
174     }
175
176     /* CPU count detection */
177     hb_log( "hb_init: checking cpu count" );
178     h->cpu_count = hb_get_cpu_count();
179
180     h->list_title = hb_list_init();
181     h->jobs       = hb_list_init();
182
183     h->state_lock  = hb_lock_init();
184     h->state.state = HB_STATE_IDLE;
185
186     h->pause_lock = hb_lock_init();
187
188     /* libavcodec */
189     avcodec_init();
190     register_avcodec( &mpeg4_encoder );
191     register_avcodec( &mp2_decoder );
192     register_avcodec( &ac3_encoder );
193
194     /* Start library thread */
195     hb_log( "hb_init: starting libhb thread" );
196     h->die         = 0;
197     h->main_thread = hb_thread_init( "libhb", thread_func, h,
198                                      HB_NORMAL_PRIORITY );
199
200     hb_register( &hb_sync ); 
201         hb_register( &hb_decmpeg2 ); 
202         hb_register( &hb_decsub ); 
203         hb_register( &hb_render ); 
204         hb_register( &hb_encavcodec ); 
205         hb_register( &hb_encxvid ); 
206         hb_register( &hb_encx264 ); 
207         hb_register( &hb_deca52 ); 
208         hb_register( &hb_decdca ); 
209         hb_register( &hb_decavcodec ); 
210         hb_register( &hb_declpcm ); 
211         hb_register( &hb_encfaac ); 
212         hb_register( &hb_enclame ); 
213         hb_register( &hb_encvorbis ); 
214         
215         return h;
216 }
217
218
219 /**
220  * Returns current version of libhb.
221  * @param h Handle to hb_handle_t.
222  * @return character array of version number.
223  */
224 char * hb_get_version( hb_handle_t * h )
225 {
226     return HB_VERSION;
227 }
228
229 /**
230  * Returns current build of libhb.
231  * @param h Handle to hb_handle_t.
232  * @return character array of build number.
233  */
234 int hb_get_build( hb_handle_t * h )
235 {
236     return HB_BUILD;
237 }
238
239 /**
240  * Checks for needed update.
241  * @param h Handle to hb_handle_t.
242  * @param version Pointer to handle where version will be copied.
243  * @return update indicator.
244  */
245 int hb_check_update( hb_handle_t * h, char ** version )
246 {
247     *version = ( h->build < 0 ) ? NULL : h->version;
248     return h->build;
249 }
250
251 /**
252  * Sets the cpu count to the desired value.
253  * @param h Handle to hb_handle_t
254  * @param cpu_count Number of CPUs to use.
255  */
256 void hb_set_cpu_count( hb_handle_t * h, int cpu_count )
257 {
258     cpu_count    = MAX( 1, cpu_count );
259     cpu_count    = MIN( cpu_count, 8 );
260     h->cpu_count = cpu_count;
261 }
262
263 /**
264  * Initializes a scan of the by calling hb_scan_init
265  * @param h Handle to hb_handle_t
266  * @param path location of VIDEO_TS folder.
267  * @param title_index Desired title to scan.  0 for all titles.
268  */
269 void hb_scan( hb_handle_t * h, const char * path, int title_index )
270 {
271     hb_title_t * title;
272
273     /* Clean up from previous scan */
274     while( ( title = hb_list_item( h->list_title, 0 ) ) )
275     {
276         hb_list_rem( h->list_title, title );
277         hb_title_close( &title );
278     }
279     
280     hb_log( "hb_scan: path=%s, title_index=%d", path, title_index );
281     h->scan_thread = hb_scan_init( h, path, title_index, h->list_title );
282 }
283
284 /**
285  * Returns the list of titles found.
286  * @param h Handle to hb_handle_t
287  * @return Handle to hb_list_t of the title list.
288  */
289 hb_list_t * hb_get_titles( hb_handle_t * h )
290 {
291     return h->list_title;
292 }
293
294 /**
295  * Create preview image of desired title a index of picture.
296  * @param h Handle to hb_handle_t.
297  * @param title Handle to hb_title_t of desired title.
298  * @param picture Index in title.
299  * @param buffer Handle to buufer were inage will be drawn.
300  */
301 void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture,
302                      uint8_t * buffer )
303 {
304     hb_job_t           * job = title->job;
305     char                 filename[1024];
306     FILE               * file;
307     uint8_t            * buf1, * buf2, * buf3, * buf4, * pen;
308     uint32_t           * p32;
309     AVPicture            pic1, pic2, pic3, pic4;
310     ImgReSampleContext * context;
311     int                  i;
312
313     buf1 = malloc( title->width * title->height * 3 / 2 );
314     buf2 = malloc( title->width * title->height * 3 / 2 );
315     buf3 = malloc( title->width * title->height * 3 / 2 );
316     buf4 = malloc( title->width * title->height * 4 );
317     avpicture_fill( &pic1, buf1, PIX_FMT_YUV420P,
318                     title->width, title->height );
319     avpicture_fill( &pic2, buf2, PIX_FMT_YUV420P,
320                     title->width, title->height );
321     avpicture_fill( &pic3, buf3, PIX_FMT_YUV420P,
322                     job->width, job->height );
323     avpicture_fill( &pic4, buf4, PIX_FMT_RGBA32,
324                     job->width, job->height );
325     
326     memset( filename, 0, 1024 );
327
328     hb_get_tempory_filename( h, filename, "%x%d",
329                              (intptr_t) title, picture );
330
331     file = fopen( filename, "r" );
332     if( !file )
333     {
334         hb_log( "hb_get_preview: fopen failed" );
335         return;
336     }
337
338     fread( buf1, title->width * title->height * 3 / 2, 1, file );
339     fclose( file );
340
341     context = img_resample_full_init(
342             job->width, job->height, title->width, title->height,
343             job->crop[0], job->crop[1], job->crop[2], job->crop[3],
344             0, 0, 0, 0 );
345
346     if( job->deinterlace )
347     {
348         avpicture_deinterlace( &pic2, &pic1, PIX_FMT_YUV420P,
349                                title->width, title->height );
350         img_resample( context, &pic3, &pic2 );
351     }
352     else
353     {
354         img_resample( context, &pic3, &pic1 );
355     }
356     img_convert( &pic4, PIX_FMT_RGBA32, &pic3, PIX_FMT_YUV420P,
357                  job->width, job->height );
358
359     /* Gray background */
360     p32 = (uint32_t *) buffer;
361     for( i = 0; i < ( title->width + 2 ) * ( title->height + 2 ); i++ )
362     {
363         p32[i] = 0xFF808080;
364     }
365
366     /* Draw the picture, centered, and draw the cropping zone */
367     pen = buffer + ( title->height - job->height ) *
368         ( title->width + 2 ) * 2 + ( title->width - job->width ) * 2;
369     memset( pen, 0xFF, 4 * ( job->width + 2 ) );
370     pen += 4 * ( title->width + 2 );
371     for( i = 0; i < job->height; i++ )
372     {
373         uint8_t * nextLine;
374         nextLine = pen + 4 * ( title->width + 2 );
375         memset( pen, 0xFF, 4 );
376         pen += 4;
377         memcpy( pen, buf4 + 4 * job->width * i, 4 * job->width );
378         pen += 4 * job->width;
379         memset( pen, 0xFF, 4 );
380         pen = nextLine;
381     }
382     memset( pen, 0xFF, 4 * ( job->width + 2 ) );
383
384     free( buf1 );
385     free( buf2 );
386     free( buf3 );
387     free( buf4 );
388 }
389
390 /**
391  * Calculates job width, height, and cropping parameters.
392  * @param job Handle to hb_job_t.
393  * @param aspect Desired aspect ratio. Value of -1 uses title aspect.
394  * @param pixels Maximum desired pixel count.
395  */
396 void hb_set_size( hb_job_t * job, int aspect, int pixels )
397 {
398     hb_title_t * title = job->title;
399
400     int croppedWidth  = title->width - title->crop[2] - title->crop[3];
401     int croppedHeight = title->height - title->crop[0] - title->crop[1];
402     int croppedAspect = title->aspect * title->height * croppedWidth /
403                             croppedHeight / title->width;
404     int addCrop;
405     int i, w, h;
406
407     if( aspect <= 0 )
408     {
409         /* Keep the best possible aspect ratio */
410         aspect = croppedAspect;
411     }
412
413     /* Crop if necessary to obtain the desired ratio */
414     memcpy( job->crop, title->crop, 4 * sizeof( int ) );
415     if( aspect < croppedAspect )
416     {
417         /* Need to crop on the left and right */
418         addCrop = croppedWidth - aspect * croppedHeight * title->width /
419                     title->aspect / title->height;
420         if( addCrop & 3 )
421         {
422             addCrop = ( addCrop + 1 ) / 2;
423             job->crop[2] += addCrop;
424             job->crop[3] += addCrop;
425         }
426         else if( addCrop & 2 )
427         {
428             addCrop /= 2;
429             job->crop[2] += addCrop - 1;
430             job->crop[3] += addCrop + 1;
431         }
432         else
433         {
434             addCrop /= 2;
435             job->crop[2] += addCrop;
436             job->crop[3] += addCrop;
437         }
438     }
439     else if( aspect > croppedAspect )
440     {
441         /* Need to crop on the top and bottom */
442         addCrop = croppedHeight - croppedWidth * title->aspect *
443             title->height / aspect / title->width;
444         if( addCrop & 3 )
445         {
446             addCrop = ( addCrop + 1 ) / 2;
447             job->crop[0] += addCrop;
448             job->crop[1] += addCrop;
449         }
450         else if( addCrop & 2 )
451         {
452             addCrop /= 2;
453             job->crop[0] += addCrop - 1;
454             job->crop[1] += addCrop + 1;
455         }
456         else
457         {
458             addCrop /= 2;
459             job->crop[0] += addCrop;
460             job->crop[1] += addCrop;
461         }
462     }
463
464     /* Compute a resolution from the number of pixels and aspect */
465     for( i = 0;; i++ )
466     {
467         w = 16 * i;
468         h = MULTIPLE_16( w * HB_ASPECT_BASE / aspect );
469         if( w * h > pixels )
470         {
471             break;
472         }
473     }
474     i--;
475     job->width  = 16 * i;
476     job->height = MULTIPLE_16( 16 * i * HB_ASPECT_BASE / aspect );
477 }
478
479 /**
480  * Returns the number of jobs in the queue.
481  * @param h Handle to hb_handle_t.
482  * @return Number of jobs.
483  */
484 int hb_count( hb_handle_t * h )
485 {
486     return hb_list_count( h->jobs );
487 }
488
489 /**
490  * Returns handle to job at index i within the job list.
491  * @param h Handle to hb_handle_t.
492  * @param i Index of job.
493  * @returns Handle to hb_job_t of desired job.
494  */
495 hb_job_t * hb_job( hb_handle_t * h, int i )
496 {
497     return hb_list_item( h->jobs, i );
498 }
499
500 /**
501  * Adds a job to the job list.
502  * @param h Handle to hb_handle_t.
503  * @param job Handle to hb_job_t.
504  */
505 void hb_add( hb_handle_t * h, hb_job_t * job )
506 {
507     hb_job_t      * job_copy;
508     hb_title_t    * title,    * title_copy;
509     hb_chapter_t  * chapter,  * chapter_copy;
510     hb_audio_t    * audio,    * audio_copy;
511     hb_subtitle_t * subtitle, * subtitle_copy;
512     int             i;
513
514     /* Copy the title */
515     title      = job->title;
516     title_copy = malloc( sizeof( hb_title_t ) );
517     memcpy( title_copy, title, sizeof( hb_title_t ) );
518
519     title_copy->list_chapter = hb_list_init();
520     for( i = 0; i < hb_list_count( title->list_chapter ); i++ )
521     {
522         chapter      = hb_list_item( title->list_chapter, i );
523         chapter_copy = malloc( sizeof( hb_chapter_t ) );
524         memcpy( chapter_copy, chapter, sizeof( hb_chapter_t ) );
525         hb_list_add( title_copy->list_chapter, chapter_copy );
526     }
527
528     /* Copy the audio track(s) we want */
529     title_copy->list_audio = hb_list_init();
530
531     /* Do nothing about audio during first pass */
532     if( job->pass != 1 )
533     {
534         for( i = 0; i < 8; i++ )
535         {
536             if( job->audios[i] < 0 )
537             {
538                 break;
539             }
540             if( ( audio = hb_list_item( title->list_audio, job->audios[i] ) ) )
541             {
542                 audio_copy = malloc( sizeof( hb_audio_t ) );
543                 memcpy( audio_copy, audio, sizeof( hb_audio_t ) );
544                 hb_list_add( title_copy->list_audio, audio_copy );
545             }
546         }
547     }
548
549     title_copy->list_subtitle = hb_list_init();
550
551     if( job->pass != 1 ) 
552     {
553         /* Copy the subtitle we want (or not) 
554          */
555         if( ( subtitle = hb_list_item( title->list_subtitle, job->subtitle ) ) )
556         {
557             subtitle_copy = malloc( sizeof( hb_subtitle_t ) );
558             memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) );
559             hb_list_add( title_copy->list_subtitle, subtitle_copy );
560         }
561     } else { 
562         char audio_lang[4];
563
564         memset( audio_lang, 0, sizeof( audio_lang ) );
565
566         /*
567          * Pass 1, do we want to do a subtitle scan?
568          */
569         if( job->subtitle_scan ) 
570         {
571             /*
572              * Search for all occurances of the audio language in the
573              * subtitles and add them all to the
574              * title_copy->list_subtitle. First of all find the
575              * language for the audio.
576              */
577             for( i = 0; i < 8; i++ )
578             {
579                 if( job->audios[i] < 0 )
580                 {
581                     break;
582                 }
583                 if( ( audio = hb_list_item( title->list_audio, job->audios[i] ) ) )
584                 {
585                     strncpy(audio_lang, audio->iso639_2, sizeof(audio_lang));
586                 }
587             }
588         }
589
590         /*
591          * If we have a native language now is the time to see whether we want
592          * to enable subtitles for it if it differs from the audio language.
593          */
594         if( job->native_language ) 
595         {
596             if( strncasecmp( job->native_language, audio_lang, 
597                              sizeof( audio_lang ) ) != 0 )
598             {             
599
600                 hb_log( "Enabled subtitles in native language '%s', audio is in '%s'",
601                         job->native_language, audio_lang);
602                 /*
603                  * The main audio track is not in our native language, so switch
604                  * the subtitle scan to use our native language instead.
605                  */
606                 strncpy( audio_lang, job->native_language, sizeof( audio_lang ) );
607             } else {
608                 /*
609                  * native language is irrelevent, free it.
610                  */
611                 free( job->native_language );
612                 job->native_language = NULL;
613             }
614         }
615
616         for( i=0; i < hb_list_count( title->list_subtitle ); i++ ) 
617         {
618             subtitle = hb_list_item( title->list_subtitle, i );
619             if( strcmp( subtitle->iso639_2, audio_lang ) == 0 ) 
620             {
621                 /*
622                  * Matched subtitle language with audio language, so
623                  * add this to our list to scan.
624                  */
625                 subtitle_copy = malloc( sizeof( hb_subtitle_t ) );
626                 memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) );
627                 hb_list_add( title_copy->list_subtitle, subtitle_copy );
628             }
629         }
630     }
631
632     /* Copy the job */
633     job_copy        = calloc( sizeof( hb_job_t ), 1 );
634     memcpy( job_copy, job, sizeof( hb_job_t ) );
635     title_copy->job = job_copy;
636     job_copy->title = title_copy;
637     job_copy->file  = strdup( job->file );
638     job_copy->h     = h;
639     job_copy->pause = h->pause_lock;
640
641     /* Add the job to the list */
642     hb_list_add( h->jobs, job_copy );
643 }
644
645 /**
646  * Removes a job from the job list.
647  * @param h Handle to hb_handle_t.
648  * @param job Handle to hb_job_t.
649  */
650 void hb_rem( hb_handle_t * h, hb_job_t * job )
651 {
652     hb_list_rem( h->jobs, job );
653
654     /* XXX free everything XXX */
655 }
656
657 /**
658  * Starts the conversion process.
659  * Sets state to HB_STATE_WORKING.
660  * calls hb_work_init, to launch work thread. Stores handle to work thread.
661  * @param h Handle to hb_handle_t.
662  */
663 void hb_start( hb_handle_t * h )
664 {
665     /* XXX Hack */
666     h->job_count = hb_list_count( h->jobs );
667
668     hb_lock( h->state_lock );
669     h->state.state = HB_STATE_WORKING;
670 #define p h->state.param.working
671     p.progress  = 0.0;
672     p.job_cur   = 1;
673     p.job_count = h->job_count;
674     p.rate_cur  = 0.0;
675     p.rate_avg  = 0.0;
676     p.hours     = -1;
677     p.minutes   = -1;
678     p.seconds   = -1;
679 #undef p
680     hb_unlock( h->state_lock );
681
682     h->paused = 0;
683
684     h->work_die    = 0;
685     h->work_thread = hb_work_init( h->jobs, h->cpu_count,
686                                    &h->work_die, &h->work_error );
687 }
688
689 /**
690  * Pauses the conversion process.
691  * @param h Handle to hb_handle_t.
692  */
693 void hb_pause( hb_handle_t * h )
694 {
695     if( !h->paused )
696     {
697         hb_lock( h->pause_lock );
698         h->paused = 1;
699
700         hb_lock( h->state_lock );
701         h->state.state = HB_STATE_PAUSED;
702         hb_unlock( h->state_lock );
703     }
704 }
705
706 /**
707  * Resumes the conversion process.
708  * @param h Handle to hb_handle_t.
709  */
710 void hb_resume( hb_handle_t * h )
711 {
712     if( h->paused )
713     {
714         hb_unlock( h->pause_lock );
715         h->paused = 0;
716     }
717 }
718
719 /**
720  * Stops the conversion process.
721  * @param h Handle to hb_handle_t.
722  */
723 void hb_stop( hb_handle_t * h )
724 {
725     h->work_die = 1;
726
727     hb_resume( h );
728 }
729
730 /**
731  * Returns the state of the conversion process.
732  * @param h Handle to hb_handle_t.
733  * @param s Handle to hb_state_t which to copy the state data.
734  */
735 void hb_get_state( hb_handle_t * h, hb_state_t * s )
736 {
737     hb_lock( h->state_lock );
738
739     memcpy( s, &h->state, sizeof( hb_state_t ) );
740     h->state.state = HB_STATE_IDLE;
741
742     hb_unlock( h->state_lock );
743 }
744
745 /**
746  * Closes access to libhb by freeing the hb_handle_t handle ontained in hb_init_real.
747  * @param _h Pointer to handle to hb_handle_t.
748  */
749 void hb_close( hb_handle_t ** _h )
750 {
751     hb_handle_t * h = *_h;
752     hb_title_t * title;
753
754     h->die = 1;
755     hb_thread_close( &h->main_thread );
756
757     while( ( title = hb_list_item( h->list_title, 0 ) ) )
758     {
759         hb_list_rem( h->list_title, title );
760         free( title->job );
761         hb_title_close( &title );
762     }
763     hb_list_close( &h->list_title );
764
765     hb_list_close( &h->jobs );
766     hb_lock_close( &h->state_lock );
767     hb_lock_close( &h->pause_lock );
768     free( h );
769     *_h = NULL;
770 }
771
772 /**
773  * Monitors the state of the update, scan, and work threads.
774  * Sets scan done state when scan thread exits.
775  * Sets work done state when work thread exits.
776  * @param _h Handle to hb_handle_t
777  */
778 static void thread_func( void * _h )
779 {
780     hb_handle_t * h = (hb_handle_t *) _h;
781     char dirname[1024];
782     DIR * dir;
783     struct dirent * entry;
784
785     h->pid = getpid();
786
787     /* Create folder for temporary files */
788     memset( dirname, 0, 1024 );
789     hb_get_tempory_directory( h, dirname );
790
791     hb_mkdir( dirname );
792
793     while( !h->die )
794     {
795         /* In case the check_update thread hangs, it'll die sooner or
796            later. Then, we join it here */
797         if( h->update_thread &&
798             hb_thread_has_exited( h->update_thread ) )
799         {
800             hb_thread_close( &h->update_thread );
801         }
802
803         /* Check if the scan thread is done */
804         if( h->scan_thread &&
805             hb_thread_has_exited( h->scan_thread ) )
806         {
807             hb_thread_close( &h->scan_thread );
808
809             hb_log( "libhb: scan thread found %d valid title(s)",
810                     hb_list_count( h->list_title ) );
811             hb_lock( h->state_lock );
812             h->state.state = HB_STATE_SCANDONE;
813             hb_unlock( h->state_lock );
814         }
815
816         /* Check if the work thread is done */
817         if( h->work_thread &&
818             hb_thread_has_exited( h->work_thread ) )
819         {
820             hb_thread_close( &h->work_thread );
821
822             hb_log( "libhb: work result = %d",
823                     h->work_error );
824             hb_lock( h->state_lock );
825             h->state.state                = HB_STATE_WORKDONE;
826             h->state.param.workdone.error = h->work_error;
827             hb_unlock( h->state_lock );
828         }
829
830         hb_snooze( 50 );
831     }
832
833     if( h->work_thread )
834     {
835         hb_stop( h );
836         hb_thread_close( &h->work_thread );
837     }
838
839     /* Remove temp folder */
840     dir = opendir( dirname );
841     while( ( entry = readdir( dir ) ) )
842     {
843         char filename[1024];
844         if( entry->d_name[0] == '.' )
845         {
846             continue;
847         }
848         memset( filename, 0, 1024 );
849         snprintf( filename, 1023, "%s/%s", dirname, entry->d_name );
850         unlink( filename );
851     }
852     closedir( dir );
853     rmdir( dirname );
854 }
855
856 /**
857  * Returns the PID.
858  * @param h Handle to hb_handle_t
859  */
860 int hb_get_pid( hb_handle_t * h )
861 {
862     return h->pid;
863 }
864
865 /**
866  * Sets the current state.
867  * @param h Handle to hb_handle_t
868  * @param s Handle to new hb_state_t
869  */
870 void hb_set_state( hb_handle_t * h, hb_state_t * s )
871 {
872     hb_lock( h->pause_lock );
873     hb_lock( h->state_lock );
874     memcpy( &h->state, s, sizeof( hb_state_t ) );
875     if( h->state.state == HB_STATE_WORKING )
876     {
877         /* XXX Hack */
878         h->state.param.working.job_cur =
879             h->job_count - hb_list_count( h->jobs );
880         h->state.param.working.job_count = h->job_count;
881     }
882     hb_unlock( h->state_lock );
883     hb_unlock( h->pause_lock );
884 }