?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MODE_INFO size reduction
[libvpx.git] / vp8 / encoder / bitstream.c
blob284025d4ea2b36b6f57d90dbdc5c69b39f7141c8
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 int_mv *ref, const MV_CONTEXT *mvc
803 )
804 {
805 MV e;
806 e.row = mv->row - ref->as_mv.row;
807 e.col = mv->col - ref->as_mv.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].as_mode, pc->fc.bmode_prob);
952 while (++j < 16);
953 }
954
955 write_uv_mode(w, mi->uv_mode, pc->fc.uv_mode_prob);
956 }
957 else /* inter coded */
958 {
959 int_mv best_mv;
960 vp8_prob mv_ref_p [VP8_MVREFS-1];
961
962 vp8_write(w, 1, cpi->prob_intra_coded);
963
964 if (rf == LAST_FRAME)
965 vp8_write(w, 0, prob_last_coded);
966 else
967 {
968 vp8_write(w, 1, prob_last_coded);
969 vp8_write(w, (rf == GOLDEN_FRAME) ? 0 : 1, prob_gf_coded);
970 }
971
972 {
973 int_mv n1, n2;
974 int ct[4];
975
976 vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, cpi->common.ref_frame_sign_bias);
977 vp8_mv_ref_probs(mv_ref_p, ct);
978
979 #ifdef ENTROPY_STATS
980 accum_mv_refs(mode, ct);
981 #endif
982
983 }
984
985 #ifdef ENTROPY_STATS
986 active_section = 3;
987 #endif
988
989 write_mv_ref(w, mode, mv_ref_p);
990
991 switch (mode) /* new, split require MVs */
992 {
993 case NEWMV:
994
995 #ifdef ENTROPY_STATS
996 active_section = 5;
997 #endif
998
999 write_mv(w, &mi->mv.as_mv, &best_mv, mvc);
1000 break;
1001
1002 case SPLITMV:
1003 {
1004 int j = 0;
1005
1006 #ifdef MODE_STATS
1007 ++count_mb_seg [mi->partitioning];
1008 #endif
1009
1010 write_split(w, mi->partitioning);
1011
1012 do
1013 {
1014 const B_MODE_INFO *const b = cpi->mb.partition_info->bmi + j;
1015 const int *const L = vp8_mbsplits [mi->partitioning];
1016 int k = -1; /* first block in subset j */
1017 int mv_contz;
1018 int_mv leftmv, abovemv;
1019
1020
1021 while (j != L[++k])
1022 if (k >= 16)
1023 assert(0);
1024 leftmv.as_int = left_block_mv(m, k);
1025 abovemv.as_int = above_block_mv(m, k, mis);
1026 mv_contz = vp8_mv_cont(&(leftmv.as_mv), &(abovemv.as_mv));
1027
1028 write_sub_mv_ref(w, b->mode, vp8_sub_mv_ref_prob2 [mv_contz]); //pc->fc.sub_mv_ref_prob);
1029
1030 if (b->mode == NEW4X4)
1031 {
1032 #ifdef ENTROPY_STATS
1033 active_section = 11;
1034 #endif
1035 write_mv(w, &b->mv.as_mv, &best_mv, (const MV_CONTEXT *) mvc);
1036 }
1037 }
1038 while (++j < cpi->mb.partition_info->count);
1039 }
1040 break;
1041 default:
1042 break;
1043 }
1044 }
1045
1046 ++m;
1047 cpi->mb.partition_info++;
1048 }
1049
1050 ++m; /* skip L prediction border */
1051 cpi->mb.partition_info++;
1052 }
1053 }
1054
1055
1056 static void write_kfmodes(VP8_COMP *cpi)
1057 {
1058 vp8_writer *const bc = & cpi->bc;
1059 const VP8_COMMON *const c = & cpi->common;
1060 /* const */
1061 MODE_INFO *m = c->mi;
1062
1063 int mb_row = -1;
1064 int prob_skip_false = 0;
1065
1066 if (c->mb_no_coeff_skip)
1067 {
1068 prob_skip_false = cpi->skip_false_count * 256 / (cpi->skip_false_count + cpi->skip_true_count);
1069
1070 if (prob_skip_false <= 1)
1071 prob_skip_false = 1;
1072
1073 if (prob_skip_false >= 255)
1074 prob_skip_false = 255;
1075
1076 cpi->prob_skip_false = prob_skip_false;
1077 vp8_write_literal(bc, prob_skip_false, 8);
1078 }
1079
1080 while (++mb_row < c->mb_rows)
1081 {
1082 int mb_col = -1;
1083
1084 while (++mb_col < c->mb_cols)
1085 {
1086 const int ym = m->mbmi.mode;
1087
1088 if (cpi->mb.e_mbd.update_mb_segmentation_map)
1089 write_mb_features(bc, &m->mbmi, &cpi->mb.e_mbd);
1090
1091 if (c->mb_no_coeff_skip)
1092 vp8_encode_bool(bc, m->mbmi.mb_skip_coeff, prob_skip_false);
1093
1094 kfwrite_ymode(bc, ym, c->kf_ymode_prob);
1095
1096 if (ym == B_PRED)
1097 {
1098 const int mis = c->mode_info_stride;
1099 int i = 0;
1100
1101 do
1102 {
1103 const B_PREDICTION_MODE A = above_block_mode(m, i, mis);
1104 const B_PREDICTION_MODE L = left_block_mode(m, i);
1105 const int bm = m->bmi[i].as_mode;
1106
1107 #ifdef ENTROPY_STATS
1108 ++intra_mode_stats [A] [L] [bm];
1109 #endif
1110
1111 write_bmode(bc, bm, c->kf_bmode_prob [A] [L]);
1112 }
1113 while (++i < 16);
1114 }
1115
1116 write_uv_mode(bc, (m++)->mbmi.uv_mode, c->kf_uv_mode_prob);
1117 }
1118
1119 m++; // skip L prediction border
1120 }
1121 }
1122 int vp8_estimate_entropy_savings(VP8_COMP *cpi)
1123 {
1124 int i = 0;
1125 int savings = 0;
1126
1127 const int *const rfct = cpi->count_mb_ref_frame_usage;
1128 const int rf_intra = rfct[INTRA_FRAME];
1129 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
1130 int new_intra, new_last, gf_last, oldtotal, newtotal;
1131 int ref_frame_cost[MAX_REF_FRAMES];
1132
1133 vp8_clear_system_state(); //__asm emms;
1134
1135 if (cpi->common.frame_type != KEY_FRAME)
1136 {
1137 if (!(new_intra = rf_intra * 255 / (rf_intra + rf_inter)))
1138 new_intra = 1;
1139
1140 new_last = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
1141
1142 gf_last = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
1143 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
1144
1145 // new costs
1146 ref_frame_cost[INTRA_FRAME] = vp8_cost_zero(new_intra);
1147 ref_frame_cost[LAST_FRAME] = vp8_cost_one(new_intra)
1148 + vp8_cost_zero(new_last);
1149 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(new_intra)
1150 + vp8_cost_one(new_last)
1151 + vp8_cost_zero(gf_last);
1152 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(new_intra)
1153 + vp8_cost_one(new_last)
1154 + vp8_cost_one(gf_last);
1155
1156 newtotal =
1157 rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] +
1158 rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] +
1159 rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] +
1160 rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME];
1161
1162
1163 // old costs
1164 ref_frame_cost[INTRA_FRAME] = vp8_cost_zero(cpi->prob_intra_coded);
1165 ref_frame_cost[LAST_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1166 + vp8_cost_zero(cpi->prob_last_coded);
1167 ref_frame_cost[GOLDEN_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1168 + vp8_cost_one(cpi->prob_last_coded)
1169 + vp8_cost_zero(cpi->prob_gf_coded);
1170 ref_frame_cost[ALTREF_FRAME] = vp8_cost_one(cpi->prob_intra_coded)
1171 + vp8_cost_one(cpi->prob_last_coded)
1172 + vp8_cost_one(cpi->prob_gf_coded);
1173
1174 oldtotal =
1175 rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] +
1176 rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] +
1177 rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] +
1178 rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME];
1179
1180 savings += (oldtotal - newtotal) / 256;
1181 }
1182
1183
1184 do
1185 {
1186 int j = 0;
1187
1188 do
1189 {
1190 int k = 0;
1191
1192 do
1193 {
1194 /* at every context */
1195
1196 /* calc probs and branch cts for this frame only */
1197 //vp8_prob new_p [vp8_coef_tokens-1];
1198 //unsigned int branch_ct [vp8_coef_tokens-1] [2];
1199
1200 int t = 0; /* token/prob index */
1201
1202 vp8_tree_probs_from_distribution(
1203 vp8_coef_tokens, vp8_coef_encodings, vp8_coef_tree,
1204 cpi->frame_coef_probs [i][j][k], cpi->frame_branch_ct [i][j][k], cpi->coef_counts [i][j][k],
1205 256, 1
1206 );
1207
1208 do
1209 {
1210 const unsigned int *ct = cpi->frame_branch_ct [i][j][k][t];
1211 const vp8_prob newp = cpi->frame_coef_probs [i][j][k][t];
1212
1213 const vp8_prob old = cpi->common.fc.coef_probs [i][j][k][t];
1214 const vp8_prob upd = vp8_coef_update_probs [i][j][k][t];
1215
1216 const int old_b = vp8_cost_branch(ct, old);
1217 const int new_b = vp8_cost_branch(ct, newp);
1218
1219 const int update_b = 8 +
1220 ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8);
1221
1222 const int s = old_b - new_b - update_b;
1223
1224 if (s > 0)
1225 savings += s;
1226
1227
1228 }
1229 while (++t < vp8_coef_tokens - 1);
1230
1231
1232 }
1233 while (++k < PREV_COEF_CONTEXTS);
1234 }
1235 while (++j < COEF_BANDS);
1236 }
1237 while (++i < BLOCK_TYPES);
1238
1239 return savings;
1240 }
1241
1242 static void update_coef_probs(VP8_COMP *cpi)
1243 {
1244 int i = 0;
1245 vp8_writer *const w = & cpi->bc;
1246 int savings = 0;
1247
1248 vp8_clear_system_state(); //__asm emms;
1249
1250
1251 do
1252 {
1253 int j = 0;
1254
1255 do
1256 {
1257 int k = 0;
1258
1259 do
1260 {
1261 //note: use result from vp8_estimate_entropy_savings, so no need to call vp8_tree_probs_from_distribution here.
1262 /* at every context */
1263
1264 /* calc probs and branch cts for this frame only */
1265 //vp8_prob new_p [vp8_coef_tokens-1];
1266 //unsigned int branch_ct [vp8_coef_tokens-1] [2];
1267
1268 int t = 0; /* token/prob index */
1269
1270 //vp8_tree_probs_from_distribution(
1271 // vp8_coef_tokens, vp8_coef_encodings, vp8_coef_tree,
1272 // new_p, branch_ct, (unsigned int *)cpi->coef_counts [i][j][k],
1273 // 256, 1
1274 // );
1275
1276 do
1277 {
1278 const unsigned int *ct = cpi->frame_branch_ct [i][j][k][t];
1279 const vp8_prob newp = cpi->frame_coef_probs [i][j][k][t];
1280
1281 vp8_prob *Pold = cpi->common.fc.coef_probs [i][j][k] + t;
1282 const vp8_prob old = *Pold;
1283 const vp8_prob upd = vp8_coef_update_probs [i][j][k][t];
1284
1285 const int old_b = vp8_cost_branch(ct, old);
1286 const int new_b = vp8_cost_branch(ct, newp);
1287
1288 const int update_b = 8 +
1289 ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8);
1290
1291 const int s = old_b - new_b - update_b;
1292 const int u = s > 0 ? 1 : 0;
1293
1294 vp8_write(w, u, upd);
1295
1296
1297 #ifdef ENTROPY_STATS
1298 ++ tree_update_hist [i][j][k][t] [u];
1299 #endif
1300
1301 if (u)
1302 {
1303 /* send/use new probability */
1304
1305 *Pold = newp;
1306 vp8_write_literal(w, newp, 8);
1307
1308 savings += s;
1309
1310 }
1311
1312 }
1313 while (++t < vp8_coef_tokens - 1);
1314
1315 /* Accum token counts for generation of default statistics */
1316 #ifdef ENTROPY_STATS
1317 t = 0;
1318
1319 do
1320 {
1321 context_counters [i][j][k][t] += cpi->coef_counts [i][j][k][t];
1322 }
1323 while (++t < vp8_coef_tokens);
1324
1325 #endif
1326
1327 }
1328 while (++k < PREV_COEF_CONTEXTS);
1329 }
1330 while (++j < COEF_BANDS);
1331 }
1332 while (++i < BLOCK_TYPES);
1333
1334 }
1335 #ifdef PACKET_TESTING
1336 FILE *vpxlogc = 0;
1337 #endif
1338
1339 static void put_delta_q(vp8_writer *bc, int delta_q)
1340 {
1341 if (delta_q != 0)
1342 {
1343 vp8_write_bit(bc, 1);
1344 vp8_write_literal(bc, abs(delta_q), 4);
1345
1346 if (delta_q < 0)
1347 vp8_write_bit(bc, 1);
1348 else
1349 vp8_write_bit(bc, 0);
1350 }
1351 else
1352 vp8_write_bit(bc, 0);
1353 }
1354
1355 void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
1356 {
1357 int i, j;
1358 VP8_HEADER oh;
1359 VP8_COMMON *const pc = & cpi->common;
1360 vp8_writer *const bc = & cpi->bc;
1361 MACROBLOCKD *const xd = & cpi->mb.e_mbd;
1362 int extra_bytes_packed = 0;
1363
1364 unsigned char *cx_data = dest;
1365 const int *mb_feature_data_bits;
1366
1367 oh.show_frame = (int) pc->show_frame;
1368 oh.type = (int)pc->frame_type;
1369 oh.version = pc->version;
1370 oh.first_partition_length_in_bytes = 0;
1371
1372 mb_feature_data_bits = vp8_mb_feature_data_bits;
1373 cx_data += 3;
1374
1375 #if defined(SECTIONBITS_OUTPUT)
1376 Sectionbits[active_section = 1] += sizeof(VP8_HEADER) * 8 * 256;
1377 #endif
1378
1379 //vp8_kf_default_bmode_probs() is called in vp8_setup_key_frame() once for each
1380 //K frame before encode frame. pc->kf_bmode_prob doesn't get changed anywhere
1381 //else. No need to call it again here. --yw
1382 //vp8_kf_default_bmode_probs( pc->kf_bmode_prob);
1383
1384 // every keyframe send startcode, width, height, scale factor, clamp and color type
1385 if (oh.type == KEY_FRAME)
1386 {
1387 int v;
1388
1389 // Start / synch code
1390 cx_data[0] = 0x9D;
1391 cx_data[1] = 0x01;
1392 cx_data[2] = 0x2a;
1393
1394 v = (pc->horiz_scale << 14) | pc->Width;
1395 cx_data[3] = v;
1396 cx_data[4] = v >> 8;
1397
1398 v = (pc->vert_scale << 14) | pc->Height;
1399 cx_data[5] = v;
1400 cx_data[6] = v >> 8;
1401
1402 extra_bytes_packed = 7;
1403 cx_data += extra_bytes_packed ;
1404
1405 vp8_start_encode(bc, cx_data);
1406
1407 // signal clr type
1408 vp8_write_bit(bc, pc->clr_type);
1409 vp8_write_bit(bc, pc->clamp_type);
1410
1411 }
1412 else
1413 vp8_start_encode(bc, cx_data);
1414
1415
1416 // Signal whether or not Segmentation is enabled
1417 vp8_write_bit(bc, (xd->segmentation_enabled) ? 1 : 0);
1418
1419 // Indicate which features are enabled
1420 if (xd->segmentation_enabled)
1421 {
1422 // Signal whether or not the segmentation map is being updated.
1423 vp8_write_bit(bc, (xd->update_mb_segmentation_map) ? 1 : 0);
1424 vp8_write_bit(bc, (xd->update_mb_segmentation_data) ? 1 : 0);
1425
1426 if (xd->update_mb_segmentation_data)
1427 {
1428 signed char Data;
1429
1430 vp8_write_bit(bc, (xd->mb_segement_abs_delta) ? 1 : 0);
1431
1432 // For each segmentation feature (Quant and loop filter level)
1433 for (i = 0; i < MB_LVL_MAX; i++)
1434 {
1435 // For each of the segments
1436 for (j = 0; j < MAX_MB_SEGMENTS; j++)
1437 {
1438 Data = xd->segment_feature_data[i][j];
1439
1440 // Frame level data
1441 if (Data)
1442 {
1443 vp8_write_bit(bc, 1);
1444
1445 if (Data < 0)
1446 {
1447 Data = - Data;
1448 vp8_write_literal(bc, Data, mb_feature_data_bits[i]);
1449 vp8_write_bit(bc, 1);
1450 }
1451 else
1452 {
1453 vp8_write_literal(bc, Data, mb_feature_data_bits[i]);
1454 vp8_write_bit(bc, 0);
1455 }
1456 }
1457 else
1458 vp8_write_bit(bc, 0);
1459 }
1460 }
1461 }
1462
1463 if (xd->update_mb_segmentation_map)
1464 {
1465 // Write the probs used to decode the segment id for each macro block.
1466 for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
1467 {
1468 int Data = xd->mb_segment_tree_probs[i];
1469
1470 if (Data != 255)
1471 {
1472 vp8_write_bit(bc, 1);
1473 vp8_write_literal(bc, Data, 8);
1474 }
1475 else
1476 vp8_write_bit(bc, 0);
1477 }
1478 }
1479 }
1480
1481 // Code to determine whether or not to update the scan order.
1482 vp8_write_bit(bc, pc->filter_type);
1483 vp8_write_literal(bc, pc->filter_level, 6);
1484 vp8_write_literal(bc, pc->sharpness_level, 3);
1485
1486 // Write out loop filter deltas applied at the MB level based on mode or ref frame (if they are enabled).
1487 vp8_write_bit(bc, (xd->mode_ref_lf_delta_enabled) ? 1 : 0);
1488
1489 if (xd->mode_ref_lf_delta_enabled)
1490 {
1491 // Do the deltas need to be updated
1492 int send_update = xd->mode_ref_lf_delta_update
1493 || cpi->oxcf.error_resilient_mode;
1494
1495 vp8_write_bit(bc, send_update);
1496 if (send_update)
1497 {
1498 int Data;
1499
1500 // Send update
1501 for (i = 0; i < MAX_REF_LF_DELTAS; i++)
1502 {
1503 Data = xd->ref_lf_deltas[i];
1504
1505 // Frame level data
1506 if (xd->ref_lf_deltas[i] != xd->last_ref_lf_deltas[i]
1507 || cpi->oxcf.error_resilient_mode)
1508 {
1509 xd->last_ref_lf_deltas[i] = xd->ref_lf_deltas[i];
1510 vp8_write_bit(bc, 1);
1511
1512 if (Data > 0)
1513 {
1514 vp8_write_literal(bc, (Data & 0x3F), 6);
1515 vp8_write_bit(bc, 0); // sign
1516 }
1517 else
1518 {
1519 Data = -Data;
1520 vp8_write_literal(bc, (Data & 0x3F), 6);
1521 vp8_write_bit(bc, 1); // sign
1522 }
1523 }
1524 else
1525 vp8_write_bit(bc, 0);
1526 }
1527
1528 // Send update
1529 for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
1530 {
1531 Data = xd->mode_lf_deltas[i];
1532
1533 if (xd->mode_lf_deltas[i] != xd->last_mode_lf_deltas[i]
1534 || cpi->oxcf.error_resilient_mode)
1535 {
1536 xd->last_mode_lf_deltas[i] = xd->mode_lf_deltas[i];
1537 vp8_write_bit(bc, 1);
1538
1539 if (Data > 0)
1540 {
1541 vp8_write_literal(bc, (Data & 0x3F), 6);
1542 vp8_write_bit(bc, 0); // sign
1543 }
1544 else
1545 {
1546 Data = -Data;
1547 vp8_write_literal(bc, (Data & 0x3F), 6);
1548 vp8_write_bit(bc, 1); // sign
1549 }
1550 }
1551 else
1552 vp8_write_bit(bc, 0);
1553 }
1554 }
1555 }
1556
1557 //signal here is multi token partition is enabled
1558 vp8_write_literal(bc, pc->multi_token_partition, 2);
1559
1560 // Frame Qbaseline quantizer index
1561 vp8_write_literal(bc, pc->base_qindex, 7);
1562
1563 // Transmit Dc, Second order and Uv quantizer delta information
1564 put_delta_q(bc, pc->y1dc_delta_q);
1565 put_delta_q(bc, pc->y2dc_delta_q);
1566 put_delta_q(bc, pc->y2ac_delta_q);
1567 put_delta_q(bc, pc->uvdc_delta_q);
1568 put_delta_q(bc, pc->uvac_delta_q);
1569
1570 // When there is a key frame all reference buffers are updated using the new key frame
1571 if (pc->frame_type != KEY_FRAME)
1572 {
1573 // Should the GF or ARF be updated using the transmitted frame or buffer
1574 vp8_write_bit(bc, pc->refresh_golden_frame);
1575 vp8_write_bit(bc, pc->refresh_alt_ref_frame);
1576
1577 // If not being updated from current frame should either GF or ARF be updated from another buffer
1578 if (!pc->refresh_golden_frame)
1579 vp8_write_literal(bc, pc->copy_buffer_to_gf, 2);
1580
1581 if (!pc->refresh_alt_ref_frame)
1582 vp8_write_literal(bc, pc->copy_buffer_to_arf, 2);
1583
1584 // Indicate reference frame sign bias for Golden and ARF frames (always 0 for last frame buffer)
1585 vp8_write_bit(bc, pc->ref_frame_sign_bias[GOLDEN_FRAME]);
1586 vp8_write_bit(bc, pc->ref_frame_sign_bias[ALTREF_FRAME]);
1587 }
1588
1589 vp8_write_bit(bc, pc->refresh_entropy_probs);
1590
1591 if (pc->frame_type != KEY_FRAME)
1592 vp8_write_bit(bc, pc->refresh_last_frame);
1593
1594 #ifdef ENTROPY_STATS
1595
1596 if (pc->frame_type == INTER_FRAME)
1597 active_section = 0;
1598 else
1599 active_section = 7;
1600
1601 #endif
1602
1603 vp8_clear_system_state(); //__asm emms;
1604
1605 //************************************************
1606 // save a copy for later refresh
1607 {
1608 vpx_memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc));
1609 }
1610
1611 update_coef_probs(cpi);
1612
1613 #ifdef ENTROPY_STATS
1614 active_section = 2;
1615 #endif
1616
1617 // Write out the mb_no_coeff_skip flag
1618 vp8_write_bit(bc, pc->mb_no_coeff_skip);
1619
1620 if (pc->frame_type == KEY_FRAME)
1621 {
1622 write_kfmodes(cpi);
1623
1624 #ifdef ENTROPY_STATS
1625 active_section = 8;
1626 #endif
1627 }
1628 else
1629 {
1630 pack_inter_mode_mvs(cpi);
1631
1632 #ifdef ENTROPY_STATS
1633 active_section = 1;
1634 #endif
1635 }
1636
1637 vp8_stop_encode(bc);
1638
1639 oh.first_partition_length_in_bytes = cpi->bc.pos;
1640
1641 /* update frame tag */
1642 {
1643 int v = (oh.first_partition_length_in_bytes << 5) |
1644 (oh.show_frame << 4) |
1645 (oh.version << 1) |
1646 oh.type;
1647
1648 dest[0] = v;
1649 dest[1] = v >> 8;
1650 dest[2] = v >> 16;
1651 }
1652
1653 *size = VP8_HEADER_SIZE + extra_bytes_packed + cpi->bc.pos;
1654
1655 if (pc->multi_token_partition != ONE_PARTITION)
1656 {
1657 int num_part;
1658 int asize;
1659 num_part = 1 << pc->multi_token_partition;
1660
1661 pack_tokens_into_partitions(cpi, cx_data + bc->pos, num_part, &asize);
1662
1663 *size += asize;
1664 }
1665 else
1666 {
1667 vp8_start_encode(&cpi->bc2, cx_data + bc->pos);
1668
1669 #if CONFIG_MULTITHREAD
1670 if (cpi->b_multi_threaded)
1671 pack_mb_row_tokens(cpi, &cpi->bc2);
1672 else
1673 #endif
1674 pack_tokens(&cpi->bc2, cpi->tok, cpi->tok_count);
1675
1676 vp8_stop_encode(&cpi->bc2);
1677
1678 *size += cpi->bc2.pos;
1679 }
1680 }
1681
1682 #ifdef ENTROPY_STATS
1683 void print_tree_update_probs()
1684 {
1685 int i, j, k, l;
1686 FILE *f = fopen("context.c", "a");
1687 int Sum;
1688 fprintf(f, "\n/* Update probabilities for token entropy tree. */\n\n");
1689 fprintf(f, "const vp8_prob tree_update_probs[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens-1] = {\n");
1690
1691 for (i = 0; i < BLOCK_TYPES; i++)
1692 {
1693 fprintf(f, " { \n");
1694
1695 for (j = 0; j < COEF_BANDS; j++)
1696 {
1697 fprintf(f, " {\n");
1698
1699 for (k = 0; k < PREV_COEF_CONTEXTS; k++)
1700 {
1701 fprintf(f, " {");
1702
1703 for (l = 0; l < MAX_ENTROPY_TOKENS - 1; l++)
1704 {
1705 Sum = tree_update_hist[i][j][k][l][0] + tree_update_hist[i][j][k][l][1];
1706
1707 if (Sum > 0)
1708 {
1709 if (((tree_update_hist[i][j][k][l][0] * 255) / Sum) > 0)
1710 fprintf(f, "%3ld, ", (tree_update_hist[i][j][k][l][0] * 255) / Sum);
1711 else
1712 fprintf(f, "%3ld, ", 1);
1713 }
1714 else
1715 fprintf(f, "%3ld, ", 128);
1716 }
1717
1718 fprintf(f, "},\n");
1719 }
1720
1721 fprintf(f, " },\n");
1722 }
1723
1724 fprintf(f, " },\n");
1725 }
1726
1727 fprintf(f, "};\n");
1728 fclose(f);
1729 }
1730 #endif
mirror for libvpx