1 /* $Id: render.c,v 1.17 2005/04/14 17:37:54 titer Exp $
3 This file is part of the HandBrake source code.
4 Homepage: <http://handbrake.fr/>.
5 It may be used under the terms of the GNU General Public License. */
10 struct hb_work_private_s
14 struct SwsContext * context;
16 AVPicture pic_tmp_crop;
17 AVPicture pic_tmp_out;
18 hb_buffer_t * buf_scale;
19 hb_fifo_t * subtitle_queue;
20 hb_fifo_t * delay_queue;
23 uint64_t last_start[4];
24 uint64_t last_stop[4];
25 uint64_t lost_time[4];
26 uint64_t total_lost_time;
27 uint64_t total_gained_time;
30 int count_frames; // frames output so far
31 double frame_rate; // 90KHz ticks per frame (for CFR/PFR)
32 double out_last_stop; // where last frame ended (for CFR/PFR)
33 int drops; // frames dropped (for CFR/PFR)
34 int dups; // frames duped (for CFR/PFR)
37 int renderInit( hb_work_object_t *, hb_job_t * );
38 int renderWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
39 void renderClose( hb_work_object_t * );
41 hb_work_object_t hb_render =
53 * Utility function that finds where the U is in the YUV sub-picture
55 * The Y data is at the top, followed by U and V, but the U and V
56 * are half the width of the Y, i.e. each chroma element covers 2x2
59 static uint8_t *getU(uint8_t *data, int width, int height, int x, int y)
61 return(&data[(y>>1) * ((width+1)>>1) + (x>>1) + width*height]);
64 static uint8_t *getV(uint8_t *data, int width, int height, int x, int y)
66 int w2 = (width+1) >> 1, h2 = (height+1) >> 1;
67 return(&data[(y>>1) * w2 + (x>>1) + width*height + w2*h2]);
70 // Draws the specified PICTURESUB subtitle on the specified video packet.
71 // Disposes the subtitle afterwards.
72 static void ApplySub( hb_job_t * job, hb_buffer_t * buf,
75 hb_buffer_t * sub = *_sub;
76 hb_title_t * title = job->title;
77 int i, j, offset_top, offset_left, margin_top, margin_percent;
78 uint8_t * lum, * alpha, * out, * sub_chromaU, * sub_chromaV;
81 * Percent of height of picture that form a margin that subtitles
82 * should not be displayed within.
92 * If necessary, move the subtitle so it is not in a cropped zone.
93 * When it won't fit, we center it so we lose as much on both ends.
94 * Otherwise we try to leave a 20px or 2% margin around it.
96 margin_top = ( ( title->height - job->crop[0] - job->crop[1] ) *
97 margin_percent ) / 100;
102 * A maximum margin of 20px regardless of height of the picture.
107 if( sub->height > title->height - job->crop[0] - job->crop[1] -
111 * The subtitle won't fit in the cropped zone, so center
112 * it vertically so we fit in as much as we can.
114 offset_top = job->crop[0] + ( title->height - job->crop[0] -
115 job->crop[1] - sub->height ) / 2;
117 else if( sub->y < job->crop[0] + margin_top )
120 * The subtitle fits in the cropped zone, but is currently positioned
121 * within our top margin, so move it outside of our margin.
123 offset_top = job->crop[0] + margin_top;
125 else if( sub->y > title->height - job->crop[1] - margin_top - sub->height )
128 * The subtitle fits in the cropped zone, and is not within the top
129 * margin but is within the bottom margin, so move it to be above
132 offset_top = title->height - job->crop[1] - margin_top - sub->height;
137 * The subtitle is fine where it is.
142 if( sub->width > title->width - job->crop[2] - job->crop[3] - 40 )
143 offset_left = job->crop[2] + ( title->width - job->crop[2] -
144 job->crop[3] - sub->width ) / 2;
145 else if( sub->x < job->crop[2] + 20 )
146 offset_left = job->crop[2] + 20;
147 else if( sub->x > title->width - job->crop[3] - 20 - sub->width )
148 offset_left = title->width - job->crop[3] - 20 - sub->width;
150 offset_left = sub->x;
153 alpha = lum + sub->width * sub->height;
154 sub_chromaU = alpha + sub->width * sub->height;
155 sub_chromaV = sub_chromaU + sub->width * sub->height;
157 out = buf->data + offset_top * title->width + offset_left;
159 for( i = 0; i < sub->height; i++ )
161 if( offset_top + i >= 0 && offset_top + i < title->height )
163 for( j = 0; j < sub->width; j++ )
165 if( offset_left + j >= 0 && offset_left + j < title->width )
167 uint8_t *chromaU, *chromaV;
170 * Merge the luminance and alpha with the picture
172 out[j] = ( (uint16_t) out[j] * ( 16 - (uint16_t) alpha[j] ) +
173 (uint16_t) lum[j] * (uint16_t) alpha[j] ) >> 4;
175 * Set the chroma (colour) based on whether there is
176 * any alpha at all. Don't try to blend with the picture.
178 chromaU = getU(buf->data, title->width, title->height,
179 offset_left+j, offset_top+i);
181 chromaV = getV(buf->data, title->width, title->height,
182 offset_left+j, offset_top+i);
187 * Add the chroma from the sub-picture, as this is
188 * not a transparent element.
190 *chromaU = sub_chromaU[j];
191 *chromaV = sub_chromaV[j];
199 sub_chromaU += sub->width;
200 sub_chromaV += sub->width;
204 hb_buffer_close( _sub );
207 // delete the buffer 'out' from the chain of buffers whose head is 'buf_out'.
208 // out & buf_out must be non-null (checks prior to anywhere this routine
209 // can be called guarantee this) and out must be on buf_out's chain
210 // (all places that call this get 'out' while traversing the chain).
211 // 'out' is freed and its predecessor is returned.
212 static hb_buffer_t *delete_buffer_from_chain( hb_buffer_t **buf_out, hb_buffer_t *out)
214 hb_buffer_t *succ = out->next;
215 hb_buffer_t *pred = *buf_out;
218 // we're deleting the first buffer
223 // target isn't the first buf so search for its predecessor.
224 while ( pred->next != out )
228 // found 'out' - remove it from the chain
232 hb_buffer_close( &out );
236 // insert buffer 'succ' after buffer chain element 'pred'.
237 // caller must guarantee that 'pred' and 'succ' are non-null.
238 static hb_buffer_t *insert_buffer_in_chain( hb_buffer_t *pred, hb_buffer_t *succ )
240 succ->next = pred->next;
245 // This section of the code implements video frame rate control.
246 // Since filters are allowed to duplicate and drop frames (which
247 // changes the timing), this has to be the last thing done in render.
249 // There are three options, selected by the value of job->cfr:
250 // 0 - Variable Frame Rate (VFR) or 'same as source': frame times
252 // 1 - Constant Frame Rate (CFR): Frame timings are adjusted so that all
253 // frames are exactly job->vrate_base ticks apart. Frames are dropped
254 // or duplicated if necessary to maintain this spacing.
255 // 2 - Peak Frame Rate (PFR): job->vrate_base is treated as the peak
256 // average frame rate. I.e., the average frame rate (current frame
257 // end time divided by number of frames so far) is never allowed to be
258 // greater than job->vrate_base and frames are dropped if necessary
259 // to keep the average under this value. Other than those drops, frame
260 // times are left alone.
263 static void adjust_frame_rate( hb_work_private_t *pv, hb_buffer_t **buf_out )
265 hb_buffer_t *out = *buf_out;
267 while ( out && out->size > 0 )
269 // this frame has to start where the last one stopped.
270 out->start = pv->out_last_stop;
272 // compute where this frame would stop if the frame rate were constant
273 // (this is our target stopping time for CFR and earliest possible
274 // stopping time for PFR).
275 double cfr_stop = pv->frame_rate * ( pv->count_frames + 1 );
277 if ( cfr_stop - (double)out->stop >= pv->frame_rate )
279 // This frame stops a frame time or more in the past - drop it
280 // but don't lose its chapter mark.
283 pv->chapter_time = out->start;
284 pv->chapter_val = out->new_chap;
287 out = delete_buffer_from_chain( buf_out, out );
291 // at this point we know that this frame doesn't push the average
292 // rate over the limit so we just pass it on for PFR. For CFR we're
293 // going to return it (with its start & stop times modified) and
294 // we may have to dup it.
296 if ( pv->job->cfr > 1 )
298 // PFR - we're going to keep the frame but may need to
299 // adjust it's stop time to meet the average rate constraint.
300 if ( out->stop <= cfr_stop )
302 out->stop = cfr_stop;
307 // we're doing CFR so we have to either trim some time from a
308 // buffer that ends too far in the future or, if the buffer is
309 // two or more frame times long, split it into multiple pieces,
310 // each of which is a frame time long.
311 double excess_dur = (double)out->stop - cfr_stop;
312 out->stop = cfr_stop;
313 for ( ; excess_dur >= pv->frame_rate; excess_dur -= cfr_stop )
315 /* next frame too far ahead - dup current frame */
316 hb_buffer_t *dup = hb_buffer_init( out->size );
317 memcpy( dup->data, out->data, out->size );
318 hb_buffer_copy_settings( dup, out );
320 dup->start = cfr_stop;
321 cfr_stop += pv->frame_rate;
322 dup->stop = cfr_stop;
323 out = insert_buffer_in_chain( out, dup );
328 pv->out_last_stop = out->stop;
333 int renderWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
334 hb_buffer_t ** buf_out )
336 hb_work_private_t * pv = w->private_data;
337 hb_job_t * job = pv->job;
338 hb_title_t * title = job->title;
339 hb_buffer_t * in = *buf_in, * buf_tmp_in = *buf_in;
340 hb_buffer_t * ivtc_buffer = NULL;
344 hb_buffer_t *head = NULL, *tail = NULL, *next;
347 /* If the input buffer is end of stream, send out an empty one
348 * to the next stage as well. To avoid losing the contents of
349 * the delay queue connect the buffers in the delay queue in
350 * the correct order, and add the end of stream buffer to the
353 while( ( next = hb_fifo_get( pv->delay_queue ) ) != NULL )
356 /* We can't use the given time stamps. Previous frames
357 might already have been extended, throwing off the
358 raw values fed to render.c. Instead, their
359 stop and start times are stored in arrays.
360 The 4th cached frame will be the to use.
361 If it needed its duration extended to make up
362 lost time, it will have happened above. */
363 next->start = pv->last_start[counter];
364 next->stop = pv->last_stop[counter--];
380 adjust_frame_rate( pv, buf_out );
390 * During the indepth_scan ditch the buffers here before applying filters or attempting to
393 if( job->indepth_scan )
399 /* Push subtitles onto queue just in case we need to delay a frame */
402 hb_fifo_push_list_element( pv->subtitle_queue, in->sub );
406 hb_fifo_push_list_element( pv->subtitle_queue, NULL );
409 /* If there's a chapter mark remember it in case we delay or drop its frame */
412 pv->chapter_time = in->start;
413 pv->chapter_val = in->new_chap;
417 /* Setup render buffer */
418 hb_buffer_t * buf_render = hb_video_buffer_init( job->width, job->height );
423 int filter_count = hb_list_count( job->filters );
426 for( i = 0; i < filter_count; i++ )
428 hb_filter_object_t * filter = hb_list_item( job->filters, i );
435 hb_buffer_t * buf_tmp_out = NULL;
437 int result = filter->work( buf_tmp_in,
442 filter->private_data );
445 * FILTER_OK: set temp buffer to filter buffer, continue
446 * FILTER_DELAY: set temp buffer to NULL, abort
447 * FILTER_DROP: set temp buffer to NULL, pop subtitle, abort
448 * FILTER_FAILED: leave temp buffer alone, continue
450 if( result == FILTER_OK )
452 buf_tmp_in = buf_tmp_out;
454 else if( result == FILTER_DELAY )
456 // Process the current frame later
461 else if( result == FILTER_DROP )
463 // Drop the current frame
465 /* We need to compensate for the time lost by dropping this frame.
466 Spread its duration out in quarters, because usually dropped frames
467 maintain a 1-out-of-5 pattern and this spreads it out amongst the remaining ones.
468 Store these in the lost_time array, which has 4 slots in it.
469 Because not every frame duration divides evenly by 4, and we can't lose the
470 remainder, we have to go through an awkward process to preserve it in the 4th array index. */
471 uint64_t temp_duration = buf_tmp_out->stop - buf_tmp_out->start;
472 pv->lost_time[0] += (temp_duration / 4);
473 pv->lost_time[1] += (temp_duration / 4);
474 pv->lost_time[2] += (temp_duration / 4);
475 pv->lost_time[3] += ( temp_duration - (temp_duration / 4) - (temp_duration / 4) - (temp_duration / 4) );
477 pv->total_lost_time += temp_duration;
478 pv->dropped_frames++;
480 /* Pop the frame's subtitle list and dispose of it. */
481 hb_buffer_t * sub_list = hb_fifo_get_list_element( pv->subtitle_queue );
483 hb_buffer_t * sub_next;
484 for ( sub = sub_list; sub; sub = sub_next )
486 sub_next = sub->next;
487 // XXX: Prevent hb_buffer_close from killing the whole list
488 // before we finish iterating over it
491 hb_buffer_t * subpicture_list = sub;
492 hb_buffer_t * subpicture;
493 hb_buffer_t * subpicture_next;
494 for ( subpicture = subpicture_list; subpicture; subpicture = subpicture_next )
496 subpicture_next = subpicture->next_subpicture;
498 hb_buffer_close( &subpicture );
510 /* Cache frame start and stop times, so we can renumber
511 time stamps if dropping frames for VFR. */
513 for( i = 3; i >= 1; i-- )
515 pv->last_start[i] = pv->last_start[i-1];
516 pv->last_stop[i] = pv->last_stop[i-1];
519 /* In order to make sure we have continuous time stamps, store
520 the current frame's duration as starting when the last one stopped. */
521 pv->last_start[0] = pv->last_stop[1];
522 pv->last_stop[0] = pv->last_start[0] + (buf_tmp_in->stop - buf_tmp_in->start);
525 /* Apply subtitles and dispose them */
528 hb_buffer_t * sub_list = hb_fifo_get_list_element( pv->subtitle_queue );
530 hb_buffer_t * sub_next;
531 for ( sub = sub_list; sub; sub = sub_next )
533 sub_next = sub->next;
534 // XXX: Prevent hb_buffer_close inside ApplySub from killing the whole list
535 // before we finish iterating over it
538 hb_buffer_t * subpicture_list = sub;
539 hb_buffer_t * subpicture;
540 hb_buffer_t * subpicture_next;
541 for ( subpicture = subpicture_list; subpicture; subpicture = subpicture_next )
543 subpicture_next = subpicture->next_subpicture;
545 ApplySub( job, buf_tmp_in, &subpicture );
550 /* Apply crop/scale if specified */
551 if( buf_tmp_in && pv->context )
553 avpicture_fill( &pv->pic_tmp_in, buf_tmp_in->data,
555 title->width, title->height );
557 avpicture_fill( &pv->pic_tmp_out, buf_render->data,
559 job->width, job->height );
561 // Crop; this alters the pointer to the data to point to the correct place for cropped frame
562 av_picture_crop( &pv->pic_tmp_crop, &pv->pic_tmp_in, PIX_FMT_YUV420P,
563 job->crop[0], job->crop[2] );
565 // Scale pic_crop into pic_render according to the context set up in renderInit
566 sws_scale(pv->context,
567 pv->pic_tmp_crop.data, pv->pic_tmp_crop.linesize,
568 0, title->height - (job->crop[0] + job->crop[1]),
569 pv->pic_tmp_out.data, pv->pic_tmp_out.linesize);
571 hb_buffer_copy_settings( buf_render, buf_tmp_in );
573 buf_tmp_in = buf_render;
576 /* Set output to render buffer */
577 (*buf_out) = buf_render;
579 if( buf_tmp_in == NULL )
581 /* Teardown and cleanup buffers if we are emitting NULL */
582 if( buf_in && *buf_in )
584 hb_buffer_close( buf_in );
587 if( buf_out && *buf_out )
589 hb_buffer_close( buf_out );
593 else if( buf_tmp_in != buf_render )
595 /* Copy temporary results and settings into render buffer */
596 memcpy( buf_render->data, buf_tmp_in->data, buf_render->size );
597 hb_buffer_copy_settings( buf_render, buf_tmp_in );
602 hb_fifo_push( pv->delay_queue, *buf_out );
607 * Keep the last three frames in our queue, this ensures that we have the last
608 * two always in there should we need to rewrite the durations on them.
611 if( hb_fifo_size( pv->delay_queue ) >= 4 )
613 *buf_out = hb_fifo_get( pv->delay_queue );
618 /* The current frame exists. That means it hasn't been dropped by a filter.
619 Make it accessible as ivtc_buffer so we can edit its duration if needed. */
620 ivtc_buffer = *buf_out;
622 if( pv->lost_time[3] > 0 )
625 * A frame's been dropped earlier by VFR detelecine.
626 * Gotta make up the lost time. This will also
627 * slow down the video.
628 * The dropped frame's has to be accounted for, so
629 * divvy it up amongst the 4 frames left behind.
630 * This is what the delay_queue is for;
631 * telecined sequences start 2 frames before
632 * the dropped frame, so to slow down the right
633 * ones you need a 2 frame delay between
634 * reading input and writing output.
637 /* We want to extend the outputted frame's duration by the value
638 stored in the 4th slot of the lost_time array. Because we need
639 to adjust all the values in the array so they're contiguous,
640 extend the duration inside the array first, before applying
641 it to the current frame buffer. */
642 pv->last_stop[3] += pv->lost_time[3];
644 /* Log how much time has been added back in to the video. */
645 pv->total_gained_time += pv->lost_time[3];
647 /* We've pulled the 4th value from the lost_time array
648 and added it to the last_stop array's 4th slot. Now, rotate the
649 lost_time array so the 4th slot now holds the 3rd's value, and
650 so on down the line, and set the 0 index to a value of 0. */
652 for( i=2; i >= 0; i--)
654 pv->lost_time[i+1] = pv->lost_time[i];
656 pv->lost_time[0] = 0;
658 /* Log how many frames have had their durations extended. */
659 pv->extended_frames++;
662 /* We can't use the given time stamps. Previous frames
663 might already have been extended, throwing off the
664 raw values fed to render.c. Instead, their
665 stop and start times are stored in arrays.
666 The 4th cached frame will be the to use.
667 If it needed its duration extended to make up
668 lost time, it will have happened above. */
669 ivtc_buffer->start = pv->last_start[3];
670 ivtc_buffer->stop = pv->last_stop[3];
672 /* Set the 3rd cached frame to start when this one stops,
673 and so on down the line. If any of them need to be
674 extended as well to make up lost time, it'll be handled
675 on the next loop through the renderer. */
677 for (i = 2; i >= 0; i--)
679 int temp_duration = pv->last_stop[i] - pv->last_start[i];
680 pv->last_start[i] = pv->last_stop[i+1];
681 pv->last_stop[i] = pv->last_start[i] + temp_duration;
684 /* If we have a pending chapter mark and this frame is at
685 or after the time of the mark, mark this frame & clear
687 if( pv->chapter_time && pv->chapter_time <= ivtc_buffer->start )
689 ivtc_buffer->new_chap = pv->chapter_val;
690 pv->chapter_time = 0;
695 if ( buf_out && *buf_out && job->cfr )
697 adjust_frame_rate( pv, buf_out );
702 void renderClose( hb_work_object_t * w )
704 hb_work_private_t * pv = w->private_data;
708 hb_log("render: %d frames output, %d dropped and %d duped for CFR/PFR",
709 pv->count_frames, pv->drops, pv->dups );
712 hb_interjob_t * interjob = hb_interjob_get( w->private_data->job->h );
714 /* Preserve dropped frame count for more accurate framerates in 2nd passes. */
715 interjob->render_dropped = pv->dropped_frames;
717 hb_log("render: lost time: %"PRId64" (%i frames)", pv->total_lost_time, pv->dropped_frames);
718 hb_log("render: gained time: %"PRId64" (%i frames) (%"PRId64" not accounted for)", pv->total_gained_time, pv->extended_frames, pv->total_lost_time - pv->total_gained_time);
719 if (pv->dropped_frames)
720 hb_log("render: average dropped frame duration: %"PRId64, (pv->total_lost_time / pv->dropped_frames) );
722 /* Cleanup subtitle queue */
723 if( pv->subtitle_queue )
725 hb_fifo_close( &pv->subtitle_queue );
728 if( pv->delay_queue )
730 hb_fifo_close( &pv->delay_queue );
733 /* Cleanup render work structure */
735 w->private_data = NULL;
738 int renderInit( hb_work_object_t * w, hb_job_t * job )
740 /* Allocate new private work object */
741 hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
743 w->private_data = pv;
746 swsflags = SWS_LANCZOS | SWS_ACCURATE_RND;
748 /* Get title and title size */
749 hb_title_t * title = job->title;
751 /* If crop or scale is specified, setup rescale context */
752 if( job->crop[0] || job->crop[1] || job->crop[2] || job->crop[3] ||
753 job->width != title->width || job->height != title->height )
755 pv->context = hb_sws_get_context(title->width - (job->crop[2] + job->crop[3]),
756 title->height - (job->crop[0] + job->crop[1]),
758 job->width, job->height, PIX_FMT_YUV420P,
762 /* Setup FIFO queue for subtitle cache */
763 pv->subtitle_queue = hb_fifo_init( 8, 1 );
764 pv->delay_queue = hb_fifo_init( 8, 1 );
766 /* VFR IVTC needs a bunch of time-keeping variables to track
767 how many frames are dropped, how many are extended, what the
768 last 4 start and stop times were (so they can be modified),
769 how much time has been lost and gained overall, how much time
770 the latest 4 frames should be extended by, and where chapter
771 markers are (so they can be saved if their frames are dropped.) */
772 pv->dropped_frames = 0;
773 pv->extended_frames = 0;
774 pv->last_start[0] = 0;
775 pv->last_stop[0] = 0;
776 pv->total_lost_time = 0;
777 pv->total_gained_time = 0;
778 pv->lost_time[0] = 0; pv->lost_time[1] = 0; pv->lost_time[2] = 0; pv->lost_time[3] = 0;
779 pv->chapter_time = 0;
782 pv->frame_rate = (double)job->vrate_base * (1./300.);
785 /* TODO: Move to work.c? */
788 int filter_count = hb_list_count( job->filters );
791 for( i = 0; i < filter_count; i++ )
793 hb_filter_object_t * filter = hb_list_item( job->filters, i );
795 if( !filter ) continue;
797 filter->private_data = filter->init( PIX_FMT_YUV420P,