1
2 #ifdef HAVE_CONFIG_H
3 #include "config.h"
4 #endif
5 #define SCHRO_ARITH_DEFINE_INLINE
6 #include <schroedinger/schro.h>
7 #include <string.h>
8 #include <math.h>
9 #include <stddef.h>
10 #include <orc/orc.h>
11 #include "schroorc.h"
12
13 #if 0
14 /* Used for testing bitstream */
15 #define MARKER(pack) schro_pack_encode_uint (pack, 1234567)
16 #else
17 #define MARKER(pack)
18 #endif
19
20 void schro_encoder_render_picture (SchroEncoderFrame * frame);
21 static void
22 schro_encoder_encode_picture_prediction_parameters (SchroEncoderFrame * frame);
23 static void schro_encoder_encode_superblock_split (SchroEncoderFrame * frame);
24 static void schro_encoder_encode_prediction_modes (SchroEncoderFrame * frame);
25 static void schro_encoder_encode_vector_data (SchroEncoderFrame * frame,
26 int ref, int xy);
27 static void schro_encoder_encode_dc_data (SchroEncoderFrame * frame, int comp);
28 static void schro_encoder_encode_transform_parameters (SchroEncoderFrame *
29 frame);
30 static void schro_encoder_encode_transform_data (SchroEncoderFrame * frame);
31 static int schro_encoder_pull_is_ready_locked (SchroEncoder * encoder);
32 static void schro_encoder_encode_codec_comment (SchroEncoder * encoder);
33 static void schro_encoder_encode_bitrate_comment (SchroEncoder * encoder,
34 unsigned int bitrate);
35 static int schro_encoder_encode_padding (SchroEncoder * encoder, int n);
36 static void schro_encoder_clean_up_transform_subband (SchroEncoderFrame * frame,
37 int component, int index);
38 static void schro_encoder_fixup_offsets (SchroEncoder * encoder,
39 SchroBuffer * buffer, schro_bool is_eos);
40 static void schro_encoder_frame_complete (SchroAsyncStage * stage);
41 static int schro_encoder_async_schedule (SchroEncoder * encoder,
42 SchroExecDomain exec_domain);
43 static void schro_encoder_init_perceptual_weighting (SchroEncoder * encoder);
44 void schro_encoder_encode_sequence_header_header (SchroEncoder * encoder,
45 SchroPack * pack);
46 static schro_bool schro_frame_data_is_zero (SchroFrameData * fd);
47 static void schro_encoder_setting_set_defaults (SchroEncoder * encoder);
48
49 /*
50 * Set a frame lambda based on the encoder lambda
51 */
52 void
schro_encoder_set_frame_lambda(SchroEncoderFrame * frame)53 schro_encoder_set_frame_lambda (SchroEncoderFrame * frame)
54 {
55 SchroEncoder *encoder = frame->encoder;
56
57 SCHRO_ASSERT (frame);
58 SCHRO_ASSERT (frame->encoder);
59 switch (frame->encoder->rate_control) {
60 case SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE:
61 if (frame->encoder->enable_rdo_cbr) {
62 double q;
63
64 //frame->frame_lambda = pow( 10.0 , -(12.0-frame->encoder->qf )/2.5 )/16.0;
65 frame->frame_lambda = exp (0.921034 * encoder->qf - 13.825);
66
67 q = (log (frame->frame_lambda) + 16.2826) / 1.6447;
68
69 frame->frame_me_lambda = frame->encoder->magic_me_lambda_scale *
70 sqrt (frame->frame_lambda);
71
72 frame->frame_me_lambda = MIN (0.002 * exp (q * 0.2 * M_LN10), 1.0);
73 if (frame->frame_me_lambda > 1.0) {
74 frame->frame_me_lambda = 1.0;
75 }
76 frame->frame_me_lambda *= encoder->magic_me_lambda_scale;
77 } else {
78 /* overwritten in schro_encoder_choose_quantisers_rdo_bit_allocation */
79 frame->frame_lambda = 0;
80 frame->frame_me_lambda = 0.1; /* used to be magic_mc_lambda */
81 }
82 break;
83 case SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY:
84 {
85 double q = encoder->quality;
86
87 q += -3.5 * (frame->encoder->magic_error_power - 4);
88 q *= 1.0 + (frame->encoder->magic_error_power - 4) * 0.2;
89 if (frame->encoder->magic_error_power < 2.5) {
90 q += 2;
91 }
92 //frame->frame_lambda = exp(((q-5)/0.7 - 7.0)*M_LN10*0.5);
93 frame->frame_lambda = exp (1.6447 * q - 16.2826);
94
95 frame->frame_me_lambda = MIN (0.002 * exp (q * 0.2 * M_LN10), 1.0);
96 if (frame->frame_me_lambda > 1.0) {
97 frame->frame_me_lambda = 1.0;
98 }
99 frame->frame_me_lambda *= encoder->magic_me_lambda_scale;
100
101 }
102 break;
103 case SCHRO_ENCODER_RATE_CONTROL_LOSSLESS:
104 frame->frame_me_lambda = 10;
105 break;
106 default:
107 /* others don't use lambda */
108 frame->frame_lambda = 1.0;
109 frame->frame_me_lambda = 0.1;
110 break;
111 }
112 if ((frame->num_refs != 0)) {
113 if (schro_encoder_frame_is_B_frame (frame)) {
114 frame->frame_lambda *= frame->encoder->magic_B_lambda_scale;
115 } else {
116 frame->frame_lambda *= frame->encoder->magic_P_lambda_scale;
117 }
118 } else {
119 if (frame->encoder->rate_control ==
120 SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE) {
121 if (frame->encoder->intra_cbr_lambda != -1) {
122 frame->frame_lambda = sqrt (frame->frame_lambda *
123 frame->encoder->intra_cbr_lambda);
124 }
125 frame->encoder->intra_cbr_lambda = frame->frame_lambda;
126 SCHRO_DEBUG ("Using filtered CBR value for intra lambda %g (picture %d)",
127 frame->frame_lambda, frame->frame_number);
128 } else {
129 frame->frame_lambda *= frame->encoder->magic_I_lambda_scale;
130 }
131 }
132 }
133
134 /*
135 * Return 1 if the last subgroup has been coded, 0 otherwise
136 *
137 */
138 #if 0
139 int
140 schro_encoder_last_subgroup_coded (SchroEncoder * encoder, int picnum)
141 {
142 int subgroup_coded = 1;
143 int pos, fnum;
144
145 int last_P_frame =
146 (picnum + encoder->subgroup_length - 1) / encoder->subgroup_length;
147 last_P_frame *= encoder->subgroup_length;
148 last_P_frame -= encoder->subgroup_length;
149
150 if (picnum > encoder->subgroup_length) {
151 for (pos = 0; pos < encoder->frame_queue->n; ++pos) {
152 SchroEncoderFrame *frame = encoder->frame_queue->elements[pos].data;
153 fnum = frame->frame_number;
154 if (fnum <= last_P_frame
155 && fnum >= last_P_frame - encoder->subgroup_length + 1) {
156 if (!(frame->state & SCHRO_ENCODER_FRAME_STATE_ENCODING))
157 subgroup_coded = 0;
158 }
159 }
160 } else {
161 for (pos = 0; pos < encoder->frame_queue->n; ++pos) {
162 SchroEncoderFrame *frame = encoder->frame_queue->elements[pos].data;
163 fnum = frame->frame_number;
164 if (fnum == 0 && !(frame->state & SCHRO_ENCODER_FRAME_STATE_ENCODING))
165 subgroup_coded = 0;
166 }
167 }
168
169 SCHRO_DEBUG ("Last subgroup coded value %d at %d", subgroup_coded, picnum);
170
171 return subgroup_coded;
172
173 }
174 #endif
175
176 /*
177 * schro_encoder_init_rc_buffer
178 *
179 * Initialises the buffer model for rate control
180 *
181 */
182 static void
schro_encoder_init_rc_buffer(SchroEncoder * encoder)183 schro_encoder_init_rc_buffer (SchroEncoder * encoder)
184 {
185 int gop_length;
186
187 SCHRO_ASSERT (encoder);
188
189 gop_length = encoder->au_distance;
190 if (encoder->buffer_size == 0) {
191 encoder->buffer_size = 3 * encoder->bitrate;
192 }
193 // Set initial level at 100%
194 if (encoder->buffer_level == 0) {
195 encoder->buffer_level = encoder->buffer_size;
196 }
197 encoder->bits_per_picture = muldiv64 (encoder->bitrate,
198 encoder->video_format.frame_rate_denominator,
199 encoder->video_format.frame_rate_numerator);
200 encoder->gop_target = muldiv64 (encoder->bitrate * gop_length,
201 encoder->video_format.frame_rate_denominator,
202 encoder->video_format.frame_rate_numerator);
203
204 if (encoder->video_format.interlaced_coding) {
205 encoder->bits_per_picture /= 2;
206 }
207
208 encoder->B_complexity_sum = 0;
209
210 // Set up an initial allocation
211 if (encoder->gop_structure == SCHRO_ENCODER_GOP_INTRA_ONLY) {
212 encoder->I_frame_alloc = encoder->bits_per_picture;
213 encoder->P_frame_alloc = 0;
214 encoder->B_frame_alloc = 0;
215 } else {
216 int num_P_frames =
217 encoder->au_distance / encoder->magic_subgroup_length - 1;
218 int num_B_frames = gop_length - num_P_frames - 1;
219 int total;
220 encoder->I_frame_alloc = 2 ^ 24;
221 encoder->P_frame_alloc = encoder->I_frame_alloc / 3;
222 encoder->B_frame_alloc = encoder->P_frame_alloc / 3;
223 total = encoder->I_frame_alloc + num_P_frames * encoder->P_frame_alloc +
224 num_B_frames * encoder->B_frame_alloc;
225 encoder->I_frame_alloc =
226 (encoder->I_frame_alloc * encoder->gop_target) / total;
227 encoder->P_frame_alloc =
228 (encoder->P_frame_alloc * encoder->gop_target) / total;
229 encoder->B_frame_alloc =
230 (encoder->B_frame_alloc * encoder->gop_target) / total;
231 }
232 encoder->I_complexity = encoder->I_frame_alloc;
233 encoder->P_complexity = encoder->P_frame_alloc;
234 encoder->B_complexity = encoder->B_frame_alloc;
235
236 SCHRO_DEBUG ("Initialising buffer with allocations (I, B, P) %d, %d, %d",
237 encoder->I_frame_alloc, encoder->P_frame_alloc, encoder->B_frame_alloc);
238
239 encoder->subgroup_position = 1;
240 }
241
242 /*
243 * schro_encoder_projected_subgroup_bits
244 *
245 * Returns the total number of bits expected for the next subgroup
246 *
247 */
248 static int
schro_encoder_projected_subgroup_bits(SchroEncoder * encoder)249 schro_encoder_projected_subgroup_bits (SchroEncoder * encoder)
250 {
251 // FIXME: take account of subgroups with an I instead of a P??
252 int bits = encoder->P_complexity +
253 (encoder->magic_subgroup_length - 1) * encoder->B_complexity;
254 return bits;
255 }
256
257 /*
258 * schro_encoder_target_subgroup_bits
259 *
260 * Returns the target for the next subgroup
261 *
262 */
263 static int
schro_encoder_target_subgroup_bits(SchroEncoder * encoder)264 schro_encoder_target_subgroup_bits (SchroEncoder * encoder)
265 {
266 // FIXME: take account of subgroups with an I instead of a P??
267 int bits = encoder->P_frame_alloc +
268 (encoder->magic_subgroup_length - 1) * encoder->B_frame_alloc;
269 return bits;
270 }
271
272 /*
273 * schro_encoder_cbr_allocate:
274 *
275 * TM5-style bit allocation routine
276 *
277 */
278 static void
schro_encoder_cbr_allocate(SchroEncoder * encoder,int fnum)279 schro_encoder_cbr_allocate (SchroEncoder * encoder, int fnum)
280 {
281 int gop_length;
282 int Icty;
283 int Pcty;
284 int Bcty;
285 int num_I_frames;
286 int num_P_frames;
287 int num_B_frames;
288 int total_gop_bits;
289 int sg_len;
290 double buffer_occ;
291 int min_bits;
292
293 SCHRO_ASSERT (encoder);
294
295 gop_length = encoder->au_distance;
296 Icty = encoder->I_complexity;
297 Pcty = encoder->P_complexity;
298 Bcty = encoder->B_complexity;
299 num_I_frames = 1;
300 num_P_frames = encoder->au_distance / encoder->magic_subgroup_length - 1;
301 num_B_frames = gop_length - num_I_frames - num_P_frames;
302 total_gop_bits = muldiv64 (encoder->bitrate * gop_length,
303 encoder->video_format.frame_rate_denominator,
304 encoder->video_format.frame_rate_numerator);
305 sg_len = encoder->magic_subgroup_length;
306 buffer_occ =
307 ((double) encoder->buffer_level) / ((double) encoder->buffer_size);
308
309 if (encoder->gop_structure != SCHRO_ENCODER_GOP_INTRA_ONLY) {
310 double correction;
311 if (buffer_occ < 0.9 && ((fnum + 1) % 4 * sg_len) == 0) {
312 // If we're undershooting buffer target, correct slowly
313 correction = MIN (0.25, 0.25 * (0.9 - buffer_occ) / 0.9);
314 encoder->gop_target =
315 (long int) ((double) (total_gop_bits) * (1.0 - correction));
316 } else if (buffer_occ > 0.9 && ((fnum + 1) % sg_len) == 0) {
317 // If we're overshooting buffer target, correct quickly
318 correction = MIN (0.5, 0.5 * (buffer_occ - 0.9) / 0.9);
319 encoder->gop_target =
320 (long int) ((double) (total_gop_bits) * (1.0 + correction));
321 }
322 }
323
324 min_bits = total_gop_bits / (100 * gop_length);
325
326 encoder->I_frame_alloc = (long int) (encoder->gop_target
327 / (num_I_frames
328 + (double) (num_P_frames * Pcty) / Icty
329 + (double) (num_B_frames * Bcty) / Icty));
330
331 encoder->I_frame_alloc = MAX (min_bits, encoder->I_frame_alloc);
332
333 encoder->P_frame_alloc = (long int) (encoder->gop_target
334 / (num_P_frames
335 + (double) (num_I_frames * Icty) / Pcty
336 + (double) (num_B_frames * Bcty) / Pcty));
337
338 encoder->P_frame_alloc = MAX (min_bits, encoder->P_frame_alloc);
339
340 encoder->B_frame_alloc = (long int) (encoder->gop_target
341 / (num_B_frames
342 + (double) (num_I_frames * Icty) / Bcty
343 + (double) (num_P_frames * Pcty) / Bcty));
344
345 encoder->B_frame_alloc = MAX (min_bits, encoder->B_frame_alloc);
346
347 }
348
349 /*
350 * schro_encoder_cbr_update
351 *
352 * Sets the qf (and hence lambdas) for the next subgroup to be coded
353 *
354 */
355 static void
schro_encoder_cbr_update(SchroEncoderFrame * frame,int num_bits)356 schro_encoder_cbr_update (SchroEncoderFrame * frame, int num_bits)
357 {
358 SchroEncoder *encoder = frame->encoder;
359 double target_ratio;
360 double actual_ratio;
361 double filter_tap;
362 int P_separation;
363 int field_factor;
364 int emergency_realloc;
365 int target;
366 double tbits, pbits;
367
368 // The target buffer occupancy
369 target_ratio = 0.9;
370 actual_ratio = (double) (encoder->buffer_level) /
371 (double) (encoder->buffer_size);
372 P_separation = encoder->magic_subgroup_length;
373
374 // 1 is coding frames, 2 if coding fields
375 field_factor = 1;
376 if (encoder->video_format.interlaced_coding)
377 field_factor = 2;
378
379 emergency_realloc = 0;
380
381 // Decrement the subgroup frame counter. This is zero just after the last
382 // B frame before the next P frame i.e. before the start of a subgroup
383 encoder->subgroup_position--;
384
385 /* Determine the filter tap for adjusting lambda */
386 if ((frame->frame_number / field_factor) <= 3 * P_separation) {
387 // Adjust immediately at the beginning of the sequence
388 filter_tap = 1.0;
389 } else {
390 if (actual_ratio > target_ratio)
391 filter_tap = (actual_ratio - target_ratio) / (1.0 - target_ratio);
392 else
393 filter_tap = (target_ratio - actual_ratio) / target_ratio;
394
395 filter_tap = CLAMP (filter_tap, 0.25, 1.0);
396 }
397
398 // Now for the actual update
399 if (encoder->gop_structure != SCHRO_ENCODER_GOP_INTRA_ONLY) {
400 // Long-GOP coding
401
402 if (frame->num_refs == 0) {
403 encoder->I_complexity = num_bits;
404 target = encoder->I_frame_alloc;
405
406 if (num_bits < target / 2 || num_bits > 3 * target)
407 emergency_realloc = 1;
408
409 if ((frame->frame_number / field_factor) == 0) { //FIXME: needed?
410 // We've just coded the very first frame, which is a special
411 // case as the B frames which normally follow are missing
412 encoder->subgroup_position = P_separation;
413 }
414 }
415
416 if (((frame->frame_number) / field_factor) % P_separation != 0) {
417 // Scheduled B picture
418 encoder->B_complexity_sum += num_bits;
419 target = encoder->B_frame_alloc;
420
421 if (num_bits < target / 2 || num_bits > 3 * target) {
422 emergency_realloc = 1;
423 }
424
425 } else if (frame->num_refs != 0) {
426 // Scheduled P picture (if inserted I picture, don't change the complexity)
427 encoder->P_complexity = num_bits;
428 target = encoder->P_frame_alloc;
429
430 if (num_bits < target / 2 || num_bits > 3 * target) {
431 emergency_realloc = 1;
432 }
433
434 }
435
436 if (encoder->subgroup_position == 0 || emergency_realloc == 1) {
437 double K;
438 double new_qf;
439
440 if (emergency_realloc == 1)
441 SCHRO_DEBUG ("Major undershoot of frame bit rate: Reallocating");
442
443 // We recompute allocations for the next subgroup
444 if (P_separation > 1 && encoder->subgroup_position < P_separation - 1) {
445 encoder->B_complexity =
446 encoder->B_complexity_sum / (P_separation - 1 -
447 encoder->subgroup_position);
448 }
449 schro_encoder_cbr_allocate (encoder, frame->frame_number / field_factor);
450
451 // We work out what this means for the quality factor and set it
452
453 tbits = (double) (schro_encoder_target_subgroup_bits (encoder));
454 pbits = (double) (schro_encoder_projected_subgroup_bits (encoder));
455
456 SCHRO_DEBUG ("Reallocating: target bits = %g, projected bits = %g", tbits,
457 pbits);
458
459 // Determine K value in model
460 K = pow (pbits, 2) * pow (10.0,
461 ((double) 2 / 5 * (12 - encoder->qf))) / 16;
462
463 // Determine a new qf from K
464 new_qf = 12 - (double) 5 / 2 * log10 (16 * K / pow (tbits, 2));
465
466 if ((abs (encoder->qf - new_qf) >= 0.25 || new_qf <= 4.0)
467 && new_qf <= 8.0)
468 new_qf = filter_tap * new_qf + (1.0 - filter_tap) * encoder->qf;
469
470 if (new_qf <= 8.0) {
471 if (pbits < 2 * tbits) {
472 new_qf = MAX (new_qf, encoder->qf - 1.0);
473 } else {
474 new_qf = MAX (new_qf, encoder->qf - 2.0);
475 }
476 }
477 new_qf =
478 MIN (new_qf,
479 5 + 10 * ((double) encoder->buffer_level) / encoder->buffer_size);
480
481 encoder->qf = new_qf;
482 SCHRO_DEBUG ("Setting qf for next subgroup to %g, bits %d", encoder->qf,
483 encoder->buffer_level);
484
485 // Reset the frame counter
486 if (encoder->subgroup_position == 0) {
487 encoder->subgroup_position = encoder->magic_subgroup_length;
488 encoder->B_complexity_sum = 0;
489 }
490
491 }
492 } else {
493 // We're doing intraonly coding
494
495 double tbits = (double) encoder->bits_per_picture;
496 double pbits = (double) num_bits;
497
498 // Determine K value
499 double K =
500 pow (pbits, 2) * pow (10.0, ((double) 2 / 5 * (12 - encoder->qf))) / 16;
501
502 // Determine a new QF
503 double new_qf = 12 - (double) 5 / 2 * log10 (16 * K / pow (tbits, 2));
504
505 // Adjust the QF to meet the target
506 double abs_delta = abs (new_qf - encoder->qf);
507 if (abs_delta > 0.01) {
508 // Rate of convergence to new QF
509 double r;
510
511 // Use an Sshaped curve to compute r
512 // Where the qf difference is less than 1/2, r decreases to zero
513 // exponentially, so for small differences in QF we jump straight
514 // to the target value. For large differences in QF, r converges
515 // exponentially to 0.75, so we converge to the target value at
516 // a fixed rate.
517
518 // Overall behaviour is to converge steadily for 2 or 3 frames until
519 // close and then lock to the correct value. This avoids very rapid
520 // changes in quality.
521
522 // Actual parameters may be adjusted later. Some applications may
523 // require instant lock.
524
525 double lg_diff = log (abs_delta / 2.0);
526 if (lg_diff < 0.0)
527 r = 0.5 * exp (-lg_diff * lg_diff / 2.0);
528 else
529 r = 1.0 - 0.5 * exp (-lg_diff * lg_diff / 2.0);
530
531 r *= 0.75;
532 encoder->qf = r * encoder->qf + (1.0 - r) * new_qf;
533 SCHRO_DEBUG ("Setting qf for next subgroup to %g", encoder->qf);
534 }
535 }
536
537 }
538
539 /**
540 * schro_encoder_new:
541 *
542 * Create a new encoder object.
543 *
544 * Returns: a new encoder object
545 */
546 SchroEncoder *
schro_encoder_new(void)547 schro_encoder_new (void)
548 {
549 SchroEncoder *encoder;
550 int c, b;
551
552 encoder = schro_malloc0 (sizeof (SchroEncoder));
553
554 encoder->version_major = 2;
555 encoder->version_minor = 2;
556
557 encoder->au_frame = -1;
558
559 encoder->last_ref = -1;
560 encoder->qf = 7.0;
561
562 schro_encoder_setting_set_defaults (encoder);
563
564 schro_video_format_set_std_video_format (&encoder->video_format,
565 SCHRO_VIDEO_FORMAT_CUSTOM);
566
567 encoder->inserted_buffers =
568 schro_list_new_full ((SchroListFreeFunc) schro_buffer_unref, NULL);
569
570 for (c = 0; c < 3; ++c) {
571 for (b = 0; b < SCHRO_LIMIT_SUBBANDS; ++b) {
572 encoder->average_arith_context_ratios_intra[c][b] = 1.0;
573 encoder->average_arith_context_ratios_inter[c][b] = 1.0;
574 }
575 }
576
577 return encoder;
578 }
579
580 static void
handle_gop_enum(SchroEncoder * encoder)581 handle_gop_enum (SchroEncoder * encoder)
582 {
583 switch (encoder->gop_structure) {
584 case SCHRO_ENCODER_GOP_BACKREF:
585 case SCHRO_ENCODER_GOP_CHAINED_BACKREF:
586 SCHRO_DEBUG ("Setting backref\n");
587 encoder->init_frame = schro_encoder_init_frame;
588 encoder->handle_gop = schro_encoder_handle_gop_backref;
589 encoder->handle_quants = schro_encoder_handle_quants;
590 encoder->setup_frame = schro_encoder_setup_frame_backref;
591 break;
592 case SCHRO_ENCODER_GOP_INTRA_ONLY:
593 SCHRO_DEBUG ("Setting intra only\n");
594 encoder->init_frame = schro_encoder_init_frame;
595 encoder->handle_gop = schro_encoder_handle_gop_intra_only;
596 encoder->handle_quants = schro_encoder_handle_quants;
597 encoder->setup_frame = schro_encoder_setup_frame_intra_only;
598 break;
599 case SCHRO_ENCODER_GOP_ADAPTIVE:
600 case SCHRO_ENCODER_GOP_BIREF:
601 case SCHRO_ENCODER_GOP_CHAINED_BIREF:
602 SCHRO_DEBUG ("Setting tworef engine\n");
603 encoder->init_frame = schro_encoder_init_frame;
604 encoder->handle_gop = schro_encoder_handle_gop_tworef;
605 encoder->handle_quants = schro_encoder_handle_quants;
606 encoder->setup_frame = schro_encoder_setup_frame_tworef;
607 break;
608 default:
609 SCHRO_ASSERT (0);
610 }
611
612 }
613
614 /**
615 * schro_encoder_start:
616 * @encoder: an encoder object
617 *
618 * Locks in encoder configuration and causes the encoder to start
619 * encoding pictures. At this point, the encoder will start worker
620 * threads to do the actual encoding.
621 */
622 void
schro_encoder_start(SchroEncoder * encoder)623 schro_encoder_start (SchroEncoder * encoder)
624 {
625 encoder->frame_queue = schro_queue_new (encoder->queue_depth,
626 (SchroQueueFreeFunc) schro_encoder_frame_unref);
627 SCHRO_DEBUG ("queue depth %d", encoder->queue_depth);
628
629 encoder->engine_init = 1;
630 encoder->force_sequence_header = TRUE;
631
632 /* add check on 'enable' switches */
633 if (encoder->enable_scene_change_detection) {
634 encoder->magic_scene_change_threshold = 3.25;
635 } else {
636 encoder->magic_scene_change_threshold = 0.2;
637 }
638 if (encoder->enable_bigblock_estimation && encoder->enable_deep_estimation) {
639 /* only one can be set at any one time */
640 encoder->enable_bigblock_estimation = FALSE;
641 } else if (!encoder->enable_bigblock_estimation
642 && !encoder->enable_deep_estimation) {
643 SCHRO_ERROR ("no motion estimation selected!");
644 SCHRO_ASSERT (0);
645 }
646 if (!encoder->enable_deep_estimation && encoder->enable_chroma_me) {
647 encoder->enable_chroma_me = FALSE;
648 }
649 /* Global motion is broken */
650 encoder->enable_global_motion = FALSE;
651
652 encoder->bit_depth = schro_video_format_get_bit_depth (&encoder->video_format);
653 if (encoder->video_format.luma_excursion >= 256 ||
654 encoder->video_format.chroma_excursion >= 256) {
655 encoder->input_frame_depth = 16;
656 encoder->intermediate_frame_depth = 32;
657 } else {
658 encoder->input_frame_depth = 8;
659 //encoder->intermediate_frame_depth = 32;
660 encoder->intermediate_frame_depth = 16;
661 }
662
663 encoder->video_format.interlaced_coding = encoder->interlaced_coding;
664
665 schro_encoder_encode_codec_comment (encoder);
666
667 schro_tables_init ();
668 schro_encoder_init_perceptual_weighting (encoder);
669 /* special value indicating invalid */
670 encoder->intra_cbr_lambda = -1;
671
672 schro_encoder_init_error_tables (encoder);
673
674 encoder->async = schro_async_new (0,
675 (SchroAsyncScheduleFunc) schro_encoder_async_schedule,
676 (SchroAsyncCompleteFunc) schro_encoder_frame_complete, encoder);
677
678 if (encoder->force_profile == SCHRO_ENCODER_PROFILE_AUTO) {
679 if (encoder->rate_control == SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY) {
680 encoder->force_profile = SCHRO_ENCODER_PROFILE_VC2_LOW_DELAY;
681 } else if (encoder->enable_noarith) {
682 encoder->force_profile = SCHRO_ENCODER_PROFILE_VC2_SIMPLE;
683 } else if (encoder->gop_structure == SCHRO_ENCODER_GOP_INTRA_ONLY) {
684 encoder->force_profile = SCHRO_ENCODER_PROFILE_VC2_MAIN;
685 } else {
686 encoder->force_profile = SCHRO_ENCODER_PROFILE_MAIN;
687 }
688 }
689
690 if (encoder->bitrate == 0) {
691 encoder->bitrate = encoder->video_format.width *
692 encoder->video_format.height *
693 encoder->video_format.frame_rate_numerator /
694 encoder->video_format.frame_rate_denominator;
695 if (encoder->force_profile == SCHRO_ENCODER_PROFILE_MAIN) {
696 encoder->bitrate /= 10;
697 } else {
698 encoder->bitrate *= 2;
699 }
700 }
701
702 switch (encoder->force_profile) {
703 case SCHRO_ENCODER_PROFILE_VC2_LOW_DELAY:
704 encoder->profile = SCHRO_PROFILE_LOW_DELAY;
705 encoder->rate_control = SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY;
706 encoder->gop_structure = SCHRO_ENCODER_GOP_INTRA_ONLY;
707 encoder->au_distance = 1;
708 break;
709 case SCHRO_ENCODER_PROFILE_VC2_SIMPLE:
710 encoder->profile = SCHRO_PROFILE_SIMPLE;
711 encoder->enable_noarith = TRUE;
712 encoder->gop_structure = SCHRO_ENCODER_GOP_INTRA_ONLY;
713 encoder->au_distance = 1;
714 break;
715 case SCHRO_ENCODER_PROFILE_VC2_MAIN:
716 encoder->profile = SCHRO_PROFILE_MAIN_INTRA;
717 encoder->enable_noarith = FALSE;
718 encoder->gop_structure = SCHRO_ENCODER_GOP_INTRA_ONLY;
719 encoder->au_distance = 1;
720 break;
721 case SCHRO_ENCODER_PROFILE_MAIN:
722 encoder->profile = SCHRO_PROFILE_MAIN;
723 encoder->enable_noarith = FALSE;
724 break;
725 case SCHRO_ENCODER_PROFILE_AUTO:
726 default:
727 SCHRO_ASSERT (0);
728 }
729
730 switch (encoder->rate_control) {
731 case SCHRO_ENCODER_RATE_CONTROL_CONSTANT_NOISE_THRESHOLD:
732 handle_gop_enum (encoder);
733 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_SIMPLE;
734 break;
735 case SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE:
736 handle_gop_enum (encoder);
737 if (encoder->enable_rdo_cbr) {
738 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_CBR;
739 } else {
740 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_RDO_BIT_ALLOCATION;
741 }
742 schro_encoder_init_rc_buffer (encoder);
743
744 schro_encoder_encode_bitrate_comment (encoder, encoder->bitrate);
745 break;
746 case SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY:
747 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_LOWDELAY;
748
749 encoder->init_frame = schro_encoder_init_frame;
750 encoder->handle_gop = schro_encoder_handle_gop_lowdelay;
751 encoder->handle_quants = schro_encoder_handle_quants;
752 encoder->setup_frame = schro_encoder_setup_frame_lowdelay;
753
754 schro_encoder_encode_bitrate_comment (encoder, encoder->bitrate);
755 break;
756 case SCHRO_ENCODER_RATE_CONTROL_LOSSLESS:
757 if (encoder->force_profile == SCHRO_ENCODER_PROFILE_MAIN) {
758 encoder->handle_gop = schro_encoder_handle_gop_lossless;
759 } else {
760 encoder->handle_gop = schro_encoder_handle_gop_intra_only;
761 }
762 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_LOSSLESS;
763 encoder->init_frame = schro_encoder_init_frame;
764 encoder->handle_quants = schro_encoder_handle_quants;
765 encoder->setup_frame = schro_encoder_setup_frame_tworef;
766 break;
767 case SCHRO_ENCODER_RATE_CONTROL_CONSTANT_LAMBDA:
768 handle_gop_enum (encoder);
769 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_RDO_LAMBDA;
770 break;
771 case SCHRO_ENCODER_RATE_CONTROL_CONSTANT_ERROR:
772 handle_gop_enum (encoder);
773 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_CONSTANT_ERROR;
774 break;
775 case SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY:
776 handle_gop_enum (encoder);
777 encoder->quantiser_engine = SCHRO_QUANTISER_ENGINE_RDO_LAMBDA;
778 break;
779 default:
780 SCHRO_ASSERT (0);
781 }
782
783 encoder->level = 0;
784 encoder->video_format.index =
785 schro_video_format_get_std_video_format (&encoder->video_format);
786 switch (encoder->profile) {
787 case SCHRO_PROFILE_LOW_DELAY:
788 case SCHRO_PROFILE_SIMPLE:
789 case SCHRO_PROFILE_MAIN_INTRA:
790 if (schro_video_format_check_VC2_DL (&encoder->video_format)) {
791 encoder->level = 1;
792 }
793 break;
794 case SCHRO_PROFILE_MAIN:
795 if (schro_video_format_check_MP_DL (&encoder->video_format)) {
796 encoder->level = 128;
797 }
798 break;
799 default:
800 SCHRO_ASSERT (0);
801 }
802
803 {
804 /* 1, 3, 4, 6 have overflows at transform-depth>=5
805 * 5 has errors at transform-depth=any */
806 const int max_transform_depths[] = { 5, 4, 5, 4, 4, 3, 4 };
807
808 encoder->transform_depth = MIN (encoder->transform_depth,
809 max_transform_depths[encoder->intra_wavelet]);
810 if (encoder->gop_structure != SCHRO_ENCODER_GOP_INTRA_ONLY) {
811 encoder->transform_depth = MIN (encoder->transform_depth,
812 max_transform_depths[encoder->inter_wavelet]);
813 }
814 }
815
816 encoder->start_time = schro_utils_get_time ();
817 }
818
819 /**
820 * schro_encoder_free:
821 * @encoder: an encoder object
822 *
823 * Frees an encoder object and all its resources.
824 */
825 void
schro_encoder_free(SchroEncoder * encoder)826 schro_encoder_free (SchroEncoder * encoder)
827 {
828 int i;
829
830 if (encoder->async) {
831 schro_async_free (encoder->async);
832 }
833
834 if (encoder->last_frame) {
835 schro_encoder_frame_unref (encoder->last_frame);
836 encoder->last_frame = NULL;
837 }
838
839 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
840 if (encoder->reference_pictures[i]) {
841 schro_encoder_frame_unref (encoder->reference_pictures[i]);
842 encoder->reference_pictures[i] = NULL;
843 }
844 }
845 if (encoder->frame_queue) {
846 schro_queue_free (encoder->frame_queue);
847 }
848
849 if (encoder->inserted_buffers) {
850 schro_list_free (encoder->inserted_buffers);
851 }
852
853 schro_free (encoder);
854 }
855
856 static void
schro_encoder_init_perceptual_weighting(SchroEncoder * encoder)857 schro_encoder_init_perceptual_weighting (SchroEncoder * encoder)
858 {
859 encoder->cycles_per_degree_vert = 0.5 * encoder->video_format.height /
860 (2.0 * atan (0.5 / encoder->perceptual_distance) * 180 / M_PI);
861 encoder->cycles_per_degree_horiz = encoder->cycles_per_degree_vert *
862 encoder->video_format.aspect_ratio_denominator /
863 encoder->video_format.aspect_ratio_numerator;
864
865 if (encoder->video_format.interlaced_coding) {
866 encoder->cycles_per_degree_vert *= 0.5;
867 }
868
869 SCHRO_DEBUG ("cycles per degree horiz=%g vert=%g",
870 encoder->cycles_per_degree_horiz, encoder->cycles_per_degree_vert);
871
872 switch (encoder->perceptual_weighting) {
873 default:
874 case SCHRO_ENCODER_PERCEPTUAL_CONSTANT:
875 schro_encoder_calculate_subband_weights (encoder,
876 schro_encoder_perceptual_weight_constant);
877 break;
878 case SCHRO_ENCODER_PERCEPTUAL_CCIR959:
879 schro_encoder_calculate_subband_weights (encoder,
880 schro_encoder_perceptual_weight_ccir959);
881 break;
882 case SCHRO_ENCODER_PERCEPTUAL_MOO:
883 schro_encoder_calculate_subband_weights (encoder,
884 schro_encoder_perceptual_weight_moo);
885 break;
886 case SCHRO_ENCODER_PERCEPTUAL_MANOS_SAKRISON:
887 schro_encoder_calculate_subband_weights (encoder,
888 schro_encoder_perceptual_weight_manos_sakrison);
889 break;
890 }
891 }
892
893 /**
894 * schro_encoder_get_video_format:
895 * @encoder: an encoder object
896 *
897 * Creates a new SchroVideoFormat structure and copies the
898 * video format information of @decoder into it.
899 *
900 * When no longer needed, the returned pointer should be
901 * freed using free().
902 *
903 * Returns: a pointer to a SchroVideoFormat structure
904 */
905 SchroVideoFormat *
schro_encoder_get_video_format(SchroEncoder * encoder)906 schro_encoder_get_video_format (SchroEncoder * encoder)
907 {
908 SchroVideoFormat *format;
909
910 format = malloc (sizeof (SchroVideoFormat));
911 memcpy (format, &encoder->video_format, sizeof (SchroVideoFormat));
912
913 return format;
914 }
915
916 /**
917 * schro_encoder_set_video_format:
918 * @encoder: an encoder object
919 * @format: the video format to use
920 *
921 * Sets the video format used by @encoder to the values specified
922 * in @format. This function may only be called before schro_encoder_start()
923 * is called on the encoder.
924 */
925 void
schro_encoder_set_video_format(SchroEncoder * encoder,SchroVideoFormat * format)926 schro_encoder_set_video_format (SchroEncoder * encoder,
927 SchroVideoFormat * format)
928 {
929 /* FIXME check that we're in the right state to do this */
930
931 memcpy (&encoder->video_format, format, sizeof (SchroVideoFormat));
932
933 schro_video_format_validate (&encoder->video_format);
934 }
935
936 /**
937 * schro_encoder_set_packet_assembly:
938 * @encoder: an encoder object
939 * @value:
940 *
941 * If @value is TRUE, all subsequent calls to schro_encoder_pull()
942 * will return a buffer that contains all Dirac packets related to
943 * a frame. If @value is FALSE, each buffer will be one Dirac packet.
944 *
945 * It is recommended that users always call this function with TRUE
946 * immediately after creating an encoder object.
947 */
948 void
schro_encoder_set_packet_assembly(SchroEncoder * encoder,int value)949 schro_encoder_set_packet_assembly (SchroEncoder * encoder, int value)
950 {
951 encoder->assemble_packets = value;
952 }
953
954 static int
schro_encoder_push_is_ready_locked(SchroEncoder * encoder)955 schro_encoder_push_is_ready_locked (SchroEncoder * encoder)
956 {
957 int n;
958
959 if (encoder->end_of_stream) {
960 return FALSE;
961 }
962
963 n = schro_queue_slots_available (encoder->frame_queue);
964
965 if (encoder->video_format.interlaced_coding) {
966 return (n >= 2);
967 } else {
968 return (n >= 1);
969 }
970 }
971
972 /**
973 * schro_encoder_push_ready:
974 * @encoder: an encoder object
975 *
976 * Returns true if the encoder has available space for additional
977 * video frames.
978 *
979 * Returns: TRUE if the encoder is ready for another video frame to
980 * be pushed.
981 */
982 int
schro_encoder_push_ready(SchroEncoder * encoder)983 schro_encoder_push_ready (SchroEncoder * encoder)
984 {
985 int ret;
986
987 schro_async_lock (encoder->async);
988 ret = schro_encoder_push_is_ready_locked (encoder);
989 schro_async_unlock (encoder->async);
990
991 return ret;
992 }
993
994 /**
995 * schro_encoder_force_sequence_header:
996 * @encoder: an encoder object
997 *
998 * Indicates to the encoder that the next frame pushed should be
999 * encoded with a sequence header.
1000 */
1001 void
schro_encoder_force_sequence_header(SchroEncoder * encoder)1002 schro_encoder_force_sequence_header (SchroEncoder * encoder)
1003 {
1004 encoder->force_sequence_header = TRUE;
1005 }
1006
1007 /**
1008 * schro_encoder_push_frame:
1009 * @encoder: an encoder object
1010 * @frame: a frame to encode
1011 *
1012 * Provides a frame to the encoder to encode.
1013 */
1014 void
schro_encoder_push_frame(SchroEncoder * encoder,SchroFrame * frame)1015 schro_encoder_push_frame (SchroEncoder * encoder, SchroFrame * frame)
1016 {
1017 schro_encoder_push_frame_full (encoder, frame, NULL);
1018 }
1019
1020 /**
1021 * schro_encoder_push_frame_full:
1022 * @encoder: an encoder object
1023 * @frame: a frame to encode
1024 * @priv: a private tag
1025 *
1026 * Provides a frame to the encoder to encode. The value of @priv is
1027 * returned when schro_encoder_pull_full() is called for the encoded
1028 * frame.
1029 */
1030 void
schro_encoder_push_frame_full(SchroEncoder * encoder,SchroFrame * frame,void * priv)1031 schro_encoder_push_frame_full (SchroEncoder * encoder, SchroFrame * frame,
1032 void *priv)
1033 {
1034 schro_async_lock (encoder->async);
1035 if (encoder->video_format.interlaced_coding == 0) {
1036 SchroEncoderFrame *encoder_frame;
1037 SchroFrameFormat format;
1038
1039 encoder_frame = schro_encoder_frame_new (encoder);
1040 encoder_frame->encoder = encoder;
1041
1042 encoder_frame->priv = priv;
1043
1044 encoder_frame->previous_frame = encoder->last_frame;
1045 schro_encoder_frame_ref (encoder_frame);
1046 encoder->last_frame = encoder_frame;
1047
1048 format =
1049 schro_params_get_frame_format (encoder->input_frame_depth, encoder->video_format.chroma_format);
1050 if (format == frame->format) {
1051 encoder_frame->original_frame = frame;
1052 } else {
1053 encoder_frame->original_frame = schro_frame_new_and_alloc (NULL, format,
1054 encoder->video_format.width, encoder->video_format.height);
1055 schro_frame_convert (encoder_frame->original_frame, frame);
1056 schro_frame_unref (frame);
1057 frame = NULL;
1058 }
1059
1060 encoder_frame->frame_number = encoder->next_frame_number++;
1061
1062 if (schro_queue_is_full (encoder->frame_queue)) {
1063 SCHRO_ERROR ("push when queue full");
1064 SCHRO_ASSERT (0);
1065 }
1066 schro_queue_add (encoder->frame_queue, encoder_frame,
1067 encoder_frame->frame_number);
1068 schro_async_signal_scheduler (encoder->async);
1069 schro_async_unlock (encoder->async);
1070 } else {
1071 SchroEncoderFrame *encoder_frame1;
1072 SchroEncoderFrame *encoder_frame2;
1073 SchroFrameFormat format;
1074 int width, height;
1075
1076 encoder_frame1 = schro_encoder_frame_new (encoder);
1077 encoder_frame1->encoder = encoder;
1078 encoder_frame1->priv = priv;
1079 encoder_frame2 = schro_encoder_frame_new (encoder);
1080 encoder_frame2->encoder = encoder;
1081
1082 encoder_frame1->previous_frame = encoder->last_frame;
1083 schro_encoder_frame_ref (encoder_frame1);
1084 encoder_frame2->previous_frame = encoder_frame1;
1085 schro_encoder_frame_ref (encoder_frame2);
1086 encoder->last_frame = encoder_frame2;
1087
1088 schro_video_format_get_picture_luma_size (&encoder->video_format,
1089 &width, &height);
1090 format = schro_params_get_frame_format (encoder->input_frame_depth,
1091 encoder->video_format.chroma_format);
1092
1093 encoder_frame1->original_frame = schro_frame_new_and_alloc (NULL, format,
1094 width, height);
1095 encoder_frame2->original_frame = schro_frame_new_and_alloc (NULL, format,
1096 width, height);
1097 schro_frame_split_fields (encoder_frame1->original_frame,
1098 encoder_frame2->original_frame, frame);
1099 schro_frame_unref (frame);
1100 frame = NULL;
1101
1102 encoder_frame1->frame_number = encoder->next_frame_number++;
1103 encoder_frame2->frame_number = encoder->next_frame_number++;
1104
1105 if (schro_queue_slots_available (encoder->frame_queue) < 2) {
1106 SCHRO_ERROR ("push when queue full");
1107 SCHRO_ASSERT (0);
1108 }
1109 schro_queue_add (encoder->frame_queue, encoder_frame1,
1110 encoder_frame1->frame_number);
1111 schro_queue_add (encoder->frame_queue, encoder_frame2,
1112 encoder_frame2->frame_number);
1113 schro_async_signal_scheduler (encoder->async);
1114 schro_async_unlock (encoder->async);
1115 }
1116 }
1117
1118 static int
schro_encoder_pull_is_ready_locked(SchroEncoder * encoder)1119 schro_encoder_pull_is_ready_locked (SchroEncoder * encoder)
1120 {
1121 int i;
1122
1123 for (i = 0; i < encoder->frame_queue->n; i++) {
1124 SchroEncoderFrame *frame;
1125 frame = encoder->frame_queue->elements[i].data;
1126 if (frame->slot == encoder->output_slot &&
1127 (frame->stages[SCHRO_ENCODER_FRAME_STAGE_DONE].is_done)) {
1128 return TRUE;
1129 }
1130 }
1131
1132 if (schro_queue_is_empty (encoder->frame_queue) && encoder->end_of_stream
1133 && !encoder->end_of_stream_pulled) {
1134 return TRUE;
1135 }
1136
1137 return FALSE;
1138 }
1139
1140 static void
schro_encoder_shift_frame_queue(SchroEncoder * encoder)1141 schro_encoder_shift_frame_queue (SchroEncoder * encoder)
1142 {
1143 SchroEncoderFrame *frame;
1144
1145 while (!schro_queue_is_empty (encoder->frame_queue)) {
1146 frame = encoder->frame_queue->elements[0].data;
1147 if (!(frame->stages[SCHRO_ENCODER_FRAME_STAGE_FREE].is_done)) {
1148 break;
1149 }
1150
1151 schro_queue_pop (encoder->frame_queue);
1152 }
1153 }
1154
1155 /**
1156 * schro_encoder_pull:
1157 * @encoder: an encoder object
1158 * @presentation_frame: (output) latest decodable frame
1159 *
1160 * Pulls a buffer of compressed video from the encoder. If
1161 * @presentation_frame is not NULL, the frame number of the
1162 * latest decodable frame is returned.
1163 *
1164 * Returns: a buffer containing compressed video
1165 */
1166 SchroBuffer *
schro_encoder_pull(SchroEncoder * encoder,int * presentation_frame)1167 schro_encoder_pull (SchroEncoder * encoder, int *presentation_frame)
1168 {
1169 return schro_encoder_pull_full (encoder, presentation_frame, NULL);
1170 }
1171
1172 static int
schro_encoder_frame_get_encoded_size(SchroEncoderFrame * frame)1173 schro_encoder_frame_get_encoded_size (SchroEncoderFrame * frame)
1174 {
1175 SchroBuffer *buffer;
1176 int size = 0;
1177 int i;
1178
1179 if (frame->sequence_header_buffer) {
1180 size += frame->sequence_header_buffer->length;
1181 }
1182
1183 for (i = 0; i < schro_list_get_size (frame->inserted_buffers); i++) {
1184 buffer = schro_list_get (frame->inserted_buffers, i);
1185 size += buffer->length;
1186 }
1187 for (i = 0; i < schro_list_get_size (frame->encoder->inserted_buffers); i++) {
1188 buffer = schro_list_get (frame->encoder->inserted_buffers, i);
1189 size += buffer->length;
1190 }
1191
1192 size += frame->output_buffer->length;
1193
1194 return size;
1195 }
1196
1197 static void
schro_encoder_frame_assemble_buffer(SchroEncoderFrame * frame,SchroBuffer * buffer)1198 schro_encoder_frame_assemble_buffer (SchroEncoderFrame * frame,
1199 SchroBuffer * buffer)
1200 {
1201 SchroBuffer *buf;
1202 int offset = 0;
1203 int i;
1204
1205 if (frame->sequence_header_buffer) {
1206 buf = frame->sequence_header_buffer;
1207 schro_encoder_fixup_offsets (frame->encoder, buf, FALSE);
1208 orc_memcpy (buffer->data + offset, buf->data, buf->length);
1209 offset += frame->sequence_header_buffer->length;
1210 }
1211
1212 for (i = 0; i < schro_list_get_size (frame->inserted_buffers); i++) {
1213 buf = schro_list_get (frame->inserted_buffers, i);
1214 schro_encoder_fixup_offsets (frame->encoder, buf, FALSE);
1215 orc_memcpy (buffer->data + offset, buf->data, buf->length);
1216 offset += buf->length;
1217 }
1218 while (schro_list_get_size (frame->encoder->inserted_buffers) > 0) {
1219 buf = schro_list_remove (frame->encoder->inserted_buffers, 0);
1220 schro_encoder_fixup_offsets (frame->encoder, buf, FALSE);
1221 orc_memcpy (buffer->data + offset, buf->data, buf->length);
1222 offset += buf->length;
1223 schro_buffer_unref (buf);
1224 buf = NULL;
1225 }
1226
1227 buf = frame->output_buffer;
1228 schro_encoder_fixup_offsets (frame->encoder, buf, FALSE);
1229 orc_memcpy (buffer->data + offset, buf->data, buf->length);
1230 offset += buf->length;
1231 }
1232
1233 int
schro_encoder_get_frame_stats_size(SchroEncoder * encoder)1234 schro_encoder_get_frame_stats_size (SchroEncoder * encoder)
1235 {
1236 return 21;
1237 }
1238
1239 void
schro_encoder_get_frame_stats(SchroEncoder * encoder,double * dest,int n)1240 schro_encoder_get_frame_stats (SchroEncoder * encoder, double *dest, int n)
1241 {
1242 memcpy (dest, encoder->frame_stats, sizeof (double) * MIN (n, 21));
1243 }
1244
1245 /**
1246 * schro_encoder_pull_full:
1247 * @encoder: an encoder object
1248 * @presentation_frame: (output) latest decodable frame
1249 * @priv: (output)
1250 *
1251 * Pulls a buffer of compressed video from the encoder. If
1252 * @presentation_frame is not NULL, the frame number of the
1253 * latest decodable frame is returned. If @priv is not NULL,
1254 * the private tag attached to the pushed uncompressed frame
1255 * is returned.
1256 *
1257 * Returns: a buffer containing compressed video
1258 */
1259 SchroBuffer *
schro_encoder_pull_full(SchroEncoder * encoder,int * presentation_frame,void ** priv)1260 schro_encoder_pull_full (SchroEncoder * encoder, int *presentation_frame,
1261 void **priv)
1262 {
1263 SchroBuffer *buffer;
1264 int i;
1265 int done = FALSE;
1266
1267 SCHRO_DEBUG ("pulling slot %d", encoder->output_slot);
1268
1269 schro_async_lock (encoder->async);
1270 for (i = 0; i < encoder->frame_queue->n; i++) {
1271 SchroEncoderFrame *frame;
1272 frame = encoder->frame_queue->elements[i].data;
1273 if (frame->slot == encoder->output_slot &&
1274 (frame->stages[SCHRO_ENCODER_FRAME_STAGE_DONE].is_done)) {
1275 int is_picture = FALSE;
1276
1277 if (presentation_frame) {
1278 *presentation_frame = frame->presentation_frame;
1279 }
1280
1281 if (encoder->assemble_packets) {
1282 int size;
1283
1284 size = schro_encoder_frame_get_encoded_size (frame);
1285 buffer = schro_buffer_new_and_alloc (size);
1286 schro_encoder_frame_assemble_buffer (frame, buffer);
1287
1288 if (priv) {
1289 *priv = frame->priv;
1290 }
1291 done = TRUE;
1292 } else {
1293 if (frame->sequence_header_buffer) {
1294 buffer = frame->sequence_header_buffer;
1295 frame->sequence_header_buffer = NULL;
1296 } else if (schro_list_get_size (frame->inserted_buffers) > 0) {
1297 buffer = schro_list_remove (frame->inserted_buffers, 0);
1298 } else if (schro_list_get_size (encoder->inserted_buffers) > 0) {
1299 buffer = schro_list_remove (encoder->inserted_buffers, 0);
1300 } else {
1301 if (priv) {
1302 *priv = frame->priv;
1303 }
1304 buffer = frame->output_buffer;
1305 frame->output_buffer = NULL;
1306
1307 done = TRUE;
1308 }
1309 }
1310 if (done) {
1311 double elapsed_time;
1312
1313 is_picture = TRUE;
1314 frame->stages[SCHRO_ENCODER_FRAME_STAGE_FREE].is_done = TRUE;
1315 encoder->output_slot++;
1316
1317 elapsed_time = schro_utils_get_time () - encoder->start_time;
1318
1319 if (frame->num_refs == 0) {
1320 frame->badblock_ratio = 0;
1321 frame->dcblock_ratio = 0;
1322 frame->mc_error = 0;
1323 }
1324
1325 schro_dump (SCHRO_DUMP_PICTURE, "%d %d %d %d %d %g %d %d %d %d %g %d %g %g %g %g %g %g %g %g\n", frame->frame_number, /* 0 */
1326 frame->num_refs, frame->is_ref, frame->allocated_mc_bits, frame->allocated_residual_bits, frame->picture_weight, /* 5 */
1327 frame->estimated_mc_bits, frame->estimated_residual_bits, frame->actual_mc_bits, frame->actual_residual_bits, frame->scene_change_score, /* 10 */
1328 encoder->buffer_level, frame->frame_lambda, frame->mc_error, frame->mean_squared_error_luma, frame->mean_squared_error_chroma, /* 15 */
1329 elapsed_time,
1330 frame->badblock_ratio, frame->dcblock_ratio, frame->hist_slope);
1331
1332 encoder->frame_stats[0] = frame->frame_number;
1333 encoder->frame_stats[1] = frame->num_refs;
1334 encoder->frame_stats[2] = frame->is_ref;
1335 encoder->frame_stats[3] = frame->allocated_mc_bits;
1336 encoder->frame_stats[4] = frame->allocated_residual_bits;
1337 encoder->frame_stats[5] = frame->picture_weight;
1338 encoder->frame_stats[6] = frame->estimated_mc_bits;
1339 encoder->frame_stats[7] = frame->estimated_residual_bits;
1340 encoder->frame_stats[8] = frame->actual_mc_bits;
1341 encoder->frame_stats[8] = frame->actual_residual_bits;
1342 encoder->frame_stats[10] = frame->scene_change_score;
1343 encoder->frame_stats[11] = encoder->buffer_level;
1344 encoder->frame_stats[12] = frame->frame_lambda;
1345 encoder->frame_stats[13] = frame->mc_error;
1346 encoder->frame_stats[14] = frame->mean_squared_error_luma;
1347 encoder->frame_stats[15] = frame->mean_squared_error_chroma;
1348 encoder->frame_stats[16] = elapsed_time;
1349 encoder->frame_stats[17] = frame->badblock_ratio;
1350 encoder->frame_stats[18] = frame->dcblock_ratio;
1351 encoder->frame_stats[19] = frame->hist_slope;
1352 encoder->frame_stats[20] = frame->mssim;
1353
1354 schro_encoder_shift_frame_queue (encoder);
1355 }
1356
1357 if (encoder->rate_control == SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE) {
1358 encoder->buffer_level -= buffer->length * 8;
1359 if (is_picture) {
1360 if (encoder->buffer_level < 0) {
1361 SCHRO_WARNING ("buffer underrun by %d bits",
1362 -encoder->buffer_level);
1363 encoder->buffer_level = 0;
1364 }
1365 encoder->buffer_level += encoder->bits_per_picture;
1366 if (encoder->buffer_level > encoder->buffer_size) {
1367 int n;
1368
1369 n = (encoder->buffer_level - encoder->buffer_size + 7) / 8;
1370 SCHRO_DEBUG ("buffer overrun, adding padding of %d bytes", n);
1371 n = schro_encoder_encode_padding (encoder, n);
1372 encoder->buffer_level -= n * 8;
1373 }
1374 SCHRO_DEBUG ("buffer level %d of %d bits", encoder->buffer_level,
1375 encoder->buffer_size);
1376 }
1377 }
1378
1379 if (!encoder->assemble_packets) {
1380 schro_encoder_fixup_offsets (encoder, buffer, FALSE);
1381 }
1382
1383 SCHRO_DEBUG ("got buffer length=%d", buffer->length);
1384 schro_async_unlock (encoder->async);
1385 return buffer;
1386 }
1387 }
1388
1389 if (schro_queue_is_empty (encoder->frame_queue) && encoder->end_of_stream) {
1390 buffer = schro_encoder_encode_end_of_stream (encoder);
1391 schro_encoder_fixup_offsets (encoder, buffer, TRUE);
1392 encoder->end_of_stream_pulled = TRUE;
1393
1394 schro_async_unlock (encoder->async);
1395 return buffer;
1396 }
1397 schro_async_unlock (encoder->async);
1398
1399 SCHRO_DEBUG ("got nothing");
1400 return NULL;
1401 }
1402
1403 /**
1404 * schro_encoder_end_of_stream:
1405 * @encoder: an encoder object
1406 *
1407 * Tells the encoder that the end of the stream has been reached, and
1408 * no more frames are available to encode. The encoder will then
1409 * finish encoding.
1410 */
1411 void
schro_encoder_end_of_stream(SchroEncoder * encoder)1412 schro_encoder_end_of_stream (SchroEncoder * encoder)
1413 {
1414 encoder->end_of_stream = TRUE;
1415 schro_async_lock (encoder->async);
1416 if (encoder->frame_queue->n > 0) {
1417 SchroEncoderFrame *encoder_frame;
1418
1419 encoder_frame =
1420 encoder->frame_queue->elements[encoder->frame_queue->n - 1].data;
1421 encoder_frame->last_frame = TRUE;
1422 }
1423 schro_async_unlock (encoder->async);
1424 }
1425
1426 static void
schro_encoder_fixup_offsets(SchroEncoder * encoder,SchroBuffer * buffer,schro_bool is_eos)1427 schro_encoder_fixup_offsets (SchroEncoder * encoder, SchroBuffer * buffer,
1428 schro_bool is_eos)
1429 {
1430 uint8_t *data = buffer->data;
1431 unsigned int next_offset;
1432
1433 if (buffer->length < 13) {
1434 SCHRO_ERROR ("packet too short (%d < 13)", buffer->length);
1435 }
1436
1437 if (is_eos) {
1438 next_offset = 0;
1439 } else {
1440 next_offset = buffer->length;
1441 }
1442
1443 data[5] = (next_offset >> 24) & 0xff;
1444 data[6] = (next_offset >> 16) & 0xff;
1445 data[7] = (next_offset >> 8) & 0xff;
1446 data[8] = (next_offset >> 0) & 0xff;
1447 data[9] = (encoder->prev_offset >> 24) & 0xff;
1448 data[10] = (encoder->prev_offset >> 16) & 0xff;
1449 data[11] = (encoder->prev_offset >> 8) & 0xff;
1450 data[12] = (encoder->prev_offset >> 0) & 0xff;
1451
1452 encoder->prev_offset = next_offset;
1453 }
1454
1455 static int
schro_encoder_encode_padding(SchroEncoder * encoder,int n)1456 schro_encoder_encode_padding (SchroEncoder * encoder, int n)
1457 {
1458 SchroBuffer *buffer;
1459 SchroPack *pack;
1460
1461 if (n < SCHRO_PARSE_HEADER_SIZE)
1462 n = SCHRO_PARSE_HEADER_SIZE;
1463
1464 buffer = schro_buffer_new_and_alloc (n);
1465
1466 pack = schro_pack_new ();
1467 schro_pack_encode_init (pack, buffer);
1468
1469 schro_encoder_encode_parse_info (pack, SCHRO_PARSE_CODE_PADDING);
1470
1471 schro_pack_append_zero (pack, n - SCHRO_PARSE_HEADER_SIZE);
1472
1473 schro_pack_free (pack);
1474
1475 schro_encoder_insert_buffer (encoder, buffer);
1476
1477 return n;
1478 }
1479
1480 static void
schro_encoder_encode_codec_comment(SchroEncoder * encoder)1481 schro_encoder_encode_codec_comment (SchroEncoder * encoder)
1482 {
1483 const char *s = "Schroedinger " VERSION;
1484 SchroBuffer *buffer;
1485
1486 buffer = schro_encoder_encode_auxiliary_data (encoder,
1487 SCHRO_AUX_DATA_ENCODER_STRING, s, strlen (s));
1488
1489 schro_encoder_insert_buffer (encoder, buffer);
1490 }
1491
1492 static void
schro_encoder_encode_bitrate_comment(SchroEncoder * encoder,unsigned int bitrate)1493 schro_encoder_encode_bitrate_comment (SchroEncoder * encoder,
1494 unsigned int bitrate)
1495 {
1496 uint8_t s[4];
1497 SchroBuffer *buffer;
1498
1499 s[0] = (bitrate >> 24) & 0xff;
1500 s[1] = (bitrate >> 16) & 0xff;
1501 s[2] = (bitrate >> 8) & 0xff;
1502 s[3] = (bitrate >> 0) & 0xff;
1503 buffer = schro_encoder_encode_auxiliary_data (encoder,
1504 SCHRO_AUX_DATA_BITRATE, s, 4);
1505
1506 schro_encoder_insert_buffer (encoder, buffer);
1507 }
1508
1509 static void
schro_encoder_encode_md5_checksum(SchroEncoderFrame * frame)1510 schro_encoder_encode_md5_checksum (SchroEncoderFrame * frame)
1511 {
1512 SchroBuffer *buffer;
1513 uint32_t checksum[4];
1514
1515 schro_frame_md5 (frame->reconstructed_frame->frames[0], checksum);
1516 buffer = schro_encoder_encode_auxiliary_data (frame->encoder,
1517 SCHRO_AUX_DATA_MD5_CHECKSUM, checksum, 16);
1518
1519 schro_encoder_frame_insert_buffer (frame, buffer);
1520 }
1521
1522 /**
1523 * schro_encoder_insert_buffer:
1524 * @encoder: an encoder object
1525 * @buffer: a buffer
1526 *
1527 * Inserts an application-provided buffer into the encoded video stream
1528 * with the next frame that is pushed.
1529 */
1530 void
schro_encoder_insert_buffer(SchroEncoder * encoder,SchroBuffer * buffer)1531 schro_encoder_insert_buffer (SchroEncoder * encoder, SchroBuffer * buffer)
1532 {
1533 schro_list_append (encoder->inserted_buffers, buffer);
1534 }
1535
1536 /**
1537 * schro_encoder_frame_insert_buffer:
1538 * @frame: an encoder frame
1539 * @buffer: a buffer
1540 *
1541 * Inserts a buffer into an encoder frame.
1542 */
1543 void
schro_encoder_frame_insert_buffer(SchroEncoderFrame * frame,SchroBuffer * buffer)1544 schro_encoder_frame_insert_buffer (SchroEncoderFrame * frame,
1545 SchroBuffer * buffer)
1546 {
1547 schro_list_append (frame->inserted_buffers, buffer);
1548 }
1549
1550 /**
1551 * schro_encoder_encode_auxiliary_data:
1552 * @encoder:
1553 * @id:
1554 * @data:
1555 * @size:
1556 *
1557 * Packs data into a Dirac auxiliary data packet.
1558 *
1559 * Returns: a buffer
1560 */
1561 SchroBuffer *
schro_encoder_encode_auxiliary_data(SchroEncoder * encoder,SchroAuxiliaryDataID id,const void * data,int size)1562 schro_encoder_encode_auxiliary_data (SchroEncoder * encoder,
1563 SchroAuxiliaryDataID id, const void *data, int size)
1564 {
1565 SchroPack *pack;
1566 SchroBuffer *buffer;
1567
1568 buffer = schro_buffer_new_and_alloc (size + SCHRO_PARSE_HEADER_SIZE + 1);
1569
1570 pack = schro_pack_new ();
1571 schro_pack_encode_init (pack, buffer);
1572
1573 schro_encoder_encode_parse_info (pack, SCHRO_PARSE_CODE_AUXILIARY_DATA);
1574 schro_pack_encode_bits (pack, 8, id);
1575 schro_pack_append (pack, data, size);
1576
1577 schro_pack_free (pack);
1578
1579 return buffer;
1580 }
1581
1582 /**
1583 * schro_encoder_encode_sequence_header:
1584 * @encoder: an encoder object
1585 *
1586 * Creates a buffer containing a sequence header.
1587 *
1588 * Returns: a buffer
1589 */
1590 SchroBuffer *
schro_encoder_encode_sequence_header(SchroEncoder * encoder)1591 schro_encoder_encode_sequence_header (SchroEncoder * encoder)
1592 {
1593 SchroPack *pack;
1594 SchroBuffer *buffer;
1595 SchroBuffer *subbuffer;
1596 int next_offset;
1597
1598 buffer = schro_buffer_new_and_alloc (0x100);
1599
1600 pack = schro_pack_new ();
1601 schro_pack_encode_init (pack, buffer);
1602
1603 schro_encoder_encode_sequence_header_header (encoder, pack);
1604
1605 schro_pack_flush (pack);
1606
1607 next_offset = schro_pack_get_offset (pack);
1608 buffer->data[5] = (next_offset >> 24) & 0xff;
1609 buffer->data[6] = (next_offset >> 16) & 0xff;
1610 buffer->data[7] = (next_offset >> 8) & 0xff;
1611 buffer->data[8] = (next_offset >> 0) & 0xff;
1612
1613 subbuffer = schro_buffer_new_subbuffer (buffer, 0,
1614 schro_pack_get_offset (pack));
1615 schro_pack_free (pack);
1616 schro_buffer_unref (buffer);
1617 buffer = NULL;
1618
1619 return subbuffer;
1620 }
1621
1622 /**
1623 * schro_encoder_encode_end_of_stream:
1624 * @encoder:
1625 *
1626 * Creates an end-of-stream packet.
1627 *
1628 * Returns: a buffer
1629 */
1630 SchroBuffer *
schro_encoder_encode_end_of_stream(SchroEncoder * encoder)1631 schro_encoder_encode_end_of_stream (SchroEncoder * encoder)
1632 {
1633 SchroPack *pack;
1634 SchroBuffer *buffer;
1635
1636 buffer = schro_buffer_new_and_alloc (SCHRO_PARSE_HEADER_SIZE);
1637
1638 pack = schro_pack_new ();
1639 schro_pack_encode_init (pack, buffer);
1640
1641 schro_encoder_encode_parse_info (pack, SCHRO_PARSE_CODE_END_OF_SEQUENCE);
1642
1643 schro_pack_free (pack);
1644
1645 return buffer;
1646 }
1647
1648 /**
1649 * schro_encoder_wait:
1650 * @encoder: an encoder object
1651 *
1652 * Checks the state of the encoder. If the encoder requires the
1653 * application to do something, an appropriate state code is returned.
1654 * Otherwise, this function waits until the encoder requires the
1655 * application to do something.
1656 *
1657 * Returns: a state code
1658 */
1659 SchroStateEnum
schro_encoder_wait(SchroEncoder * encoder)1660 schro_encoder_wait (SchroEncoder * encoder)
1661 {
1662 SchroStateEnum ret = SCHRO_STATE_AGAIN;
1663
1664 schro_async_lock (encoder->async);
1665 while (1) {
1666 if (schro_encoder_pull_is_ready_locked (encoder)) {
1667 SCHRO_DEBUG ("have buffer");
1668 ret = SCHRO_STATE_HAVE_BUFFER;
1669 break;
1670 }
1671 if (schro_encoder_push_is_ready_locked (encoder)) {
1672 SCHRO_DEBUG ("need frame");
1673 ret = SCHRO_STATE_NEED_FRAME;
1674 break;
1675 }
1676 if (schro_queue_is_empty (encoder->frame_queue)
1677 && encoder->end_of_stream_pulled) {
1678 ret = SCHRO_STATE_END_OF_STREAM;
1679 break;
1680 }
1681
1682 SCHRO_DEBUG ("encoder waiting");
1683 ret = schro_async_wait_locked (encoder->async);
1684 if (!ret) {
1685 int i;
1686
1687 SCHRO_WARNING ("deadlock? kicking scheduler");
1688 for (i = 0; i < encoder->frame_queue->n; i++) {
1689 SchroEncoderFrame *frame = encoder->frame_queue->elements[i].data;
1690 SCHRO_WARNING ("%d: %d %d %d %d %04x", i, frame->frame_number,
1691 frame->picture_number_ref[0], frame->picture_number_ref[1],
1692 frame->busy, 0 /*frame->state */ );
1693 }
1694 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
1695 SchroEncoderFrame *frame = encoder->reference_pictures[i];
1696 if (frame) {
1697 SCHRO_WARNING ("ref %d: %d %d %04x", i, frame->frame_number,
1698 frame->busy, 0 /*frame->state */ );
1699 } else {
1700 SCHRO_WARNING ("ref %d: NULL", i);
1701 }
1702 }
1703 //SCHRO_ASSERT(0);
1704 schro_async_signal_scheduler (encoder->async);
1705 ret = SCHRO_STATE_AGAIN;
1706 break;
1707 }
1708 }
1709 schro_async_unlock (encoder->async);
1710
1711 return ret;
1712 }
1713
1714 int
schro_encoder_frame_is_B_frame(SchroEncoderFrame * frame)1715 schro_encoder_frame_is_B_frame (SchroEncoderFrame * frame)
1716 {
1717 int is_B_frame = 0;
1718
1719 if (frame->num_refs == 2 &&
1720 ((frame->picture_number_ref[0] < frame->frame_number
1721 && frame->picture_number_ref[1] > frame->frame_number)
1722 || (frame->picture_number_ref[1] < frame->frame_number
1723 && frame->picture_number_ref[0] > frame->frame_number))) {
1724 is_B_frame = 1;
1725 }
1726
1727 return is_B_frame;
1728
1729 }
1730
1731
1732 static void
schro_encoder_frame_complete(SchroAsyncStage * stage)1733 schro_encoder_frame_complete (SchroAsyncStage * stage)
1734 {
1735 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
1736 int i;
1737
1738 SCHRO_INFO ("completing task, picture %d working %02x in state %02x",
1739 frame->frame_number, frame->working, 0 /*frame->state */ );
1740
1741 SCHRO_ASSERT (frame->busy == TRUE);
1742
1743 frame->busy = FALSE;
1744 stage->is_done = TRUE;
1745 frame->working = 0;
1746
1747 if (stage == frame->stages + SCHRO_ENCODER_FRAME_STAGE_POSTANALYSE) {
1748 frame->stages[SCHRO_ENCODER_FRAME_STAGE_DONE].is_done = TRUE;
1749
1750 SCHRO_ASSERT (frame->output_buffer_size > 0);
1751
1752 if (frame->previous_frame) {
1753 schro_encoder_frame_unref (frame->previous_frame);
1754 frame->previous_frame = NULL;
1755 }
1756 if (frame->motion) {
1757 schro_motion_free (frame->motion);
1758 frame->motion = NULL;
1759 }
1760 if (frame->me) {
1761 schro_motionest_free (frame->me);
1762 frame->me = NULL;
1763 }
1764 if (frame->ref_frame[0]) {
1765 schro_encoder_frame_unref (frame->ref_frame[0]);
1766 frame->ref_frame[0] = NULL;
1767 }
1768 if (frame->ref_frame[1]) {
1769 schro_encoder_frame_unref (frame->ref_frame[1]);
1770 frame->ref_frame[1] = NULL;
1771 }
1772
1773 if (frame->deep_me) {
1774 schro_me_free (frame->deep_me);
1775 frame->deep_me = NULL;
1776 }
1777
1778 for (i = 0; 2 > i; ++i) {
1779 if (frame->hier_bm[i]) {
1780 schro_hbm_unref (frame->hier_bm[i]);
1781 frame->hier_bm[i] = NULL;
1782 }
1783 }
1784
1785 if (!frame->is_ref) {
1786 for (i = 0; i < 5; i++) {
1787 if (frame->downsampled_frames[i]) {
1788 schro_frame_unref (frame->downsampled_frames[i]);
1789 frame->downsampled_frames[i] = NULL;
1790 }
1791 }
1792 }
1793
1794 if (frame->start_sequence_header) {
1795 frame->sequence_header_buffer =
1796 schro_encoder_encode_sequence_header (frame->encoder);
1797 }
1798 if (frame->last_frame) {
1799 frame->encoder->completed_eos = TRUE;
1800 }
1801 }
1802 }
1803
1804 static void
schro_encoder_sc_detect_1(SchroAsyncStage * stage)1805 schro_encoder_sc_detect_1 (SchroAsyncStage * stage)
1806 {
1807 SchroEncoderFrame *frame = stage->priv;
1808 SchroFrameData *comp1;
1809 SchroFrameData *comp2;
1810
1811 SCHRO_ASSERT (frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done
1812 && frame->previous_frame
1813 && frame->previous_frame->
1814 stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done);
1815
1816 comp1 = &frame->downsampled_frames[0]->components[0];
1817 comp2 = &frame->previous_frame->downsampled_frames[0]->components[0];
1818
1819 frame->sc_mad =
1820 schro_metric_absdiff_u8 (comp1->data, comp1->stride, comp2->data,
1821 comp2->stride, comp1->width, comp1->height);
1822 frame->sc_mad /= (comp1->width * comp1->height);
1823 frame->have_mad = 1;
1824 }
1825
1826
1827 /**
1828 * run_stage:
1829 * @frame:
1830 * @state:
1831 *
1832 * Runs a stage in the encoding process.
1833 */
1834 static void
run_stage(SchroEncoderFrame * frame,int stage)1835 run_stage (SchroEncoderFrame * frame, int stage)
1836 {
1837 void *func;
1838
1839 SCHRO_ASSERT (frame->stages[stage].is_done == FALSE);
1840
1841 frame->busy = TRUE;
1842 frame->working = stage;
1843 switch (stage) {
1844 case SCHRO_ENCODER_FRAME_STAGE_ANALYSE:
1845 func = schro_encoder_analyse_picture;
1846 break;
1847 case SCHRO_ENCODER_FRAME_STAGE_PREDICT_ROUGH:
1848 func = schro_encoder_predict_rough_picture;
1849 break;
1850 case SCHRO_ENCODER_FRAME_STAGE_PREDICT_PEL:
1851 func = schro_encoder_predict_pel_picture;
1852 break;
1853 case SCHRO_ENCODER_FRAME_STAGE_PREDICT_SUBPEL:
1854 func = schro_encoder_predict_subpel_picture;
1855 break;
1856 case SCHRO_ENCODER_FRAME_STAGE_MODE_DECISION:
1857 func = schro_encoder_mode_decision;
1858 break;
1859 case SCHRO_ENCODER_FRAME_STAGE_ENCODING:
1860 func = schro_encoder_encode_picture;
1861 break;
1862 case SCHRO_ENCODER_FRAME_STAGE_RECONSTRUCT:
1863 func = schro_encoder_reconstruct_picture;
1864 break;
1865 case SCHRO_ENCODER_FRAME_STAGE_POSTANALYSE:
1866 func = schro_encoder_postanalyse_picture;
1867 break;
1868 case SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_1:
1869 func = schro_encoder_sc_detect_1;
1870 break;
1871
1872 default:
1873 SCHRO_ASSERT (0);
1874 }
1875 frame->stages[stage].task_func = func;
1876 frame->stages[stage].priv = frame;
1877 schro_async_run_stage_locked (frame->encoder->async, frame->stages + stage);
1878 }
1879
1880 /**
1881 * check_refs:
1882 * @frame: encoder frame
1883 *
1884 * Checks whether reference pictures are available to be used for motion
1885 * rendering.
1886 */
1887 static int
check_refs(SchroEncoderFrame * frame)1888 check_refs (SchroEncoderFrame * frame)
1889 {
1890 if (frame->num_refs == 0)
1891 return TRUE;
1892
1893 if (frame->num_refs > 0 &&
1894 !(frame->ref_frame[0]->stages[SCHRO_ENCODER_FRAME_STAGE_DONE].is_done)) {
1895 return FALSE;
1896 }
1897 if (frame->num_refs > 1 &&
1898 !(frame->ref_frame[1]->stages[SCHRO_ENCODER_FRAME_STAGE_DONE].is_done)) {
1899 return FALSE;
1900 }
1901
1902 return TRUE;
1903 }
1904
1905 static void
calculate_sc_score(SchroEncoder * encoder)1906 calculate_sc_score (SchroEncoder * encoder)
1907 {
1908 #define SC_THRESHOLD_RANGE 2
1909 #define MAD_ARRAY_LEN SC_THRESHOLD_RANGE * 2 + 1
1910 #define BIG_INT 0xffffffff
1911 int i, j, end;
1912 int mad_array[MAD_ARRAY_LEN];
1913 SchroEncoderFrame *frame, *f, *f2;
1914
1915 /* calculate threshold first */
1916 for (i = SC_THRESHOLD_RANGE; encoder->frame_queue->n - SC_THRESHOLD_RANGE > i;
1917 ++i) {
1918 int mad_max = 0, mad_min = BIG_INT;
1919
1920 frame = encoder->frame_queue->elements[i].data;
1921 if (!frame->need_mad)
1922 continue;
1923 if (frame->have_scene_change_score)
1924 continue;
1925 if (0 > frame->sc_threshold) {
1926 memset (mad_array, -1, sizeof (mad_array));
1927 mad_array[SC_THRESHOLD_RANGE] = frame->sc_mad;
1928 for (j = 0; SC_THRESHOLD_RANGE > j; ++j) {
1929 f = encoder->frame_queue->elements[i - j - 1].data;
1930 mad_array[SC_THRESHOLD_RANGE - j - 1] = f->sc_mad;
1931 f = encoder->frame_queue->elements[i + j + 1].data;
1932 mad_array[SC_THRESHOLD_RANGE + j + 1] = f->sc_mad;
1933 }
1934 for (j = 0; MAD_ARRAY_LEN > j; ++j) {
1935 if (mad_array[j] > mad_max)
1936 mad_max = mad_array[j];
1937 if (mad_array[j] < mad_min)
1938 mad_min = mad_array[j];
1939 }
1940 frame->sc_threshold = mad_max + 0.8 * (mad_max - mad_min);
1941 }
1942 }
1943 /* and now calculate the score */
1944 for (i = SC_THRESHOLD_RANGE + 3;
1945 encoder->frame_queue->n - SC_THRESHOLD_RANGE - 3 > i; ++i) {
1946 frame = encoder->frame_queue->elements[i].data;
1947 if (!frame->need_mad)
1948 continue;
1949 if (frame->have_scene_change_score)
1950 continue;
1951 f = encoder->frame_queue->elements[i - 3].data;
1952 f2 = encoder->frame_queue->elements[i + 3].data;
1953 frame->scene_change_score =
1954 frame->sc_mad - (f->sc_threshold + f2->sc_threshold) / 2;
1955 frame->have_scene_change_score = 1;
1956 }
1957 /* finally we update the state of the processed items */
1958 if (encoder->queue_depth > encoder->frame_queue->n && encoder->end_of_stream) {
1959 /* end of sequence */
1960 end = encoder->frame_queue->n;
1961 } else {
1962 end = encoder->frame_queue->n - SC_THRESHOLD_RANGE - 3;
1963 }
1964 for (i = 0; end > i; ++i) {
1965 f = encoder->frame_queue->elements[i].data;
1966 f->stages[SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_2].is_done = TRUE;
1967 SCHRO_DEBUG ("calculate sc score for i=%d picture=%d state=%d", i,
1968 f->frame_number, 0 /* f->state */ );
1969 }
1970 }
1971
1972 #undef BIG_INT
1973
1974
1975 static int
schro_encoder_async_schedule(SchroEncoder * encoder,SchroExecDomain exec_domain)1976 schro_encoder_async_schedule (SchroEncoder * encoder,
1977 SchroExecDomain exec_domain)
1978 {
1979 SchroEncoderFrame *frame;
1980 int i;
1981 int ref;
1982
1983 SCHRO_INFO ("iterate %d", encoder->completed_eos);
1984
1985 for (i = 0; i < encoder->frame_queue->n; i++) {
1986 frame = encoder->frame_queue->elements[i].data;
1987 SCHRO_DEBUG ("analyse i=%d picture=%d state=%d busy=%d", i,
1988 frame->frame_number, 0 /*frame->state */ , frame->busy);
1989
1990 if (frame->busy)
1991 continue;
1992
1993 #define TODO(stage) (frame->stages[(stage)].is_needed && !frame->stages[(stage)].is_done)
1994
1995 if (TODO (SCHRO_ENCODER_FRAME_STAGE_ANALYSE)) {
1996 encoder->init_frame (frame);
1997 init_params (frame);
1998 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_ANALYSE);
1999 return TRUE;
2000 }
2001 }
2002
2003 if (encoder->enable_scene_change_detection) {
2004 /* calculate MAD for entire queue of frames */
2005 for (i = 0; encoder->frame_queue->n > i; ++i) {
2006 SchroEncoderFrame *prev_frame;
2007
2008 frame = encoder->frame_queue->elements[i].data;
2009 SCHRO_DEBUG
2010 ("phase I of shot change detection for i=%d picture=%d state=%d", i,
2011 frame->frame_number, 0 /* frame->state */ );
2012
2013 if (frame->busy)
2014 continue;
2015
2016 if (0 == i || FALSE == frame->need_mad) {
2017 /* we can't calculate a MAD for first frame in the queue */
2018 frame->stages[SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_1].is_done = TRUE;
2019 continue;
2020 }
2021 prev_frame = frame->previous_frame;
2022
2023 if (!frame->stages[SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_1].is_done
2024 && prev_frame
2025 && prev_frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done
2026 && frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done) {
2027 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_1);
2028 return TRUE;
2029 }
2030 }
2031
2032 /* calculate new scene change score */
2033 for (i = 0; encoder->frame_queue->n > i; ++i) {
2034 frame = encoder->frame_queue->elements[i].data;
2035 if (!frame->stages[SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_1].is_done) {
2036 return TRUE;
2037 }
2038 }
2039 calculate_sc_score (encoder);
2040 } else {
2041 for (i = 0; encoder->frame_queue->n > i; ++i) {
2042 frame = encoder->frame_queue->elements[i].data;
2043 if (frame->stages[SCHRO_ENCODER_FRAME_STAGE_ANALYSE].is_done) {
2044 frame->stages[SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_1].is_done = TRUE;
2045 frame->stages[SCHRO_ENCODER_FRAME_STAGE_SC_DETECT_2].is_done = TRUE;
2046 }
2047 }
2048 }
2049
2050 for (i = 0; i < encoder->frame_queue->n; i++) {
2051 frame = encoder->frame_queue->elements[i].data;
2052 if (frame->frame_number == encoder->gop_picture) {
2053 encoder->handle_gop (encoder, i);
2054 break;
2055 }
2056 }
2057
2058 /* Reference pictures are higher priority, so we pass over the list
2059 * first for reference pictures, then for non-ref. */
2060 for (ref = 1; ref >= 0; ref--) {
2061 for (i = 0; i < encoder->frame_queue->n; i++) {
2062 frame = encoder->frame_queue->elements[i].data;
2063 SCHRO_DEBUG ("backref i=%d picture=%d state=%d busy=%d", i,
2064 frame->frame_number, 0 /*frame->state */ , frame->busy);
2065
2066 if (frame->busy)
2067 continue;
2068
2069 if (frame->is_ref != ref)
2070 continue;
2071
2072 if (TODO (SCHRO_ENCODER_FRAME_STAGE_HAVE_PARAMS) &&
2073 frame->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_GOP].is_done) {
2074
2075 if (encoder->setup_frame (frame)) {
2076 frame->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_PARAMS].is_done = TRUE;
2077 }
2078 }
2079
2080 if (TODO (SCHRO_ENCODER_FRAME_STAGE_PREDICT_ROUGH) &&
2081 frame->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_PARAMS].is_done) {
2082 if (!check_refs (frame))
2083 continue;
2084 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_PREDICT_ROUGH);
2085 return TRUE;
2086 }
2087
2088 if (TODO (SCHRO_ENCODER_FRAME_STAGE_PREDICT_PEL) &&
2089 frame->stages[SCHRO_ENCODER_FRAME_STAGE_PREDICT_ROUGH].is_done) {
2090 schro_frame_set_wavelet_params (frame);
2091 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_PREDICT_PEL);
2092 return TRUE;
2093 }
2094
2095 }
2096 }
2097
2098 for (ref = 1; ref >= 0; ref--) {
2099 for (i = 0; encoder->frame_queue->n > i; ++i) {
2100 frame = encoder->frame_queue->elements[i].data;
2101 SCHRO_DEBUG ("serialised stage i=%d picture=%d state=%d slot=%d quant_slot=%d", i, frame->frame_number, 0 /* frame>state */
2102 , frame->slot, encoder->quant_slot);
2103
2104 if (frame->busy)
2105 continue;
2106
2107 if (encoder->enable_deep_estimation) {
2108 if (frame->slot != encoder->quant_slot) {
2109 continue;
2110 }
2111 } else if (encoder->enable_bigblock_estimation) {
2112 if (frame->is_ref != ref)
2113 continue;
2114 }
2115
2116 if (TODO (SCHRO_ENCODER_FRAME_STAGE_PREDICT_SUBPEL) &&
2117 frame->stages[SCHRO_ENCODER_FRAME_STAGE_PREDICT_PEL].is_done) {
2118 schro_encoder_set_frame_lambda (frame);
2119 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_PREDICT_SUBPEL);
2120 return TRUE;
2121 }
2122
2123 if (TODO (SCHRO_ENCODER_FRAME_STAGE_MODE_DECISION) &&
2124 frame->stages[SCHRO_ENCODER_FRAME_STAGE_PREDICT_SUBPEL].is_done) {
2125 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_MODE_DECISION);
2126 return TRUE;
2127 }
2128 }
2129 }
2130
2131 for (i = 0; i < encoder->frame_queue->n; i++) {
2132 frame = encoder->frame_queue->elements[i].data;
2133 if (frame->slot == encoder->quant_slot) {
2134 int ret;
2135 ret = encoder->handle_quants (encoder, i);
2136 if (!ret)
2137 break;
2138 }
2139 }
2140
2141 for (ref = 1; ref >= 0; ref--) {
2142 for (i = 0; encoder->frame_queue->n > i; ++i) {
2143 frame = encoder->frame_queue->elements[i].data;
2144
2145 if (frame->busy)
2146 continue;
2147
2148 if (encoder->enable_deep_estimation) {
2149 if (frame->slot != encoder->quant_slot)
2150 continue;
2151 } else if (encoder->enable_bigblock_estimation) {
2152 if (frame->is_ref != ref)
2153 continue;
2154 }
2155
2156 if (TODO (SCHRO_ENCODER_FRAME_STAGE_ENCODING) &&
2157 frame->stages[SCHRO_ENCODER_FRAME_STAGE_HAVE_QUANTS].is_done) {
2158 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_ENCODING);
2159 return TRUE;
2160 }
2161 }
2162 }
2163
2164 for (ref = 1; ref >= 0; ref--) {
2165 for (i = 0; i < encoder->frame_queue->n; i++) {
2166 frame = encoder->frame_queue->elements[i].data;
2167 SCHRO_DEBUG ("backref i=%d picture=%d state=%d busy=%d", i,
2168 frame->frame_number, 0 /*frame->state */ , frame->busy);
2169
2170 if (frame->busy)
2171 continue;
2172 if (frame->is_ref != ref)
2173 continue;
2174
2175 if (TODO (SCHRO_ENCODER_FRAME_STAGE_RECONSTRUCT) &&
2176 frame->stages[SCHRO_ENCODER_FRAME_STAGE_ENCODING].is_done) {
2177 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_RECONSTRUCT);
2178 return TRUE;
2179 }
2180 if (TODO (SCHRO_ENCODER_FRAME_STAGE_POSTANALYSE) &&
2181 frame->stages[SCHRO_ENCODER_FRAME_STAGE_RECONSTRUCT].is_done) {
2182 run_stage (frame, SCHRO_ENCODER_FRAME_STAGE_POSTANALYSE);
2183 return TRUE;
2184 }
2185 }
2186 }
2187
2188 return FALSE;
2189 }
2190
2191
2192 void
schro_encoder_analyse_picture(SchroAsyncStage * stage)2193 schro_encoder_analyse_picture (SchroAsyncStage * stage)
2194 {
2195 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
2196
2197 if (frame->encoder->filtering != 0 || frame->need_extension) {
2198 if (frame->encoder->enable_deep_estimation) {
2199 frame->filtered_frame =
2200 schro_frame_dup_full (frame->original_frame,
2201 MAX (frame->params.xbsep_luma * 4, frame->params.ybsep_luma * 4),
2202 TRUE);
2203 } else if (frame->encoder->enable_bigblock_estimation) {
2204 frame->filtered_frame = schro_frame_dup_full (frame->original_frame,
2205 32, TRUE);
2206 } else
2207 SCHRO_ASSERT (0);
2208 switch (frame->encoder->filtering) {
2209 case 1:
2210 schro_frame_filter_cwmN (frame->filtered_frame,
2211 frame->encoder->filter_value);
2212 break;
2213 case 2:
2214 schro_frame_filter_lowpass2 (frame->filtered_frame,
2215 frame->encoder->filter_value);
2216 break;
2217 case 3:
2218 schro_frame_filter_addnoise (frame->filtered_frame,
2219 frame->encoder->filter_value);
2220 break;
2221 case 4:
2222 schro_frame_filter_adaptive_lowpass (frame->filtered_frame);
2223 break;
2224 case 5:
2225 schro_frame_filter_lowpass (frame->filtered_frame,
2226 frame->encoder->filter_value);
2227 break;
2228 default:
2229 /* do nothing */
2230 break;
2231 }
2232 schro_frame_mc_edgeextend (frame->filtered_frame);
2233 } else {
2234 frame->filtered_frame = schro_frame_dup_full (frame->original_frame,
2235 32, TRUE);
2236 }
2237
2238 if (frame->need_downsampling) {
2239 schro_encoder_frame_downsample (frame);
2240 frame->have_downsampling = TRUE;
2241 }
2242 schro_frame_ref (frame->filtered_frame);
2243 frame->upsampled_original_frame =
2244 schro_upsampled_frame_new (frame->filtered_frame);
2245 if (frame->need_upsampling) {
2246 schro_upsampled_frame_upsample (frame->upsampled_original_frame);
2247 frame->have_upsampling = TRUE;
2248 }
2249
2250 if (frame->need_average_luma) {
2251 if (frame->have_downsampling) {
2252 frame->average_luma =
2253 schro_frame_calculate_average_luma (frame->
2254 downsampled_frames[frame->encoder->downsample_levels - 1]);
2255 } else {
2256 frame->average_luma =
2257 schro_frame_calculate_average_luma (frame->filtered_frame);
2258 }
2259 frame->have_average_luma = TRUE;
2260 }
2261 }
2262
2263 void
schro_encoder_predict_rough_picture(SchroAsyncStage * stage)2264 schro_encoder_predict_rough_picture (SchroAsyncStage * stage)
2265 {
2266 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
2267
2268 SCHRO_INFO ("predict picture %d", frame->frame_number);
2269
2270 if (frame->params.num_refs > 0) {
2271 schro_encoder_motion_predict_rough (frame);
2272 }
2273 }
2274
2275 /* should perform fullpel ME without "rendering",
2276 * ie without mode decision and motion compensation and DWT */
2277 void
schro_encoder_predict_pel_picture(SchroAsyncStage * stage)2278 schro_encoder_predict_pel_picture (SchroAsyncStage * stage)
2279 {
2280 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
2281
2282 SCHRO_ASSERT (frame
2283 && frame->stages[SCHRO_ENCODER_FRAME_STAGE_PREDICT_ROUGH].is_done);
2284 SCHRO_INFO ("fullpel predict picture %d", frame->frame_number);
2285
2286 if (frame->params.num_refs > 0) {
2287 schro_encoder_motion_predict_pel (frame);
2288 }
2289 }
2290
2291 void
schro_encoder_predict_subpel_picture(SchroAsyncStage * stage)2292 schro_encoder_predict_subpel_picture (SchroAsyncStage * stage)
2293 {
2294 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
2295
2296 if (frame->encoder->enable_bigblock_estimation) {
2297 if (frame->params.num_refs > 0 && frame->params.mv_precision > 0) {
2298 schro_encoder_motion_predict_subpel (frame);
2299 }
2300 } else if (frame->encoder->enable_deep_estimation) {
2301 int ref, xnum_blocks, ynum_blocks;
2302 SchroMotionField *mf_dest, *mf_src;
2303
2304 if (frame->params.num_refs > 0) {
2305 xnum_blocks = frame->params.x_num_blocks;
2306 ynum_blocks = frame->params.y_num_blocks;
2307 for (ref = 0; frame->params.num_refs > ref; ++ref) {
2308 mf_dest = schro_motion_field_new (xnum_blocks, ynum_blocks);
2309 mf_src = schro_hbm_motion_field (frame->hier_bm[ref], 0);
2310 memcpy (mf_dest->motion_vectors, mf_src->motion_vectors,
2311 xnum_blocks * ynum_blocks * sizeof (SchroMotionVector));
2312 schro_me_set_subpel_mf (frame->deep_me, mf_dest, ref);
2313 }
2314 }
2315 if (frame->params.num_refs > 0 && frame->params.mv_precision > 0) {
2316 schro_me_set_lambda (frame->deep_me, frame->frame_me_lambda);
2317 schro_encoder_motion_predict_subpel_deep (frame->deep_me);
2318 }
2319 }
2320 }
2321
2322 /* performs mode decision and superblock splitting
2323 * finally it does DWT */
2324 void
schro_encoder_mode_decision(SchroAsyncStage * stage)2325 schro_encoder_mode_decision (SchroAsyncStage * stage)
2326 {
2327 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
2328
2329 SCHRO_ASSERT (frame->stages[SCHRO_ENCODER_FRAME_STAGE_PREDICT_PEL].is_done);
2330 SCHRO_INFO ("mode decision and superblock splitting picture %d",
2331 frame->frame_number);
2332
2333 if (frame->encoder->enable_deep_estimation) {
2334 SchroMotionField *mf, *mf_src;
2335 int xnum_blocks, ynum_blocks, ref;
2336 if (frame->params.num_refs > 0) {
2337 xnum_blocks = frame->params.x_num_blocks;
2338 ynum_blocks = frame->params.y_num_blocks;
2339 for (ref = 0; frame->params.num_refs > ref; ++ref) {
2340 mf = schro_motion_field_new (xnum_blocks, ynum_blocks);
2341 schro_motion_field_set (mf, 2, ref + 1);
2342 /* copy split2 from subpel */
2343 mf_src = schro_me_subpel_mf (frame->deep_me, ref);
2344 SCHRO_ASSERT (mf_src);
2345 memcpy (mf->motion_vectors, mf_src->motion_vectors,
2346 xnum_blocks * ynum_blocks * sizeof (SchroMotionVector));
2347 schro_me_set_split2_mf (frame->deep_me, mf, ref);
2348
2349 mf = schro_motion_field_new (xnum_blocks, ynum_blocks);
2350 schro_motion_field_set (mf, 1, ref + 1);
2351 schro_me_set_split1_mf (frame->deep_me, mf, ref);
2352
2353 mf = schro_motion_field_new (xnum_blocks, ynum_blocks);
2354 schro_motion_field_set (mf, 0, ref + 1);
2355 schro_me_set_split0_mf (frame->deep_me, mf, ref);
2356 }
2357 SCHRO_INFO ("mode decision and superblock splitting picture %d",
2358 frame->frame_number);
2359 schro_me_set_motion (frame->deep_me, frame->motion);
2360 schro_me_set_lambda (frame->deep_me, frame->frame_me_lambda);
2361 schro_mode_decision (frame->deep_me);
2362 schro_motion_calculate_stats (frame->motion, frame);
2363 frame->estimated_mc_bits = schro_motion_estimate_entropy (frame->motion);
2364 frame->badblock_ratio = schro_me_badblocks_ratio (frame->deep_me);
2365 frame->dcblock_ratio = schro_me_dcblock_ratio (frame->deep_me);
2366 frame->mc_error = schro_me_mc_error (frame->deep_me);
2367
2368 SCHRO_DEBUG ("DC block ratio for frame %d s %g", frame->frame_number,
2369 frame->dcblock_ratio);
2370
2371 if (frame->dcblock_ratio > frame->encoder->magic_me_bailout_limit) {
2372 if (frame->deep_me) {
2373 /* Free the motion estimation info if we are inserting an I frame */
2374 schro_me_free (frame->deep_me);
2375 frame->deep_me = NULL;
2376 }
2377 frame->params.num_refs = 0;
2378 frame->num_refs = 0;
2379 SCHRO_WARNING
2380 ("DC block ratio too high for frame %d, inserting an intra picture",
2381 frame->frame_number);
2382 }
2383 }
2384 }
2385
2386 schro_encoder_render_picture (frame);
2387 }
2388
2389 static void
schro_encoder_iwt_transform(SchroFrame * frame,SchroParams * params)2390 schro_encoder_iwt_transform (SchroFrame * frame, SchroParams * params)
2391 {
2392 int component;
2393 int width;
2394 int height;
2395 int level;
2396 int16_t *tmp;
2397
2398 tmp = schro_malloc (sizeof (int32_t) * (params->iwt_luma_width + 8) * 2);
2399
2400 for (component = 0; component < 3; component++) {
2401 SchroFrameData *comp = &frame->components[component];
2402
2403 if (component == 0) {
2404 width = params->iwt_luma_width;
2405 height = params->iwt_luma_height;
2406 } else {
2407 width = params->iwt_chroma_width;
2408 height = params->iwt_chroma_height;
2409 }
2410
2411 for (level = 0; level < params->transform_depth; level++) {
2412 SchroFrameData fd;
2413
2414 fd.format = frame->format;
2415 fd.data = comp->data;
2416 fd.width = width >> level;
2417 fd.height = height >> level;
2418 fd.stride = comp->stride << level;
2419
2420 schro_wavelet_transform_2d (&fd, params->wavelet_filter_index, tmp);
2421 }
2422 }
2423
2424 schro_free (tmp);
2425 }
2426
2427 void
schro_encoder_render_picture(SchroEncoderFrame * frame)2428 schro_encoder_render_picture (SchroEncoderFrame * frame)
2429 {
2430 SCHRO_INFO ("render picture %d", frame->frame_number);
2431
2432 if (frame->params.num_refs > 0) {
2433 frame->motion->src1 = frame->ref_frame[0]->reconstructed_frame;
2434 if (frame->params.num_refs > 1) {
2435 frame->motion->src2 = frame->ref_frame[1]->reconstructed_frame;
2436 }
2437
2438 SCHRO_ASSERT (schro_motion_verify (frame->motion));
2439
2440 }
2441
2442 if (frame->params.num_refs > 0) {
2443 schro_frame_convert (frame->iwt_frame, frame->filtered_frame);
2444
2445 schro_motion_render (frame->motion, frame->prediction_frame,
2446 frame->iwt_frame, FALSE, NULL);
2447
2448 schro_frame_zero_extend (frame->iwt_frame,
2449 frame->params.video_format->width,
2450 schro_video_format_get_picture_height (frame->params.video_format));
2451 } else {
2452 schro_frame_convert (frame->iwt_frame, frame->filtered_frame);
2453 }
2454
2455 schro_encoder_iwt_transform (frame->iwt_frame, &frame->params);
2456
2457 schro_encoder_clean_up_transform (frame);
2458 }
2459
2460 void
schro_encoder_encode_picture(SchroAsyncStage * stage)2461 schro_encoder_encode_picture (SchroAsyncStage * stage)
2462 {
2463 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
2464 SchroBuffer *subbuffer;
2465 int picture_chroma_width, picture_chroma_height;
2466 int width, height;
2467 int total_frame_bits;
2468 double factor;
2469 double est_subband_bits;
2470
2471 SCHRO_INFO ("encode picture %d", frame->frame_number);
2472
2473 frame->output_buffer = schro_buffer_new_and_alloc (frame->output_buffer_size);
2474
2475 schro_video_format_get_iwt_alloc_size (&frame->encoder->video_format,
2476 &width, &height, frame->encoder->transform_depth);
2477 frame->subband_size = width * height / 4;
2478 frame->subband_buffer =
2479 schro_buffer_new_and_alloc (frame->subband_size * sizeof (int16_t));
2480
2481 schro_video_format_get_picture_chroma_size (&frame->encoder->video_format,
2482 &picture_chroma_width, &picture_chroma_height);
2483
2484 /* FIXME this is only used for lowdelay, and is way too big */
2485 frame->quant_data = schro_malloc (sizeof (int16_t) * frame->subband_size);
2486
2487 frame->pack = schro_pack_new ();
2488 schro_pack_encode_init (frame->pack, frame->output_buffer);
2489
2490 total_frame_bits = -schro_pack_get_offset (frame->pack) * 8;
2491
2492 /* encode header */
2493 schro_encoder_encode_parse_info (frame->pack,
2494 SCHRO_PARSE_CODE_PICTURE (frame->is_ref, frame->params.num_refs,
2495 frame->params.is_lowdelay, frame->params.is_noarith));
2496 schro_encoder_encode_picture_header (frame);
2497
2498 if (frame->params.num_refs > 0) {
2499 schro_pack_sync (frame->pack);
2500 schro_encoder_encode_picture_prediction_parameters (frame);
2501 schro_pack_sync (frame->pack);
2502 frame->actual_mc_bits = -schro_pack_get_offset (frame->pack) * 8;
2503 schro_encoder_encode_superblock_split (frame);
2504 schro_encoder_encode_prediction_modes (frame);
2505 schro_encoder_encode_vector_data (frame, 0, 0);
2506 schro_encoder_encode_vector_data (frame, 0, 1);
2507 if (frame->params.num_refs > 1) {
2508 schro_encoder_encode_vector_data (frame, 1, 0);
2509 schro_encoder_encode_vector_data (frame, 1, 1);
2510 }
2511 schro_encoder_encode_dc_data (frame, 0);
2512 schro_encoder_encode_dc_data (frame, 1);
2513 schro_encoder_encode_dc_data (frame, 2);
2514 frame->actual_mc_bits += schro_pack_get_offset (frame->pack) * 8;
2515 }
2516
2517 if (schro_pack_get_offset (frame->pack) * 8 > frame->hard_limit_bits) {
2518 SCHRO_ERROR ("over hard_limit_bits after MC (%d>%d)",
2519 schro_pack_get_offset (frame->pack) * 8, frame->hard_limit_bits);
2520 }
2521
2522 schro_pack_sync (frame->pack);
2523 schro_encoder_encode_transform_parameters (frame);
2524
2525 if (schro_pack_get_offset (frame->pack) * 8 > frame->hard_limit_bits) {
2526 SCHRO_ERROR ("over hard_limit_bits after transform params (%d>%d)",
2527 schro_pack_get_offset (frame->pack) * 8, frame->hard_limit_bits);
2528 }
2529
2530 frame->actual_residual_bits = -schro_pack_get_offset (frame->pack) * 8;
2531
2532 schro_pack_sync (frame->pack);
2533 if (frame->params.is_lowdelay) {
2534 schro_encoder_encode_lowdelay_transform_data (frame);
2535 } else {
2536 schro_encoder_encode_transform_data (frame);
2537 }
2538
2539 schro_pack_flush (frame->pack);
2540 frame->actual_residual_bits += schro_pack_get_offset (frame->pack) * 8;
2541 total_frame_bits += schro_pack_get_offset (frame->pack) * 8;
2542
2543 SCHRO_DEBUG ("Actual frame %d residual bits : %d", frame->frame_number,
2544 frame->actual_residual_bits);
2545 // Update the fiddle factors for estimating entropy
2546 if (frame->num_refs == 0) {
2547 int component, b;
2548 for (component = 0; component < 3; ++component) {
2549 for (b = 0; b < 1 + 3 * frame->params.transform_depth; ++b) {
2550 est_subband_bits =
2551 frame->
2552 est_entropy[component][b][frame->quant_indices[component][b][0]];
2553 SCHRO_DEBUG ("Actual versus estimated band bits : %d %d %g %g",
2554 component, b, frame->actual_subband_bits[component][b],
2555 est_subband_bits);
2556 if (est_subband_bits > 200.0) {
2557 double ratio;
2558 factor = frame->actual_subband_bits[component][b] / est_subband_bits;
2559 ratio =
2560 frame->encoder->average_arith_context_ratios_intra[component][b];
2561 ratio = ratio * 0.9 + factor * 0.1;
2562 frame->encoder->average_arith_context_ratios_intra[component][b] =
2563 ratio;
2564 }
2565 }
2566 }
2567 } else {
2568 int component, b;
2569 for (component = 0; component < 3; ++component) {
2570 for (b = 0; b < 1 + 3 * frame->params.transform_depth; ++b) {
2571 est_subband_bits =
2572 frame->
2573 est_entropy[component][b][frame->quant_indices[component][b][0]];
2574 SCHRO_DEBUG ("Actual versus estimated band bits : %d %d %g %g",
2575 component, b, frame->actual_subband_bits[component][b],
2576 est_subband_bits);
2577 if (est_subband_bits > 200.0) {
2578 double ratio;
2579 factor = frame->actual_subband_bits[component][b] / est_subband_bits;
2580 ratio =
2581 frame->encoder->average_arith_context_ratios_inter[component][b];
2582 ratio = ratio * 0.9 + factor * 0.1;
2583 frame->encoder->average_arith_context_ratios_inter[component][b] =
2584 ratio;
2585 }
2586 }
2587 }
2588 }
2589
2590 // Update the buffer model
2591 if (frame->encoder->rate_control ==
2592 SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE) {
2593 SchroEncoder *encoder = frame->encoder;
2594 encoder->buffer_level -= total_frame_bits;
2595 encoder->buffer_level += encoder->bits_per_picture;
2596
2597 if (encoder->buffer_level < 0) {
2598 SCHRO_DEBUG ("buffer underrun by %d bytes", -encoder->buffer_level);
2599 encoder->buffer_level = 0;
2600 }
2601
2602 if (encoder->buffer_level > encoder->buffer_size) {
2603 int n;
2604
2605 n = (encoder->buffer_level - encoder->buffer_size + 7) / 8;
2606 SCHRO_DEBUG ("buffer overrun, adding padding of %d bytes", n);
2607 n = schro_encoder_encode_padding (encoder, n);
2608 encoder->buffer_level -= n * 8;
2609 }
2610 SCHRO_DEBUG ("At frame %d, buffer level %d of %d bits", frame->frame_number,
2611 encoder->buffer_level, encoder->buffer_size);
2612
2613 schro_encoder_cbr_update (frame, total_frame_bits);
2614 }
2615
2616 if (schro_pack_get_offset (frame->pack) * 8 > frame->hard_limit_bits) {
2617 SCHRO_ERROR ("over hard_limit_bits after residual (%d>%d)",
2618 schro_pack_get_offset (frame->pack) * 8, frame->hard_limit_bits);
2619 }
2620
2621 subbuffer = schro_buffer_new_subbuffer (frame->output_buffer, 0,
2622 schro_pack_get_offset (frame->pack));
2623 schro_buffer_unref (frame->output_buffer);
2624 frame->output_buffer = subbuffer;
2625
2626 if (frame->subband_buffer) {
2627 schro_buffer_unref (frame->subband_buffer);
2628 }
2629 if (frame->quant_data) {
2630 free (frame->quant_data);
2631 }
2632 if (frame->quant_frame) {
2633 schro_frame_unref (frame->quant_frame);
2634 }
2635 if (frame->pack) {
2636 schro_pack_free (frame->pack);
2637 frame->pack = NULL;
2638 }
2639
2640 frame->encoder->quant_slot++;
2641 }
2642
2643 void
schro_encoder_inverse_iwt_transform(SchroFrame * frame,SchroParams * params)2644 schro_encoder_inverse_iwt_transform (SchroFrame * frame, SchroParams * params)
2645 {
2646 int width;
2647 int height;
2648 int level;
2649 int component;
2650 int16_t *tmp;
2651
2652 tmp = schro_malloc (sizeof (int32_t) * (params->iwt_luma_width + 16));
2653
2654 for (component = 0; component < 3; component++) {
2655 SchroFrameData *comp = &frame->components[component];
2656
2657 if (component == 0) {
2658 width = params->iwt_luma_width;
2659 height = params->iwt_luma_height;
2660 } else {
2661 width = params->iwt_chroma_width;
2662 height = params->iwt_chroma_height;
2663 }
2664
2665 for (level = params->transform_depth - 1; level >= 0; level--) {
2666 SchroFrameData fd_dest;
2667 SchroFrameData fd_src;
2668
2669 fd_src.format = frame->format;
2670 fd_src.data = comp->data;
2671 fd_src.width = width >> level;
2672 fd_src.height = height >> level;
2673 fd_src.stride = comp->stride << level;
2674
2675 fd_dest.format = frame->format;
2676 fd_dest.data = comp->data;
2677 fd_dest.width = width >> level;
2678 fd_dest.height = height >> level;
2679 fd_dest.stride = comp->stride << level;
2680
2681 schro_wavelet_inverse_transform_2d (&fd_dest, &fd_src,
2682 params->wavelet_filter_index, tmp);
2683 }
2684 }
2685
2686 schro_free (tmp);
2687 }
2688
2689 void
schro_encoder_reconstruct_picture(SchroAsyncStage * stage)2690 schro_encoder_reconstruct_picture (SchroAsyncStage * stage)
2691 {
2692 SchroEncoderFrame *encoder_frame = (SchroEncoderFrame *) stage->priv;
2693
2694 schro_encoder_inverse_iwt_transform (encoder_frame->iwt_frame,
2695 &encoder_frame->params);
2696
2697 if (encoder_frame->params.num_refs > 0) {
2698 schro_frame_add (encoder_frame->iwt_frame, encoder_frame->prediction_frame);
2699 }
2700
2701 if (encoder_frame->encoder->enable_md5 || (encoder_frame->is_ref &&
2702 encoder_frame->encoder->gop_structure != SCHRO_ENCODER_GOP_INTRA_ONLY)) {
2703 SchroFrameFormat frame_format;
2704 SchroFrame *frame;
2705
2706 frame_format = schro_params_get_frame_format (encoder_frame->encoder->input_frame_depth,
2707 encoder_frame->encoder->video_format.chroma_format);
2708 frame = schro_frame_new_and_alloc_full (NULL, frame_format,
2709 encoder_frame->encoder->video_format.width,
2710 schro_video_format_get_picture_height (&encoder_frame->
2711 encoder->video_format), 32, TRUE);
2712 schro_frame_convert (frame, encoder_frame->iwt_frame);
2713 schro_frame_mc_edgeextend (frame);
2714 encoder_frame->reconstructed_frame = schro_upsampled_frame_new (frame);
2715 }
2716
2717 if (encoder_frame->encoder->enable_md5) {
2718 schro_encoder_encode_md5_checksum (encoder_frame);
2719 }
2720
2721 if (encoder_frame->is_ref && encoder_frame->encoder->mv_precision > 0) {
2722 schro_upsampled_frame_upsample (encoder_frame->reconstructed_frame);
2723 }
2724 }
2725
2726 void
schro_encoder_postanalyse_picture(SchroAsyncStage * stage)2727 schro_encoder_postanalyse_picture (SchroAsyncStage * stage)
2728 {
2729 SchroEncoderFrame *frame = (SchroEncoderFrame *) stage->priv;
2730 SchroVideoFormat *video_format = frame->params.video_format;
2731
2732 if (frame->encoder->enable_psnr) {
2733 double mse[3];
2734
2735 schro_frame_mean_squared_error (frame->filtered_frame,
2736 frame->reconstructed_frame->frames[0], mse);
2737
2738 frame->mean_squared_error_luma = mse[0] /
2739 (video_format->luma_excursion * video_format->luma_excursion);
2740 frame->mean_squared_error_chroma = 0.5 * (mse[1] + mse[2]) /
2741 (video_format->chroma_excursion * video_format->chroma_excursion);
2742 }
2743
2744 if (frame->encoder->enable_ssim) {
2745 frame->mssim = schro_frame_ssim (frame->original_frame,
2746 frame->reconstructed_frame->frames[0]);
2747 schro_dump (SCHRO_DUMP_SSIM, "%d %g\n", frame->frame_number, frame->mssim);
2748 }
2749 }
2750
2751 static void
schro_encoder_encode_picture_prediction_parameters(SchroEncoderFrame * frame)2752 schro_encoder_encode_picture_prediction_parameters (SchroEncoderFrame * frame)
2753 {
2754 SchroParams *params = &frame->params;
2755 int index;
2756
2757 /* block parameters */
2758 index = schro_params_get_block_params (params);
2759 schro_pack_encode_uint (frame->pack, index);
2760 if (index == 0) {
2761 schro_pack_encode_uint (frame->pack, params->xblen_luma);
2762 schro_pack_encode_uint (frame->pack, params->yblen_luma);
2763 schro_pack_encode_uint (frame->pack, params->xbsep_luma);
2764 schro_pack_encode_uint (frame->pack, params->xbsep_luma);
2765 }
2766
2767 MARKER (frame->pack);
2768
2769 /* mv precision */
2770 schro_pack_encode_uint (frame->pack, params->mv_precision);
2771
2772 MARKER (frame->pack);
2773
2774 /* global motion flag */
2775 schro_pack_encode_bit (frame->pack, params->have_global_motion);
2776 if (params->have_global_motion) {
2777 int i;
2778 for (i = 0; i < params->num_refs; i++) {
2779 SchroGlobalMotion *gm = params->global_motion + i;
2780
2781 /* pan tilt */
2782 if (gm->b0 == 0 && gm->b1 == 0) {
2783 schro_pack_encode_bit (frame->pack, 0);
2784 } else {
2785 schro_pack_encode_bit (frame->pack, 1);
2786 schro_pack_encode_sint (frame->pack, gm->b0);
2787 schro_pack_encode_sint (frame->pack, gm->b1);
2788 }
2789
2790 /* zoom rotate shear */
2791 if (gm->a_exp == 0 && gm->a00 == 1 && gm->a01 == 0 && gm->a10 == 0 &&
2792 gm->a11 == 1) {
2793 schro_pack_encode_bit (frame->pack, 0);
2794 } else {
2795 schro_pack_encode_bit (frame->pack, 1);
2796 schro_pack_encode_uint (frame->pack, gm->a_exp);
2797 schro_pack_encode_sint (frame->pack, gm->a00);
2798 schro_pack_encode_sint (frame->pack, gm->a01);
2799 schro_pack_encode_sint (frame->pack, gm->a10);
2800 schro_pack_encode_sint (frame->pack, gm->a11);
2801 }
2802
2803 /* perspective */
2804 if (gm->c_exp == 0 && gm->c0 == 0 && gm->c1 == 0) {
2805 schro_pack_encode_bit (frame->pack, 0);
2806 } else {
2807 schro_pack_encode_bit (frame->pack, 1);
2808 schro_pack_encode_uint (frame->pack, gm->c_exp);
2809 schro_pack_encode_sint (frame->pack, gm->c0);
2810 schro_pack_encode_sint (frame->pack, gm->c1);
2811 }
2812 }
2813 }
2814
2815 MARKER (frame->pack);
2816
2817 /* picture prediction mode flag */
2818 schro_pack_encode_uint (frame->pack, params->picture_pred_mode);
2819
2820 /* non-default weights flag */
2821 SCHRO_ASSERT (params->picture_weight_2 == 1 || params->num_refs == 2);
2822 if (params->picture_weight_bits == 1 &&
2823 params->picture_weight_1 == 1 && params->picture_weight_2 == 1) {
2824 schro_pack_encode_bit (frame->pack, FALSE);
2825 } else {
2826 schro_pack_encode_bit (frame->pack, TRUE);
2827 schro_pack_encode_uint (frame->pack, params->picture_weight_bits);
2828 schro_pack_encode_sint (frame->pack, params->picture_weight_1);
2829 if (params->num_refs > 1) {
2830 schro_pack_encode_sint (frame->pack, params->picture_weight_2);
2831 }
2832 }
2833
2834 MARKER (frame->pack);
2835
2836 }
2837
2838 static void
schro_encoder_encode_superblock_split(SchroEncoderFrame * frame)2839 schro_encoder_encode_superblock_split (SchroEncoderFrame * frame)
2840 {
2841 SchroParams *params = &frame->params;
2842 int i, j;
2843 SchroArith *arith = NULL;
2844 SchroPack b, *pack = &b;
2845
2846 if (params->is_noarith) {
2847 schro_pack_encode_init (pack, frame->subband_buffer);
2848 } else {
2849 arith = schro_arith_new ();
2850 schro_arith_encode_init (arith, frame->subband_buffer);
2851 }
2852
2853 for (j = 0; j < params->y_num_blocks; j += 4) {
2854 for (i = 0; i < params->x_num_blocks; i += 4) {
2855 int split_prediction;
2856 int split_residual;
2857 SchroMotionVector *mv =
2858 &frame->motion->motion_vectors[j * params->x_num_blocks + i];
2859
2860 SCHRO_ASSERT (mv->split < 3);
2861
2862 split_prediction = schro_motion_split_prediction (frame->motion, i, j);
2863 split_residual = (mv->split - split_prediction + 3) % 3;
2864 if (params->is_noarith) {
2865 schro_pack_encode_uint (pack, split_residual);
2866 } else {
2867 _schro_arith_encode_uint (arith, SCHRO_CTX_SB_F1,
2868 SCHRO_CTX_SB_DATA, split_residual);
2869 }
2870 }
2871 }
2872
2873 schro_pack_sync (frame->pack);
2874 if (params->is_noarith) {
2875 schro_pack_flush (pack);
2876 schro_pack_encode_uint (frame->pack, schro_pack_get_offset (pack));
2877 schro_pack_sync (frame->pack);
2878 schro_pack_append (frame->pack, pack->buffer->data,
2879 schro_pack_get_offset (pack));
2880 } else {
2881 schro_arith_flush (arith);
2882 schro_pack_encode_uint (frame->pack, arith->offset);
2883 schro_pack_sync (frame->pack);
2884 schro_pack_append (frame->pack, arith->buffer->data, arith->offset);
2885 schro_arith_free (arith);
2886 }
2887 }
2888
2889 static void
schro_encoder_encode_prediction_modes(SchroEncoderFrame * frame)2890 schro_encoder_encode_prediction_modes (SchroEncoderFrame * frame)
2891 {
2892 SchroParams *params = &frame->params;
2893 int i, j;
2894 SchroArith *arith = NULL;
2895 SchroPack b, *pack = &b;
2896
2897 if (params->is_noarith) {
2898 schro_pack_encode_init (pack, frame->subband_buffer);
2899 } else {
2900 arith = schro_arith_new ();
2901 schro_arith_encode_init (arith, frame->subband_buffer);
2902 }
2903
2904 for (j = 0; j < params->y_num_blocks; j += 4) {
2905 for (i = 0; i < params->x_num_blocks; i += 4) {
2906 int k, l;
2907 SchroMotionVector *mv1 =
2908 &frame->motion->motion_vectors[j * params->x_num_blocks + i];
2909
2910 for (l = 0; l < 4; l += (4 >> mv1->split)) {
2911 for (k = 0; k < 4; k += (4 >> mv1->split)) {
2912 SchroMotionVector *mv =
2913 &frame->motion->motion_vectors[(j + l) * params->x_num_blocks +
2914 i + k];
2915 int pred_mode;
2916
2917 pred_mode = mv->pred_mode ^
2918 schro_motion_get_mode_prediction (frame->motion, i + k, j + l);
2919
2920 if (params->is_noarith) {
2921 schro_pack_encode_bit (pack, pred_mode & 1);
2922 } else {
2923 _schro_arith_encode_bit (arith, SCHRO_CTX_BLOCK_MODE_REF1,
2924 pred_mode & 1);
2925 }
2926 if (params->num_refs > 1) {
2927 if (params->is_noarith) {
2928 schro_pack_encode_bit (pack, pred_mode >> 1);
2929 } else {
2930 _schro_arith_encode_bit (arith, SCHRO_CTX_BLOCK_MODE_REF2,
2931 pred_mode >> 1);
2932 }
2933 }
2934 if (mv->pred_mode != 0) {
2935 if (params->have_global_motion) {
2936 int pred;
2937 pred = schro_motion_get_global_prediction (frame->motion,
2938 i + k, j + l);
2939 if (params->is_noarith) {
2940 schro_pack_encode_bit (pack, mv->using_global ^ pred);
2941 } else {
2942 _schro_arith_encode_bit (arith, SCHRO_CTX_GLOBAL_BLOCK,
2943 mv->using_global ^ pred);
2944 }
2945 } else {
2946 SCHRO_ASSERT (mv->using_global == FALSE);
2947 }
2948 }
2949 }
2950 }
2951 }
2952 }
2953
2954 schro_pack_sync (frame->pack);
2955 if (params->is_noarith) {
2956 schro_pack_flush (pack);
2957 schro_pack_encode_uint (frame->pack, schro_pack_get_offset (pack));
2958 schro_pack_sync (frame->pack);
2959 schro_pack_append (frame->pack, pack->buffer->data,
2960 schro_pack_get_offset (pack));
2961 } else {
2962 schro_arith_flush (arith);
2963 schro_pack_encode_uint (frame->pack, arith->offset);
2964 schro_pack_sync (frame->pack);
2965 schro_pack_append (frame->pack, arith->buffer->data, arith->offset);
2966 schro_arith_free (arith);
2967 }
2968 }
2969
2970 static void
schro_encoder_encode_vector_data(SchroEncoderFrame * frame,int ref,int xy)2971 schro_encoder_encode_vector_data (SchroEncoderFrame * frame, int ref, int xy)
2972 {
2973 SchroParams *params = &frame->params;
2974 int i, j;
2975 SchroArith *arith = NULL;
2976 int cont, value, sign;
2977 SchroPack b, *pack = &b;
2978
2979 if (params->is_noarith) {
2980 schro_pack_encode_init (pack, frame->subband_buffer);
2981 } else {
2982 arith = schro_arith_new ();
2983 schro_arith_encode_init (arith, frame->subband_buffer);
2984 }
2985
2986 if (xy == 0) {
2987 if (ref == 0) {
2988 cont = SCHRO_CTX_MV_REF1_H_CONT_BIN1;
2989 value = SCHRO_CTX_MV_REF1_H_VALUE;
2990 sign = SCHRO_CTX_MV_REF1_H_SIGN;
2991 } else {
2992 cont = SCHRO_CTX_MV_REF2_H_CONT_BIN1;
2993 value = SCHRO_CTX_MV_REF2_H_VALUE;
2994 sign = SCHRO_CTX_MV_REF2_H_SIGN;
2995 }
2996 } else {
2997 if (ref == 0) {
2998 cont = SCHRO_CTX_MV_REF1_V_CONT_BIN1;
2999 value = SCHRO_CTX_MV_REF1_V_VALUE;
3000 sign = SCHRO_CTX_MV_REF1_V_SIGN;
3001 } else {
3002 cont = SCHRO_CTX_MV_REF2_V_CONT_BIN1;
3003 value = SCHRO_CTX_MV_REF2_V_VALUE;
3004 sign = SCHRO_CTX_MV_REF2_V_SIGN;
3005 }
3006 }
3007
3008 for (j = 0; j < params->y_num_blocks; j += 4) {
3009 for (i = 0; i < params->x_num_blocks; i += 4) {
3010 int k, l;
3011 SchroMotionVector *mv1 =
3012 &frame->motion->motion_vectors[j * params->x_num_blocks + i];
3013
3014 for (l = 0; l < 4; l += (4 >> mv1->split)) {
3015 for (k = 0; k < 4; k += (4 >> mv1->split)) {
3016 int pred_x, pred_y;
3017 int x, y;
3018 SchroMotionVector *mv =
3019 &frame->motion->motion_vectors[(j + l) * params->x_num_blocks +
3020 i + k];
3021
3022 if ((mv->pred_mode & (1 << ref)) && !mv->using_global) {
3023 schro_motion_vector_prediction (frame->motion,
3024 i + k, j + l, &pred_x, &pred_y, 1 << ref);
3025 x = mv->u.vec.dx[ref];
3026 y = mv->u.vec.dy[ref];
3027
3028 if (!params->is_noarith) {
3029 if (xy == 0) {
3030 _schro_arith_encode_sint (arith, cont, value, sign, x - pred_x);
3031 } else {
3032 _schro_arith_encode_sint (arith, cont, value, sign, y - pred_y);
3033 }
3034 } else {
3035 if (xy == 0) {
3036 schro_pack_encode_sint (pack, x - pred_x);
3037 } else {
3038 schro_pack_encode_sint (pack, y - pred_y);
3039 }
3040 }
3041 }
3042 }
3043 }
3044 }
3045 }
3046
3047 schro_pack_sync (frame->pack);
3048 if (params->is_noarith) {
3049 schro_pack_flush (pack);
3050 schro_pack_encode_uint (frame->pack, schro_pack_get_offset (pack));
3051 schro_pack_sync (frame->pack);
3052 schro_pack_append (frame->pack, pack->buffer->data,
3053 schro_pack_get_offset (pack));
3054 } else {
3055 schro_arith_flush (arith);
3056 schro_pack_encode_uint (frame->pack, arith->offset);
3057 schro_pack_sync (frame->pack);
3058 schro_pack_append (frame->pack, arith->buffer->data, arith->offset);
3059 schro_arith_free (arith);
3060 }
3061 }
3062
3063 static void
schro_encoder_encode_dc_data(SchroEncoderFrame * frame,int comp)3064 schro_encoder_encode_dc_data (SchroEncoderFrame * frame, int comp)
3065 {
3066 SchroParams *params = &frame->params;
3067 int i, j;
3068 SchroArith *arith = NULL;
3069 SchroPack b, *pack = &b;
3070
3071 if (params->is_noarith) {
3072 schro_pack_encode_init (pack, frame->subband_buffer);
3073 } else {
3074 arith = schro_arith_new ();
3075 schro_arith_encode_init (arith, frame->subband_buffer);
3076 }
3077
3078 for (j = 0; j < params->y_num_blocks; j += 4) {
3079 for (i = 0; i < params->x_num_blocks; i += 4) {
3080 int k, l;
3081 SchroMotionVector *mv1 =
3082 &frame->motion->motion_vectors[j * params->x_num_blocks + i];
3083
3084 for (l = 0; l < 4; l += (4 >> mv1->split)) {
3085 for (k = 0; k < 4; k += (4 >> mv1->split)) {
3086 SchroMotionVector *mv =
3087 &frame->motion->motion_vectors[(j + l) * params->x_num_blocks +
3088 i + k];
3089
3090 if (mv->pred_mode == 0) {
3091 int pred[3];
3092
3093 schro_motion_dc_prediction (frame->motion, i + k, j + l, pred);
3094
3095 if (!params->is_noarith) {
3096 switch (comp) {
3097 case 0:
3098 _schro_arith_encode_sint (arith,
3099 SCHRO_CTX_LUMA_DC_CONT_BIN1, SCHRO_CTX_LUMA_DC_VALUE,
3100 SCHRO_CTX_LUMA_DC_SIGN, mv->u.dc.dc[0] - pred[0]);
3101 break;
3102 case 1:
3103 _schro_arith_encode_sint (arith,
3104 SCHRO_CTX_CHROMA1_DC_CONT_BIN1,
3105 SCHRO_CTX_CHROMA1_DC_VALUE, SCHRO_CTX_CHROMA1_DC_SIGN,
3106 mv->u.dc.dc[1] - pred[1]);
3107 break;
3108 case 2:
3109 _schro_arith_encode_sint (arith,
3110 SCHRO_CTX_CHROMA2_DC_CONT_BIN1,
3111 SCHRO_CTX_CHROMA2_DC_VALUE, SCHRO_CTX_CHROMA2_DC_SIGN,
3112 mv->u.dc.dc[2] - pred[2]);
3113 break;
3114 default:
3115 SCHRO_ASSERT (0);
3116 }
3117 } else {
3118 schro_pack_encode_sint (pack, mv->u.dc.dc[comp] - pred[comp]);
3119 }
3120 }
3121 }
3122 }
3123 }
3124 }
3125
3126 schro_pack_sync (frame->pack);
3127 if (params->is_noarith) {
3128 schro_pack_flush (pack);
3129 schro_pack_encode_uint (frame->pack, schro_pack_get_offset (pack));
3130 schro_pack_sync (frame->pack);
3131 schro_pack_append (frame->pack, pack->buffer->data,
3132 schro_pack_get_offset (pack));
3133 } else {
3134 schro_arith_flush (arith);
3135 schro_pack_encode_uint (frame->pack, arith->offset);
3136 schro_pack_sync (frame->pack);
3137 schro_pack_append (frame->pack, arith->buffer->data, arith->offset);
3138 schro_arith_free (arith);
3139 }
3140 }
3141
3142
3143 void
schro_encoder_encode_sequence_header_header(SchroEncoder * encoder,SchroPack * pack)3144 schro_encoder_encode_sequence_header_header (SchroEncoder * encoder,
3145 SchroPack * pack)
3146 {
3147 SchroVideoFormat *format = &encoder->video_format;
3148 SchroVideoFormat _std_format;
3149 SchroVideoFormat *std_format = &_std_format;
3150 int i;
3151
3152 schro_encoder_encode_parse_info (pack, SCHRO_PARSE_CODE_SEQUENCE_HEADER);
3153
3154 /* parse parameters */
3155 schro_pack_encode_uint (pack, encoder->version_major);
3156 schro_pack_encode_uint (pack, encoder->version_minor);
3157 schro_pack_encode_uint (pack, encoder->profile);
3158 schro_pack_encode_uint (pack, encoder->level);
3159
3160 /* sequence parameters */
3161 schro_pack_encode_uint (pack, encoder->video_format.index);
3162 schro_video_format_set_std_video_format (std_format,
3163 encoder->video_format.index);
3164
3165 if (std_format->width == format->width &&
3166 std_format->height == format->height) {
3167 schro_pack_encode_bit (pack, FALSE);
3168 } else {
3169 schro_pack_encode_bit (pack, TRUE);
3170 schro_pack_encode_uint (pack, format->width);
3171 schro_pack_encode_uint (pack, format->height);
3172 }
3173
3174 if (std_format->chroma_format == format->chroma_format) {
3175 schro_pack_encode_bit (pack, FALSE);
3176 } else {
3177 schro_pack_encode_bit (pack, TRUE);
3178 schro_pack_encode_uint (pack, format->chroma_format);
3179 }
3180
3181 /* scan format */
3182 if (std_format->interlaced == format->interlaced) {
3183 schro_pack_encode_bit (pack, FALSE);
3184 } else {
3185 schro_pack_encode_bit (pack, TRUE);
3186 schro_pack_encode_uint (pack, format->interlaced);
3187 }
3188
3189 MARKER (pack);
3190
3191 /* frame rate */
3192 if (std_format->frame_rate_numerator == format->frame_rate_numerator &&
3193 std_format->frame_rate_denominator == format->frame_rate_denominator) {
3194 schro_pack_encode_bit (pack, FALSE);
3195 } else {
3196 schro_pack_encode_bit (pack, TRUE);
3197 i = schro_video_format_get_std_frame_rate (format);
3198 schro_pack_encode_uint (pack, i);
3199 if (i == 0) {
3200 schro_pack_encode_uint (pack, format->frame_rate_numerator);
3201 schro_pack_encode_uint (pack, format->frame_rate_denominator);
3202 }
3203 }
3204
3205 MARKER (pack);
3206
3207 /* pixel aspect ratio */
3208 if (std_format->aspect_ratio_numerator == format->aspect_ratio_numerator &&
3209 std_format->aspect_ratio_denominator ==
3210 format->aspect_ratio_denominator) {
3211 schro_pack_encode_bit (pack, FALSE);
3212 } else {
3213 schro_pack_encode_bit (pack, TRUE);
3214 i = schro_video_format_get_std_aspect_ratio (format);
3215 schro_pack_encode_uint (pack, i);
3216 if (i == 0) {
3217 schro_pack_encode_uint (pack, format->aspect_ratio_numerator);
3218 schro_pack_encode_uint (pack, format->aspect_ratio_denominator);
3219 }
3220 }
3221
3222 MARKER (pack);
3223
3224 /* clean area */
3225 if (std_format->clean_width == format->clean_width &&
3226 std_format->clean_height == format->clean_height &&
3227 std_format->left_offset == format->left_offset &&
3228 std_format->top_offset == format->top_offset) {
3229 schro_pack_encode_bit (pack, FALSE);
3230 } else {
3231 schro_pack_encode_bit (pack, TRUE);
3232 schro_pack_encode_uint (pack, format->clean_width);
3233 schro_pack_encode_uint (pack, format->clean_height);
3234 schro_pack_encode_uint (pack, format->left_offset);
3235 schro_pack_encode_uint (pack, format->top_offset);
3236 }
3237
3238 MARKER (pack);
3239
3240 /* signal range */
3241 if (std_format->luma_offset == format->luma_offset &&
3242 std_format->luma_excursion == format->luma_excursion &&
3243 std_format->chroma_offset == format->chroma_offset &&
3244 std_format->chroma_excursion == format->chroma_excursion) {
3245 schro_pack_encode_bit (pack, FALSE);
3246 } else {
3247 schro_pack_encode_bit (pack, TRUE);
3248 i = schro_video_format_get_std_signal_range (format);
3249 schro_pack_encode_uint (pack, i);
3250 if (i == 0) {
3251 schro_pack_encode_uint (pack, format->luma_offset);
3252 schro_pack_encode_uint (pack, format->luma_excursion);
3253 schro_pack_encode_uint (pack, format->chroma_offset);
3254 schro_pack_encode_uint (pack, format->chroma_excursion);
3255 }
3256 }
3257
3258 MARKER (pack);
3259
3260 /* colour spec */
3261 if (std_format->colour_primaries == format->colour_primaries &&
3262 std_format->colour_matrix == format->colour_matrix &&
3263 std_format->transfer_function == format->transfer_function) {
3264 schro_pack_encode_bit (pack, FALSE);
3265 } else {
3266 schro_pack_encode_bit (pack, TRUE);
3267 i = schro_video_format_get_std_colour_spec (format);
3268 schro_pack_encode_uint (pack, i);
3269 if (i == 0) {
3270 schro_pack_encode_bit (pack, TRUE);
3271 schro_pack_encode_uint (pack, format->colour_primaries);
3272 schro_pack_encode_bit (pack, TRUE);
3273 schro_pack_encode_uint (pack, format->colour_matrix);
3274 schro_pack_encode_bit (pack, TRUE);
3275 schro_pack_encode_uint (pack, format->transfer_function);
3276 }
3277 }
3278
3279 /* interlaced coding */
3280 schro_pack_encode_uint (pack, format->interlaced_coding);
3281
3282 MARKER (pack);
3283
3284 schro_pack_sync (pack);
3285 }
3286
3287 void
schro_encoder_encode_parse_info(SchroPack * pack,int parse_code)3288 schro_encoder_encode_parse_info (SchroPack * pack, int parse_code)
3289 {
3290 /* parse parameters */
3291 schro_pack_encode_bits (pack, 8, 'B');
3292 schro_pack_encode_bits (pack, 8, 'B');
3293 schro_pack_encode_bits (pack, 8, 'C');
3294 schro_pack_encode_bits (pack, 8, 'D');
3295 schro_pack_encode_bits (pack, 8, parse_code);
3296
3297 /* offsets */
3298 schro_pack_encode_bits (pack, 32, 0);
3299 schro_pack_encode_bits (pack, 32, 0);
3300 }
3301
3302 void
schro_encoder_encode_picture_header(SchroEncoderFrame * frame)3303 schro_encoder_encode_picture_header (SchroEncoderFrame * frame)
3304 {
3305 schro_pack_sync (frame->pack);
3306 schro_pack_encode_bits (frame->pack, 32, frame->frame_number);
3307
3308 SCHRO_DEBUG ("refs %d ref0 %d ref1 %d", frame->params.num_refs,
3309 frame->picture_number_ref[0], frame->picture_number_ref[1]);
3310
3311 if (frame->params.num_refs > 0) {
3312 schro_pack_encode_sint (frame->pack,
3313 (int32_t) (frame->picture_number_ref[0] - frame->frame_number));
3314 if (frame->params.num_refs > 1) {
3315 schro_pack_encode_sint (frame->pack,
3316 (int32_t) (frame->picture_number_ref[1] - frame->frame_number));
3317 }
3318 }
3319
3320 if (frame->is_ref) {
3321 if (frame->retired_picture_number != -1) {
3322 schro_pack_encode_sint (frame->pack,
3323 (int32_t) (frame->retired_picture_number - frame->frame_number));
3324 } else {
3325 schro_pack_encode_sint (frame->pack, 0);
3326 }
3327 }
3328 }
3329
3330
3331 static void
schro_encoder_encode_transform_parameters(SchroEncoderFrame * frame)3332 schro_encoder_encode_transform_parameters (SchroEncoderFrame * frame)
3333 {
3334 SchroParams *params = &frame->params;
3335 SchroPack *pack = frame->pack;
3336
3337 if (params->num_refs > 0) {
3338 /* zero residual */
3339 schro_pack_encode_bit (pack, FALSE);
3340 }
3341
3342 /* transform */
3343 schro_pack_encode_uint (pack, params->wavelet_filter_index);
3344
3345 /* transform depth */
3346 schro_pack_encode_uint (pack, params->transform_depth);
3347
3348 /* spatial partitioning */
3349 if (!params->is_lowdelay) {
3350 if (schro_params_is_default_codeblock (params)) {
3351 schro_pack_encode_bit (pack, FALSE);
3352 } else {
3353 int i;
3354
3355 schro_pack_encode_bit (pack, TRUE);
3356 for (i = 0; i < params->transform_depth + 1; i++) {
3357 schro_pack_encode_uint (pack, params->horiz_codeblocks[i]);
3358 schro_pack_encode_uint (pack, params->vert_codeblocks[i]);
3359 }
3360 schro_pack_encode_uint (pack, params->codeblock_mode_index);
3361 }
3362 } else {
3363 schro_pack_encode_uint (pack, params->n_horiz_slices);
3364 schro_pack_encode_uint (pack, params->n_vert_slices);
3365 schro_pack_encode_uint (pack, params->slice_bytes_num);
3366 schro_pack_encode_uint (pack, params->slice_bytes_denom);
3367
3368 if (schro_params_is_default_quant_matrix (params)) {
3369 schro_pack_encode_bit (pack, FALSE);
3370 } else {
3371 int i;
3372 schro_pack_encode_bit (pack, TRUE);
3373 schro_pack_encode_uint (pack, params->quant_matrix[0]);
3374 for (i = 0; i < params->transform_depth; i++) {
3375 schro_pack_encode_uint (pack, params->quant_matrix[1 + 3 * i]);
3376 schro_pack_encode_uint (pack, params->quant_matrix[2 + 3 * i]);
3377 schro_pack_encode_uint (pack, params->quant_matrix[3 + 3 * i]);
3378 }
3379 }
3380 }
3381 }
3382
3383
3384
3385 void
schro_encoder_clean_up_transform(SchroEncoderFrame * frame)3386 schro_encoder_clean_up_transform (SchroEncoderFrame * frame)
3387 {
3388 int i;
3389 int component;
3390 SchroParams *params = &frame->params;
3391
3392 for (component = 0; component < 3; component++) {
3393 for (i = 0; i < 1 + 3 * params->transform_depth; i++) {
3394 schro_encoder_clean_up_transform_subband (frame, component, i);
3395 }
3396 }
3397 }
3398
3399 static void
schro_encoder_clean_up_transform_subband(SchroEncoderFrame * frame,int component,int index)3400 schro_encoder_clean_up_transform_subband (SchroEncoderFrame * frame,
3401 int component, int index)
3402 {
3403 static const int wavelet_extent[SCHRO_N_WAVELETS] = { 2, 1, 2, 0, 0, 4, 2 };
3404 SchroParams *params = &frame->params;
3405 SchroFrameData fd;
3406 int w;
3407 int h;
3408 int i, j;
3409 int position;
3410
3411 position = schro_subband_get_position (index);
3412 schro_subband_get_frame_data (&fd, frame->iwt_frame, component,
3413 position, params);
3414
3415 if (component == 0) {
3416 schro_video_format_get_picture_luma_size (params->video_format, &w, &h);
3417 } else {
3418 schro_video_format_get_picture_chroma_size (params->video_format, &w, &h);
3419 }
3420
3421 h = MIN (h + wavelet_extent[params->wavelet_filter_index], fd.height);
3422 w = MIN (w + wavelet_extent[params->wavelet_filter_index], fd.width);
3423
3424 if ((SCHRO_FRAME_FORMAT_DEPTH (fd.format) ==
3425 SCHRO_FRAME_FORMAT_DEPTH_S16)) {
3426 int16_t *line;
3427 if (w < fd.width) {
3428 for (j = 0; j < h; j++) {
3429 line = SCHRO_FRAME_DATA_GET_LINE (&fd, j);
3430 for (i = w; i < fd.width; i++) {
3431 line[i] = 0;
3432 }
3433 }
3434 }
3435 for (j = h; j < fd.height; j++) {
3436 line = SCHRO_FRAME_DATA_GET_LINE (&fd, j);
3437 for (i = 0; i < fd.width; i++) {
3438 line[i] = 0;
3439 }
3440 }
3441 } else {
3442 int32_t *line;
3443 if (w < fd.width) {
3444 for (j = 0; j < h; j++) {
3445 line = SCHRO_FRAME_DATA_GET_LINE (&fd, j);
3446 for (i = w; i < fd.width; i++) {
3447 line[i] = 0;
3448 }
3449 }
3450 }
3451 for (j = h; j < fd.height; j++) {
3452 line = SCHRO_FRAME_DATA_GET_LINE (&fd, j);
3453 for (i = 0; i < fd.width; i++) {
3454 line[i] = 0;
3455 }
3456 }
3457 }
3458 }
3459
3460 static void
schro_encoder_encode_transform_data(SchroEncoderFrame * frame)3461 schro_encoder_encode_transform_data (SchroEncoderFrame * frame)
3462 {
3463 int i;
3464 int component;
3465 SchroParams *params = &frame->params;
3466
3467 for (component = 0; component < 3; component++) {
3468 for (i = 0; i < 1 + 3 * params->transform_depth; i++) {
3469 schro_pack_sync (frame->pack);
3470 frame->actual_subband_bits[component][i] =
3471 -schro_pack_get_offset (frame->pack) * 8;
3472 if (params->is_noarith) {
3473 schro_encoder_encode_subband_noarith (frame, component, i);
3474 } else {
3475 schro_encoder_encode_subband (frame, component, i);
3476 }
3477 frame->actual_subband_bits[component][i] +=
3478 schro_pack_get_offset (frame->pack) * 8;
3479 }
3480 }
3481 }
3482
3483 static void
schro_frame_data_quantise(SchroFrameData * quant_fd,SchroFrameData * fd,int quant_index,schro_bool is_intra)3484 schro_frame_data_quantise (SchroFrameData * quant_fd,
3485 SchroFrameData * fd, int quant_index, schro_bool is_intra)
3486 {
3487 int j;
3488 int16_t *line;
3489 int16_t *quant_line;
3490 int quant_factor = schro_table_quant[quant_index];
3491 int quant_offset;
3492 int quant_shift = (quant_index >> 2) + 2;
3493 int real_quant_offset;
3494 int inv_quant = schro_table_inverse_quant[quant_index];
3495
3496 if (is_intra) {
3497 quant_offset = schro_table_offset_1_2[quant_index];
3498 } else {
3499 quant_offset = schro_table_offset_3_8[quant_index];
3500 }
3501 real_quant_offset = quant_offset;
3502 quant_offset -= quant_factor >> 1;
3503
3504 if (SCHRO_FRAME_FORMAT_DEPTH (fd->format) ==
3505 SCHRO_FRAME_FORMAT_DEPTH_S32) {
3506 for (j = 0; j < fd->height; j++) {
3507 int32_t *line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3508 int32_t *quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3509
3510 schro_quantise_s32 (quant_line, line, quant_factor, real_quant_offset,
3511 fd->width);
3512 }
3513 return;
3514 }
3515
3516 if (quant_index == 0) {
3517 for (j = 0; j < fd->height; j++) {
3518 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3519 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3520
3521 orc_memcpy (quant_line, line, fd->width * sizeof (int16_t));
3522 }
3523 } else if ((quant_index & 3) == 0) {
3524 for (j = 0; j < fd->height; j++) {
3525 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3526 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3527
3528 orc_quantdequant2_s16 (quant_line, line, quant_shift,
3529 quant_offset, quant_factor, real_quant_offset + 2, fd->width);
3530 }
3531 } else if (quant_index == 3) {
3532 for (j = 0; j < fd->height; j++) {
3533 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3534 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3535
3536 orc_quantdequant3_s16 (quant_line, line, inv_quant, quant_offset,
3537 quant_shift + 16, quant_factor, real_quant_offset + 2, 32768,
3538 fd->width);
3539 }
3540 } else {
3541 if (quant_index > 8)
3542 quant_offset--;
3543 for (j = 0; j < fd->height; j++) {
3544 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3545 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3546
3547 orc_quantdequant1_s16 (quant_line, line, inv_quant, quant_offset,
3548 quant_shift, quant_factor, real_quant_offset + 2, fd->width);
3549 }
3550 }
3551 }
3552
3553 #if 0
3554 static void
3555 schro_frame_data_dequantise (SchroFrameData * fd,
3556 SchroFrameData * quant_fd, int quant_index, schro_bool is_intra)
3557 {
3558 int j;
3559 int16_t *line;
3560 int16_t *quant_line;
3561 int quant_factor = schro_table_quant[quant_index];
3562 int quant_offset;
3563
3564 if (is_intra) {
3565 quant_offset = schro_table_offset_1_2[quant_index];
3566 } else {
3567 quant_offset = schro_table_offset_3_8[quant_index];
3568 }
3569
3570 if (quant_index == 0) {
3571 for (j = 0; j < fd->height; j++) {
3572 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3573 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3574
3575 orc_memcpy (line, quant_line, fd->width * sizeof (int16_t));
3576 }
3577 } else {
3578 for (j = 0; j < fd->height; j++) {
3579 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3580 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3581
3582 orc_dequantise_s16 (line, quant_line, quant_factor, quant_offset + 2,
3583 fd->width);
3584 }
3585 }
3586 }
3587 #endif
3588
3589 static void
schro_frame_data_quantise_dc_predict(SchroFrameData * quant_fd,SchroFrameData * fd,int quant_factor,int quant_offset,int x,int y)3590 schro_frame_data_quantise_dc_predict (SchroFrameData * quant_fd,
3591 SchroFrameData * fd, int quant_factor, int quant_offset, int x, int y)
3592 {
3593 if (SCHRO_FRAME_FORMAT_DEPTH (fd->format) ==
3594 SCHRO_FRAME_FORMAT_DEPTH_S16) {
3595 int i, j;
3596 int16_t *line;
3597 int16_t *prev_line;
3598 int16_t *quant_line;
3599
3600 for (j = 0; j < fd->height; j++) {
3601 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3602 prev_line = SCHRO_FRAME_DATA_GET_LINE (fd, j - 1);
3603 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3604
3605 for (i = 0; i < fd->width; i++) {
3606 int q;
3607 int pred_value;
3608
3609 if (y + j > 0) {
3610 if (x + i > 0) {
3611 pred_value = schro_divide3 (line[i - 1] +
3612 prev_line[i] + prev_line[i - 1] + 1);
3613 } else {
3614 pred_value = prev_line[i];
3615 }
3616 } else {
3617 if (x + i > 0) {
3618 pred_value = line[i - 1];
3619 } else {
3620 pred_value = 0;
3621 }
3622 }
3623
3624 q = schro_quantise (line[i] - pred_value, quant_factor, quant_offset);
3625 line[i] = schro_dequantise (q, quant_factor, quant_offset) + pred_value;
3626 quant_line[i] = q;
3627 }
3628 }
3629 } else {
3630 int i, j;
3631 int32_t *line;
3632 int32_t *prev_line;
3633 int32_t *quant_line;
3634
3635 for (j = 0; j < fd->height; j++) {
3636 line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
3637 prev_line = SCHRO_FRAME_DATA_GET_LINE (fd, j - 1);
3638 quant_line = SCHRO_FRAME_DATA_GET_LINE (quant_fd, j);
3639
3640 for (i = 0; i < fd->width; i++) {
3641 int q;
3642 int pred_value;
3643
3644 if (y + j > 0) {
3645 if (x + i > 0) {
3646 pred_value = schro_divide (line[i - 1] +
3647 prev_line[i] + prev_line[i - 1] + 1, 3);
3648 } else {
3649 pred_value = prev_line[i];
3650 }
3651 } else {
3652 if (x + i > 0) {
3653 pred_value = line[i - 1];
3654 } else {
3655 pred_value = 0;
3656 }
3657 }
3658
3659 q = schro_quantise (line[i] - pred_value, quant_factor, quant_offset);
3660 line[i] = schro_dequantise (q, quant_factor, quant_offset) + pred_value;
3661 quant_line[i] = q;
3662 }
3663 }
3664 }
3665 }
3666
3667 int
schro_encoder_frame_get_quant_index(SchroEncoderFrame * frame,int component,int index,int x,int y)3668 schro_encoder_frame_get_quant_index (SchroEncoderFrame * frame, int component,
3669 int index, int x, int y)
3670 {
3671 SchroParams *params = &frame->params;
3672 int position;
3673 int horiz_codeblocks;
3674 int *codeblock_quants;
3675
3676 position = schro_subband_get_position (index);
3677 horiz_codeblocks =
3678 params->horiz_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
3679
3680 codeblock_quants = frame->quant_indices[component][index];
3681
3682 SCHRO_ASSERT (codeblock_quants);
3683
3684 return codeblock_quants[y * horiz_codeblocks + x];
3685 }
3686
3687 void
schro_encoder_frame_set_quant_index(SchroEncoderFrame * frame,int component,int index,int x,int y,int quant_index)3688 schro_encoder_frame_set_quant_index (SchroEncoderFrame * frame, int component,
3689 int index, int x, int y, int quant_index)
3690 {
3691 SchroParams *params = &frame->params;
3692 int *codeblock_quants;
3693 int position;
3694 int horiz_codeblocks;
3695 int vert_codeblocks;
3696 int i;
3697
3698
3699 position = schro_subband_get_position (index);
3700 horiz_codeblocks =
3701 params->horiz_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
3702 vert_codeblocks = params->vert_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
3703
3704 SCHRO_ASSERT (horiz_codeblocks > 0);
3705 SCHRO_ASSERT (vert_codeblocks > 0);
3706 SCHRO_ASSERT (x < horiz_codeblocks);
3707 SCHRO_ASSERT (y < vert_codeblocks);
3708
3709 if (frame->quant_indices[component][index] == NULL) {
3710 frame->quant_indices[component][index] =
3711 schro_malloc (horiz_codeblocks * vert_codeblocks * sizeof (int));
3712 x = -1;
3713 y = -1;
3714 }
3715
3716 codeblock_quants = frame->quant_indices[component][index];
3717
3718 if (x < 0 || y < 0) {
3719 for (i = 0; i < horiz_codeblocks * vert_codeblocks; i++) {
3720 codeblock_quants[i] = quant_index;
3721 }
3722 } else {
3723 codeblock_quants[x + y * horiz_codeblocks] = quant_index;
3724 }
3725 }
3726
3727 static int
schro_encoder_quantise_subband(SchroEncoderFrame * frame,int component,int index)3728 schro_encoder_quantise_subband (SchroEncoderFrame * frame, int component,
3729 int index)
3730 {
3731 int quant_index;
3732 int quant_factor;
3733 int quant_offset;
3734 SchroFrameData fd;
3735 SchroFrameData qd;
3736 int position;
3737 SchroParams *params = &frame->params;
3738 int horiz_codeblocks;
3739 int vert_codeblocks;
3740 int x, y;
3741
3742 position = schro_subband_get_position (index);
3743 schro_subband_get_frame_data (&fd, frame->iwt_frame, component,
3744 position, params);
3745 schro_subband_get_frame_data (&qd, frame->quant_frame, component,
3746 position, params);
3747
3748 horiz_codeblocks =
3749 params->horiz_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
3750 vert_codeblocks = params->vert_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
3751
3752 for (y = 0; y < vert_codeblocks; y++) {
3753
3754 for (x = 0; x < horiz_codeblocks; x++) {
3755 SchroFrameData quant_cb;
3756 SchroFrameData cb;
3757
3758 quant_index = schro_encoder_frame_get_quant_index (frame, component,
3759 index, x, y);
3760 quant_factor = schro_table_quant[quant_index];
3761 if (params->num_refs > 0) {
3762 quant_offset = schro_table_offset_3_8[quant_index];
3763 } else {
3764 quant_offset = schro_table_offset_1_2[quant_index];
3765 }
3766
3767 schro_frame_data_get_codeblock (&cb, &fd, x, y, horiz_codeblocks,
3768 vert_codeblocks);
3769 schro_frame_data_get_codeblock (&quant_cb, &qd, x, y, horiz_codeblocks,
3770 vert_codeblocks);
3771
3772 if (params->num_refs == 0 && index == 0) {
3773 schro_frame_data_quantise_dc_predict (&quant_cb, &cb, quant_factor,
3774 quant_offset, x, y);
3775 } else {
3776 schro_frame_data_quantise (&quant_cb, &cb, quant_index,
3777 (params->num_refs == 0));
3778 }
3779 }
3780 }
3781
3782 return schro_frame_data_is_zero (&qd);
3783 }
3784
3785 static void
schro_frame_data_clear(SchroFrameData * fd)3786 schro_frame_data_clear (SchroFrameData * fd)
3787 {
3788 int i;
3789
3790 for (i = 0; i < fd->height; i++) {
3791 orc_splat_s16_ns (SCHRO_FRAME_DATA_GET_LINE (fd, i), 0, fd->width);
3792 }
3793 }
3794
3795 void
schro_encoder_encode_subband(SchroEncoderFrame * frame,int component,int index)3796 schro_encoder_encode_subband (SchroEncoderFrame * frame, int component,
3797 int index)
3798 {
3799 SchroParams *params = &frame->params;
3800 SchroArith *arith;
3801 int i, j;
3802 int subband_zero_flag;
3803 int x, y;
3804 int horiz_codeblocks;
3805 int vert_codeblocks;
3806 int have_zero_flags;
3807 int have_quant_offset;
3808 int position;
3809 SchroFrameData fd;
3810 SchroFrameData qd;
3811 SchroFrameData parent_fd;
3812 int quant_index;
3813 int n_subbands_left;
3814 int first_quant_index;
3815
3816 position = schro_subband_get_position (index);
3817 schro_subband_get_frame_data (&fd, frame->iwt_frame, component,
3818 position, params);
3819 schro_subband_get_frame_data (&qd, frame->quant_frame, component,
3820 position, params);
3821
3822 if (position >= 4) {
3823 schro_subband_get_frame_data (&parent_fd, frame->iwt_frame, component,
3824 position - 4, params);
3825 } else {
3826 parent_fd.data = NULL;
3827 parent_fd.stride = 0;
3828 }
3829
3830 arith = schro_arith_new ();
3831 schro_arith_encode_init (arith, frame->subband_buffer);
3832
3833 subband_zero_flag = schro_encoder_quantise_subband (frame, component, index);
3834
3835 if (subband_zero_flag) {
3836 SCHRO_DEBUG ("subband is zero");
3837 schro_pack_encode_uint (frame->pack, 0);
3838 schro_arith_free (arith);
3839 return;
3840 }
3841
3842 if (index == 0) {
3843 horiz_codeblocks = params->horiz_codeblocks[0];
3844 vert_codeblocks = params->vert_codeblocks[0];
3845 } else {
3846 horiz_codeblocks =
3847 params->horiz_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
3848 vert_codeblocks =
3849 params->vert_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
3850 }
3851 if (horiz_codeblocks > 1 || vert_codeblocks > 1) {
3852 have_zero_flags = TRUE;
3853 } else {
3854 have_zero_flags = FALSE;
3855 }
3856 if (params->codeblock_mode_index == 1) {
3857 have_quant_offset = TRUE;
3858 } else {
3859 have_quant_offset = FALSE;
3860 }
3861
3862 first_quant_index = -1;
3863 quant_index = 0;
3864 for (y = 0; y < vert_codeblocks; y++) {
3865 int ymin = (fd.height * y) / vert_codeblocks;
3866 int ymax = (fd.height * (y + 1)) / vert_codeblocks;
3867
3868 for (x = 0; x < horiz_codeblocks; x++) {
3869 int xmin = (fd.width * x) / horiz_codeblocks;
3870 int xmax = (fd.width * (x + 1)) / horiz_codeblocks;
3871 SchroFrameData quant_cb;
3872 SchroFrameData cb;
3873
3874 schro_frame_data_get_codeblock (&cb, &fd, x, y, horiz_codeblocks,
3875 vert_codeblocks);
3876 schro_frame_data_get_codeblock (&quant_cb, &qd, x, y, horiz_codeblocks,
3877 vert_codeblocks);
3878
3879 if (have_zero_flags) {
3880 int zero_codeblock = schro_frame_data_is_zero (&quant_cb);
3881
3882 _schro_arith_encode_bit (arith, SCHRO_CTX_ZERO_CODEBLOCK,
3883 zero_codeblock);
3884 if (zero_codeblock) {
3885 continue;
3886 }
3887 }
3888
3889 if (have_quant_offset) {
3890 int new_quant_index;
3891
3892 new_quant_index = schro_encoder_frame_get_quant_index (frame,
3893 component, index, x, y);
3894 if (first_quant_index == -1) {
3895 quant_index = new_quant_index;
3896 first_quant_index = new_quant_index;
3897 }
3898
3899 _schro_arith_encode_sint (arith,
3900 SCHRO_CTX_QUANTISER_CONT, SCHRO_CTX_QUANTISER_VALUE,
3901 SCHRO_CTX_QUANTISER_SIGN, new_quant_index - quant_index);
3902
3903 quant_index = new_quant_index;
3904 }
3905
3906 for (j = ymin; j < ymax; j++) {
3907 int16_t *prev_quant_line = SCHRO_FRAME_DATA_GET_LINE (&qd, j - 1);
3908 int16_t *quant_line = SCHRO_FRAME_DATA_GET_LINE (&qd, j);
3909 int16_t *parent_line = SCHRO_FRAME_DATA_GET_LINE (&parent_fd, (j >> 1));
3910
3911 #define STUFF(have_parent,is_horiz,is_vert) \
3912 for(i=xmin;i<xmax;i++){ \
3913 int parent; \
3914 int cont_context; \
3915 int value_context; \
3916 int nhood_or; \
3917 int previous_value; \
3918 int sign_context; \
3919 \
3920 if (have_parent) { \
3921 parent = parent_line[(i>>1)]; \
3922 } else { \
3923 parent = 0; \
3924 } \
3925 \
3926 nhood_or = 0; \
3927 if (j>0) { \
3928 nhood_or |= prev_quant_line[i]; \
3929 } \
3930 if (i>0) { \
3931 nhood_or |= quant_line[i - 1]; \
3932 } \
3933 if (i>0 && j>0) { \
3934 nhood_or |= prev_quant_line[i - 1]; \
3935 } \
3936 \
3937 previous_value = 0; \
3938 if (is_horiz) { \
3939 if (i > 0) { \
3940 previous_value = quant_line[i - 1]; \
3941 } \
3942 } else if (is_vert) { \
3943 if (j > 0) { \
3944 previous_value = prev_quant_line[i]; \
3945 } \
3946 } \
3947 \
3948 if (previous_value < 0) { \
3949 sign_context = SCHRO_CTX_SIGN_NEG; \
3950 } else { \
3951 if (previous_value > 0) { \
3952 sign_context = SCHRO_CTX_SIGN_POS; \
3953 } else { \
3954 sign_context = SCHRO_CTX_SIGN_ZERO; \
3955 } \
3956 } \
3957 \
3958 if (parent == 0) { \
3959 if (nhood_or == 0) { \
3960 cont_context = SCHRO_CTX_ZPZN_F1; \
3961 } else { \
3962 cont_context = SCHRO_CTX_ZPNN_F1; \
3963 } \
3964 } else { \
3965 if (nhood_or == 0) { \
3966 cont_context = SCHRO_CTX_NPZN_F1; \
3967 } else { \
3968 cont_context = SCHRO_CTX_NPNN_F1; \
3969 } \
3970 } \
3971 \
3972 value_context = SCHRO_CTX_COEFF_DATA; \
3973 \
3974 _schro_arith_encode_sint (arith, cont_context, value_context, \
3975 sign_context, quant_line[i]); \
3976 }
3977
3978 if (position >= 4) {
3979 if (SCHRO_SUBBAND_IS_HORIZONTALLY_ORIENTED (position)) {
3980 STUFF (TRUE, TRUE, FALSE);
3981 } else if (SCHRO_SUBBAND_IS_VERTICALLY_ORIENTED (position)) {
3982 STUFF (TRUE, FALSE, TRUE);
3983 } else {
3984 STUFF (TRUE, FALSE, FALSE);
3985 }
3986 } else {
3987 if (SCHRO_SUBBAND_IS_HORIZONTALLY_ORIENTED (position)) {
3988 STUFF (FALSE, TRUE, FALSE);
3989 } else if (SCHRO_SUBBAND_IS_VERTICALLY_ORIENTED (position)) {
3990 STUFF (FALSE, FALSE, TRUE);
3991 } else {
3992 STUFF (FALSE, FALSE, FALSE);
3993 }
3994 }
3995 }
3996 }
3997 }
3998
3999 schro_arith_flush (arith);
4000
4001 SCHRO_ASSERT (arith->offset < frame->subband_buffer->length);
4002
4003 schro_dump (SCHRO_DUMP_SUBBAND_EST, "%d %d %d %g %d\n",
4004 frame->frame_number, component, index,
4005 frame->
4006 est_entropy[component][index][frame->quant_indices[component][index][0]],
4007 arith->offset * 8);
4008
4009 n_subbands_left = (3 - component) * (1 + 3 * params->transform_depth) - index;
4010 if ((schro_pack_get_offset (frame->pack) + arith->offset +
4011 n_subbands_left + 4) * 8 > frame->hard_limit_bits) {
4012 SCHRO_ERROR ("skipping comp=%d subband=%d, too big (%d+%d+%d+32 > %d)",
4013 component, index,
4014 schro_pack_get_offset (frame->pack) * 8, arith->offset * 8,
4015 n_subbands_left * 8, frame->hard_limit_bits);
4016
4017 schro_pack_encode_uint (frame->pack, 0);
4018
4019 schro_frame_data_clear (&fd);
4020 } else {
4021 SCHRO_DEBUG ("appending comp=%d subband=%d, (%d+%d+%d+32 <= %d)",
4022 component, index,
4023 schro_pack_get_offset (frame->pack) * 8, arith->offset * 8,
4024 n_subbands_left * 8, frame->hard_limit_bits);
4025 schro_pack_encode_uint (frame->pack, arith->offset);
4026 if (first_quant_index == -1) {
4027 first_quant_index =
4028 schro_encoder_frame_get_quant_index (frame, component, index, 0, 0);
4029 }
4030 if (arith->offset > 0) {
4031 schro_pack_encode_uint (frame->pack, first_quant_index);
4032
4033 schro_pack_sync (frame->pack);
4034
4035 schro_pack_append (frame->pack, arith->buffer->data, arith->offset);
4036 }
4037 }
4038 schro_arith_free (arith);
4039 }
4040
4041 static schro_bool
schro_frame_data_is_zero(SchroFrameData * fd)4042 schro_frame_data_is_zero (SchroFrameData * fd)
4043 {
4044 int j;
4045 int acc;
4046
4047 if (SCHRO_FRAME_FORMAT_DEPTH (fd->format) ==
4048 SCHRO_FRAME_FORMAT_DEPTH_S32) {
4049 for (j = 0; j < fd->height; j++) {
4050 int32_t *line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
4051 int i;
4052 for (i=0; i < fd->width; i++) {
4053 if (line[i] != 0) return FALSE;
4054 }
4055 }
4056 } else {
4057 for (j = 0; j < fd->height; j++) {
4058 int16_t *line = SCHRO_FRAME_DATA_GET_LINE (fd, j);
4059 /* FIXME this could theoretically cause false positives. Fix when
4060 * Orc gets an accorw opcode. */
4061 orc_accw (&acc, line, fd->width);
4062 if (acc != 0)
4063 return FALSE;
4064 }
4065 }
4066
4067 return TRUE;
4068 }
4069
4070 void
schro_encoder_encode_subband_noarith(SchroEncoderFrame * frame,int component,int index)4071 schro_encoder_encode_subband_noarith (SchroEncoderFrame * frame,
4072 int component, int index)
4073 {
4074 SchroParams *params = &frame->params;
4075 SchroPack b;
4076 SchroPack *pack = &b;
4077 int i, j;
4078 int subband_zero_flag;
4079 int x, y;
4080 int horiz_codeblocks;
4081 int vert_codeblocks;
4082 int have_zero_flags;
4083 int have_quant_offset;
4084 int position;
4085 SchroFrameData fd;
4086 SchroFrameData qd;
4087 schro_bool deep;
4088
4089 position = schro_subband_get_position (index);
4090 schro_subband_get_frame_data (&fd, frame->iwt_frame, component,
4091 position, params);
4092 schro_subband_get_frame_data (&qd, frame->quant_frame, component,
4093 position, params);
4094
4095 deep = (SCHRO_FRAME_FORMAT_DEPTH (fd.format) ==
4096 SCHRO_FRAME_FORMAT_DEPTH_S32);
4097
4098 if (deep) {
4099 subband_zero_flag = schro_encoder_quantise_subband (frame, component, index);
4100 } else {
4101 subband_zero_flag = schro_encoder_quantise_subband (frame, component, index);
4102 }
4103
4104 if (subband_zero_flag) {
4105 SCHRO_DEBUG ("subband is zero");
4106 schro_pack_encode_uint (frame->pack, 0);
4107 return;
4108 }
4109
4110 schro_pack_encode_init (pack, frame->subband_buffer);
4111
4112 if (index == 0) {
4113 horiz_codeblocks = params->horiz_codeblocks[0];
4114 vert_codeblocks = params->vert_codeblocks[0];
4115 } else {
4116 horiz_codeblocks =
4117 params->horiz_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
4118 vert_codeblocks =
4119 params->vert_codeblocks[SCHRO_SUBBAND_SHIFT (position) + 1];
4120 }
4121 if ((horiz_codeblocks > 1 || vert_codeblocks > 1) && index > 0) {
4122 have_zero_flags = TRUE;
4123 } else {
4124 have_zero_flags = FALSE;
4125 }
4126 if (horiz_codeblocks > 1 || vert_codeblocks > 1) {
4127 if (params->codeblock_mode_index == 1) {
4128 have_quant_offset = TRUE;
4129 } else {
4130 have_quant_offset = FALSE;
4131 }
4132 } else {
4133 have_quant_offset = FALSE;
4134 }
4135
4136 for (y = 0; y < vert_codeblocks; y++) {
4137 for (x = 0; x < horiz_codeblocks; x++) {
4138 SchroFrameData cb;
4139
4140 schro_frame_data_get_codeblock (&cb, &qd, x, y, horiz_codeblocks,
4141 vert_codeblocks);
4142
4143 if (have_zero_flags) {
4144 int zero_codeblock = schro_frame_data_is_zero (&cb);
4145 schro_pack_encode_bit (pack, zero_codeblock);
4146 if (zero_codeblock) {
4147 continue;
4148 }
4149 }
4150
4151 if (have_quant_offset) {
4152 schro_pack_encode_sint (pack, 0);
4153 }
4154
4155 if (deep) {
4156 for (j = 0; j < cb.height; j++) {
4157 int32_t *quant_line = SCHRO_FRAME_DATA_GET_LINE (&cb, j);
4158 for (i = 0; i < cb.width; i++) {
4159 schro_pack_encode_sint (pack, quant_line[i]);
4160 }
4161 }
4162 } else {
4163 for (j = 0; j < cb.height; j++) {
4164 int16_t *quant_line = SCHRO_FRAME_DATA_GET_LINE (&cb, j);
4165 for (i = 0; i < cb.width; i++) {
4166 schro_pack_encode_sint (pack, quant_line[i]);
4167 }
4168 }
4169 }
4170 }
4171 }
4172 schro_pack_flush (pack);
4173
4174 SCHRO_ASSERT (schro_pack_get_offset (pack) < frame->subband_buffer->length);
4175
4176 schro_dump (SCHRO_DUMP_SUBBAND_EST, "%d %d %d %d %d\n",
4177 frame->frame_number, component, index,
4178 frame->estimated_residual_bits, schro_pack_get_offset (pack) * 8);
4179
4180 schro_pack_encode_uint (frame->pack, schro_pack_get_offset (pack));
4181 if (schro_pack_get_offset (pack) > 0) {
4182 schro_pack_encode_uint (frame->pack,
4183 schro_encoder_frame_get_quant_index (frame, component, index, 0, 0));
4184
4185 schro_pack_sync (frame->pack);
4186 schro_pack_append (frame->pack, pack->buffer->data,
4187 schro_pack_get_offset (pack));
4188 }
4189
4190 }
4191
4192 /* frame queue */
4193
4194 SchroEncoderFrame *
schro_encoder_frame_new(SchroEncoder * encoder)4195 schro_encoder_frame_new (SchroEncoder * encoder)
4196 {
4197 SchroEncoderFrame *encoder_frame;
4198 SchroFrameFormat frame_format;
4199 int iwt_width, iwt_height;
4200 int picture_width;
4201 int picture_height;
4202 int i;
4203
4204 encoder_frame = schro_malloc0 (sizeof (SchroEncoderFrame));
4205 for (i = 0; i < SCHRO_ENCODER_FRAME_STAGE_LAST; i++) {
4206 encoder_frame->stages[i].is_needed = TRUE;
4207 }
4208 encoder_frame->refcount = 1;
4209
4210 encoder_frame->sc_mad = -1;
4211 encoder_frame->sc_threshold = -1.;
4212 encoder_frame->scene_change_score = -1.;
4213
4214 frame_format = schro_params_get_frame_format (encoder->intermediate_frame_depth,
4215 encoder->video_format.chroma_format);
4216
4217 schro_video_format_get_iwt_alloc_size (&encoder->video_format,
4218 &iwt_width, &iwt_height, encoder->transform_depth);
4219 encoder_frame->iwt_frame = schro_frame_new_and_alloc (NULL, frame_format,
4220 iwt_width, iwt_height);
4221 encoder_frame->quant_frame = schro_frame_new_and_alloc (NULL, frame_format,
4222 iwt_width, iwt_height);
4223
4224 schro_video_format_get_picture_luma_size (&encoder->video_format,
4225 &picture_width, &picture_height);
4226 encoder_frame->prediction_frame =
4227 schro_frame_new_and_alloc (NULL, frame_format, picture_width,
4228 picture_height);
4229
4230 encoder_frame->inserted_buffers =
4231 schro_list_new_full ((SchroListFreeFunc) schro_buffer_unref, NULL);
4232
4233 encoder_frame->retired_picture_number = -1;
4234
4235 return encoder_frame;
4236 }
4237
4238 void
schro_encoder_frame_ref(SchroEncoderFrame * frame)4239 schro_encoder_frame_ref (SchroEncoderFrame * frame)
4240 {
4241 SCHRO_ASSERT (frame && frame->refcount > 0);
4242 frame->refcount++;
4243 }
4244
4245 void
schro_encoder_frame_unref(SchroEncoderFrame * frame)4246 schro_encoder_frame_unref (SchroEncoderFrame * frame)
4247 {
4248 int i;
4249
4250 frame->refcount--;
4251 if (frame->refcount == 0) {
4252 if (frame->previous_frame) {
4253 schro_encoder_frame_unref (frame->previous_frame);
4254 }
4255 if (frame->original_frame) {
4256 schro_frame_unref (frame->original_frame);
4257 }
4258 if (frame->filtered_frame) {
4259 schro_frame_unref (frame->filtered_frame);
4260 }
4261 if (frame->reconstructed_frame) {
4262 schro_upsampled_frame_free (frame->reconstructed_frame);
4263 }
4264
4265 if (frame->upsampled_original_frame) {
4266 schro_upsampled_frame_free (frame->upsampled_original_frame);
4267 }
4268 #if 0
4269 for (i = 0; i < 2; i++) {
4270 if (frame->mf[i]) {
4271 schro_motion_field_free (frame->mf[i]);
4272 }
4273 }
4274 #endif
4275
4276 for (i = 0; i < frame->encoder->downsample_levels; i++) {
4277 if (frame->downsampled_frames[i]) {
4278 schro_frame_unref (frame->downsampled_frames[i]);
4279 }
4280 }
4281 if (frame->iwt_frame) {
4282 schro_frame_unref (frame->iwt_frame);
4283 }
4284 if (frame->prediction_frame) {
4285 schro_frame_unref (frame->prediction_frame);
4286 }
4287 if (frame->motion) {
4288 schro_motion_free (frame->motion);
4289 }
4290
4291 schro_list_free (frame->inserted_buffers);
4292 if (frame->output_buffer) {
4293 schro_buffer_unref (frame->output_buffer);
4294 }
4295 if (frame->sequence_header_buffer) {
4296 schro_buffer_unref (frame->sequence_header_buffer);
4297 }
4298
4299 if (frame->me) {
4300 schro_motionest_free (frame->me);
4301 }
4302 if (frame->rme[0])
4303 schro_rough_me_free (frame->rme[0]);
4304 if (frame->rme[1])
4305 schro_rough_me_free (frame->rme[1]);
4306 if (frame->hier_bm[0])
4307 schro_hbm_unref (frame->hier_bm[0]);
4308 frame->hier_bm[0] = NULL;
4309 if (frame->hier_bm[1])
4310 schro_hbm_unref (frame->hier_bm[1]);
4311 frame->hier_bm[1] = NULL;
4312 if (frame->deep_me)
4313 schro_me_free (frame->deep_me);
4314 frame->deep_me = NULL;
4315 if (frame->phasecorr[0])
4316 schro_phasecorr_free (frame->phasecorr[0]);
4317 if (frame->phasecorr[1])
4318 schro_phasecorr_free (frame->phasecorr[1]);
4319
4320 for (i = 0; i < SCHRO_LIMIT_SUBBANDS; i++) {
4321 if (frame->quant_indices[0][i])
4322 schro_free (frame->quant_indices[0][i]);
4323 if (frame->quant_indices[1][i])
4324 schro_free (frame->quant_indices[1][i]);
4325 if (frame->quant_indices[2][i])
4326 schro_free (frame->quant_indices[2][i]);
4327 }
4328
4329
4330 schro_free (frame);
4331 }
4332 }
4333
4334 #if 0
4335 /* reference pool */
4336
4337 void
4338 schro_encoder_reference_add (SchroEncoder * encoder, SchroEncoderFrame * frame)
4339 {
4340 if (schro_queue_is_full (encoder->reference_queue)) {
4341 schro_queue_pop (encoder->reference_queue);
4342 }
4343
4344 SCHRO_DEBUG ("adding reference %p %d", frame, frame->frame_number);
4345
4346 schro_encoder_frame_ref (frame);
4347 schro_queue_add (encoder->reference_queue, frame, frame->frame_number);
4348 }
4349 #endif
4350
4351 SchroEncoderFrame *
schro_encoder_reference_get(SchroEncoder * encoder,SchroPictureNumber frame_number)4352 schro_encoder_reference_get (SchroEncoder * encoder,
4353 SchroPictureNumber frame_number)
4354 {
4355 int i;
4356 for (i = 0; i < SCHRO_LIMIT_REFERENCE_FRAMES; i++) {
4357 if (encoder->reference_pictures[i] &&
4358 encoder->reference_pictures[i]->frame_number == frame_number) {
4359 return encoder->reference_pictures[i];
4360 }
4361 }
4362 return NULL;
4363 }
4364
4365 /* settings */
4366
4367 #define ENUM(name,list,def) \
4368 {{#name, SCHRO_ENCODER_SETTING_TYPE_ENUM, 0, ARRAY_SIZE(list)-1, def, list}, offsetof(SchroEncoder, name)}
4369 #define INT(name,min,max,def) \
4370 {{#name, SCHRO_ENCODER_SETTING_TYPE_INT, min, max, def}, offsetof(SchroEncoder, name)}
4371 #define BOOL(name,def) \
4372 {{#name, SCHRO_ENCODER_SETTING_TYPE_BOOLEAN, 0, 1, def}, offsetof(SchroEncoder, name)}
4373 #define DOUB(name,min,max,def) \
4374 {{#name, SCHRO_ENCODER_SETTING_TYPE_DOUBLE, min, max, def}, offsetof(SchroEncoder, name)}
4375
4376 static const char *rate_control_list[] = {
4377 "constant_noise_threshold",
4378 "constant_bitrate",
4379 "low_delay",
4380 "lossless",
4381 "constant_lambda",
4382 "constant_error",
4383 "constant_quality"
4384 };
4385
4386 static const char *profile_list[] = {
4387 "auto",
4388 "vc2_low_delay",
4389 "vc2_simple",
4390 "vc2_main",
4391 "main"
4392 };
4393
4394 static const char *gop_structure_list[] = {
4395 "adaptive",
4396 "intra_only",
4397 "backref",
4398 "chained_backref",
4399 "biref",
4400 "chained_biref"
4401 };
4402
4403 static const char *perceptual_weighting_list[] = {
4404 "none",
4405 "ccir959",
4406 "moo",
4407 "manos_sakrison"
4408 };
4409
4410 static const char *filtering_list[] = {
4411 "none",
4412 "center_weighted_median",
4413 "gaussian",
4414 "add_noise",
4415 "adaptive_gaussian",
4416 "lowpass"
4417 };
4418
4419 static const char *wavelet_list[] = {
4420 "desl_dubuc_9_7",
4421 "le_gall_5_3",
4422 "desl_dubuc_13_7",
4423 "haar_0",
4424 "haar_1",
4425 "fidelity",
4426 "daub_9_7"
4427 };
4428
4429 static const char *block_size_list[] = {
4430 "automatic",
4431 "small",
4432 "medium",
4433 "large"
4434 };
4435
4436 static const char *codeblock_size_list[] = {
4437 "automatic",
4438 "small",
4439 "medium",
4440 "large",
4441 "full"
4442 };
4443
4444 static const char *block_overlap_list[] = {
4445 "automatic",
4446 "none",
4447 "partial",
4448 "full"
4449 };
4450
4451 #ifndef INT_MAX
4452 #define INT_MAX 2147483647
4453 #endif
4454
4455 struct SchroEncoderSettings
4456 {
4457 SchroEncoderSetting s;
4458 int offset;
4459 } static const encoder_settings[] = {
4460 ENUM (rate_control, rate_control_list, 6),
4461 INT (bitrate, 0, INT_MAX, 0),
4462 INT (max_bitrate, 0, INT_MAX, 13824000),
4463 INT (min_bitrate, 0, INT_MAX, 13824000),
4464 INT (buffer_size, 0, INT_MAX, 0),
4465 INT (buffer_level, 0, INT_MAX, 0),
4466 DOUB (quality, 0, 10.0, 5.0),
4467 DOUB (noise_threshold, 0, 100.0, 25.0),
4468 ENUM (gop_structure, gop_structure_list, 0),
4469 INT (queue_depth, 1, SCHRO_LIMIT_FRAME_QUEUE_LENGTH, 20),
4470 ENUM (perceptual_weighting, perceptual_weighting_list, 1),
4471 DOUB (perceptual_distance, 0, 100.0, 4.0),
4472 ENUM (filtering, filtering_list, 0),
4473 DOUB (filter_value, 0, 100.0, 5.0),
4474 INT (profile, 0, 0, 0),
4475 ENUM (force_profile, profile_list, 0),
4476 INT (level, 0, 0, 0),
4477 INT (max_refs, 1, 4, 3),
4478 BOOL (open_gop, TRUE),
4479 INT (au_distance, 1, INT_MAX, 120),
4480 BOOL (enable_psnr, FALSE),
4481 BOOL (enable_ssim, FALSE),
4482
4483 INT (transform_depth, 0, SCHRO_LIMIT_ENCODER_TRANSFORM_DEPTH, 3),
4484 ENUM (intra_wavelet, wavelet_list, SCHRO_WAVELET_DESLAURIERS_DUBUC_9_7),
4485 ENUM (inter_wavelet, wavelet_list, SCHRO_WAVELET_DESLAURIERS_DUBUC_9_7),
4486 INT (mv_precision, 0, 3, 0),
4487 INT (downsample_levels, 2, 8, 5),
4488 ENUM (motion_block_size, block_size_list, 0),
4489 ENUM (motion_block_overlap, block_overlap_list, 0),
4490 BOOL (interlaced_coding, FALSE),
4491 BOOL (enable_internal_testing, FALSE),
4492 BOOL (enable_noarith, FALSE),
4493 BOOL (enable_md5, FALSE),
4494 BOOL (enable_fullscan_estimation, FALSE),
4495 BOOL (enable_hierarchical_estimation, TRUE),
4496 BOOL (enable_zero_estimation, FALSE),
4497 BOOL (enable_phasecorr_estimation, FALSE),
4498 BOOL (enable_bigblock_estimation, TRUE),
4499 BOOL (enable_multiquant, FALSE),
4500 BOOL (enable_dc_multiquant, FALSE),
4501 BOOL (enable_global_motion, FALSE),
4502 BOOL (enable_scene_change_detection, TRUE),
4503 BOOL (enable_deep_estimation, TRUE),
4504 BOOL (enable_rdo_cbr, TRUE),
4505 BOOL (enable_chroma_me, FALSE),
4506 INT (horiz_slices, 0, INT_MAX, 0),
4507 INT (vert_slices, 0, INT_MAX, 0),
4508 ENUM (codeblock_size, codeblock_size_list, 0),
4509
4510 DOUB (magic_dc_metric_offset, 0.0, 1000.0, 1.0),
4511 DOUB (magic_subband0_lambda_scale, 0.0, 1000.0, 10.0),
4512 DOUB (magic_chroma_lambda_scale, 0.0, 1000.0, 0.1),
4513 DOUB (magic_nonref_lambda_scale, 0.0, 1000.0, 0.01),
4514 DOUB (magic_me_lambda_scale, 0.0, 100.0, 1.0),
4515 DOUB (magic_I_lambda_scale, 0.0, 100.0, 1.0),
4516 DOUB (magic_P_lambda_scale, 0.0, 10.0, 0.25),
4517 DOUB (magic_B_lambda_scale, 0.0, 10.0, 0.01),
4518 DOUB (magic_allocation_scale, 0.0, 1000.0, 1.1),
4519 DOUB (magic_inter_cpd_scale, 0.0, 1.0, 1.0),
4520 DOUB (magic_keyframe_weight, 0.0, 1000.0, 7.5),
4521 DOUB (magic_scene_change_threshold, 0.0, 1000.0, 3.0),
4522 DOUB (magic_inter_p_weight, 0.0, 1000.0, 1.5),
4523 DOUB (magic_inter_b_weight, 0.0, 1000.0, 0.2),
4524 DOUB (magic_me_bailout_limit, 0.0, 1000.0, 0.33),
4525 DOUB (magic_bailout_weight, 0.0, 1000.0, 4.0),
4526 DOUB (magic_error_power, 0.0, 1000.0, 4.0),
4527 DOUB (magic_subgroup_length, 1.0, 10.0, 4.0),
4528 DOUB (magic_badblock_multiplier_nonref, 0.0, 1000.0, 4.0),
4529 DOUB (magic_badblock_multiplier_ref, 0.0, 1000.0, 8.0),
4530 DOUB (magic_block_search_threshold, 0.0, 1000.0, 15.0),
4531 DOUB (magic_scan_distance, 0.0, 1000.0, 4.0),
4532 DOUB (magic_diagonal_lambda_scale, 0.0, 1000.0, 1.0),
4533 };
4534
4535 int
schro_encoder_get_n_settings(void)4536 schro_encoder_get_n_settings (void)
4537 {
4538 return ARRAY_SIZE (encoder_settings);
4539 }
4540
4541 const SchroEncoderSetting *
schro_encoder_get_setting_info(int i)4542 schro_encoder_get_setting_info (int i)
4543 {
4544 if (i >= 0 && i < ARRAY_SIZE (encoder_settings)) {
4545 return &encoder_settings[i].s;
4546 }
4547 return NULL;
4548 }
4549
4550 /**
4551 * schro_encoder_setting_set_defaults:
4552 * @encoder: an encoder structure
4553 *
4554 * set the encoder options to the defaults advertised through
4555 * schro_encoder_get_setting_info. old settings are lost.
4556 */
4557 static void
schro_encoder_setting_set_defaults(SchroEncoder * encoder)4558 schro_encoder_setting_set_defaults (SchroEncoder * encoder)
4559 {
4560 int i;
4561 for (i = 0; i < ARRAY_SIZE (encoder_settings); i++) {
4562 switch (encoder_settings[i].s.type) {
4563 case SCHRO_ENCODER_SETTING_TYPE_BOOLEAN:
4564 case SCHRO_ENCODER_SETTING_TYPE_INT:
4565 case SCHRO_ENCODER_SETTING_TYPE_ENUM:
4566 *(int *) SCHRO_OFFSET (encoder, encoder_settings[i].offset) =
4567 encoder_settings[i].s.default_value;
4568 break;
4569 case SCHRO_ENCODER_SETTING_TYPE_DOUBLE:
4570 *(double *) SCHRO_OFFSET (encoder, encoder_settings[i].offset) =
4571 encoder_settings[i].s.default_value;
4572 break;
4573 default:
4574 break;
4575 }
4576 }
4577 }
4578
4579 /**
4580 * schro_encoder_setting_set_double:
4581 * @encoder: an encoder object
4582 *
4583 * set the encoder option given by @name to @value.
4584 */
4585 void
schro_encoder_setting_set_double(SchroEncoder * encoder,const char * name,double value)4586 schro_encoder_setting_set_double (SchroEncoder * encoder, const char *name,
4587 double value)
4588 {
4589 int i;
4590 for (i = 0; i < ARRAY_SIZE (encoder_settings); i++) {
4591 if (strcmp (name, encoder_settings[i].s.name)) {
4592 continue;
4593 }
4594 switch (encoder_settings[i].s.type) {
4595 case SCHRO_ENCODER_SETTING_TYPE_BOOLEAN:
4596 case SCHRO_ENCODER_SETTING_TYPE_INT:
4597 case SCHRO_ENCODER_SETTING_TYPE_ENUM:
4598 *(int *) SCHRO_OFFSET (encoder, encoder_settings[i].offset) = value;
4599 return;
4600 case SCHRO_ENCODER_SETTING_TYPE_DOUBLE:
4601 *(double *) SCHRO_OFFSET (encoder, encoder_settings[i].offset) = value;
4602 return;
4603 default:
4604 return;
4605 }
4606 }
4607 }
4608
4609 /**
4610 * schro_encoder_setting_get_double:
4611 * @encoder: an encoder object
4612 *
4613 * Returns: the current value of an encoder option given by @name
4614 */
4615 double
schro_encoder_setting_get_double(SchroEncoder * encoder,const char * name)4616 schro_encoder_setting_get_double (SchroEncoder * encoder, const char *name)
4617 {
4618 int i;
4619 for (i = 0; i < ARRAY_SIZE (encoder_settings); i++) {
4620 if (strcmp (name, encoder_settings[i].s.name)) {
4621 continue;
4622 }
4623 switch (encoder_settings[i].s.type) {
4624 case SCHRO_ENCODER_SETTING_TYPE_BOOLEAN:
4625 case SCHRO_ENCODER_SETTING_TYPE_INT:
4626 case SCHRO_ENCODER_SETTING_TYPE_ENUM:
4627 return *(int *) SCHRO_OFFSET (encoder, encoder_settings[i].offset);
4628 case SCHRO_ENCODER_SETTING_TYPE_DOUBLE:
4629 return *(double *) SCHRO_OFFSET (encoder, encoder_settings[i].offset);
4630 default:
4631 return 0;
4632 }
4633 }
4634
4635 return 0;
4636 }
4637