1
2 #ifdef HAVE_CONFIG_H
3 #include "config.h"
4 #endif
5 #include <schroedinger/schro.h>
6
7 #include <math.h>
8
9 int schro_engine_get_scene_change_score (SchroEncoder * encoder, int i);
10 void schro_encoder_calculate_allocation (SchroEncoderFrame * frame);
11
12 /**
13 * schro_engine_check_new_sequence_header:
14 * @encoder: encoder
15 * @frame: encoder frame
16 *
17 * Checks if the current picture should be the start of a new access
18 * unit.
19 */
20 static void
schro_engine_check_new_sequence_header(SchroEncoder * encoder,SchroEncoderFrame * frame)21 schro_engine_check_new_sequence_header (SchroEncoder * encoder,
22 SchroEncoderFrame * frame)
23 {
24 if (encoder->force_sequence_header ||
25 frame->frame_number >= encoder->au_frame + encoder->au_distance) {
26 frame->start_sequence_header = TRUE;
27 encoder->au_frame = frame->frame_number;
28 encoder->force_sequence_header = FALSE;
29 }
30 }
31
32 /**
33 * schro_engine_code_picture:
34 * @frame: encoder frame
35 * @is_ref:
36 * @retire:
37 * @num_refs:
38 * @ref0:
39 * @ref1:
40 *
41 * Used to set coding order and coding parameters for a picture.
42 */
43 static void
schro_engine_code_picture(SchroEncoderFrame * frame,int is_ref,int retire,int num_refs,int ref0,int ref1)44 schro_engine_code_picture (SchroEncoderFrame * frame,
45 int is_ref, int retire, int num_refs, int ref0, int ref1)
46 {
47 SchroEncoder *encoder = frame->encoder;
48
49 SCHRO_DEBUG
50 ("preparing %d as is_ref=%d retire=%d num_refs=%d ref0=%d ref1=%d",
51 frame->frame_number, is_ref, retire, num_refs, ref0, ref1);
52
53 frame->is_ref = is_ref;
54 frame->retired_picture_number = retire;
55 frame->num_refs = num_refs;
56 frame->picture_number_ref[0] = ref0;
57 frame->picture_number_ref[1] = ref1;
58
59 frame->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_GOP].is_done = TRUE;
60 frame->slot = encoder->next_slot++;
61
62 if (num_refs > 0) {
63 SCHRO_ASSERT (ref0 >= encoder->au_frame);
64 frame->ref_frame[0] = schro_encoder_reference_get (encoder, ref0);
65 SCHRO_ASSERT (frame->ref_frame[0]);
66 schro_encoder_frame_ref (frame->ref_frame[0]);
67 }
68 if (num_refs > 1) {
69 SCHRO_ASSERT (ref0 >= encoder->au_frame);
70 frame->ref_frame[1] = schro_encoder_reference_get (encoder, ref1);
71 SCHRO_ASSERT (frame->ref_frame[1]);
72 schro_encoder_frame_ref (frame->ref_frame[1]);
73 }
74 if (is_ref) {
75 int i;
76 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
77 if (encoder->reference_pictures[i] == NULL)
78 break;
79 if (encoder->reference_pictures[i]->frame_number == retire) {
80 schro_encoder_frame_unref (encoder->reference_pictures[i]);
81 encoder->reference_pictures[i] = NULL;
82 break;
83 }
84 }
85 SCHRO_ASSERT (i < SCHRO_LIMIT_REFERENCE_FRAMES);
86 encoder->reference_pictures[i] = frame;
87 schro_encoder_frame_ref (frame);
88 }
89 }
90
91 static int
subgroup_ready(SchroQueue * queue,int index,int subgroup_length,SchroEncoderFrameStateEnum gop_state)92 subgroup_ready (SchroQueue * queue, int index, int subgroup_length,
93 SchroEncoderFrameStateEnum gop_state)
94 {
95 size_t i = index;
96 SchroEncoderFrame *f;
97
98 for (; index + subgroup_length > i; ++i) {
99 f = queue->elements[i].data;
100 SCHRO_ASSERT (!f->stages[gop_state].is_done);
101 if (!f->stages[gop_state - 1].is_done) {
102 return 0;
103 }
104 }
105 return 1;
106 }
107
108 /**
109 * schro_engine_code_intra_bailout_picture:
110 * @frame:
111 *
112 * Sets up coding parameters for encoding as a completely independent
113 * non-ref intra picture.
114 */
115 #if 0
116 static void
117 schro_engine_code_intra (SchroEncoderFrame * frame, double weight)
118 {
119 schro_engine_code_picture (frame, FALSE, -1, 0, -1, -1);
120 frame->presentation_frame = frame->frame_number;
121 frame->picture_weight = weight;
122 frame->gop_length = 1;
123 }
124 #endif
125
126 static void
schro_encoder_pick_refs(SchroEncoderFrame * frame,SchroPictureNumber * ptr_ref0,SchroPictureNumber * ptr_ref1)127 schro_encoder_pick_refs (SchroEncoderFrame * frame,
128 SchroPictureNumber * ptr_ref0, SchroPictureNumber * ptr_ref1)
129 {
130 SchroEncoder *encoder = frame->encoder;
131 SchroPictureNumber ref0;
132 SchroPictureNumber ref1;
133 int i;
134
135 ref0 = SCHRO_PICTURE_NUMBER_INVALID;
136 /* pick the most recent back ref */
137 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
138 if (encoder->reference_pictures[i] == NULL)
139 continue;
140 if (encoder->reference_pictures[i]->frame_number < frame->frame_number &&
141 (ref0 == SCHRO_PICTURE_NUMBER_INVALID ||
142 encoder->reference_pictures[i]->frame_number > ref0)) {
143 ref0 = encoder->reference_pictures[i]->frame_number;
144 }
145 }
146 SCHRO_ASSERT (ref0 != SCHRO_PICTURE_NUMBER_INVALID);
147
148 /* pick the earliest forward ref */
149 ref1 = SCHRO_PICTURE_NUMBER_INVALID;
150 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
151 if (encoder->reference_pictures[i] == NULL)
152 continue;
153 if (!encoder->reference_pictures[i]->expired_reference &&
154 encoder->reference_pictures[i]->frame_number > frame->frame_number &&
155 (ref1 == SCHRO_PICTURE_NUMBER_INVALID ||
156 encoder->reference_pictures[i]->frame_number < ref1)) {
157 ref1 = encoder->reference_pictures[i]->frame_number;
158 }
159 }
160
161 if (ref1 == SCHRO_PICTURE_NUMBER_INVALID) {
162 /* if there's no fwd ref, pick an older back ref */
163 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
164 if (encoder->reference_pictures[i] == NULL)
165 continue;
166 if (!encoder->reference_pictures[i]->expired_reference &&
167 encoder->reference_pictures[i]->frame_number < ref0 &&
168 (ref1 == SCHRO_PICTURE_NUMBER_INVALID ||
169 encoder->reference_pictures[i]->frame_number > ref1)) {
170 ref1 = encoder->reference_pictures[i]->frame_number;
171 }
172 }
173 }
174
175 *ptr_ref0 = ref0;
176 *ptr_ref1 = ref1;
177 }
178
179 static void
schro_encoder_pick_retire(SchroEncoderFrame * frame,SchroPictureNumber * ptr_retire)180 schro_encoder_pick_retire (SchroEncoderFrame * frame,
181 SchroPictureNumber * ptr_retire)
182 {
183 SchroEncoder *encoder = frame->encoder;
184 SchroPictureNumber retire;
185 int n_refs = 0;
186 int i;
187
188 retire = SCHRO_PICTURE_NUMBER_INVALID;
189 /* pick the oldest expired ref */
190 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
191 if (encoder->reference_pictures[i] == NULL)
192 continue;
193 n_refs++;
194 if (encoder->reference_pictures[i]->expired_reference &&
195 (retire == SCHRO_PICTURE_NUMBER_INVALID ||
196 encoder->reference_pictures[i]->frame_number < retire)) {
197 retire = encoder->reference_pictures[i]->frame_number;
198 }
199 }
200
201 if (retire == SCHRO_PICTURE_NUMBER_INVALID && n_refs == 3) {
202 /* if we have a full queue, forceably retire something */
203 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
204 if (encoder->reference_pictures[i] == NULL)
205 continue;
206 if (retire == SCHRO_PICTURE_NUMBER_INVALID ||
207 encoder->reference_pictures[i]->frame_number < retire) {
208 retire = encoder->reference_pictures[i]->frame_number;
209 }
210 }
211 SCHRO_ASSERT (retire != SCHRO_PICTURE_NUMBER_INVALID);
212 }
213
214 *ptr_retire = retire;
215 }
216
217 static void
schro_encoder_expire_reference(SchroEncoder * encoder,SchroPictureNumber ref)218 schro_encoder_expire_reference (SchroEncoder * encoder, SchroPictureNumber ref)
219 {
220 int i;
221
222 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
223 if (encoder->reference_pictures[i] == NULL)
224 continue;
225 if (encoder->reference_pictures[i]->frame_number == ref) {
226 encoder->reference_pictures[i]->expired_reference = TRUE;
227 }
228 }
229 }
230
231 static void
schro_encoder_expire_refs_before(SchroEncoder * encoder,SchroPictureNumber ref)232 schro_encoder_expire_refs_before (SchroEncoder * encoder,
233 SchroPictureNumber ref)
234 {
235 int i;
236
237 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
238 if (encoder->reference_pictures[i] == NULL)
239 continue;
240 if (encoder->reference_pictures[i]->frame_number < ref) {
241 encoder->reference_pictures[i]->expired_reference = TRUE;
242 }
243 }
244 }
245
246 static void
schro_engine_code_BBBP(SchroEncoder * encoder,int i,int gop_length)247 schro_engine_code_BBBP (SchroEncoder * encoder, int i, int gop_length)
248 {
249 SchroEncoderFrame *frame;
250 SchroEncoderFrame *f;
251 int j;
252 SchroPictureNumber ref0;
253 SchroPictureNumber ref1;
254 SchroPictureNumber retire;
255
256 frame = encoder->frame_queue->elements[i].data;
257
258 /* BBBP */
259 frame->gop_length = gop_length;
260
261 f = encoder->frame_queue->elements[i + gop_length - 1].data;
262 if (f->start_sequence_header) {
263 schro_encoder_pick_retire (f, &retire);
264
265 schro_engine_code_picture (f, TRUE, retire, 0, -1, -1);
266 f->picture_weight = encoder->magic_keyframe_weight;
267 } else {
268 schro_encoder_pick_retire (f, &retire);
269 schro_encoder_pick_refs (f, &ref0, &ref1);
270
271 schro_engine_code_picture (f, TRUE, retire,
272 (ref1 == SCHRO_PICTURE_NUMBER_INVALID) ? 1 : 2, ref0, ref1);
273 f->picture_weight = encoder->magic_inter_p_weight;
274
275 schro_encoder_expire_reference (encoder, encoder->last_ref);
276 encoder->last_ref = f->frame_number;
277 }
278
279 for (j = 0; j < gop_length - 1; j++) {
280 f = encoder->frame_queue->elements[i + j].data;
281 schro_encoder_pick_refs (f, &ref0, &ref1);
282
283 schro_engine_code_picture (f, FALSE, -1, 2, ref0, ref1);
284 f->presentation_frame = f->frame_number;
285 if (j == gop_length - 2) {
286 f->presentation_frame++;
287 }
288 f->picture_weight = encoder->magic_inter_b_weight;
289 }
290
291 f = encoder->frame_queue->elements[i + gop_length - 1].data;
292 if (f->start_sequence_header) {
293 schro_encoder_expire_refs_before (encoder, f->frame_number);
294 }
295 }
296
297 /**
298 * schro_engine_get_scene_change_score:
299 * @frame: encoder frame
300 * @i: index
301 *
302 * Calculates scene change score for two pictures.
303 */
304 int
schro_engine_get_scene_change_score(SchroEncoder * encoder,int i)305 schro_engine_get_scene_change_score (SchroEncoder * encoder, int i)
306 {
307 SchroEncoderFrame *frame1;
308 SchroEncoderFrame *frame2;
309 double luma;
310
311 frame1 = encoder->frame_queue->elements[i].data;
312 if (frame1->have_scene_change_score)
313 return TRUE;
314
315 frame2 = frame1->previous_frame;
316 if (frame2 == NULL) {
317 frame1->scene_change_score = 1.0;
318 frame1->have_scene_change_score = TRUE;
319 return TRUE;
320 }
321 if (!(frame2->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done)) {
322 return FALSE;
323 }
324
325 SCHRO_DEBUG ("%g %g", frame1->average_luma, frame2->average_luma);
326
327 luma = frame1->average_luma - 16.0;
328 if (luma > 0.01) {
329 double mse[3];
330 schro_frame_mean_squared_error (frame1->
331 downsampled_frames[encoder->downsample_levels - 1],
332 frame2->downsampled_frames[encoder->downsample_levels - 1], mse);
333 frame1->scene_change_score = mse[0] / (luma * luma);
334 } else {
335 frame1->scene_change_score = 1.0;
336 }
337
338 SCHRO_DEBUG ("scene change score %g", frame1->scene_change_score);
339
340 schro_encoder_frame_unref (frame1->previous_frame);
341 frame1->previous_frame = NULL;
342
343 frame1->have_scene_change_score = TRUE;
344 return TRUE;
345 }
346
347
348 /**
349 * schro_engine_pick_output_buffer_size:
350 * @encoder: encoder
351 * @frame: encoder frame
352 *
353 * Calculates allocated size of output buffer for a picture. Horribly
354 * inefficient and outdated.
355 */
356 static int
schro_engine_pick_output_buffer_size(SchroEncoder * encoder,SchroEncoderFrame * frame)357 schro_engine_pick_output_buffer_size (SchroEncoder * encoder,
358 SchroEncoderFrame * frame)
359 {
360 int size;
361
362 size = encoder->video_format.width * encoder->video_format.height;
363 switch (encoder->video_format.chroma_format) {
364 case SCHRO_CHROMA_444:
365 size *= 3;
366 break;
367 case SCHRO_CHROMA_422:
368 size *= 2;
369 break;
370 case SCHRO_CHROMA_420:
371 size += size / 2;
372 break;
373 default:
374 SCHRO_ASSERT (0);
375 }
376
377 /* random scale factor of 2 in order to be safe */
378 size *= 2;
379
380 return size;
381 }
382
383 /**
384 * init_params:
385 * @frame: encoder frame
386 *
387 * Initializes params structure for picture based on encoder parameters
388 * and some heuristics.
389 */
390 void
init_params(SchroEncoderFrame * frame)391 init_params (SchroEncoderFrame * frame)
392 {
393 SchroParams *params = &frame->params;
394 SchroEncoder *encoder = frame->encoder;
395 SchroVideoFormat *video_format = params->video_format;
396 int shift;
397 int i;
398 int size;
399 int overlap;
400
401 params->video_format = &encoder->video_format;
402
403 schro_params_init (params, params->video_format->index);
404
405 if ((encoder->enable_noarith && frame->num_refs == 0) || params->is_lowdelay) {
406 params->is_noarith = TRUE;
407 }
408
409 params->transform_depth = encoder->transform_depth;
410
411 size = encoder->motion_block_size;
412 if (size == 0) {
413 if (video_format->width * video_format->height >= 1920 * 1080) {
414 size = 3;
415 } else if (video_format->width * video_format->height >= 960 * 540) {
416 size = 2;
417 } else {
418 size = 1;
419 }
420 }
421 switch (size) {
422 default:
423 case 1:
424 params->xbsep_luma = 8;
425 params->ybsep_luma = 8;
426 break;
427 case 2:
428 params->xbsep_luma = 12;
429 params->ybsep_luma = 12;
430 break;
431 case 3:
432 params->xbsep_luma = 16;
433 params->ybsep_luma = 16;
434 break;
435 }
436 overlap = encoder->motion_block_overlap;
437 if (overlap == 0) {
438 overlap = 3;
439 }
440 switch (overlap) {
441 case 1:
442 params->xblen_luma = params->xbsep_luma;
443 params->yblen_luma = params->ybsep_luma;
444 break;
445 default:
446 case 2:
447 params->xblen_luma = (params->xbsep_luma * 3 / 2) & (~3);
448 params->yblen_luma = (params->ybsep_luma * 3 / 2) & (~3);
449 break;
450 case 3:
451 params->xblen_luma = 2 * params->xbsep_luma;
452 params->yblen_luma = 2 * params->ybsep_luma;
453 break;
454 }
455
456 schro_params_calculate_mc_sizes (params);
457 schro_params_calculate_iwt_sizes (params);
458
459 switch (encoder->codeblock_size) {
460 case 1: /* small (blocks of size 5x5) */
461 shift = params->transform_depth;
462 params->horiz_codeblocks[0] =
463 MAX (1, (params->iwt_luma_width >> shift) / 5);
464 params->vert_codeblocks[0] =
465 MAX (1, (params->iwt_luma_height >> shift) / 5);
466 for (i = 1; i < params->transform_depth + 1; i++) {
467 shift = params->transform_depth + 1 - i;
468 /* These values are empirically derived from fewer than 2 test results */
469 params->horiz_codeblocks[i] =
470 MAX (1, (params->iwt_luma_width >> shift) / 5);
471 params->vert_codeblocks[i] =
472 MAX (1, (params->iwt_luma_height >> shift) / 5);
473 SCHRO_DEBUG ("codeblocks %d %d %d", i, params->horiz_codeblocks[i],
474 params->vert_codeblocks[i]);
475 }
476 break;
477 case 0:
478 default:
479 case 2: /* medium (blocks of size 8x8) */
480 shift = params->transform_depth;
481 params->horiz_codeblocks[0] =
482 MAX (1, (params->iwt_luma_width >> shift) / 8);
483 params->vert_codeblocks[0] =
484 MAX (1, (params->iwt_luma_height >> shift) / 8);
485 for (i = 1; i < params->transform_depth + 1; i++) {
486 shift = params->transform_depth + 1 - i;
487 params->horiz_codeblocks[i] =
488 MAX (1, (params->iwt_luma_width >> shift) / 8);
489 params->vert_codeblocks[i] =
490 MAX (1, (params->iwt_luma_height >> shift) / 8);
491 SCHRO_DEBUG ("codeblocks %d %d %d", i, params->horiz_codeblocks[i],
492 params->vert_codeblocks[i]);
493 }
494 break;
495 case 3: /* large (uses spec defaults) */
496 break;
497 case 4: /* full (codeblocks are entire subband) */
498 params->horiz_codeblocks[0] = 1;
499 params->vert_codeblocks[0] = 1;
500 for (i = 1; i < params->transform_depth + 1; i++) {
501 params->horiz_codeblocks[i] = 1;
502 params->vert_codeblocks[i] = 1;
503 }
504 break;
505 }
506
507 if (!encoder->enable_dc_multiquant) {
508 /* This is to work around a bug in the decoder that was fixed 8/2008. */
509 params->horiz_codeblocks[0] = 1;
510 params->vert_codeblocks[0] = 1;
511 }
512
513 params->mv_precision = encoder->mv_precision;
514 if (encoder->enable_global_motion) {
515 params->have_global_motion = TRUE;
516 }
517 if (encoder->enable_multiquant) {
518 params->codeblock_mode_index = 1;
519 } else {
520 params->codeblock_mode_index = 0;
521 }
522 }
523
524
525 void
schro_frame_set_wavelet_params(SchroEncoderFrame * frame)526 schro_frame_set_wavelet_params (SchroEncoderFrame * frame)
527 {
528 SchroParams *params = &frame->params;
529 SchroEncoder *encoder = frame->encoder;
530
531 if (params->num_refs > 0) {
532 params->wavelet_filter_index = encoder->inter_wavelet;
533 } else {
534 params->wavelet_filter_index = encoder->intra_wavelet;
535 }
536
537 /* overrides for near-lossless */
538 if (encoder->rate_control == 0) {
539 double offset = 6.0 * (encoder->bit_depth - 8);
540 if (encoder->noise_threshold < 40.0 + offset) {
541 /* do nothing */
542 } else if (encoder->noise_threshold < 47.0 + offset) {
543 params->wavelet_filter_index = 1;
544 } else {
545 params->wavelet_filter_index = 3;
546 }
547 } else if (encoder->rate_control == SCHRO_ENCODER_RATE_CONTROL_LOSSLESS) {
548 params->wavelet_filter_index = 3;
549 }
550 }
551
552 static double
get_alloc(SchroEncoder * encoder,double requested_bits)553 get_alloc (SchroEncoder * encoder, double requested_bits)
554 {
555 double x;
556 double y;
557 int must_use_bits;
558 double alloc;
559
560 must_use_bits = MAX (0, encoder->buffer_level + encoder->bits_per_picture
561 - encoder->buffer_size);
562
563 x = MAX (0, requested_bits - must_use_bits) /
564 MAX (0, encoder->buffer_size - encoder->bits_per_picture);
565
566 y = 1 - exp (-x);
567
568 alloc = must_use_bits + (encoder->buffer_level - must_use_bits) * y;
569
570 SCHRO_DEBUG ("request %g, level %d/%d, must use %d -> x %g y %g alloc %g",
571 requested_bits,
572 encoder->buffer_level, encoder->buffer_size, must_use_bits, x, y, alloc);
573
574 return alloc;
575 }
576
577 /**
578 * schro_encoder_calculate_allocation:
579 * @frame:
580 *
581 * Calculates the number of bits to allocate to a picture.
582 */
583 void
schro_encoder_calculate_allocation(SchroEncoderFrame * frame)584 schro_encoder_calculate_allocation (SchroEncoderFrame * frame)
585 {
586 SchroEncoder *encoder = frame->encoder;
587
588 if (encoder->rate_control != SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE) {
589 /* FIXME this function shouldn't be called for CBR */
590
591 frame->hard_limit_bits = frame->output_buffer_size * 8;
592 frame->allocated_mc_bits = frame->hard_limit_bits;
593 frame->allocated_residual_bits = frame->hard_limit_bits;
594 return;
595 }
596
597 /* FIXME should be fixed elsewhere */
598 if (frame->picture_weight == 0.0)
599 frame->picture_weight = 1.0;
600
601 if (frame->num_refs == 0) {
602 frame->allocated_mc_bits = 0;
603 frame->allocated_residual_bits = get_alloc (encoder,
604 encoder->bits_per_picture * frame->picture_weight *
605 encoder->magic_allocation_scale);
606 frame->hard_limit_bits = encoder->buffer_level;
607 } else {
608 double weight;
609
610 frame->allocated_mc_bits = frame->estimated_mc_bits;
611
612 weight = frame->picture_weight;
613 if (frame->is_ref) {
614 weight += frame->badblock_ratio * encoder->magic_badblock_multiplier_ref;
615 } else {
616 weight +=
617 frame->badblock_ratio * encoder->magic_badblock_multiplier_nonref;
618 }
619
620 frame->allocated_residual_bits = get_alloc (encoder,
621 encoder->bits_per_picture * weight * encoder->magic_allocation_scale);
622 frame->allocated_residual_bits -= frame->estimated_mc_bits;
623 if (frame->allocated_residual_bits < 0) {
624 SCHRO_DEBUG ("allocated residual bits less than 0");
625 frame->allocated_residual_bits = 0;
626 }
627 frame->hard_limit_bits = encoder->buffer_level;
628 }
629 }
630
631 /**
632 * init_frame:
633 * @frame:
634 *
635 * Initializes a frame prior to any analysis.
636 */
637 void
schro_encoder_init_frame(SchroEncoderFrame * frame)638 schro_encoder_init_frame (SchroEncoderFrame * frame)
639 {
640 SchroEncoder *encoder = frame->encoder;
641
642 frame->params.video_format = &encoder->video_format;
643
644 frame->need_filtering = (encoder->filtering != 0);
645 switch (encoder->gop_structure) {
646 case SCHRO_ENCODER_GOP_INTRA_ONLY:
647 frame->need_downsampling = FALSE;
648 frame->need_upsampling = FALSE;
649 frame->need_average_luma = FALSE;
650 frame->need_mad = FALSE;
651 break;
652 case SCHRO_ENCODER_GOP_ADAPTIVE:
653 case SCHRO_ENCODER_GOP_BACKREF:
654 case SCHRO_ENCODER_GOP_CHAINED_BACKREF:
655 frame->need_downsampling = TRUE;
656 frame->need_upsampling = (encoder->mv_precision > 0);
657 frame->need_average_luma = TRUE;
658 frame->need_extension = TRUE;
659 frame->need_mad = encoder->enable_scene_change_detection;
660 break;
661 case SCHRO_ENCODER_GOP_BIREF:
662 case SCHRO_ENCODER_GOP_CHAINED_BIREF:
663 frame->need_downsampling = TRUE;
664 frame->need_upsampling = (encoder->mv_precision > 0);
665 frame->need_average_luma = TRUE;
666 frame->need_extension = TRUE;
667 frame->need_mad = encoder->enable_scene_change_detection;
668 break;
669 default:
670 SCHRO_ASSERT (0);
671 }
672 }
673
674
675 /***** tworef *****/
676
677 /**
678 * handle_gop_tworef:
679 * @encoder:
680 * @i:
681 *
682 * Sets up a minor group of pictures for the tworef engine.
683 */
684 void
schro_encoder_handle_gop_tworef(SchroEncoder * encoder,int i)685 schro_encoder_handle_gop_tworef (SchroEncoder * encoder, int i)
686 {
687 SchroEncoderFrame *frame;
688 SchroEncoderFrame *f;
689 int j;
690 int gop_length;
691 //double scs_sum;
692
693 frame = encoder->frame_queue->elements[i].data;
694
695 SCHRO_ASSERT (frame->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_GOP].is_done ==
696 FALSE);
697
698 if (frame->busy || !frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done)
699 return;
700
701 schro_engine_check_new_sequence_header (encoder, frame);
702
703 gop_length = encoder->magic_subgroup_length;
704 SCHRO_DEBUG ("handling gop from %d to %d (index %d)", encoder->gop_picture,
705 encoder->gop_picture + gop_length - 1, i);
706
707 if (encoder->end_of_stream) {
708 gop_length = MIN (gop_length, encoder->frame_queue->n - i);
709 }
710 //intra_start = frame->start_sequence_header;
711 //scs_sum = 0;
712 for (j = 0; j < gop_length; j++) {
713 if (i + j >= encoder->frame_queue->n) {
714 SCHRO_DEBUG ("not enough pictures in queue");
715 return;
716 }
717
718 f = encoder->frame_queue->elements[i + j].data;
719
720 SCHRO_ASSERT (f->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_GOP].is_done ==
721 FALSE);
722
723 if (f->busy || !f->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done) {
724 SCHRO_DEBUG ("picture %d not ready", i + j);
725 return;
726 }
727
728 if (f->start_sequence_header ||
729 f->frame_number >= encoder->au_frame + encoder->au_distance) {
730 f->start_sequence_header = TRUE;
731 if (encoder->open_gop || j == 0) {
732 gop_length = j + 1;
733 } else {
734 gop_length = j;
735 }
736 break;
737 }
738
739 if (encoder->enable_scene_change_detection) {
740 if (!subgroup_ready (encoder->frame_queue, i, gop_length,
741 SCHRO_ENCODER_FRAME_STAGE_HAVE_GOP))
742 return; /*not all frames in subgroup have scene change score calculated */
743 } else {
744 schro_engine_get_scene_change_score (encoder, i + j);
745 }
746 schro_dump (SCHRO_DUMP_SCENE_CHANGE, "%d %g %g\n",
747 f->frame_number, f->scene_change_score, f->average_luma);
748 SCHRO_DEBUG ("scene change score %g", f->scene_change_score);
749
750 if (f->scene_change_score > encoder->magic_scene_change_threshold) {
751 SCHRO_DEBUG ("Scene change detected: score %g for picture %d",
752 f->scene_change_score, f->frame_number);
753 if (j == 0) {
754 /* If the first picture of the proposed subgroup is first
755 * picture of a new shot, we want to encode a sequence header
756 * and an I frame. */
757 f->start_sequence_header = TRUE;
758 gop_length = 1;
759 break;
760 } else {
761 /* If there's a shot change in the middle of the proposed
762 * subgroup, terminate the subgroup early. Also flag that
763 * picture as a new sequence header (not really necessary). */
764 f->start_sequence_header = TRUE;
765 gop_length = j;
766 }
767 }
768 #if 0
769 scs_sum += f->scene_change_score;
770 if (scs_sum > encoder->magic_scene_change_threshold) {
771 /* matching is getting bad. terminate gop */
772 gop_length = j;
773 }
774 #endif
775 }
776
777 SCHRO_DEBUG ("gop length %d", gop_length);
778
779 for (j = 0; j < gop_length - 1; j++) {
780 f = encoder->frame_queue->elements[i + j].data;
781 SCHRO_ASSERT (f->start_sequence_header == FALSE);
782 }
783
784 if (gop_length == 1) {
785 schro_engine_code_BBBP (encoder, i, gop_length);
786 } else {
787 schro_engine_code_BBBP (encoder, i, gop_length);
788 }
789
790 f = encoder->frame_queue->elements[i + gop_length - 1].data;
791 if (f->start_sequence_header) {
792 encoder->au_frame = f->frame_number;
793 }
794
795 encoder->gop_picture += gop_length;
796 }
797
798 int
schro_encoder_setup_frame_tworef(SchroEncoderFrame * frame)799 schro_encoder_setup_frame_tworef (SchroEncoderFrame * frame)
800 {
801 SchroEncoder *encoder = frame->encoder;
802
803 frame->output_buffer_size =
804 schro_engine_pick_output_buffer_size (encoder, frame);
805 SCHRO_ASSERT (frame->output_buffer_size != 0);
806
807 /* set up params - num_refs only */
808 frame->params.num_refs = frame->num_refs;
809
810 return TRUE;
811 }
812
813 int
schro_encoder_handle_quants(SchroEncoder * encoder,int i)814 schro_encoder_handle_quants (SchroEncoder * encoder, int i)
815 {
816 SchroEncoderFrame *frame;
817
818 frame = encoder->frame_queue->elements[i].data;
819
820 if (frame->busy
821 || !frame->stages[SCHRO_ENCODER_FRAME_STAGE_MODE_DECISION].is_done)
822 return FALSE;
823
824 schro_encoder_calculate_allocation (frame);
825 schro_encoder_choose_quantisers (frame);
826 schro_encoder_estimate_entropy (frame);
827
828 frame->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_QUANTS].is_done = TRUE;
829
830 return TRUE;
831 }
832
833 /**** backref ****/
834
835 /**
836 * handle_gop_backref:
837 * @encoder:
838 * @i:
839 *
840 * Sets up a minor group of pictures for the backref engine.
841 */
842 void
schro_encoder_handle_gop_backref(SchroEncoder * encoder,int i)843 schro_encoder_handle_gop_backref (SchroEncoder * encoder, int i)
844 {
845 SchroEncoderFrame *frame;
846 SchroPictureNumber retire;
847 SchroPictureNumber ref0;
848 SchroPictureNumber ref1;
849
850 frame = encoder->frame_queue->elements[i].data;
851
852 if (frame->busy || !frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done)
853 return;
854
855 schro_engine_check_new_sequence_header (encoder, frame);
856
857 //schro_engine_code_BBBP (encoder, i, 1);
858 if (frame->start_sequence_header) {
859 schro_encoder_pick_retire (frame, &retire);
860 schro_engine_code_picture (frame, TRUE, retire, 0, -1, -1);
861 frame->picture_weight = encoder->magic_keyframe_weight;
862 } else {
863 schro_encoder_pick_retire (frame, &retire);
864 schro_encoder_pick_refs (frame, &ref0, &ref1);
865
866 schro_engine_code_picture (frame, TRUE, retire,
867 (ref1 == SCHRO_PICTURE_NUMBER_INVALID) ? 1 : 2, ref0, ref1);
868 frame->picture_weight = encoder->magic_inter_p_weight;
869 }
870 schro_encoder_expire_reference (encoder, frame->frame_number - 2);
871 frame->presentation_frame = frame->frame_number;
872 frame->picture_weight = 1;
873 encoder->last_ref = frame->frame_number;
874
875 encoder->gop_picture += 1;
876 if (frame->start_sequence_header) {
877 schro_encoder_expire_refs_before (encoder, frame->frame_number);
878 }
879 }
880
881 int
schro_encoder_setup_frame_backref(SchroEncoderFrame * frame)882 schro_encoder_setup_frame_backref (SchroEncoderFrame * frame)
883 {
884 SchroEncoder *encoder = frame->encoder;
885
886 frame->output_buffer_size =
887 schro_engine_pick_output_buffer_size (encoder, frame);
888
889 /* set up params */
890 frame->params.num_refs = frame->num_refs;
891
892 return TRUE;
893 }
894
895 /*** intra-only ***/
896
897 /**
898 * handle_gop_intra_only:
899 * @encoder:
900 * @i:
901 *
902 * Sets up GOP structure for an intra picture.
903 */
904 void
schro_encoder_handle_gop_intra_only(SchroEncoder * encoder,int i)905 schro_encoder_handle_gop_intra_only (SchroEncoder * encoder, int i)
906 {
907 SchroEncoderFrame *frame;
908
909 frame = encoder->frame_queue->elements[i].data;
910
911 if (frame->busy || !frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done)
912 return;
913
914 schro_engine_check_new_sequence_header (encoder, frame);
915
916 SCHRO_DEBUG ("handling gop from %d to %d (index %d)", encoder->gop_picture,
917 encoder->gop_picture, i);
918
919 if (frame->busy || !frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done) {
920 SCHRO_DEBUG ("picture %d not ready", i);
921 return;
922 }
923
924 schro_engine_code_picture (frame, FALSE, -1, 0, -1, -1);
925 frame->presentation_frame = frame->frame_number;
926 frame->picture_weight = 1.0;
927
928 encoder->gop_picture++;
929 }
930
931 /**
932 * setup_params_intra_only:
933 * @frame:
934 *
935 * sets up parameters for a picture for intra-only encoding.
936 */
937 int
schro_encoder_setup_frame_intra_only(SchroEncoderFrame * frame)938 schro_encoder_setup_frame_intra_only (SchroEncoderFrame * frame)
939 {
940 SchroEncoder *encoder = frame->encoder;
941
942 frame->output_buffer_size =
943 schro_engine_pick_output_buffer_size (encoder, frame);
944
945 frame->params.num_refs = frame->num_refs;
946
947 /* set up params */
948
949 return TRUE;
950 }
951
952
953 /*** lossless ***/
954
955 /**
956 * setup_params_lossless:
957 * @frame:
958 *
959 * sets up parameters for a picture for intra-only encoding.
960 */
961 int
schro_encoder_setup_frame_lossless(SchroEncoderFrame * frame)962 schro_encoder_setup_frame_lossless (SchroEncoderFrame * frame)
963 {
964 SchroEncoder *encoder = frame->encoder;
965 SchroParams *params;
966
967 frame->output_buffer_size =
968 schro_engine_pick_output_buffer_size (encoder, frame);
969
970 frame->params.num_refs = frame->num_refs;
971
972 /* set up params */
973 params = &frame->params;
974
975 params->wavelet_filter_index = SCHRO_WAVELET_HAAR_0;
976 params->transform_depth = 3;
977
978 params->num_refs = frame->num_refs;
979 params->video_format = &encoder->video_format;
980 init_params (frame);
981
982 params->xbsep_luma = 8;
983 params->xblen_luma = 8;
984 params->ybsep_luma = 8;
985 params->yblen_luma = 8;
986 schro_params_calculate_mc_sizes (params);
987
988 return TRUE;
989 }
990
991 void
schro_encoder_handle_gop_lossless(SchroEncoder * encoder,int i)992 schro_encoder_handle_gop_lossless (SchroEncoder * encoder, int i)
993 {
994 schro_encoder_handle_gop_backref (encoder, i);
995 }
996
997 /*** low delay ***/
998
999 void
schro_encoder_handle_gop_lowdelay(SchroEncoder * encoder,int i)1000 schro_encoder_handle_gop_lowdelay (SchroEncoder * encoder, int i)
1001 {
1002 SchroEncoderFrame *frame;
1003
1004 frame = encoder->frame_queue->elements[i].data;
1005
1006 if (frame->busy || !frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done)
1007 return;
1008
1009 schro_engine_check_new_sequence_header (encoder, frame);
1010
1011 SCHRO_DEBUG ("handling gop from %d to %d (index %d)", encoder->gop_picture,
1012 encoder->gop_picture, i);
1013
1014 schro_engine_code_picture (frame, FALSE, -1, 0, -1, -1);
1015 frame->presentation_frame = frame->frame_number;
1016 frame->picture_weight = 1.0;
1017
1018 encoder->gop_picture++;
1019 }
1020
1021 int
schro_encoder_setup_frame_lowdelay(SchroEncoderFrame * frame)1022 schro_encoder_setup_frame_lowdelay (SchroEncoderFrame * frame)
1023 {
1024 SchroEncoder *encoder = frame->encoder;
1025 SchroParams *params = &frame->params;
1026 int num;
1027 int denom;
1028
1029 frame->output_buffer_size =
1030 schro_engine_pick_output_buffer_size (encoder, frame);
1031
1032 /* set up params */
1033 params->num_refs = frame->num_refs;
1034 params->is_lowdelay = TRUE;
1035
1036 if (encoder->horiz_slices != 0 && encoder->vert_slices != 0) {
1037 params->n_horiz_slices = encoder->horiz_slices;
1038 params->n_vert_slices = encoder->vert_slices;
1039 } else {
1040 params->n_horiz_slices =
1041 params->iwt_chroma_width >> params->transform_depth;
1042 params->n_vert_slices =
1043 params->iwt_chroma_height >> params->transform_depth;
1044 }
1045 schro_params_set_default_quant_matrix (params);
1046
1047 num = muldiv64 (encoder->bitrate,
1048 encoder->video_format.frame_rate_denominator,
1049 encoder->video_format.frame_rate_numerator * 8);
1050 denom = params->n_horiz_slices * params->n_vert_slices;
1051 if (encoder->video_format.interlaced_coding) {
1052 denom *= 2;
1053 }
1054 SCHRO_ASSERT (denom != 0);
1055 schro_utils_reduce_fraction (&num, &denom);
1056 params->slice_bytes_num = num;
1057 params->slice_bytes_denom = denom;
1058
1059 return TRUE;
1060 }
1061