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