OSDN Git Service

MacGui: Make Debug window non editable.
[handbrake-jp/handbrake-jp-git.git] / libhb / work.c
1 /* $Id: work.c,v 1.43 2005/03/17 16:38:49 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 #include "a52dec/a52.h"
9 #include "dca.h"
10
11 typedef struct
12 {
13     hb_list_t * jobs;
14     int         cpu_count;
15     int       * error;
16     volatile int * die;
17
18 } hb_work_t;
19
20 static void work_func();
21 static void do_job( hb_job_t *, int cpu_count );
22 static void work_loop( void * );
23
24 /**
25  * Allocates work object and launches work thread with work_func.
26  * @param jobs Handle to hb_list_t.
27  * @param cpu_count Humber of CPUs found in system.
28  * @param die Handle to user inititated exit indicator.
29  * @param error Handle to error indicator.
30  */
31 hb_thread_t * hb_work_init( hb_list_t * jobs, int cpu_count,
32                             volatile int * die, int * error )
33 {
34     hb_work_t * work = calloc( sizeof( hb_work_t ), 1 );
35
36     work->jobs      = jobs;
37     work->cpu_count = cpu_count;
38     work->die       = die;
39     work->error     = error;
40
41     return hb_thread_init( "work", work_func, work, HB_LOW_PRIORITY );
42 }
43
44 /**
45  * Iterates through job list and calls do_job for each job.
46  * @param _work Handle work object.
47  */
48 static void work_func( void * _work )
49 {
50     hb_work_t  * work = _work;
51     hb_job_t   * job;
52
53     hb_log( "%d job(s) to process", hb_list_count( work->jobs ) );
54
55     while( !*work->die && ( job = hb_list_item( work->jobs, 0 ) ) )
56     {
57         hb_list_rem( work->jobs, job );
58         job->die = work->die;
59         do_job( job, work->cpu_count );
60     }
61
62     *(work->error) = HB_ERROR_NONE;
63
64     free( work );
65 }
66
67 static hb_work_object_t * getWork( int id )
68 {
69     hb_work_object_t * w;
70     for( w = hb_objects; w; w = w->next )
71     {
72         if( w->id == id )
73         {
74             return w;
75         }
76     }
77     return NULL;
78 }
79
80 /**
81  * Job initialization rountine.
82  * Initializes fifos.
83  * Creates work objects for synchronizer, video decoder, video renderer, video decoder, audio decoder, audio encoder, reader, muxer.
84  * Launches thread for each work object with work_loop.
85  * Loops while monitoring status of work threads and fifos.
86  * Exits loop when conversion is done and fifos are empty.
87  * Closes threads and frees fifos.
88  * @param job Handle work hb_job_t.
89  * @param cpu_count number of CPUs found in system.
90  */
91 static void do_job( hb_job_t * job, int cpu_count )
92 {
93     hb_title_t    * title;
94     int             i, j;
95     hb_work_object_t * w;
96     
97     /* FIXME: This feels really hackish, anything better? */
98     hb_work_object_t * audio_w = NULL;
99
100     hb_audio_t   * audio;
101     hb_subtitle_t * subtitle;
102     int done;
103
104     title = job->title;
105
106     job->list_work = hb_list_init();
107
108     hb_log( "starting job" );
109     hb_log( " + device %s", title->dvd );
110     hb_log( " + title %d, chapter(s) %d to %d", title->index,
111             job->chapter_start, job->chapter_end );
112     if ( job->pixel_ratio == 1 )
113     {
114         /* Correct the geometry of the output movie when using PixelRatio */
115         job->height=title->height-job->crop[0]-job->crop[1];
116         job->width=title->width-job->crop[2]-job->crop[3];
117     }
118
119         /* Keep width and height within these boundaries */
120         if (job->maxHeight && (job->height > job->maxHeight) )
121         {
122                 job->height = job->maxHeight;
123                 hb_fix_aspect( job, HB_KEEP_HEIGHT );
124                 hb_log("Height out of bounds, scaling down to %i", job->maxHeight);
125                 hb_log("New dimensions %i * %i", job->width, job->height);
126         }
127         if (job->maxWidth && (job->width > job->maxWidth) )
128         {
129                 job->width = job->maxWidth;
130                 hb_fix_aspect( job, HB_KEEP_WIDTH );   
131                 hb_log("Width out of bounds, scaling down to %i", job->maxWidth);
132                 hb_log("New dimensions %i * %i", job->width, job->height);
133         }
134
135     hb_log( " + %dx%d -> %dx%d, crop %d/%d/%d/%d",
136             title->width, title->height, job->width, job->height,
137             job->crop[0], job->crop[1], job->crop[2], job->crop[3] );
138     hb_log( " + deinterlace %s", job->deinterlace ? "on" : "off" );
139     hb_log( " + grayscale %s", job->grayscale ? "on" : "off" );
140     if( job->vquality >= 0.0 && job->vquality <= 1.0 )
141     {
142         hb_log( " + %.3f fps, video quality %.2f", (float) job->vrate /
143                 (float) job->vrate_base, job->vquality );
144     }
145     else
146     {
147         hb_log( " + %.3f fps, video bitrate %d kbps, pass %d",
148                 (float) job->vrate / (float) job->vrate_base,
149                 job->vbitrate, job->pass );
150     }
151         hb_log (" + PixelRatio: %d, width:%d, height: %d",job->pixel_ratio,job->width, job->height);
152     job->fifo_mpeg2  = hb_fifo_init( 2048 );
153     job->fifo_raw    = hb_fifo_init( 8 );
154     job->fifo_sync   = hb_fifo_init( 8 );
155     job->fifo_render = hb_fifo_init( 8 );
156     job->fifo_mpeg4  = hb_fifo_init( 8 );
157
158     /* Synchronization */
159     hb_list_add( job->list_work, ( w = getWork( WORK_SYNC ) ) );
160     w->fifo_in  = NULL;
161     w->fifo_out = NULL;
162
163     /* Video decoder */
164     hb_list_add( job->list_work, ( w = getWork( WORK_DECMPEG2 ) ) );
165     w->fifo_in  = job->fifo_mpeg2;
166     w->fifo_out = job->fifo_raw;
167
168     /* Video renderer */
169     hb_list_add( job->list_work, ( w = getWork( WORK_RENDER ) ) );
170     w->fifo_in  = job->fifo_sync;
171     w->fifo_out = job->fifo_render;
172
173     /* Video encoder */
174     switch( job->vcodec )
175     {
176         case HB_VCODEC_FFMPEG:
177             hb_log( " + encoder FFmpeg" );
178             w = getWork( WORK_ENCAVCODEC );
179             break;
180         case HB_VCODEC_XVID:
181             hb_log( " + encoder XviD" );
182             w = getWork( WORK_ENCXVID );
183             break;
184         case HB_VCODEC_X264:
185             hb_log( " + encoder x264" );
186             w = getWork( WORK_ENCX264 );
187             break;
188     }
189     w->fifo_in  = job->fifo_render;
190     w->fifo_out = job->fifo_mpeg4;
191     w->config   = &job->config;
192     hb_list_add( job->list_work, w );
193
194     subtitle = hb_list_item( title->list_subtitle, 0 );
195     if( subtitle )
196     {
197         hb_log( " + subtitle %x, %s", subtitle->id, subtitle->lang );
198
199         subtitle->fifo_in  = hb_fifo_init( 8 );
200         subtitle->fifo_raw = hb_fifo_init( 8 );
201
202         hb_list_add( job->list_work, ( w = getWork( WORK_DECSUB ) ) );
203         w->fifo_in  = subtitle->fifo_in;
204         w->fifo_out = subtitle->fifo_raw;
205     }
206
207     if( job->acodec & HB_ACODEC_AC3 )
208     {
209         hb_log( " + audio AC3 passthrough" );
210     }
211     else
212     {
213         hb_log( " + audio %d kbps, %d Hz", job->abitrate, job->arate );
214         hb_log( " + encoder %s", ( job->acodec & HB_ACODEC_FAAC ) ?
215                 "faac" : ( ( job->acodec & HB_ACODEC_LAME ) ? "lame" :
216                 "vorbis" ) );
217     }
218
219     /* if we are doing AC3 passthru, then remove any non-AC3 audios from the job */
220     /* otherwise, Bad Things will happen */
221     for( i = 0; i < hb_list_count( title->list_audio ); )
222     {
223         audio = hb_list_item( title->list_audio, i );
224         if( ( job->acodec & HB_ACODEC_AC3 ) && ( audio->codec != HB_ACODEC_AC3 ) )
225         {
226             hb_list_rem( title->list_audio, audio );
227             free( audio );
228             continue;
229         }
230         i++;
231     }
232
233     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
234     {
235         audio = hb_list_item( title->list_audio, i );
236         hb_log( "   + %x, %s", audio->id, audio->lang );
237                         
238                 /* sense-check the current mixdown options */
239
240                 /* log the requested mixdown */
241                 for (j = 0; j < hb_audio_mixdowns_count; j++) {
242                         if (hb_audio_mixdowns[j].amixdown == job->audio_mixdowns[i]) {
243                                 hb_log( "     + Requested mixdown: %s (%s)", hb_audio_mixdowns[j].human_readable_name, hb_audio_mixdowns[j].internal_name );
244                                 break;
245                         }
246                 }
247
248         /* sense-check the requested mixdown */
249
250         /* audioCodecsSupportMono and audioCodecsSupport6Ch are the same for now,
251            but this may change in the future, so they are separated for flexibility */
252         int audioCodecsSupportMono = ((audio->codec == HB_ACODEC_AC3 ||
253             audio->codec == HB_ACODEC_DCA) && job->acodec == HB_ACODEC_FAAC);
254         int audioCodecsSupport6Ch =  ((audio->codec == HB_ACODEC_AC3 ||
255             audio->codec == HB_ACODEC_DCA) && job->acodec == HB_ACODEC_FAAC);
256
257         /* find out what the format of our source audio is */
258         switch (audio->input_channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK) {
259         
260             /* mono sources */
261             case HB_INPUT_CH_LAYOUT_MONO:
262                 /* regardless of what stereo mixdown we've requested, a mono source always get mixed down
263                 to mono if we can, and mixed up to stereo if we can't */
264                 if (job->audio_mixdowns[i] == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 1) {
265                     job->audio_mixdowns[i] = HB_AMIXDOWN_MONO;
266                 } else {
267                     job->audio_mixdowns[i] = HB_AMIXDOWN_STEREO;
268                 }
269                 break;
270
271             /* stereo input */
272             case HB_INPUT_CH_LAYOUT_STEREO:
273                 /* if we've requested a mono mixdown, and it is supported, then do the mix */
274                 /* use stereo if not supported */
275                 if (job->audio_mixdowns[i] == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
276                     job->audio_mixdowns[i] = HB_AMIXDOWN_STEREO;
277                 /* otherwise, preserve stereo regardless of if we requested something higher */
278                 } else if (job->audio_mixdowns[i] > HB_AMIXDOWN_STEREO) {
279                     job->audio_mixdowns[i] = HB_AMIXDOWN_STEREO;
280                 }
281                 break;
282
283             /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */
284             /* the A52 flags don't allow for a way to distinguish between DPL1 and DPL2 on a DVD,
285                so we always assume a DPL1 source for A52_DOLBY */
286             case HB_INPUT_CH_LAYOUT_DOLBY:
287                 /* if we've requested a mono mixdown, and it is supported, then do the mix */
288                 /* preserve dolby if not supported */
289                 if (job->audio_mixdowns[i] == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
290                     job->audio_mixdowns[i] = HB_AMIXDOWN_DOLBY;
291                 /* otherwise, preserve dolby even if we requested something higher */
292                 /* a stereo mixdown will still be honoured here */
293                 } else if (job->audio_mixdowns[i] > HB_AMIXDOWN_DOLBY) {
294                     job->audio_mixdowns[i] = HB_AMIXDOWN_DOLBY;
295                 }
296                 break;
297
298             /* 3F/2R input */
299             case HB_INPUT_CH_LAYOUT_3F2R:
300                 /* if we've requested a mono mixdown, and it is supported, then do the mix */
301                 /* use dpl2 if not supported */
302                 if (job->audio_mixdowns[i] == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
303                     job->audio_mixdowns[i] = HB_AMIXDOWN_DOLBYPLII;
304                 } else {
305                     /* check if we have 3F2R input and also have an LFE - i.e. we have a 5.1 source) */
306                     if (audio->input_channel_layout & HB_INPUT_CH_LAYOUT_HAS_LFE) {
307                         /* we have a 5.1 source */
308                         /* if we requested 6ch, but our audio format doesn't support it, then mix to DPLII instead */
309                         if (job->audio_mixdowns[i] == HB_AMIXDOWN_6CH && audioCodecsSupport6Ch == 0) {
310                             job->audio_mixdowns[i] = HB_AMIXDOWN_DOLBYPLII;
311                         }
312                     } else {
313                         /* we have a 5.0 source, so we can't do 6ch conversion
314                         default to DPL II instead */
315                         if (job->audio_mixdowns[i] > HB_AMIXDOWN_DOLBYPLII) {
316                             job->audio_mixdowns[i] = HB_AMIXDOWN_DOLBYPLII;
317                         }
318                     }
319                 }
320                 /* all other mixdowns will have been preserved here */
321                 break;
322
323             /* 3F/1R input */
324             case HB_INPUT_CH_LAYOUT_3F1R:
325                 /* if we've requested a mono mixdown, and it is supported, then do the mix */
326                 /* use dpl1 if not supported */
327                 if (job->audio_mixdowns[i] == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
328                     job->audio_mixdowns[i] = HB_AMIXDOWN_DOLBY;
329                 } else {
330                     /* we have a 4.0 or 4.1 source, so we can't do DPLII or 6ch conversion
331                     default to DPL I instead */
332                     if (job->audio_mixdowns[i] > HB_AMIXDOWN_DOLBY) {
333                         job->audio_mixdowns[i] = HB_AMIXDOWN_DOLBY;
334                     }
335                 }
336                 /* all other mixdowns will have been preserved here */
337                 break;
338
339             default:
340                 /* if we've requested a mono mixdown, and it is supported, then do the mix */
341                 if (job->audio_mixdowns[i] == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 1) {
342                     job->audio_mixdowns[i] = HB_AMIXDOWN_MONO;
343                 /* mix everything else down to stereo */
344                 } else {
345                     job->audio_mixdowns[i] = HB_AMIXDOWN_STEREO;
346                 }
347
348         }
349
350                 /* log the output mixdown */
351                 for (j = 0; j < hb_audio_mixdowns_count; j++) {
352                         if (hb_audio_mixdowns[j].amixdown == job->audio_mixdowns[i]) {
353                                 hb_log( "     + Actual mixdown: %s (%s)", hb_audio_mixdowns[j].human_readable_name, hb_audio_mixdowns[j].internal_name );
354                                 break;
355                         }
356                 }
357
358                 /* we now know we have a valid mixdown for the input source and the audio output format */
359                 /* remember the mixdown for this track */
360                 audio->amixdown = job->audio_mixdowns[i];
361
362         audio->config.vorbis.language = audio->lang_simple;
363
364                 /* set up the audio work structures */
365         audio->fifo_in   = hb_fifo_init( 2048 );
366         audio->fifo_raw  = hb_fifo_init( 8 );
367         audio->fifo_sync = hb_fifo_init( 8 );
368         audio->fifo_out  = hb_fifo_init( 8 );
369
370         switch( audio->codec )
371         {
372             case HB_ACODEC_AC3:
373                 w = getWork( WORK_DECA52 );
374                 break;
375             case HB_ACODEC_DCA:
376                 w = getWork( WORK_DECDCA );
377                 break;
378             case HB_ACODEC_MPGA:
379                 w = getWork( WORK_DECAVCODEC );
380                 break;
381             case HB_ACODEC_LPCM:
382                 w = getWork( WORK_DECLPCM );
383                 break;
384         }
385         w->fifo_in       = audio->fifo_in;
386         w->fifo_out      = audio->fifo_raw;
387         w->config        = &audio->config;
388         w->amixdown      = audio->amixdown;
389         w->source_acodec = audio->codec;
390         
391         /* FIXME: This feels really hackish, anything better? */
392         audio_w = calloc( sizeof( hb_work_object_t ), 1 );
393         audio_w = memcpy( audio_w, w, sizeof( hb_work_object_t ));
394         
395         hb_list_add( job->list_work, audio_w );
396
397         switch( job->acodec )
398         {
399             case HB_ACODEC_FAAC:
400                 w = getWork( WORK_ENCFAAC );
401                 break;
402             case HB_ACODEC_LAME:
403                 w = getWork( WORK_ENCLAME );
404                 break;
405             case HB_ACODEC_VORBIS:
406                 w = getWork( WORK_ENCVORBIS );
407                 break;
408         }
409
410         if( job->acodec != HB_ACODEC_AC3 )
411         {
412             w->fifo_in       = audio->fifo_sync;
413             w->fifo_out      = audio->fifo_out;
414             w->config        = &audio->config;
415             w->amixdown      = audio->amixdown;
416             w->source_acodec = audio->codec;
417             
418             /* FIXME: This feels really hackish, anything better? */
419             audio_w = calloc( sizeof( hb_work_object_t ), 1 );
420             audio_w = memcpy( audio_w, w, sizeof( hb_work_object_t ));
421         
422             hb_list_add( job->list_work, audio_w );
423         }
424
425
426     }
427
428     /* Init read & write threads */
429     job->reader = hb_reader_init( job );
430
431     hb_log( " + output: %s", job->file );
432     job->muxer = hb_muxer_init( job );
433
434     job->done = 0;
435
436     /* Launch processing threads */
437     for( i = 1; i < hb_list_count( job->list_work ); i++ )
438     {
439         w = hb_list_item( job->list_work, i );
440         w->done = &job->done;
441                 w->thread_sleep_interval = 10;
442         w->init( w, job );
443         w->thread = hb_thread_init( w->name, work_loop, w,
444                                     HB_LOW_PRIORITY );
445     }
446
447     done = 0;
448     w = hb_list_item( job->list_work, 0 );
449         w->thread_sleep_interval = 50;
450     w->init( w, job );
451     while( !*job->die )
452     {
453         if( w->work( w, NULL, NULL ) == HB_WORK_DONE )
454         {
455             done = 1;
456         }
457         if( done &&
458             !hb_fifo_size( job->fifo_sync ) &&
459             !hb_fifo_size( job->fifo_render ) &&
460             !hb_fifo_size( job->fifo_mpeg4 ) )
461         {
462             break;
463         }
464         hb_snooze( w->thread_sleep_interval );
465     }
466     hb_list_rem( job->list_work, w );
467     w->close( w );
468     job->done = 1;
469
470     /* Close work objects */
471     while( ( w = hb_list_item( job->list_work, 0 ) ) )
472     {
473         hb_list_rem( job->list_work, w );
474         hb_thread_close( &w->thread );
475         w->close( w );
476         
477         /* FIXME: This feels really hackish, anything better? */
478         if ( w->id == WORK_DECA52 ||
479              w->id == WORK_DECDCA ||
480              w->id == WORK_DECLPCM ||
481              w->id == WORK_ENCFAAC ||
482              w->id == WORK_ENCLAME ||
483              w->id == WORK_ENCVORBIS )
484         {
485             free( w );
486             w = NULL;
487         }
488     }
489     
490     hb_list_close( &job->list_work );
491
492     /* Stop read & write threads */
493     hb_thread_close( &job->reader );
494     hb_thread_close( &job->muxer );
495
496     /* Close fifos */
497     hb_fifo_close( &job->fifo_mpeg2 );
498     hb_fifo_close( &job->fifo_raw );
499     hb_fifo_close( &job->fifo_sync );
500     hb_fifo_close( &job->fifo_render );
501     hb_fifo_close( &job->fifo_mpeg4 );
502     if( subtitle )
503     {
504         hb_fifo_close( &subtitle->fifo_in );
505         hb_fifo_close( &subtitle->fifo_raw );
506     }
507     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
508     {
509         audio = hb_list_item( title->list_audio, i );
510         hb_fifo_close( &audio->fifo_in );
511         hb_fifo_close( &audio->fifo_raw );
512         hb_fifo_close( &audio->fifo_sync );
513         hb_fifo_close( &audio->fifo_out );
514     }
515     
516     hb_title_close( &job->title );
517     free( job );
518 }
519
520 /**
521  * Performs the work objects specific work function.
522  * Loops calling work function for associated work object. Sleeps when fifo is full.
523  * Monitors work done indicator.
524  * Exits loop when work indiactor is set.
525  * @param _w Handle to work object.
526  */
527 static void work_loop( void * _w )
528 {
529     hb_work_object_t * w = _w;
530     hb_buffer_t      * buf_in, * buf_out;
531
532     while( !*w->done )
533     {
534 #if 0
535         hb_lock( job->pause );
536         hb_unlock( job->pause );
537 #endif
538         if( hb_fifo_is_full( w->fifo_out ) ||
539 //        if( (hb_fifo_percent_full( w->fifo_out ) > 0.8) ||
540             !( buf_in = hb_fifo_get( w->fifo_in ) ) )
541         {
542             hb_snooze( w->thread_sleep_interval );
543 //                      w->thread_sleep_interval += 1;
544             continue;
545         }
546 //              w->thread_sleep_interval = MAX(1, (w->thread_sleep_interval - 1));
547
548         w->work( w, &buf_in, &buf_out );
549
550         // Propogate any chapter breaks for the worker
551         if( buf_in && buf_out && buf_in->new_chap )
552         {
553             printf("WORK: Copying Chapter Break\n");
554             buf_out->new_chap = 1;
555         }
556         
557         if( buf_in )
558         {
559             hb_buffer_close( &buf_in );
560         }
561         if( buf_out )
562         {
563             hb_fifo_push( w->fifo_out, buf_out );
564         }
565     }
566 }