?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Define RDCOST only once
[libvpx.git] / vp8 / encoder / bitstream.c
blobadbd106980e5f6efee411d53e2d680b6ef38d8f8
1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11
12 #include "vp8/common/header.h"
13 #include "encodemv.h"
14 #include "vp8/common/entropymode.h"
15 #include "vp8/common/findnearmv.h"
16 #include "mcomp.h"
17 #include "vp8/common/systemdependent.h"
18 #include <assert.h>
19 #include <stdio.h>
20 #include "vp8/common/pragmas.h"
21 #include "vpx_mem/vpx_mem.h"
22 #include "bitstream.h"
23
24 const int vp8cx_base_skip_false_prob[128] =
25 {
26 255, 255, 255, 255, 255, 255, 255, 255,
27 255, 255, 255, 255, 255, 255, 255, 255,
28 255, 255, 255, 255, 255, 255, 255, 255,
29 255, 255, 255, 255, 255, 255, 255, 255,
30 255, 255, 255, 255, 255, 255, 255, 255,
31 255, 255, 255, 255, 255, 255, 255, 255,
32 255, 255, 255, 255, 255, 255, 255, 255,
33 251, 248, 244, 240, 236, 232, 229, 225,
34 221, 217, 213, 208, 204, 199, 194, 190,
35 187, 183, 179, 175, 172, 168, 164, 160,
36 157, 153, 149, 145, 142, 138, 134, 130,
37 127, 124, 120, 117, 114, 110, 107, 104,
38 101, 98, 95, 92, 89, 86, 83, 80,
39 77, 74, 71, 68, 65, 62, 59, 56,
40 53, 50, 47, 44, 41, 38, 35, 32,
41 30, 28, 26, 24, 22, 20, 18, 16,
42 };
43 #ifdef VP8REF
44 #define __int64 long long
45 #endif
46
47 #if defined(SECTIONBITS_OUTPUT)
48 unsigned __int64 Sectionbits[500];
49 #endif
50
51 #ifdef ENTROPY_STATS
52 int intra_mode_stats[10][10][10];
53 static unsigned int tree_update_hist [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens-1] [2];
54 extern unsigned int active_section;
55 #endif
56
57 #ifdef MODE_STATS
58 int count_mb_seg[4] = { 0, 0, 0, 0 };
59 #endif
60
61
62 static void update_mode(
63 vp8_writer *const w,
64 int n,
65 vp8_token tok [/* n */],
66 vp8_tree tree,
67 vp8_prob Pnew [/* n-1 */],
68 vp8_prob Pcur [/* n-1 */],
69 unsigned int bct [/* n-1 */] [2],
70 const unsigned int num_events[/* n */]
71 )
72 {
73 unsigned int new_b = 0, old_b = 0;
74 int i = 0;
75
76 vp8_tree_probs_from_distribution(
77 n--, tok, tree,
78 Pnew, bct, num_events,
79 256, 1
80 );
81
82 do
83 {
84 new_b += vp8_cost_branch(bct[i], Pnew[i]);
85 old_b += vp8_cost_branch(bct[i], Pcur[i]);
86 }
87 while (++i < n);
88
89 if (new_b + (n << 8) < old_b)
90 {
91 int i = 0;
92
93 vp8_write_bit(w, 1);
94
95 do
96 {
97 const vp8_prob p = Pnew[i];
98
99 vp8_write_literal(w, Pcur[i] = p ? p : 1, 8);
100 }
101 while (++i < n);
102 }
103 else
104 vp8_write_bit(w, 0);
105 }
106
107 static void update_mbintra_mode_probs(VP8_COMP *cpi)
108 {
109 VP8_COMMON *const x = & cpi->common;
110
111 vp8_writer *const w = & cpi->bc;
112
113 {
114 vp8_prob Pnew [VP8_YMODES-1];
115 unsigned int bct [VP8_YMODES-1] [2];
116
117 update_mode(
118 w, VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree,
119 Pnew, x->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
120 );
121 }
122 {
123 vp8_prob Pnew [VP8_UV_MODES-1];
124 unsigned int bct [VP8_UV_MODES-1] [2];
125
126 update_mode(
127 w, VP8_UV_MODES, vp8_uv_mode_encodings, vp8_uv_mode_tree,
128 Pnew, x->fc.uv_mode_prob, bct, (unsigned int *)cpi->uv_mode_count
129 );
130 }
131 }
132
133 static void write_ymode(vp8_writer *bc, int m, const vp8_prob *p)
134 {
135 vp8_write_token(bc, vp8_ymode_tree, p, vp8_ymode_encodings + m);
136 }
137
138 static void kfwrite_ymode(vp8_writer *bc, int m, const vp8_prob *p)
139 {
140 vp8_write_token(bc, vp8_kf_ymode_tree, p, vp8_kf_ymode_encodings + m);
141 }
142
143 static void write_uv_mode(vp8_writer *bc, int m, const vp8_prob *p)
144 {
145 vp8_write_token(bc, vp8_uv_mode_tree, p, vp8_uv_mode_encodings + m);
146 }
147
148
149 static void write_bmode(vp8_writer *bc, int m, const vp8_prob *p)
150 {
151 vp8_write_token(bc, vp8_bmode_tree, p, vp8_bmode_encodings + m);
152 }
153
154 static void write_split(vp8_writer *bc, int x)
155 {
156 vp8_write_token(
157 bc, vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + x
158 );
159 }
160
161 static const unsigned int norm[256] =
162 {
163 0, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
164 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
165 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
166 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
167 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
168 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
169 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
170 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
171 };
172
173 static void pack_tokens_c(vp8_writer *w, const TOKENEXTRA *p, int xcount)
174 {
175 const TOKENEXTRA *const stop = p + xcount;
176 unsigned int split;
177 unsigned int shift;
178 int count = w->count;
179 unsigned int range = w->range;
180 unsigned int lowvalue = w->lowvalue;
181
182 while (p < stop)
183 {
184 const int t = p->Token;
185 vp8_token *const a = vp8_coef_encodings + t;
186 const vp8_extra_bit_struct *const b = vp8_extra_bits + t;
187 int i = 0;
188 const unsigned char *pp = p->context_tree;
189 int v = a->value;
190 int n = a->Len;
191
192 if (p->skip_eob_node)
193 {
194 n--;
195 i = 2;
196 }
197
198 do
199 {
200 const int bb = (v >> --n) & 1;
201 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
202 i = vp8_coef_tree[i+bb];
203
204 if (bb)
205 {
206 lowvalue += split;
207 range = range - split;
208 }
209 else
210 {
211 range = split;
212 }
213
214 shift = norm[range];
215 range <<= shift;
216 count += shift;
217
218 if (count >= 0)
219 {
220 int offset = shift - count;
221
222 if ((lowvalue << (offset - 1)) & 0x80000000)
223 {
224 int x = w->pos - 1;
225
226 while (x >= 0 && w->buffer[x] == 0xff)
227 {
228 w->buffer[x] = (unsigned char)0;
229 x--;
230 }
231
232 w->buffer[x] += 1;
233 }
234
235 w->buffer[w->pos++] = (lowvalue >> (24 - offset));
236 lowvalue <<= offset;
237 shift = count;
238 lowvalue &= 0xffffff;
239 count -= 8 ;
240 }
241
242 lowvalue <<= shift;
243 }
244 while (n);
245
246
247 if (b->base_val)
248 {
249 const int e = p->Extra, L = b->Len;
250
251 if (L)
252 {
253 const unsigned char *pp = b->prob;
254 int v = e >> 1;
255 int n = L; /* number of bits in v, assumed nonzero */
256 int i = 0;
257
258 do
259 {
260 const int bb = (v >> --n) & 1;
261 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
262 i = b->tree[i+bb];
263
264 if (bb)
265 {
266 lowvalue += split;
267 range = range - split;
268 }
269 else
270 {
271 range = split;
272 }
273
274 shift = norm[range];
275 range <<= shift;
276 count += shift;
277
278 if (count >= 0)
279 {
280 int offset = shift - count;
281
282 if ((lowvalue << (offset - 1)) & 0x80000000)
283 {
284 int x = w->pos - 1;
285
286 while (x >= 0 && w->buffer[x] == 0xff)
287 {
288 w->buffer[x] = (unsigned char)0;
289 x--;
290 }
291
292 w->buffer[x] += 1;
293 }
294
295 w->buffer[w->pos++] = (lowvalue >> (24 - offset));
296 lowvalue <<= offset;
297 shift = count;
298 lowvalue &= 0xffffff;
299 count -= 8 ;
300 }
301
302 lowvalue <<= shift;
303 }
304 while (n);
305 }
306
307
308 {
309
310 split = (range + 1) >> 1;
311
312 if (e & 1)
313 {
314 lowvalue += split;
315 range = range - split;
316 }
317 else
318 {
319 range = split;
320 }
321
322 range <<= 1;
323
324 if ((lowvalue & 0x80000000))
325 {
326 int x = w->pos - 1;
327
328 while (x >= 0 && w->buffer[x] == 0xff)
329 {
330 w->buffer[x] = (unsigned char)0;
331 x--;
332 }
333
334 w->buffer[x] += 1;
335
336 }
337
338 lowvalue <<= 1;
339
340 if (!++count)
341 {
342 count = -8;
343 w->buffer[w->pos++] = (lowvalue >> 24);
344 lowvalue &= 0xffffff;
345 }
346 }
347
348 }
349
350 ++p;
351 }
352
353 w->count = count;
354 w->lowvalue = lowvalue;
355 w->range = range;
356
357 }
358
359 static void write_partition_size(unsigned char *cx_data, int size)
360 {
361 signed char csize;
362
363 csize = size & 0xff;
364 *cx_data = csize;
365 csize = (size >> 8) & 0xff;
366 *(cx_data + 1) = csize;
367 csize = (size >> 16) & 0xff;
368 *(cx_data + 2) = csize;
369
370 }
371
372 static void pack_tokens_into_partitions_c(VP8_COMP *cpi, unsigned char *cx_data, int num_part, int *size)
373 {
374
375 int i;
376 unsigned char *ptr = cx_data;
377 unsigned int shift;
378 vp8_writer *w = &cpi->bc2;
379 *size = 3 * (num_part - 1);
380 ptr = cx_data + (*size);
381
382 for (i = 0; i < num_part; i++)
383 {
384 vp8_start_encode(w, ptr);
385 {
386 unsigned int split;
387 int count = w->count;
388 unsigned int range = w->range;
389 unsigned int lowvalue = w->lowvalue;
390 int mb_row;
391
392 for (mb_row = i; mb_row < cpi->common.mb_rows; mb_row += num_part)
393 {
394 TOKENEXTRA *p = cpi->tplist[mb_row].start;
395 TOKENEXTRA *stop = cpi->tplist[mb_row].stop;
396
397 while (p < stop)
398 {
399 const int t = p->Token;
400 vp8_token *const a = vp8_coef_encodings + t;
401 const vp8_extra_bit_struct *const b = vp8_extra_bits + t;
402 int i = 0;
403 const unsigned char *pp = p->context_tree;
404 int v = a->value;
405 int n = a->Len;
406
407 if (p->skip_eob_node)
408 {
409 n--;
410 i = 2;
411 }
412
413 do
414 {
415 const int bb = (v >> --n) & 1;
416 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
417 i = vp8_coef_tree[i+bb];
418
419 if (bb)
420 {
421 lowvalue += split;
422 range = range - split;
423 }
424 else
425 {
426 range = split;
427 }
428
429 shift = norm[range];
430 range <<= shift;
431 count += shift;
432
433 if (count >= 0)
434 {
435 int offset = shift - count;
436
437 if ((lowvalue << (offset - 1)) & 0x80000000)
438 {
439 int x = w->pos - 1;
440
441 while (x >= 0 && w->buffer[x] == 0xff)
442 {
443 w->buffer[x] = (unsigned char)0;
444 x--;
445 }
446
447 w->buffer[x] += 1;
448 }
449
450 w->buffer[w->pos++] = (lowvalue >> (24 - offset));
451 lowvalue <<= offset;
452 shift = count;
453 lowvalue &= 0xffffff;
454 count -= 8 ;
455 }
456
457 lowvalue <<= shift;
458 }
459 while (n);
460
461
462 if (b->base_val)
463 {
464 const int e = p->Extra, L = b->Len;
465
466 if (L)
467 {
468 const unsigned char *pp = b->prob;
469 int v = e >> 1;
470 int n = L; /* number of bits in v, assumed nonzero */
471 int i = 0;
472
473 do
474 {
475 const int bb = (v >> --n) & 1;
476 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
477 i = b->tree[i+bb];
478
479 if (bb)
480 {
481 lowvalue += split;
482 range = range - split;
483 }
484 else
485 {
486 range = split;
487 }
488
489 shift = norm[range];
490 range <<= shift;
491 count += shift;
492
493 if (count >= 0)
494 {
495 int offset = shift - count;
496
497 if ((lowvalue << (offset - 1)) & 0x80000000)
498 {
499 int x = w->pos - 1;
500
501 while (x >= 0 && w->buffer[x] == 0xff)
502 {
503 w->buffer[x] = (unsigned char)0;
504 x--;
505 }
506
507 w->buffer[x] += 1;
508 }
509
510 w->buffer[w->pos++] = (lowvalue >> (24 - offset));
511 lowvalue <<= offset;
512 shift = count;
513 lowvalue &= 0xffffff;
514 count -= 8 ;
515 }
516
517 lowvalue <<= shift;
518 }
519 while (n);
520 }
521
522 {
523 split = (range + 1) >> 1;
524
525 if (e & 1)
526 {
527 lowvalue += split;
528 range = range - split;
529 }
530 else
531 {
532 range = split;
533 }
534
535 range <<= 1;
536
537 if ((lowvalue & 0x80000000))
538 {
539 int x = w->pos - 1;
540
541 while (x >= 0 && w->buffer[x] == 0xff)
542 {
543 w->buffer[x] = (unsigned char)0;
544 x--;
545 }
546
547 w->buffer[x] += 1;
548
549 }
550
551 lowvalue <<= 1;
552
553 if (!++count)
554 {
555 count = -8;
556 w->buffer[w->pos++] = (lowvalue >> 24);
557 lowvalue &= 0xffffff;
558 }
559 }
560
561 }
562
563 ++p;
564 }
565 }
566
567 w->count = count;
568 w->lowvalue = lowvalue;
569 w->range = range;
570
571 }
572
573 vp8_stop_encode(w);
574 *size += w->pos;
575
576 if (i < (num_part - 1))
577 {
578 write_partition_size(cx_data, w->pos);
579 cx_data += 3;
580 ptr += w->pos;
581 }
582 }
583 }
584
585
586 static void pack_mb_row_tokens_c(VP8_COMP *cpi, vp8_writer *w)
587 {
588
589 unsigned int split;
590 int count = w->count;
591 unsigned int range = w->range;
592 unsigned int lowvalue = w->lowvalue;
593 unsigned int shift;
594 int mb_row;
595
596 for (mb_row = 0; mb_row < cpi->common.mb_rows; mb_row++)
597 {
598 TOKENEXTRA *p = cpi->tplist[mb_row].start;
599 TOKENEXTRA *stop = cpi->tplist[mb_row].stop;
600
601 while (p < stop)
602 {
603 const int t = p->Token;
604 vp8_token *const a = vp8_coef_encodings + t;
605 const vp8_extra_bit_struct *const b = vp8_extra_bits + t;
606 int i = 0;
607 const unsigned char *pp = p->context_tree;
608 int v = a->value;
609 int n = a->Len;
610
611 if (p->skip_eob_node)
612 {
613 n--;
614 i = 2;
615 }
616
617 do
618 {
619 const int bb = (v >> --n) & 1;
620 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
621 i = vp8_coef_tree[i+bb];
622
623 if (bb)
624 {
625 lowvalue += split;
626 range = range - split;
627 }
628 else
629 {
630 range = split;
631 }
632
633 shift = norm[range];
634 range <<= shift;
635 count += shift;
636
637 if (count >= 0)
638 {
639 int offset = shift - count;
640
641 if ((lowvalue << (offset - 1)) & 0x80000000)
642 {
643 int x = w->pos - 1;
644
645 while (x >= 0 && w->buffer[x] == 0xff)
646 {
647 w->buffer[x] = (unsigned char)0;
648 x--;
649 }
650
651 w->buffer[x] += 1;
652 }
653
654 w->buffer[w->pos++] = (lowvalue >> (24 - offset));
655 lowvalue <<= offset;
656 shift = count;
657 lowvalue &= 0xffffff;
658 count -= 8 ;
659 }
660
661 lowvalue <<= shift;
662 }
663 while (n);
664
665
666 if (b->base_val)
667 {
668 const int e = p->Extra, L = b->Len;
669
670 if (L)
671 {
672 const unsigned char *pp = b->prob;
673 int v = e >> 1;
674 int n = L; /* number of bits in v, assumed nonzero */
675 int i = 0;
676
677 do
678 {
679 const int bb = (v >> --n) & 1;
680 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
681 i = b->tree[i+bb];
682
683 if (bb)
684 {
685 lowvalue += split;
686 range = range - split;
687 }
688 else
689 {
690 range = split;
691 }
692
693 shift = norm[range];
694 range <<= shift;
695 count += shift;
696
697 if (count >= 0)
698 {
699 int offset = shift - count;
700
701 if ((lowvalue << (offset - 1)) & 0x80000000)
702 {
703 int x = w->pos - 1;
704
705 while (x >= 0 && w->buffer[x] == 0xff)
706 {
707 w->buffer[x] = (unsigned char)0;
708 x--;
709 }
710
711 w->buffer[x] += 1;
712 }
713
714 w->buffer[w->pos++] = (lowvalue >> (24 - offset));
715 lowvalue <<= offset;
716 shift = count;
717 lowvalue &= 0xffffff;
718 count -= 8 ;
719 }
720
721 lowvalue <<= shift;
722 }
723 while (n);
724 }
725
726 {
727 split = (range + 1) >> 1;
728
729 if (e & 1)
730 {
731 lowvalue += split;
732 range = range - split;
733 }
734 else
735 {
736 range = split;
737 }
738
739 range <<= 1;
740
741 if ((lowvalue & 0x80000000))
742 {
743 int x = w->pos - 1;
744
745 while (x >= 0 && w->buffer[x] == 0xff)
746 {
747 w->buffer[x] = (unsigned char)0;
748 x--;
749 }
750
751 w->buffer[x] += 1;
752
753 }
754
755 lowvalue <<= 1;
756
757 if (!++count)
758 {
759 count = -8;
760 w->buffer[w->pos++] = (lowvalue >> 24);
761 lowvalue &= 0xffffff;
762 }
763 }
764
765 }
766
767 ++p;
768 }
769 }
770
771 w->count = count;
772 w->lowvalue = lowvalue;
773 w->range = range;
774
775 }
776
777 static void write_mv_ref
778 (
779 vp8_writer *w, MB_PREDICTION_MODE m, const vp8_prob *p
780 )
781 {
782
783 assert(NEARESTMV <= m && m <= SPLITMV);
784
785 vp8_write_token(w, vp8_mv_ref_tree, p,
786 vp8_mv_ref_encoding_array - NEARESTMV + m);
787 }
788
789 static void write_sub_mv_ref
790 (
791 vp8_writer *w, B_PREDICTION_MODE m, const vp8_prob *p
792 )
793 {
794 assert(LEFT4X4 <= m && m <= NEW4X4);
795
796 vp8_write_token(w, vp8_sub_mv_ref_tree, p,
797 vp8_sub_mv_ref_encoding_array - LEFT4X4 + m);
798 }
799
800 static void write_mv
801 (
802 vp8_writer *w, const MV *mv, const MV *ref, const MV_CONTEXT *mvc
803 )
804 {
805 MV e;
806 e.row = mv->row - ref->row;
807 e.col = mv->col - ref->col;
808
809 vp8_encode_motion_vector(w, &e, mvc);
810 }
811
812 static void write_mb_features(vp8_writer *w, const MB_MODE_INFO *mi, const MACROBLOCKD *x)
813 {
814 // Encode the MB segment id.
815 if (x->segmentation_enabled && x->update_mb_segmentation_map)
816 {
817 switch (mi->segment_id)
818 {
819 case 0:
820 vp8_write(w, 0, x->mb_segment_tree_probs[0]);
821 vp8_write(w, 0, x->mb_segment_tree_probs[1]);
822 break;
823 case 1:
824 vp8_write(w, 0, x->mb_segment_tree_probs[0]);
825 vp8_write(w, 1, x->mb_segment_tree_probs[1]);
826 break;
827 case 2:
828 vp8_write(w, 1, x->mb_segment_tree_probs[0]);
829 vp8_write(w, 0, x->mb_segment_tree_probs[2]);
830 break;
831 case 3:
832 vp8_write(w, 1, x->mb_segment_tree_probs[0]);
833 vp8_write(w, 1, x->mb_segment_tree_probs[2]);
834 break;
835
836 // TRAP.. This should not happen
837 default:
838 vp8_write(w, 0, x->mb_segment_tree_probs[0]);
839 vp8_write(w, 0, x->mb_segment_tree_probs[1]);
840 break;
841 }
842 }
843 }
844
845
846 static void pack_inter_mode_mvs(VP8_COMP *const cpi)
847 {
848 VP8_COMMON *const pc = & cpi->common;
849 vp8_writer *const w = & cpi->bc;
850 const MV_CONTEXT *mvc = pc->fc.mvc;
851
852 const int *const rfct = cpi->count_mb_ref_frame_usage;
853 const int rf_intra = rfct[INTRA_FRAME];
854 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
855
856 MODE_INFO *m = pc->mi, *ms;
857 const int mis = pc->mode_info_stride;
858 int mb_row = -1;
859
860 int prob_last_coded;
861 int prob_gf_coded;
862 int prob_skip_false = 0;
863 ms = pc->mi - 1;
864
865 cpi->mb.partition_info = cpi->mb.pi;
866
867 // Calculate the probabilities to be used to code the reference frame based on actual useage this frame
868 if (!(cpi->prob_intra_coded = rf_intra * 255 / (rf_intra + rf_inter)))
869 cpi->prob_intra_coded = 1;
870
871 prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
872
873 if (!prob_last_coded)
874 prob_last_coded = 1;
875
876 prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
877 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
878
879 if (!prob_gf_coded)
880 prob_gf_coded = 1;
881
882
883 #ifdef ENTROPY_STATS
884 active_section = 1;
885 #endif
886
887 if (pc->mb_no_coeff_skip)
888 {
889 prob_skip_false = cpi->skip_false_count * 256 / (cpi->skip_false_count + cpi->skip_true_count);
890
891 if (prob_skip_false <= 1)
892 prob_skip_false = 1;
893
894 if (prob_skip_false > 255)
895 prob_skip_false = 255;
896
897 cpi->prob_skip_false = prob_skip_false;
898 vp8_write_literal(w, prob_skip_false, 8);
899 }
900
901 vp8_write_literal(w, cpi->prob_intra_coded, 8);
902 vp8_write_literal(w, prob_last_coded, 8);
903 vp8_write_literal(w, prob_gf_coded, 8);
904
905 update_mbintra_mode_probs(cpi);
906
907 vp8_write_mvprobs(cpi);
908
909 while (++mb_row < pc->mb_rows)
910 {
911 int mb_col = -1;
912
913 while (++mb_col < pc->mb_cols)
914 {
915 const MB_MODE_INFO *const mi = & m->mbmi;
916 const MV_REFERENCE_FRAME rf = mi->ref_frame;
917 const MB_PREDICTION_MODE mode = mi->mode;
918
919 MACROBLOCKD *xd = &cpi->mb.e_mbd;
920
921 // Distance of Mb to the various image edges.
922 // These specified to 8th pel as they are always compared to MV values that are in 1/8th pel units
923 xd->mb_to_left_edge = -((mb_col * 16) << 3);
924 xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
925 xd->mb_to_top_edge = -((mb_row * 16)) << 3;
926 xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
927
928 #ifdef ENTROPY_STATS
929 active_section = 9;
930 #endif
931
932 if (cpi->mb.e_mbd.update_mb_segmentation_map)
933 write_mb_features(w, mi, &cpi->mb.e_mbd);
934
935 if (pc->mb_no_coeff_skip)
936 vp8_encode_bool(w, m->mbmi.mb_skip_coeff, prob_skip_false);
937
938 if (rf == INTRA_FRAME)
939 {
940 vp8_write(w, 0, cpi->prob_intra_coded);
941 #ifdef ENTROPY_STATS
942 active_section = 6;
943 #endif
944 write_ymode(w, mode, pc->fc.ymode_prob);
945
946 if (mode == B_PRED)
947 {
948 int j = 0;
949
950 do
951 write_bmode(w, m->bmi[j].mode, pc->fc.bmode_prob);
952
953 while (++j < 16);
954 }
955
956 write_uv_mode(w, mi->uv_mode, pc->fc.uv_mode_prob);
957 }
958 else /* inter coded */
959 {
960 MV best_mv;
961 vp8_prob mv_ref_p [VP8_MVREFS-1];
962
963 vp8_write(w, 1, cpi->prob_intra_coded);
964
965 if (rf == LAST_FRAME)
966 vp8_write(w, 0, prob_last_coded);
967 else
968 {
969 vp8_write(w, 1, prob_last_coded);
970 vp8_write(w, (rf == GOLDEN_FRAME) ? 0 : 1, prob_gf_coded);
971 }
972
973 {
974 MV n1, n2;
975 int ct[4];
976
977 vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, cpi->common.ref_frame_sign_bias);
978 vp8_mv_ref_probs(mv_ref_p, ct);
979
980 #ifdef ENTROPY_STATS
981 accum_mv_refs(mode, ct);
982 #endif
983
984 }
985
986 #ifdef ENTROPY_STATS
987 active_section = 3;
988 #endif
989
990 write_mv_ref(w, mode, mv_ref_p);
991
992 switch (mode) /* new, split require MVs */
993 {
994 case NEWMV:
995
996 #ifdef ENTROPY_STATS
997 active_section = 5;
998 #endif
999
1000 write_mv(w, &mi->mv.as_mv, &best_mv, mvc);
1001 break;
1002
1003 case SPLITMV:
1004 {
1005 int j = 0;
1006
1007 #ifdef MODE_STATS
1008 ++count_mb_seg [mi->partitioning];
1009 #endif
1010
1011 write_split(w, mi->partitioning);
1012
1013 do
1014 {
1015 const B_MODE_INFO *const b = cpi->mb.partition_info->bmi + j;
1016 const int *const L = vp8_mbsplits [mi->partitioning];
1017 int k = -1; /* first block in subset j */
1018 int mv_contz;
1019
1020 while (j != L[++k])
1021 if (k >= 16)
1022 assert(0);
1023
1024 mv_contz = vp8_mv_cont
1025 (&(vp8_left_bmi(m, k)->mv.as_mv),
1026 &(vp8_above_bmi(m, k, mis)->mv.as_mv));
1027 write_sub_mv_ref(w, b->mode, vp8_sub_mv_ref_prob2 [mv_contz]); //pc->fc.sub_mv_ref_prob);
1028
1029 if (b->mode == NEW4X4)
1030 {
1031 #ifdef ENTROPY_STATS
1032 active_section = 11;
1033 #endif
1034 write_mv(w, &b->mv.as_mv, &best_mv, (const MV_CONTEXT *) mvc);
1035 }
1036 }
1037 while (++j < cpi->mb.partition_info->count);
1038 }
1039 break;
1040 default:
1041 break;
1042 }
1043 }
1044
1045 ++m;
1046 cpi->mb.partition_info++;
1047 }
1048
1049 ++m; /* skip L prediction border */
1050 cpi->mb.partition_info++;
1051 }
1052 }
1053
1054
1055 static void write_kfmodes(VP8_COMP *cpi)
1056 {
1057 vp8_writer *const bc = & cpi->bc;
1058 const VP8_COMMON *const c = & cpi->common;
1059 /* const */
1060 MODE_INFO *m = c->mi;
1061
1062 int mb_row = -1;
1063 int prob_skip_false = 0;
1064
1065 if (c->mb_no_coeff_skip)
1066 {
1067 prob_skip_false = cpi->skip_false_count * 256 / (cpi->skip_false_count + cpi->skip_true_count);
1068
1069 if (prob_skip_false <= 1)
1070 prob_skip_false = 1;
1071
1072 if (prob_skip_false >= 255)
1073 prob_skip_false = 255;
1074
1075 cpi->prob_skip_false = prob_skip_false;
1076 vp8_write_literal(bc, prob_skip_false, 8);
1077 }
1078
1079 while (++mb_row < c->mb_rows)
1080 {
1081 int mb_col = -1;
1082
1083 while (++mb_col < c->mb_cols)
1084 {
1085 const int ym = m->mbmi.mode;
1086
1087 if (cpi->mb.e_mbd.update_mb_segmentation_map)
1088 write_mb_features(bc, &m->mbmi, &cpi->mb.e_mbd);
1089
1090 if (c->mb_no_coeff_skip)
1091 vp8_encode_bool(bc, m->mbmi.mb_skip_coeff, prob_skip_false);
1092
1093 kfwrite_ymode(bc, ym, c->kf_ymode_prob);
1094
1095 if (ym == B_PRED)
1096 {
1097 const int mis = c->mode_info_stride;
1098 int i = 0;
1099
1100 do
1101 {
1102 const B_PREDICTION_MODE A = vp8_above_bmi(m, i, mis)->mode;
1103 const B_PREDICTION_MODE L = vp8_left_bmi(m, i)->mode;
1104 const int bm = m->bmi[i].mode;
1105
1106 #ifdef ENTROPY_STATS
1107 ++intra_mode_stats [A] [L] [bm];
1108 #endif
1109
1110 write_bmode(bc, bm, c->kf_bmode_prob [A] [L]);
1111 }
1112 while (++i < 16);
1113 }
1114
1115 write_uv_mode(bc, (m++)->mbmi.uv_mode, c->kf_uv_mode_prob);
1116 }
1117
1118 m++; // skip L prediction border
1119 }
1120 }
1121 int vp8_estimate_entropy_savings(VP8_COMP *cpi)
1122 {
1123 int i = 0;
1124 int savings = 0;
1125
1126 const int *const rfct = cpi->count_mb_ref_frame_usage;
1127 const int rf_intra = rfct[INTRA_FRAME];
1128 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
1129 int new_intra, new_last, gf_last, oldtotal, newtotal;
1130 int ref_frame_cost[MAX_REF_FRAMES];
1131
1132 vp8_clear_system_state(); //__asm emms;
1133
1134 if (cpi->common.frame_type != KEY_FRAME)
1135 {
1136 if (!(new_intra = rf_intra * 255 / (rf_intra + rf_inter)))
1137 new_intra = 1;
1138
1139 new_last = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
1140
1141 gf_last = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
1142 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
1143
1144 // new costs
1145 ref_frame_cost[INTRA_FRAME] = vp8_cost_zero(new_intra);
1146 ref_frame_cost[LAST_FRAME] = vp8_cost_one(new_intra)
1147 + vp8_cost_zero(new_last);
1148 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(new_intra)
1149 + vp8_cost_one(new_last)
1150 + vp8_cost_zero(gf_last);
1151 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(new_intra)
1152 + vp8_cost_one(new_last)
1153 + vp8_cost_one(gf_last);
1154
1155 newtotal =
1156 rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] +
1157 rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] +
1158 rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] +
1159 rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME];
1160
1161
1162 // old costs
1163 ref_frame_cost[INTRA_FRAME] = vp8_cost_zero(cpi->prob_intra_coded);
1164 ref_frame_cost[LAST_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1165 + vp8_cost_zero(cpi->prob_last_coded);
1166 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1167 + vp8_cost_one(cpi->prob_last_coded)
1168 + vp8_cost_zero(cpi->prob_gf_coded);
1169 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1170 + vp8_cost_one(cpi->prob_last_coded)
1171 + vp8_cost_one(cpi->prob_gf_coded);
1172
1173 oldtotal =
1174 rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] +
1175 rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] +
1176 rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] +
1177 rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME];
1178
1179 savings += (oldtotal - newtotal) / 256;
1180 }
1181
1182
1183 do
1184 {
1185 int j = 0;
1186
1187 do
1188 {
1189 int k = 0;
1190
1191 do
1192 {
1193 /* at every context */
1194
1195 /* calc probs and branch cts for this frame only */
1196 //vp8_prob new_p [vp8_coef_tokens-1];
1197 //unsigned int branch_ct [vp8_coef_tokens-1] [2];
1198
1199 int t = 0; /* token/prob index */
1200
1201 vp8_tree_probs_from_distribution(
1202 vp8_coef_tokens, vp8_coef_encodings, vp8_coef_tree,
1203 cpi->frame_coef_probs [i][j][k], cpi->frame_branch_ct [i][j][k], cpi->coef_counts [i][j][k],
1204 256, 1
1205 );
1206
1207 do
1208 {
1209 const unsigned int *ct = cpi->frame_branch_ct [i][j][k][t];
1210 const vp8_prob newp = cpi->frame_coef_probs [i][j][k][t];
1211
1212 const vp8_prob old = cpi->common.fc.coef_probs [i][j][k][t];
1213 const vp8_prob upd = vp8_coef_update_probs [i][j][k][t];
1214
1215 const int old_b = vp8_cost_branch(ct, old);
1216 const int new_b = vp8_cost_branch(ct, newp);
1217
1218 const int update_b = 8 +
1219 ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8);
1220
1221 const int s = old_b - new_b - update_b;
1222
1223 if (s > 0)
1224 savings += s;
1225
1226
1227 }
1228 while (++t < vp8_coef_tokens - 1);
1229
1230
1231 }
1232 while (++k < PREV_COEF_CONTEXTS);
1233 }
1234 while (++j < COEF_BANDS);
1235 }
1236 while (++i < BLOCK_TYPES);
1237
1238 return savings;
1239 }
1240
1241 static void update_coef_probs(VP8_COMP *cpi)
1242 {
1243 int i = 0;
1244 vp8_writer *const w = & cpi->bc;
1245 int savings = 0;
1246
1247 vp8_clear_system_state(); //__asm emms;
1248
1249
1250 do
1251 {
1252 int j = 0;
1253
1254 do
1255 {
1256 int k = 0;
1257
1258 do
1259 {
1260 //note: use result from vp8_estimate_entropy_savings, so no need to call vp8_tree_probs_from_distribution here.
1261 /* at every context */
1262
1263 /* calc probs and branch cts for this frame only */
1264 //vp8_prob new_p [vp8_coef_tokens-1];
1265 //unsigned int branch_ct [vp8_coef_tokens-1] [2];
1266
1267 int t = 0; /* token/prob index */
1268
1269 //vp8_tree_probs_from_distribution(
1270 // vp8_coef_tokens, vp8_coef_encodings, vp8_coef_tree,
1271 // new_p, branch_ct, (unsigned int *)cpi->coef_counts [i][j][k],
1272 // 256, 1
1273 // );
1274
1275 do
1276 {
1277 const unsigned int *ct = cpi->frame_branch_ct [i][j][k][t];
1278 const vp8_prob newp = cpi->frame_coef_probs [i][j][k][t];
1279
1280 vp8_prob *Pold = cpi->common.fc.coef_probs [i][j][k] + t;
1281 const vp8_prob old = *Pold;
1282 const vp8_prob upd = vp8_coef_update_probs [i][j][k][t];
1283
1284 const int old_b = vp8_cost_branch(ct, old);
1285 const int new_b = vp8_cost_branch(ct, newp);
1286
1287 const int update_b = 8 +
1288 ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8);
1289
1290 const int s = old_b - new_b - update_b;
1291 const int u = s > 0 ? 1 : 0;
1292
1293 vp8_write(w, u, upd);
1294
1295
1296 #ifdef ENTROPY_STATS
1297 ++ tree_update_hist [i][j][k][t] [u];
1298 #endif
1299
1300 if (u)
1301 {
1302 /* send/use new probability */
1303
1304 *Pold = newp;
1305 vp8_write_literal(w, newp, 8);
1306
1307 savings += s;
1308
1309 }
1310
1311 }
1312 while (++t < vp8_coef_tokens - 1);
1313
1314 /* Accum token counts for generation of default statistics */
1315 #ifdef ENTROPY_STATS
1316 t = 0;
1317
1318 do
1319 {
1320 context_counters [i][j][k][t] += cpi->coef_counts [i][j][k][t];
1321 }
1322 while (++t < vp8_coef_tokens);
1323
1324 #endif
1325
1326 }
1327 while (++k < PREV_COEF_CONTEXTS);
1328 }
1329 while (++j < COEF_BANDS);
1330 }
1331 while (++i < BLOCK_TYPES);
1332
1333 }
1334 #ifdef PACKET_TESTING
1335 FILE *vpxlogc = 0;
1336 #endif
1337
1338 static void put_delta_q(vp8_writer *bc, int delta_q)
1339 {
1340 if (delta_q != 0)
1341 {
1342 vp8_write_bit(bc, 1);
1343 vp8_write_literal(bc, abs(delta_q), 4);
1344
1345 if (delta_q < 0)
1346 vp8_write_bit(bc, 1);
1347 else
1348 vp8_write_bit(bc, 0);
1349 }
1350 else
1351 vp8_write_bit(bc, 0);
1352 }
1353
1354 void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
1355 {
1356 int i, j;
1357 VP8_HEADER oh;
1358 VP8_COMMON *const pc = & cpi->common;
1359 vp8_writer *const bc = & cpi->bc;
1360 MACROBLOCKD *const xd = & cpi->mb.e_mbd;
1361 int extra_bytes_packed = 0;
1362
1363 unsigned char *cx_data = dest;
1364 const int *mb_feature_data_bits;
1365
1366 oh.show_frame = (int) pc->show_frame;
1367 oh.type = (int)pc->frame_type;
1368 oh.version = pc->version;
1369 oh.first_partition_length_in_bytes = 0;
1370
1371 mb_feature_data_bits = vp8_mb_feature_data_bits;
1372 cx_data += 3;
1373
1374 #if defined(SECTIONBITS_OUTPUT)
1375 Sectionbits[active_section = 1] += sizeof(VP8_HEADER) * 8 * 256;
1376 #endif
1377
1378 //vp8_kf_default_bmode_probs() is called in vp8_setup_key_frame() once for each
1379 //K frame before encode frame. pc->kf_bmode_prob doesn't get changed anywhere
1380 //else. No need to call it again here. --yw
1381 //vp8_kf_default_bmode_probs( pc->kf_bmode_prob);
1382
1383 // every keyframe send startcode, width, height, scale factor, clamp and color type
1384 if (oh.type == KEY_FRAME)
1385 {
1386 int v;
1387
1388 // Start / synch code
1389 cx_data[0] = 0x9D;
1390 cx_data[1] = 0x01;
1391 cx_data[2] = 0x2a;
1392
1393 v = (pc->horiz_scale << 14) | pc->Width;
1394 cx_data[3] = v;
1395 cx_data[4] = v >> 8;
1396
1397 v = (pc->vert_scale << 14) | pc->Height;
1398 cx_data[5] = v;
1399 cx_data[6] = v >> 8;
1400
1401 extra_bytes_packed = 7;
1402 cx_data += extra_bytes_packed ;
1403
1404 vp8_start_encode(bc, cx_data);
1405
1406 // signal clr type
1407 vp8_write_bit(bc, pc->clr_type);
1408 vp8_write_bit(bc, pc->clamp_type);
1409
1410 }
1411 else
1412 vp8_start_encode(bc, cx_data);
1413
1414
1415 // Signal whether or not Segmentation is enabled
1416 vp8_write_bit(bc, (xd->segmentation_enabled) ? 1 : 0);
1417
1418 // Indicate which features are enabled
1419 if (xd->segmentation_enabled)
1420 {
1421 // Signal whether or not the segmentation map is being updated.
1422 vp8_write_bit(bc, (xd->update_mb_segmentation_map) ? 1 : 0);
1423 vp8_write_bit(bc, (xd->update_mb_segmentation_data) ? 1 : 0);
1424
1425 if (xd->update_mb_segmentation_data)
1426 {
1427 signed char Data;
1428
1429 vp8_write_bit(bc, (xd->mb_segement_abs_delta) ? 1 : 0);
1430
1431 // For each segmentation feature (Quant and loop filter level)
1432 for (i = 0; i < MB_LVL_MAX; i++)
1433 {
1434 // For each of the segments
1435 for (j = 0; j < MAX_MB_SEGMENTS; j++)
1436 {
1437 Data = xd->segment_feature_data[i][j];
1438
1439 // Frame level data
1440 if (Data)
1441 {
1442 vp8_write_bit(bc, 1);
1443
1444 if (Data < 0)
1445 {
1446 Data = - Data;
1447 vp8_write_literal(bc, Data, mb_feature_data_bits[i]);
1448 vp8_write_bit(bc, 1);
1449 }
1450 else
1451 {
1452 vp8_write_literal(bc, Data, mb_feature_data_bits[i]);
1453 vp8_write_bit(bc, 0);
1454 }
1455 }
1456 else
1457 vp8_write_bit(bc, 0);
1458 }
1459 }
1460 }
1461
1462 if (xd->update_mb_segmentation_map)
1463 {
1464 // Write the probs used to decode the segment id for each macro block.
1465 for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
1466 {
1467 int Data = xd->mb_segment_tree_probs[i];
1468
1469 if (Data != 255)
1470 {
1471 vp8_write_bit(bc, 1);
1472 vp8_write_literal(bc, Data, 8);
1473 }
1474 else
1475 vp8_write_bit(bc, 0);
1476 }
1477 }
1478 }
1479
1480 // Code to determine whether or not to update the scan order.
1481 vp8_write_bit(bc, pc->filter_type);
1482 vp8_write_literal(bc, pc->filter_level, 6);
1483 vp8_write_literal(bc, pc->sharpness_level, 3);
1484
1485 // Write out loop filter deltas applied at the MB level based on mode or ref frame (if they are enabled).
1486 vp8_write_bit(bc, (xd->mode_ref_lf_delta_enabled) ? 1 : 0);
1487
1488 if (xd->mode_ref_lf_delta_enabled)
1489 {
1490 // Do the deltas need to be updated
1491 int send_update = xd->mode_ref_lf_delta_update
1492 || cpi->oxcf.error_resilient_mode;
1493
1494 vp8_write_bit(bc, send_update);
1495 if (send_update)
1496 {
1497 int Data;
1498
1499 // Send update
1500 for (i = 0; i < MAX_REF_LF_DELTAS; i++)
1501 {
1502 Data = xd->ref_lf_deltas[i];
1503
1504 // Frame level data
1505 if (xd->ref_lf_deltas[i] != xd->last_ref_lf_deltas[i]
1506 || cpi->oxcf.error_resilient_mode)
1507 {
1508 xd->last_ref_lf_deltas[i] = xd->ref_lf_deltas[i];
1509 vp8_write_bit(bc, 1);
1510
1511 if (Data > 0)
1512 {
1513 vp8_write_literal(bc, (Data & 0x3F), 6);
1514 vp8_write_bit(bc, 0); // sign
1515 }
1516 else
1517 {
1518 Data = -Data;
1519 vp8_write_literal(bc, (Data & 0x3F), 6);
1520 vp8_write_bit(bc, 1); // sign
1521 }
1522 }
1523 else
1524 vp8_write_bit(bc, 0);
1525 }
1526
1527 // Send update
1528 for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
1529 {
1530 Data = xd->mode_lf_deltas[i];
1531
1532 if (xd->mode_lf_deltas[i] != xd->last_mode_lf_deltas[i]
1533 || cpi->oxcf.error_resilient_mode)
1534 {
1535 xd->last_mode_lf_deltas[i] = xd->mode_lf_deltas[i];
1536 vp8_write_bit(bc, 1);
1537
1538 if (Data > 0)
1539 {
1540 vp8_write_literal(bc, (Data & 0x3F), 6);
1541 vp8_write_bit(bc, 0); // sign
1542 }
1543 else
1544 {
1545 Data = -Data;
1546 vp8_write_literal(bc, (Data & 0x3F), 6);
1547 vp8_write_bit(bc, 1); // sign
1548 }
1549 }
1550 else
1551 vp8_write_bit(bc, 0);
1552 }
1553 }
1554 }
1555
1556 //signal here is multi token partition is enabled
1557 vp8_write_literal(bc, pc->multi_token_partition, 2);
1558
1559 // Frame Qbaseline quantizer index
1560 vp8_write_literal(bc, pc->base_qindex, 7);
1561
1562 // Transmit Dc, Second order and Uv quantizer delta information
1563 put_delta_q(bc, pc->y1dc_delta_q);
1564 put_delta_q(bc, pc->y2dc_delta_q);
1565 put_delta_q(bc, pc->y2ac_delta_q);
1566 put_delta_q(bc, pc->uvdc_delta_q);
1567 put_delta_q(bc, pc->uvac_delta_q);
1568
1569 // When there is a key frame all reference buffers are updated using the new key frame
1570 if (pc->frame_type != KEY_FRAME)
1571 {
1572 // Should the GF or ARF be updated using the transmitted frame or buffer
1573 vp8_write_bit(bc, pc->refresh_golden_frame);
1574 vp8_write_bit(bc, pc->refresh_alt_ref_frame);
1575
1576 // If not being updated from current frame should either GF or ARF be updated from another buffer
1577 if (!pc->refresh_golden_frame)
1578 vp8_write_literal(bc, pc->copy_buffer_to_gf, 2);
1579
1580 if (!pc->refresh_alt_ref_frame)
1581 vp8_write_literal(bc, pc->copy_buffer_to_arf, 2);
1582
1583 // Indicate reference frame sign bias for Golden and ARF frames (always 0 for last frame buffer)
1584 vp8_write_bit(bc, pc->ref_frame_sign_bias[GOLDEN_FRAME]);
1585 vp8_write_bit(bc, pc->ref_frame_sign_bias[ALTREF_FRAME]);
1586 }
1587
1588 vp8_write_bit(bc, pc->refresh_entropy_probs);
1589
1590 if (pc->frame_type != KEY_FRAME)
1591 vp8_write_bit(bc, pc->refresh_last_frame);
1592
1593 #ifdef ENTROPY_STATS
1594
1595 if (pc->frame_type == INTER_FRAME)
1596 active_section = 0;
1597 else
1598 active_section = 7;
1599
1600 #endif
1601
1602 vp8_clear_system_state(); //__asm emms;
1603
1604 //************************************************
1605 // save a copy for later refresh
1606 {
1607 vpx_memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc));
1608 }
1609
1610 update_coef_probs(cpi);
1611
1612 #ifdef ENTROPY_STATS
1613 active_section = 2;
1614 #endif
1615
1616 // Write out the mb_no_coeff_skip flag
1617 vp8_write_bit(bc, pc->mb_no_coeff_skip);
1618
1619 if (pc->frame_type == KEY_FRAME)
1620 {
1621 write_kfmodes(cpi);
1622
1623 #ifdef ENTROPY_STATS
1624 active_section = 8;
1625 #endif
1626 }
1627 else
1628 {
1629 pack_inter_mode_mvs(cpi);
1630
1631 #ifdef ENTROPY_STATS
1632 active_section = 1;
1633 #endif
1634 }
1635
1636 vp8_stop_encode(bc);
1637
1638 oh.first_partition_length_in_bytes = cpi->bc.pos;
1639
1640 /* update frame tag */
1641 {
1642 int v = (oh.first_partition_length_in_bytes << 5) |
1643 (oh.show_frame << 4) |
1644 (oh.version << 1) |
1645 oh.type;
1646
1647 dest[0] = v;
1648 dest[1] = v >> 8;
1649 dest[2] = v >> 16;
1650 }
1651
1652 *size = VP8_HEADER_SIZE + extra_bytes_packed + cpi->bc.pos;
1653
1654 if (pc->multi_token_partition != ONE_PARTITION)
1655 {
1656 int num_part;
1657 int asize;
1658 num_part = 1 << pc->multi_token_partition;
1659
1660 pack_tokens_into_partitions(cpi, cx_data + bc->pos, num_part, &asize);
1661
1662 *size += asize;
1663 }
1664 else
1665 {
1666 vp8_start_encode(&cpi->bc2, cx_data + bc->pos);
1667
1668 #if CONFIG_MULTITHREAD
1669 if (cpi->b_multi_threaded)
1670 pack_mb_row_tokens(cpi, &cpi->bc2);
1671 else
1672 #endif
1673 pack_tokens(&cpi->bc2, cpi->tok, cpi->tok_count);
1674
1675 vp8_stop_encode(&cpi->bc2);
1676
1677 *size += cpi->bc2.pos;
1678 }
1679 }
1680
1681 #ifdef ENTROPY_STATS
1682 void print_tree_update_probs()
1683 {
1684 int i, j, k, l;
1685 FILE *f = fopen("context.c", "a");
1686 int Sum;
1687 fprintf(f, "\n/* Update probabilities for token entropy tree. */\n\n");
1688 fprintf(f, "const vp8_prob tree_update_probs[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens-1] = {\n");
1689
1690 for (i = 0; i < BLOCK_TYPES; i++)
1691 {
1692 fprintf(f, " { \n");
1693
1694 for (j = 0; j < COEF_BANDS; j++)
1695 {
1696 fprintf(f, " {\n");
1697
1698 for (k = 0; k < PREV_COEF_CONTEXTS; k++)
1699 {
1700 fprintf(f, " {");
1701
1702 for (l = 0; l < MAX_ENTROPY_TOKENS - 1; l++)
1703 {
1704 Sum = tree_update_hist[i][j][k][l][0] + tree_update_hist[i][j][k][l][1];
1705
1706 if (Sum > 0)
1707 {
1708 if (((tree_update_hist[i][j][k][l][0] * 255) / Sum) > 0)
1709 fprintf(f, "%3ld, ", (tree_update_hist[i][j][k][l][0] * 255) / Sum);
1710 else
1711 fprintf(f, "%3ld, ", 1);
1712 }
1713 else
1714 fprintf(f, "%3ld, ", 128);
1715 }
1716
1717 fprintf(f, "},\n");
1718 }
1719
1720 fprintf(f, " },\n");
1721 }
1722
1723 fprintf(f, " },\n");
1724 }
1725
1726 fprintf(f, "};\n");
1727 fclose(f);
1728 }
1729 #endif
mirror for libvpx