<?php
/**
* SeekQuarry/Yioop --
* Open Source Pure PHP Search Engine, Crawler, and Indexer
*
* Copyright (C) 2009 - 2026 Chris Pollett chris@pollett.org
*
* LICENSE:
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* END LICENSE
*
* @author Chris Pollett chris@pollett.org
* @license https://www.gnu.org/licenses/ GPL3
* @link https://www.seekquarry.com/
* @copyright 2009 - 2026
* @filesource
*
* This file turns a VP8 keyframe into a picture.
*/
namespace seekquarry\yioop\library\av_processing;
/**
* Vp8Tables the constant tables the VP8 standard publishes, gathered in one
* place so the decoding code reads as arithmetic rather than as data.
*/
final class Vp8Tables
{
/**
* DEFAULT_COEFF_PROBS is how likely each coded value is when a frame
* starts. A frame may change these afterwards, but a keyframe begins from
* them.
* @var mixed
*/
public const DEFAULT_COEFF_PROBS = [
[
[
[128,128,128,128,128,128,128,128,128,128,128],
[128,128,128,128,128,128,128,128,128,128,128],
[128,128,128,128,128,128,128,128,128,128,128]
],
[
[253,136,254,255,228,219,128,128,128,128,128],
[189,129,242,255,227,213,255,219,128,128,128],
[106,126,227,252,214,209,255,255,128,128,128]
],
[
[1,98,248,255,236,226,255,255,128,128,128],
[181,133,238,254,221,234,255,154,128,128,128],
[78,134,202,247,198,180,255,219,128,128,128]
],
[
[1,185,249,255,243,255,128,128,128,128,128],
[184,150,247,255,236,224,128,128,128,128,128],
[77,110,216,255,236,230,128,128,128,128,128]
],
[
[1,101,251,255,241,255,128,128,128,128,128],
[170,139,241,252,236,209,255,255,128,128,128],
[37,116,196,243,228,255,255,255,128,128,128]
],
[
[1,204,254,255,245,255,128,128,128,128,128],
[207,160,250,255,238,128,128,128,128,128,128],
[102,103,231,255,211,171,128,128,128,128,128]
],
[
[1,152,252,255,240,255,128,128,128,128,128],
[177,135,243,255,234,225,128,128,128,128,128],
[80,129,211,255,194,224,128,128,128,128,128]
],
[
[1,1,255,128,128,128,128,128,128,128,128],
[246,1,255,128,128,128,128,128,128,128,128],
[255,128,128,128,128,128,128,128,128,128,128]
]
],
[
[
[198,35,237,223,193,187,162,160,145,155,62],
[131,45,198,221,172,176,220,157,252,221,1],
[68,47,146,208,149,167,221,162,255,223,128]
],
[
[1,149,241,255,221,224,255,255,128,128,128],
[184,141,234,253,222,220,255,199,128,128,128],
[81,99,181,242,176,190,249,202,255,255,128]
],
[
[1,129,232,253,214,197,242,196,255,255,128],
[99,121,210,250,201,198,255,202,128,128,128],
[23,91,163,242,170,187,247,210,255,255,128]
],
[
[1,200,246,255,234,255,128,128,128,128,128],
[109,178,241,255,231,245,255,255,128,128,128],
[44,130,201,253,205,192,255,255,128,128,128]
],
[
[1,132,239,251,219,209,255,165,128,128,128],
[94,136,225,251,218,190,255,255,128,128,128],
[22,100,174,245,186,161,255,199,128,128,128]
],
[
[1,182,249,255,232,235,128,128,128,128,128],
[124,143,241,255,227,234,128,128,128,128,128],
[35,77,181,251,193,211,255,205,128,128,128]
],
[
[1,157,247,255,236,231,255,255,128,128,128],
[121,141,235,255,225,227,255,255,128,128,128],
[45,99,188,251,195,217,255,224,128,128,128]
],
[
[1,1,251,255,213,255,128,128,128,128,128],
[203,1,248,255,255,128,128,128,128,128,128],
[137,1,177,255,224,255,128,128,128,128,128]
]
],
[
[
[253,9,248,251,207,208,255,192,128,128,128],
[175,13,224,243,193,185,249,198,255,255,128],
[73,17,171,221,161,179,236,167,255,234,128]
],
[
[1,95,247,253,212,183,255,255,128,128,128],
[239,90,244,250,211,209,255,255,128,128,128],
[155,77,195,248,188,195,255,255,128,128,128]
],
[
[1,24,239,251,218,219,255,205,128,128,128],
[201,51,219,255,196,186,128,128,128,128,128],
[69,46,190,239,201,218,255,228,128,128,128]
],
[
[1,191,251,255,255,128,128,128,128,128,128],
[223,165,249,255,213,255,128,128,128,128,128],
[141,124,248,255,255,128,128,128,128,128,128]
],
[
[1,16,248,255,255,128,128,128,128,128,128],
[190,36,230,255,236,255,128,128,128,128,128],
[149,1,255,128,128,128,128,128,128,128,128]
],
[
[1,226,255,128,128,128,128,128,128,128,128],
[247,192,255,128,128,128,128,128,128,128,128],
[240,128,255,128,128,128,128,128,128,128,128]
],
[
[1,134,252,255,255,128,128,128,128,128,128],
[213,62,250,255,255,128,128,128,128,128,128],
[55,93,255,128,128,128,128,128,128,128,128]
],
[
[128,128,128,128,128,128,128,128,128,128,128],
[128,128,128,128,128,128,128,128,128,128,128],
[128,128,128,128,128,128,128,128,128,128,128]
]
],
[
[
[202,24,213,235,186,191,220,160,240,175,255],
[126,38,182,232,169,184,228,174,255,187,128],
[61,46,138,219,151,178,240,170,255,216,128]
],
[
[1,112,230,250,199,191,247,159,255,255,128],
[166,109,228,252,211,215,255,174,128,128,128],
[39,77,162,232,172,180,245,178,255,255,128]
],
[
[1,52,220,246,198,199,249,220,255,255,128],
[124,74,191,243,183,193,250,221,255,255,128],
[24,71,130,219,154,170,243,182,255,255,128]
],
[
[1,182,225,249,219,240,255,224,128,128,128],
[149,150,226,252,216,205,255,171,128,128,128],
[28,108,170,242,183,194,254,223,255,255,128]
],
[
[1,81,230,252,204,203,255,192,128,128,128],
[123,102,209,247,188,196,255,233,128,128,128],
[20,95,153,243,164,173,255,203,128,128,128]
],
[
[1,222,248,255,216,213,128,128,128,128,128],
[168,175,246,252,235,205,255,255,128,128,128],
[47,116,215,255,211,212,255,255,128,128,128]
],
[
[1,121,236,253,212,214,255,255,128,128,128],
[141,84,213,252,201,202,255,219,128,128,128],
[42,80,160,240,162,185,255,205,128,128,128]
],
[
[1,1,255,128,128,128,128,128,128,128,128],
[244,1,255,128,128,128,128,128,128,128,128],
[238,1,255,128,128,128,128,128,128,128,128]
]
]
];
/**
* COEFF_UPDATE_PROBS is how likely a frame is to change each of those, read
* before any change is read.
* @var mixed
*/
public const COEFF_UPDATE_PROBS = [
[
[
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[176,246,255,255,255,255,255,255,255,255,255],
[223,241,252,255,255,255,255,255,255,255,255],
[249,253,253,255,255,255,255,255,255,255,255]
],
[
[255,244,252,255,255,255,255,255,255,255,255],
[234,254,254,255,255,255,255,255,255,255,255],
[253,255,255,255,255,255,255,255,255,255,255]
],
[
[255,246,254,255,255,255,255,255,255,255,255],
[239,253,254,255,255,255,255,255,255,255,255],
[254,255,254,255,255,255,255,255,255,255,255]
],
[
[255,248,254,255,255,255,255,255,255,255,255],
[251,255,254,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,253,254,255,255,255,255,255,255,255,255],
[251,254,254,255,255,255,255,255,255,255,255],
[254,255,254,255,255,255,255,255,255,255,255]
],
[
[255,254,253,255,254,255,255,255,255,255,255],
[250,255,254,255,254,255,255,255,255,255,255],
[254,255,255,255,255,255,255,255,255,255,255]
],
[
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
]
],
[
[
[217,255,255,255,255,255,255,255,255,255,255],
[225,252,241,253,255,255,254,255,255,255,255],
[234,250,241,250,253,255,253,254,255,255,255]
],
[
[255,254,255,255,255,255,255,255,255,255,255],
[223,254,254,255,255,255,255,255,255,255,255],
[238,253,254,254,255,255,255,255,255,255,255]
],
[
[255,248,254,255,255,255,255,255,255,255,255],
[249,254,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,253,255,255,255,255,255,255,255,255,255],
[247,254,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,253,254,255,255,255,255,255,255,255,255],
[252,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,254,254,255,255,255,255,255,255,255,255],
[253,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,254,253,255,255,255,255,255,255,255,255],
[250,255,255,255,255,255,255,255,255,255,255],
[254,255,255,255,255,255,255,255,255,255,255]
],
[
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
]
],
[
[
[186,251,250,255,255,255,255,255,255,255,255],
[234,251,244,254,255,255,255,255,255,255,255],
[251,251,243,253,254,255,254,255,255,255,255]
],
[
[255,253,254,255,255,255,255,255,255,255,255],
[236,253,254,255,255,255,255,255,255,255,255],
[251,253,253,254,254,255,255,255,255,255,255]
],
[
[255,254,254,255,255,255,255,255,255,255,255],
[254,254,254,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,254,255,255,255,255,255,255,255,255,255],
[254,254,255,255,255,255,255,255,255,255,255],
[254,255,255,255,255,255,255,255,255,255,255]
],
[
[255,255,255,255,255,255,255,255,255,255,255],
[254,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
]
],
[
[
[248,255,255,255,255,255,255,255,255,255,255],
[250,254,252,254,255,255,255,255,255,255,255],
[248,254,249,253,255,255,255,255,255,255,255]
],
[
[255,253,253,255,255,255,255,255,255,255,255],
[246,253,253,255,255,255,255,255,255,255,255],
[252,254,251,254,254,255,255,255,255,255,255]
],
[
[255,254,252,255,255,255,255,255,255,255,255],
[248,254,253,255,255,255,255,255,255,255,255],
[253,255,254,254,255,255,255,255,255,255,255]
],
[
[255,251,254,255,255,255,255,255,255,255,255],
[245,251,254,255,255,255,255,255,255,255,255],
[253,253,254,255,255,255,255,255,255,255,255]
],
[
[255,251,253,255,255,255,255,255,255,255,255],
[252,253,254,255,255,255,255,255,255,255,255],
[255,254,255,255,255,255,255,255,255,255,255]
],
[
[255,252,255,255,255,255,255,255,255,255,255],
[249,255,254,255,255,255,255,255,255,255,255],
[255,255,254,255,255,255,255,255,255,255,255]
],
[
[255,255,253,255,255,255,255,255,255,255,255],
[250,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
],
[
[255,255,255,255,255,255,255,255,255,255,255],
[254,255,255,255,255,255,255,255,255,255,255],
[255,255,255,255,255,255,255,255,255,255,255]
]
]
];
/**
* BMODE_PROBS is how likely each way of guessing a four by four block is,
* given how its neighbors above and to the left were guessed.
* @var mixed
*/
public const BMODE_PROBS = [
[
[231,120,48,89,115,113,120,152,112],
[152,179,64,126,170,118,46,70,95], [175,69,143,80,85,82,72,155,103],
[56,58,10,171,218,189,17,13,152], [144,71,10,38,171,213,144,34,26],
[114,26,17,163,44,195,21,10,173], [121,24,80,195,26,62,44,64,85],
[170,46,55,19,136,160,33,206,71], [63,20,8,114,114,208,12,9,226],
[81,40,11,96,182,84,29,16,36]
],
[
[134,183,89,137,98,101,106,165,148],
[72,187,100,130,157,111,32,75,80], [66,102,167,99,74,62,40,234,128],
[41,53,9,178,241,141,26,8,107], [104,79,12,27,217,255,87,17,7],
[74,43,26,146,73,166,49,23,157], [65,38,105,160,51,52,31,115,128],
[87,68,71,44,114,51,15,186,23], [47,41,14,110,182,183,21,17,194],
[66,45,25,102,197,189,23,18,22]
],
[
[88,88,147,150,42,46,45,196,205], [43,97,183,117,85,38,35,179,61],
[39,53,200,87,26,21,43,232,171], [56,34,51,104,114,102,29,93,77],
[107,54,32,26,51,1,81,43,31], [39,28,85,171,58,165,90,98,64],
[34,22,116,206,23,34,43,166,73], [68,25,106,22,64,171,36,225,114],
[34,19,21,102,132,188,16,76,124], [62,18,78,95,85,57,50,48,51]
],
[
[193,101,35,159,215,111,89,46,111],
[60,148,31,172,219,228,21,18,111],
[112,113,77,85,179,255,38,120,114], [40,42,1,196,245,209,10,25,109],
[100,80,8,43,154,1,51,26,71], [88,43,29,140,166,213,37,43,154],
[61,63,30,155,67,45,68,1,209], [142,78,78,16,255,128,34,197,171],
[41,40,5,102,211,183,4,1,221], [51,50,17,168,209,192,23,25,82]
],
[
[125,98,42,88,104,85,117,175,82], [95,84,53,89,128,100,113,101,45],
[75,79,123,47,51,128,81,171,1], [57,17,5,71,102,57,53,41,49],
[115,21,2,10,102,255,166,23,6], [38,33,13,121,57,73,26,1,85],
[41,10,67,138,77,110,90,47,114], [101,29,16,10,85,128,101,196,26],
[57,18,10,102,102,213,34,20,43], [117,20,15,36,163,128,68,1,26]
],
[
[138,31,36,171,27,166,38,44,229], [67,87,58,169,82,115,26,59,179],
[63,59,90,180,59,166,93,73,154], [40,40,21,116,143,209,34,39,175],
[57,46,22,24,128,1,54,17,37], [47,15,16,183,34,223,49,45,183],
[46,17,33,183,6,98,15,32,183], [65,32,73,115,28,128,23,128,205],
[40,3,9,115,51,192,18,6,223], [87,37,9,115,59,77,64,21,47]
],
[
[104,55,44,218,9,54,53,130,226], [64,90,70,205,40,41,23,26,57],
[54,57,112,184,5,41,38,166,213], [30,34,26,133,152,116,10,32,134],
[75,32,12,51,192,255,160,43,51], [39,19,53,221,26,114,32,73,255],
[31,9,65,234,2,15,1,118,73], [88,31,35,67,102,85,55,186,85],
[56,21,23,111,59,205,45,37,192], [55,38,70,124,73,102,1,34,98]
],
[
[102,61,71,37,34,53,31,243,192], [69,60,71,38,73,119,28,222,37],
[68,45,128,34,1,47,11,245,171], [62,17,19,70,146,85,55,62,70],
[75,15,9,9,64,255,184,119,16], [37,43,37,154,100,163,85,160,1],
[63,9,92,136,28,64,32,201,85], [86,6,28,5,64,255,25,248,1],
[56,8,17,132,137,255,55,116,128], [58,15,20,82,135,57,26,121,40]
],
[
[164,50,31,137,154,133,25,35,218], [51,103,44,131,131,123,31,6,158],
[86,40,64,135,148,224,45,183,128], [22,26,17,131,240,154,14,1,209],
[83,12,13,54,192,255,68,47,28], [45,16,21,91,64,222,7,1,197],
[56,21,39,155,60,138,23,102,213], [85,26,85,85,128,128,32,146,171],
[18,11,7,63,144,171,4,4,246], [35,27,10,146,174,171,12,26,128]
],
[
[190,80,35,99,180,80,126,54,45], [85,126,47,87,176,51,41,20,32],
[101,75,128,139,118,146,116,128,85], [56,41,15,176,236,85,37,9,62],
[146,36,19,30,171,255,97,27,20], [71,30,17,119,118,255,17,18,138],
[101,38,60,138,55,70,43,26,142], [138,45,61,62,219,1,81,188,64],
[32,41,20,117,151,142,20,21,163], [112,19,12,61,195,128,48,4,24]
]
];
/**
* DC_QLOOKUP is the step the first value of a block is scaled by, one entry
* for each quantizer the format allows.
* @var mixed
*/
public const DC_QLOOKUP
= [
4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 19,
20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 46,
47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 91, 93, 95, 96, 98, 100,
101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 122, 124, 126,
128,
130,132,134,136,138,140,143,145,148,151,154,157];
/**
* AC_QLOOKUP is the step the rest of a block's values are scaled by, one
* entry per quantizer.
* @var mixed
*/
public const AC_QLOOKUP
= [
4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86,
88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116,
119, 122, 125, 128, 131, 134, 137, 140, 143, 146, 149, 152, 155,
158, 161, 164, 167, 170, 173, 177, 181, 185, 189, 193, 197, 201,
205, 209, 213, 217, 221, 225, 229, 234, 239, 245, 249, 254, 259,
264, 269, 274, 279,
284];
/**
* COEFF_BAND is which group of probabilities each place in a block reads
* with. Places near the start of a block behave differently from those near
* the end, so they are grouped.
* @var mixed
*/
public const COEFF_BAND = [0,1,2,3,6,4,5,6,6,6,6,6,6,6,6,7];
}
/**
* Vp8BoolDecoder vP8 boolean entropy decoder (a numbered internet standard 6386
* section 7). A binary arithmetic coder: each call splits the current range
* according to a probability and returns which side of the split the value
* falls on.
*/
final class Vp8BoolDecoder
{
/**
* $bytes stores the part of the frame being read. VP8 splits a frame's
* values across parts that can be read side by side.
* @var string
*/
private string $bytes;
/**
* $position stores how far into those bytes the reading has gone.
* @var int
*/
private int $position;
/**
* $end stores where this part stops. Reading past it gives zeros.
* @var int
*/
private int $end;
/**
* $range stores how wide the range of values still in play is. Each bit
* read narrows it by how likely that bit was.
* @var int
*/
private int $range = 255;
/**
* $range_position stores where in that range the number being read sits.
* @var int
*/
private int $range_position = 0;
/**
* $bit_count stores how many bits of the current byte are still unread, so
* the reader knows when to take in another.
* @var int
*/
private int $bit_count = 0;
/**
* __construct sets up a reader over one arithmetic coded part of a frame.
*
* @param string $bytes the bytes to read
* @param int $offset where in the file to start reading
* @param int $length how many bytes to read
*/
public function __construct(string $bytes, int $offset, int $length)
{
$this->bytes = $bytes;
$this->position = $offset;
$this->end = $offset + $length;
if ($length < 2 || $this->end > strlen($bytes)) {
throw new VideoException('VP8 partition is truncated');
}
$this->range_position = (ord($bytes[$this->position]) << 8) |
ord($bytes[$this->position + 1]);
$this->position += 2;
}
/**
* readOneBit reads one decision, given how likely a zero is.
*
* @param int $prob the probability a value is read with
* @return int what was read
*/
public function readOneBit(int $prob): int
{
$split = 1 + ((($this->range - 1) * $prob) >> 8);
$big_split = $split << 8;
if ($this->range_position >= $big_split) {
$result = 1;
$this->range -= $split;
$this->range_position -= $big_split;
} else {
$result = 0;
$this->range = $split;
}
while ($this->range < 128) {
$this->range_position <<= 1;
$this->range <<= 1;
if (++$this->bit_count === 8) {
$this->bit_count = 0;
$this->range_position |= ($this->position < $this->end)
? ord($this->bytes[$this->position]) : 0;
$this->position++;
}
}
return $result;
}
/**
* literal reads a plain number of the given width, its highest bit first.
* VP8 writes most of its numbers through the probabilities, but a few
* fields are written straight, and this reads those.
*
* @param int $bits the reader the stream's bits are taken from
* @return int what was read
*/
public function literal(int $bits): int
{
$variant = 0;
for ($i = 0; $i < $bits; $i++) {
$variant = ($variant << 1) | $this->readOneBit(128);
}
return $variant;
}
/**
* readSignedValue reads such a plain number and then a bit saying whether
* it is negative, which is how VP8 writes the nudges it applies to a
* quantizer or to the smoothing.
*
* @param int $bits the reader the stream's bits are taken from
* @return int what was read
*/
public function readSignedValue(int $bits): int
{
$variant = $this->literal($bits);
return $this->readOneBit(128) ? -$variant : $variant;
}
/**
* readFlag reads one plain bit, where either value is equally likely.
*
* @return int what was read
*/
public function readFlag(): int
{
return $this->readOneBit(128);
}
/**
* walkTree walk a token tree. Nodes are pairs; a negative entry is the leaf
* value encoded as -(value + 1). read from
*
* @param array $tree the tree of choices a value is
* @param array $probs the probabilities values are read with
* @param int $node where in the tree the reading is
* @return int what was read
*/
public function walkTree(array $tree, array $probs, int $node = 0): int
{
$guard = 0;
while (true) {
$next = $tree[$node][$this->readOneBit($probs[$node])];
if ($next < 0) {
return -$next - 1;
}
$node = $next;
if (++$guard > 32) {
throw new VideoException('malformed VP8 token tree');
}
}
}
}
/**
* Vp8Decoder vP8 keyframe decoder. Keyframes need no reference frames, so
* motion vectors, inter modes and reference buffers are all absent: every
* macroblock is predicted from its own already-reconstructed neighbors. What
* remains is the frame header, the intra mode tree, the coefficient tokens
* spread across one to eight partitions, two inverse transforms, ten sub-block
* predictors and the deblocking filter.
*/
final class Vp8Decoder
{
/**
* smooth3 average of three neighboring samples, weighted toward the middle
* one. This is how the format smooths an edge it predicts from.
*
* @param int $first sample before the middle one
* @param int $middle sample the result sits on
* @param int $last sample after the middle one
* @return int the smoothed value
*/
private static function smooth3($first, $middle, $last)
{
return ($first + 2 * $middle + $last + 2) >> 2;
}
/**
* smooth2 average of two neighboring samples, rounded upward.
*
* @param int $first one sample
* @param int $second the sample beside it
* @return int the average
*/
private static function smooth2($first, $second)
{
return ($first + $second + 1) >> 1;
}
/**
* DC_PRED is guessing a whole block as one value, the average of its
* neighbors.
* @var mixed
*/
private const DC_PRED = 0;
/**
* V_PRED is guessing a block from the row of samples above it.
* @var mixed
*/
private const V_PRED = 1;
/**
* H_PRED is guessing a block from the column of samples to its left.
* @var mixed
*/
private const H_PRED = 2;
/**
* TM_PRED is guessing a block from the row above and the column to the left
* together, following the slope between them.
* @var mixed
*/
private const TM_PRED = 3;
/**
* B_PRED is guessing a macroblock in sixteen smaller squares, each with a
* way of its own.
* @var mixed
*/
private const B_PRED = 4;
/**
* B_DC is sub-block modes, in specification order.
* @var mixed
*/
private const B_DC = 0;
/**
* B_TM is guessing a four by four block from the row above and the column
* to the left together, following the slope between them.
* @var mixed
*/
private const B_TM = 1;
/**
* B_VE is guessing a block straight down from the row above it.
* @var mixed
*/
private const B_VE = 2;
/**
* B_HE is guessing a block straight across from the column to its left.
* @var mixed
*/
private const B_HE = 3;
/**
* B_LD is guessing a block along a slope running down and to the left.
* @var mixed
*/
private const B_LD = 4;
/**
* B_RD is guessing a block along a slope running down and to the right.
* @var mixed
*/
private const B_RD = 5;
/**
* B_VR marks guessing a block along a steep slope that leans to
* the right.
* @var mixed
*/
private const B_VR = 6;
/**
* B_VL is guessing a block along a steep slope leaning left.
* @var mixed
*/
private const B_VL = 7;
/**
* B_HD is guessing a block along a shallow slope leaning down.
* @var mixed
*/
private const B_HD = 8;
/**
* B_HU is guessing a block along a shallow slope leaning up.
* @var mixed
*/
private const B_HU = 9;
/**
* YMODE_TREE is the tree of choices that says how a whole
* macroblock of brightness was guessed, for a frame that stands on
* its own. A leaf of the tree holds one less than the way it
* stands for, made negative, which is how a leaf is told from a
* branch.
*/
private const YMODE_TREE = [
[-(self::B_PRED + 1), 1],
[2, 3],
[-(self::DC_PRED + 1), -(self::V_PRED + 1)],
[-(self::H_PRED + 1), -(self::TM_PRED + 1)],
];
/**
* YMODE_PROBS is how likely each way of guessing a whole macroblock of
* brightness is.
* @var mixed
*/
private const YMODE_PROBS = [145, 156, 163, 128];
/**
* UVMODE_TREE is the tree of choices that says how the color planes of a
* macroblock were guessed.
* @var mixed
*/
private const UVMODE_TREE = [
[-(self::DC_PRED + 1), 1],
[-(self::V_PRED + 1), 2],
[-(self::H_PRED + 1), -(self::TM_PRED + 1)],
];
/**
* UVMODE_PROBS is how likely each of those choices is.
* @var mixed
*/
private const UVMODE_PROBS = [142, 114, 183];
/**
* BMODE_TREE is the tree of choices that says how one four by four block
* was guessed.
* @var mixed
*/
private const BMODE_TREE = [
[-(self::B_DC + 1), 1],
[-(self::B_TM + 1), 2],
[-(self::B_VE + 1), 3],
[4, 6],
[-(self::B_HE + 1), 5],
[-(self::B_RD + 1), -(self::B_VR + 1)],
[-(self::B_LD + 1), 7],
[-(self::B_VL + 1), 8],
[-(self::B_HD + 1), -(self::B_HU + 1)],
];
/**
* SEGMENT_TREE is the tree of choices that says which segment a macroblock
* belongs to.
* @var mixed
*/
private const SEGMENT_TREE = [
[1, 2],
[-(0 + 1), -(1 + 1)],
[-(2 + 1), -(3 + 1)],
];
/**
* YMODE_TO_BMODE is the sixteen by sixteen mode a whole macroblock
* contributes to its neighbors' context.
*/
private const YMODE_TO_BMODE = [
self::DC_PRED => self::B_DC,
self::V_PRED => self::B_VE,
self::H_PRED => self::B_HE,
self::TM_PRED => self::B_TM,
];
/**
* COEFF_TREE is the tree of choices that reads one coded value of a block,
* from whether there is a value at all up to how large it is.
* @var mixed
*/
private const COEFF_TREE = [
/* leaf -1 marks end of block */
[-1, 1],
/* literal 0 */
[-(0 + 2), 2],
/* literal 1 */
[-(1 + 2), 3],
[4, 6],
[-(2 + 2), 5],
[-(3 + 2), -(4 + 2)],
[7, 8],
/* categories 1 and 2 */
[-(11 + 2), -(12 + 2)],
[9, 10],
/* categories 3 and 4 */
[-(13 + 2), -(14 + 2)],
/* categories 5 and 6 */
[-(15 + 2), -(16 + 2)],
];
/**
* CAT_PROBS is extra-bit probabilities and base values for the six
* magnitude categories.
*/
private const CAT_PROBS = [
[159], [165, 145], [173, 148, 140], [176, 155, 140, 135],
[180, 157, 141, 134, 130],
[254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129],
];
/**
* CAT_BASE is the smallest value each of the six large-value groups stands
* for; the bits that follow say how much larger.
* @var mixed
*/
private const CAT_BASE = [5, 7, 11, 19, 35, 67];
/**
* $frame_width stores how wide the frame is, in pixels, as its header says.
* @var int
*/
private int $frame_width = 0;
/**
* $frame_height stores how tall the frame is, in pixels.
* @var int
*/
private int $frame_height = 0;
/**
* $macroblock_width stores how many macroblocks the frame is across. A
* macroblock
* is the sixteen by sixteen square VP8 works in.
* @var int
*/
private int $macroblock_width = 0;
/**
* $macroblock_height stores how many macroblocks the frame is down.
* @var int
*/
private int $macroblock_height = 0;
/**
* $segment_enabled stores whether the frame is split into segments that
* carry their own quantizer and smoothing.
* @var bool
*/
private bool $segment_enabled = false;
/**
* $segment_absolute stores whether a segment's settings replace the frame's
* or are added to them.
* @var bool
*/
private bool $segment_absolute = false;
/**
* $segment_quant stores the quantizer each segment uses.
* @var array
*/
private array $segment_quant = [0, 0, 0, 0];
/**
* $segment_filter stores how strongly each segment's edges are smoothed.
* @var array
*/
private array $segment_filter = [0, 0, 0, 0];
/**
* $segment_probs stores how likely each segment is, used while reading
* which segment a macroblock belongs to.
* @var array
*/
private array $segment_probs = [255, 255, 255];
/**
* $update_segment_map stores whether this frame says afresh which
* macroblock belongs to which segment.
* @var bool
*/
private bool $update_segment_map = false;
/**
* $filter_simple stores whether the simpler of VP8's two edge smoothings is
* used.
* @var bool
*/
private bool $filter_simple = false;
/**
* $filter_level stores how strongly block edges are smoothed. Zero leaves
* them alone.
* @var int
*/
private int $filter_level = 0;
/**
* $sharpness stores how much that smoothing is held back at sharp edges.
* @var int
*/
private int $sharpness = 0;
/**
* $smoothing_delta_enabled stores whether the smoothing is nudged by how a
* macroblock was guessed.
* @var bool
*/
private bool $smoothing_delta_enabled = false;
/**
* $reference_smoothing_deltas stores those nudges, by which frame a
* macroblock
* leans on.
* @var array
*/
private array $reference_smoothing_deltas = [0, 0, 0, 0];
/**
* $mode_smoothing_deltas stores those nudges, by how a macroblock was
* guessed.
* @var array
*/
private array $mode_smoothing_deltas = [0, 0, 0, 0];
/**
* $value_probs stores how likely each value is, read from the frame's
* header and used for every block after it.
* @var array
*/
private array $value_probs = [];
/**
* $skip_enabled stores whether the frame says which macroblocks carry no
* values at all.
* @var bool
*/
private bool $skip_enabled = false;
/**
* $skip_prob stores how likely a macroblock is to be skipped that way.
* @var int
*/
private int $skip_prob = 0;
/**
* $quantizer_steps stores the steps each segment's values are
* scaled by: one for the first brightness value, one for the
* rest, two more for the second brightness plane, and two for the
* color planes.
* @var array
*/
private array $quant = [];
/**
* $planes stores the brightness and color values of the picture being
* built.
* @var array
*/
private array $planes = [];
/**
* $strides stores how many values one row of each plane takes.
* @var array
*/
private array $strides = [];
/**
* $offsets stores where the picture proper starts inside each plane, since
* the decoder works in whole macroblocks.
* @var array
*/
private array $offsets = [];
/**
* $macroblock_y_mode stores how the brightness of each macroblock was
* guessed. A
* neighbor's guess is needed while reading the next.
* @var array
*/
private array $macroblock_y_mode = [];
/**
* $macroblock_segment stores which segment each macroblock belongs to.
* @var array
*/
private array $macroblock_segment = [];
/**
* $macroblock_skip stores whether each macroblock carried any values.
* @var array
*/
private array $macroblock_skip = [];
/**
* $macroblock_has_values stores whether each macroblock's values were
* read, which
* the smoothing looks at to decide whether an edge needs work.
* @var array
*/
private array $macroblock_has_values = [];
/**
* $block_modes stores how each of the sixteen smaller squares of a
* macroblock
* was guessed, where the macroblock was split.
* @var array
*/
private array $block_modes = [];
/**
* decodeKeyframe decode a VP8 keyframe.
*
* @return VideoPicture what was read
* @param string $frame the frame being built
*/
public function decodeKeyframe(string $frame): VideoPicture
{
if (strlen($frame) < 10) {
throw new VideoException('VP8 frame is too short');
}
$tag = ord($frame[0]) | (ord($frame[1]) << 8) | (ord($frame[2]) << 16);
if (($tag & 1) !== 0) {
throw new VideoException('only VP8 keyframes can be decoded');
}
$first_part_size = ($tag >> 5) & 0x7FFFF;
if (substr($frame, 3, 3) !== "\x9d\x01\x2a") {
throw new VideoException('missing VP8 keyframe start code');
}
$wide = (ord($frame[6]) | (ord($frame[7]) << 8)) & 0x3FFF;
$header = (ord($frame[8]) | (ord($frame[9]) << 8)) & 0x3FFF;
if ($wide < 1 || $header < 1 || $wide > 16383 || $header > 16383) {
throw new VideoException('bad VP8 frame size');
}
$this->frame_width = $wide;
$this->frame_height = $header;
$this->macroblock_width = intdiv($wide + 15, 16);
$this->macroblock_height = intdiv($header + 15, 16);
$header_start = 10;
if ($header_start + $first_part_size > strlen($frame)) {
throw new VideoException('VP8 first partition runs past the frame');
}
$chunk = new Vp8BoolDecoder($frame, $header_start, $first_part_size);
$this->parseHeader($chunk);
$partitions = $this->splitPartitions($frame, $header_start
+ $first_part_size, $chunk);
$this->allocatePlanes();
$this->decodeMacroblocks($chunk, $partitions);
$this->loopFilter();
return $this->toPicture();
}
/* header */
/**
* parseHeader reads the frame header: how the picture is split into
* segments, how strongly it is filtered, how it is quantized, and the
* probabilities its coefficients are coded with. from
*
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
*/
private function parseHeader(Vp8BoolDecoder $chunk): void
{
/* color space */
$chunk->readFlag();
/* clamping type */
$chunk->readFlag();
$this->segment_enabled = $chunk->readFlag() === 1;
$this->update_segment_map = false;
$this->segment_probs = [255, 255, 255];
if ($this->segment_enabled) {
$this->parseSegmentation($chunk);
} else {
$this->segment_quant = [0, 0, 0, 0];
$this->segment_filter = [0, 0, 0, 0];
}
$this->filter_simple = $chunk->readFlag() === 1;
$this->filter_level = $chunk->literal(6);
$this->sharpness = $chunk->literal(3);
$this->smoothing_delta_enabled = $chunk->readFlag() === 1;
if ($this->smoothing_delta_enabled && $chunk->readFlag() === 1) {
for ($i = 0; $i < 4; $i++) {
if ($chunk->readFlag() === 1) {
$this->reference_smoothing_deltas[$i] = $chunk
->readSignedValue(6);
}
}
for ($i = 0; $i < 4; $i++) {
if ($chunk->readFlag() === 1) {
$this->mode_smoothing_deltas[$i] = $chunk
->readSignedValue(6);
}
}
}
$this->partition_count = 1 << $chunk->literal(2);
$this->parseQuantisers($chunk);
/* refresh entropy probabilities */
$chunk->readFlag();
$this->value_probs = Vp8Tables::DEFAULT_COEFF_PROBS;
for ($i = 0; $i < 4; $i++) {
for ($j = 0; $j < 8; $j++) {
for ($k = 0; $k < 3; $k++) {
for ($span
= 0; $span < 11; $span++) {
$chance
= Vp8Tables::COEFF_UPDATE_PROBS[$i][$j][$k][$span];
if ($chunk->readOneBit($chance) === 1) {
$this->value_probs[$i][$j][$k][$span]
= $chunk->literal(8);
}
}
}
}
}
$this->skip_enabled = $chunk->readFlag() === 1;
$this->skip_prob = $this->skip_enabled ? $chunk->literal(8) : 0;
}
/**
* $partition_count stores how many parts the frame's values are split
* across, one, two, four or eight.
* @var int
*/
private int $partition_count = 1;
/**
* parseSegmentation reads how the picture is split into segments and what
* quantizer and filter strength each one carries. from
*
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
*/
private function parseSegmentation(Vp8BoolDecoder $chunk): void
{
$this->update_segment_map = $chunk->readFlag() === 1;
$update_data = $chunk->readFlag() === 1;
if ($update_data) {
$this->segment_absolute = $chunk->readFlag() === 1;
for ($i = 0; $i < 4; $i++) {
$this->segment_quant[$i] = $chunk->readFlag() === 1
? $chunk->readSignedValue(7) : 0;
}
for ($i = 0; $i < 4; $i++) {
$this->segment_filter[$i] = $chunk->readFlag() === 1
? $chunk->readSignedValue(6) : 0;
}
}
if ($this->update_segment_map) {
for ($i = 0; $i < 3; $i++) {
$this->segment_probs[$i] = $chunk->readFlag() === 1
? $chunk->literal(8)
: 255;
}
}
}
/**
* parseQuantisers works out the numbers each coefficient is multiplied by,
* for every segment and for each kind of block. from
*
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
*/
private function parseQuantisers(Vp8BoolDecoder $chunk): void
{
$base = $chunk->literal(7);
$deltas = [];
foreach (['ydc', 'y2dc', 'y2ac', 'uvdc', 'uvac'] as $k) {
$deltas[$k] = $chunk->readFlag() === 1 ? $chunk
->readSignedValue(4) : 0;
}
$this->quant = [];
for ($seg = 0; $seg < 4; $seg++) {
$quality = $base;
if ($this->segment_enabled) {
$quality = $this->segment_absolute
? $this->segment_quant[$seg]
: $base + $this->segment_quant[$seg];
}
$quality = max(0, min(127, $quality));
$clamp = static fn(int $variant): int => max(0, min(127, $variant));
$brightness_first_value =
Vp8Tables::DC_QLOOKUP[$clamp($quality + $deltas['ydc'])];
$brightness_other_values = Vp8Tables::AC_QLOOKUP[$quality];
$second_brightness_first_value
= Vp8Tables::DC_QLOOKUP[$clamp($quality + $deltas['y2dc'])] * 2;
$second_brightness_other_values =
(int) (Vp8Tables::AC_QLOOKUP[$clamp($quality
+ $deltas['y2ac'])] * 155 / 100);
if ($second_brightness_other_values < 8) {
$second_brightness_other_values = 8;
}
$color_first_value = Vp8Tables::DC_QLOOKUP[$clamp($quality +
$deltas['uvdc'])];
if ($color_first_value > 132) {
$color_first_value = 132;
}
$color_other_values = Vp8Tables::AC_QLOOKUP[$clamp($quality +
$deltas['uvac'])];
$this->quant[$seg] = [$brightness_first_value,
$brightness_other_values, $second_brightness_first_value,
$second_brightness_other_values, $color_first_value,
$color_other_values];
}
}
/**
* splitPartitions from
*
* @return Vp8BoolDecoder[] what was read
* @param string $frame the frame being built
* @param int $offset how far into the file to read from
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
*/
private function splitPartitions(string $frame, int $offset,
Vp8BoolDecoder $chunk): array
{
$total = $this->partition_count;
$sizes_length = 3 * ($total - 1);
$data_start = $offset + $sizes_length;
if ($data_start > strlen($frame)) {
throw new VideoException('VP8 partition sizes run past the frame');
}
$parts = [];
$position = $data_start;
for ($i = 0; $i < $total; $i++) {
if ($i < $total - 1) {
$position = $offset + 3 * $i;
$size
= ord($frame[$position]) | (ord($frame[$position
+ 1]) << 8) | (ord($frame[$position + 2]) << 16);
} else {
$size = strlen($frame) - $position;
}
if ($size < 0 || $position + $size > strlen($frame)) {
throw new VideoException('VP8 partition runs past the frame');
}
$parts[] = new Vp8BoolDecoder($frame, $position, $size);
$position += $size;
}
return $parts;
}
/* planes */
/**
* allocatePlanes sets up the sample planes with a border, so prediction at
* the picture's edge reads the values the format says it should.
*/
private function allocatePlanes(): void
{
$line_width = $this->macroblock_width * 16;
$left_half = $this->macroblock_height * 16;
$code_word = $this->macroblock_width * 8;
$channel = $this->macroblock_height * 8;
/* one row of border above and eight columns either side, so the top */
/* row reads 127, the left column reads 129, and the four above-right */
/* samples past the right edge always exist */
foreach ([[0, $line_width, $left_half], [1, $code_word, $channel],
[2, $code_word,
$channel]] as [$plane_at, $wide,
$header]) {
$stride = $wide + 16;
$this->strides[$plane_at] = $stride;
$this->offsets[$plane_at] = $stride + 8;
$plane = array_fill(0, $stride * ($header + 1), 129);
for ($across = 0; $across < $stride; $across++) {
/* the row above the frame */
$plane[$across] = 127;
}
$this->planes[$plane_at] = $plane;
}
}
/**
* sampleAt works out where one sample sits in a plane. for color
*
* @param int $plane_at which plane, zero for brightness and one or two
* @param int $across how far across the block
* @param int $down how far down the block
* @return int what was read
*/
private function sampleAt(int $plane_at, int $across, int $down): int
{
return $this->offsets[$plane_at] + $down *
$this->strides[$plane_at] + $across;
}
/** replicate the right-hand edge of a luma row band so above-right always
exists */
/**
* extendRight repeats the rightmost sample of a row of macroblocks past the
* picture, so prediction that reaches up and to the right always has
* something to read.
*
* @param int $macroblock_y which macroblock down
*/
private function extendRight(int $macroblock_y): void
{
$stride = $this->strides[0];
$wide = $this->macroblock_width * 16;
for ($down =
$macroblock_y * 16; $down < $macroblock_y * 16 + 16; $down++) {
$last = $this->planes[0][$this->sampleAt(0, $wide - 1, $down)];
$base = $this->sampleAt(0, $wide, $down);
for ($k = 0; $k < 8; $k++) {
$this->planes[0][$base + $k] = $last;
}
}
}
/* macroblock loop */
/**
* decodeMacroblocks decodes every macroblock: its modes, its coefficients,
* and the samples that come out of them. from
*
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
* @param array $partitions the parts the frame's values are split across
*/
private function decodeMacroblocks(
Vp8BoolDecoder $chunk, array $partitions): void
{
$macroblocks_across = $this->macroblock_width;
$macroblocks_down = $this->macroblock_height;
$this->block_modes = array_fill(0, ($macroblocks_across * 4) *
($macroblocks_down * 4), self::B_DC);
$this->macroblock_y_mode = array_fill(0, $macroblocks_across *
$macroblocks_down, self::DC_PRED);
$this->macroblock_segment = array_fill(0, $macroblocks_across *
$macroblocks_down, 0);
$this->macroblock_skip = array_fill(0, $macroblocks_across *
$macroblocks_down, 0);
$this->macroblock_has_values = array_fill(0, $macroblocks_across *
$macroblocks_down, 0);
/* non-zero-coefficient contexts: four luma columns, two each for the */
/* chroma planes, one for the second-order block */
$top_value_count = array_fill(0, $macroblocks_across, array_fill(0,
9, 0));
$left_value_count = array_fill(0, 9, 0);
for ($macroblock_y = 0; $macroblock_y <
$macroblocks_down; $macroblock_y++) {
$left_value_count = array_fill(0, 9, 0);
$part = $partitions[$macroblock_y % count($partitions)];
for ($macroblock_x = 0; $macroblock_x <
$macroblocks_across; $macroblock_x++) {
$position = $macroblock_y * $macroblocks_across + $macroblock_x;
$segment = 0;
if ($this->segment_enabled && $this->update_segment_map) {
$segment
= $chunk->walkTree(self::SEGMENT_TREE,
$this->segment_probs);
}
$this->macroblock_segment[$position] = $segment;
$skip = $this->skip_enabled ? $chunk->readOneBit($this
->skip_prob) : 0;
$this->macroblock_skip[$position] = $skip;
$y_mode = $chunk->walkTree(self::YMODE_TREE, self::YMODE_PROBS);
$this->macroblock_y_mode[$position] = $y_mode;
$this->readSubModes($chunk, $macroblock_x, $macroblock_y,
$y_mode);
$color_mode = $chunk->walkTree(self::UVMODE_TREE,
self::UVMODE_PROBS);
$values = null;
$has_values = false;
if ($skip === 0) {
[$values, $has_values] = $this->decodeCoefficients(
$part, $macroblock_x, $y_mode, $segment,
$top_value_count,
$left_value_count
);
} else {
for ($i = 0; $i < 8; $i++) {
$top_value_count[$macroblock_x][$i] = 0;
$left_value_count[$i] = 0;
}
if ($y_mode !== self::B_PRED) {
$top_value_count[$macroblock_x][8] = 0;
$left_value_count[8] = 0;
}
}
$this->macroblock_has_values[$position] = $has_values ? 1 : 0;
$this->reconstruct($macroblock_x, $macroblock_y, $y_mode,
$color_mode, $values);
}
$this->extendRight($macroblock_y);
}
}
/**
* readSubModes reads the prediction modes of a macroblock, one for the
* whole block or one for each four sample square. from
*
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
* @param int $macroblock_x which macroblock across
* @param int $macroblock_y which macroblock down
* @param int $y_mode which way the brightness block is guessed
*/
private function readSubModes(Vp8BoolDecoder $chunk, int $macroblock_x,
int $macroblock_y,
int $y_mode): void
{
$stride = $this->macroblock_width * 4;
$block_start_x = $macroblock_x * 4;
$block_start_y = $macroblock_y * 4;
if ($y_mode !== self::B_PRED) {
$matches = self::YMODE_TO_BMODE[$y_mode];
for ($down = 0; $down < 4; $down++) {
for ($across = 0; $across < 4; $across++) {
$this->block_modes[($block_start_y + $down) * $stride +
$block_start_x + $across]
= $matches;
}
}
return;
}
for ($down = 0; $down < 4; $down++) {
for ($across = 0; $across < 4; $across++) {
/* outside the frame the context is the flat predictor */
$above = ($block_start_y + $down === 0)
? self::B_DC
: $this->block_modes[($block_start_y + $down - 1) * $stride
+ $block_start_x + $across];
$left = ($block_start_x + $across === 0)
? self::B_DC
: $this->block_modes[($block_start_y + $down) * $stride
+ $block_start_x + $across - 1];
$mode = $chunk->walkTree(
self::BMODE_TREE, Vp8Tables::BMODE_PROBS[$above][$left]);
$this->block_modes[($block_start_y + $down) * $stride +
$block_start_x + $across]
= $mode;
}
}
}
/* coefficients */
/**
* decodeCoefficients coefficient] from carried
*
* @return array [dequantized blocks, any non-zero
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
* @param int $macroblock_x which macroblock across
* @param int $y_mode which way the brightness block is guessed
* @param int $segment which segment of the frame the block belongs to
* @param array $top_value_count how many values the blocks above carried
* @param array $left_value_count how many values the blocks to the left
*/
private function decodeCoefficients(
Vp8BoolDecoder $chunk, int $macroblock_x, int $y_mode, int $segment,
array &$top_value_count, array &$left_value_count
): array {
[$brightness_first_value, $brightness_other_values,
$second_brightness_first_value, $second_brightness_other_values,
$color_first_value, $color_other_values] = $this
->quant[$segment];
$has_second_brightness = $y_mode !== self::B_PRED;
$blocks = [];
$any = false;
if ($has_second_brightness) {
$context =
$top_value_count[$macroblock_x][8] + $left_value_count[8];
$second_brightness = array_fill(0, 16, 0);
$total = $this->decodeBlock($chunk, $second_brightness, 1,
$context, 0, $second_brightness_first_value,
$second_brightness_other_values);
$top_value_count[$macroblock_x][8] = $left_value_count[8] =
$total > 0 ? 1 : 0;
if ($total > 0) {
$any = true;
}
$blocks['y2'] = self::inverseWalsh($second_brightness);
}
$type = $has_second_brightness ? 0 : 3;
$first = $has_second_brightness ? 1 : 0;
for ($down = 0; $down < 4; $down++) {
for ($across = 0; $across < 4; $across++) {
$context = $top_value_count[$macroblock_x][$across] +
$left_value_count[$down];
$block_at = array_fill(0, 16, 0);
$total = $this->decodeBlock(
$chunk, $block_at, $type, $context, $first,
$brightness_first_value, $brightness_other_values);
$top_value_count[$macroblock_x][$across] =
$left_value_count[$down] = $total > 0 ?
1 : 0;
if ($total > 0) {
$any = true;
}
$blocks['y'][$down * 4 + $across] = $block_at;
}
}
foreach ([1, 2] as $plane_at) {
for ($down = 0; $down < 2; $down++) {
for ($across = 0; $across < 2; $across++) {
$ti = 4 + ($plane_at - 1) * 2 + $across;
$li = 4 + ($plane_at - 1) * 2 + $down;
$context = $top_value_count[$macroblock_x][$ti] +
$left_value_count[$li];
$block_at = array_fill(0, 16, 0);
$total = $this->decodeBlock(
$chunk, $block_at, 2, $context, 0,
$color_first_value, $color_other_values);
$top_value_count[$macroblock_x][$ti] =
$left_value_count[$li] =
$total > 0 ? 1 : 0;
if ($total > 0) {
$any = true;
}
$blocks['uv'][$plane_at][$down * 2 + $across] = $block_at;
}
}
}
return [$blocks, $any];
}
/**
* decodeBlock one block of coefficient tokens, dequantized into $written in
* raster order. from
*
* @return int 0 when the block ends immediately, otherwise where it ended
* @param Vp8BoolDecoder $chunk the reader this part of the frame is taken
* @param array $written filled in with what was read
* @param int $type which kind
* @param int $context which set of probabilities to read with
* @param int $first the first one
* @param int $first_step the step the first value is scaled by
* @param int $other_steps the step the rest are scaled by
*/
private function decodeBlock(
Vp8BoolDecoder $chunk, array
&$written, int $type, int $context, int $first, int $first_step,
int $other_steps
): int {
$probs_for_type = $this->value_probs[$type];
$block_order = H264Scan::ZZ4;
$i = $first;
$skip_end_of_block = false;
$last_non_zero = 0;
while ($i < 16) {
$probs = $probs_for_type[Vp8Tables::COEFF_BAND[$i]][$context];
if (!$skip_end_of_block && $chunk->readOneBit($probs[0]) === 0) {
break;
}
$skip_end_of_block = false;
if ($chunk->readOneBit($probs[1]) === 0) {
/* a zero coefficient: the next token cannot be an end of block
*/
$context = 0;
$skip_end_of_block = true;
$i++;
continue;
}
if ($chunk->readOneBit($probs[2]) === 0) {
$value = 1;
$context = 1;
} else {
$context = 2;
if ($chunk->readOneBit($probs[3]) === 0) {
$value = $chunk->readOneBit($probs[4]) === 0 ? 2 : 3
+ $chunk->readOneBit($probs[5]);
} else {
if ($chunk->readOneBit($probs[6]) === 0) {
$block_kind = $chunk
->readOneBit($probs[7]) === 0 ? 0 : 1;
} elseif ($chunk->readOneBit($probs[8]) === 0) {
$block_kind = $chunk
->readOneBit($probs[9]) === 0 ? 2 : 3;
} else {
$block_kind = $chunk
->readOneBit($probs[10]) === 0 ? 4 : 5;
}
$value = self::CAT_BASE[$block_kind];
$extra = 0;
foreach (self::CAT_PROBS[$block_kind] as $position) {
$extra = ($extra << 1) | $chunk->readOneBit($position);
}
$value += $extra;
}
}
if ($chunk->readOneBit(128) === 1) {
$value = -$value;
}
$written[$block_order[$i]] = $value * ($i === 0
? $first_step : $other_steps);
$last_non_zero = $i + 1;
$i++;
}
return $i > $first ? max($last_non_zero, $i) : 0;
}
/**
* COS_MINUS1 is transforms.
* @var mixed
*/
private const COS_MINUS1 = 20091;
/**
* SIN is the sines the transform multiplies by, held as whole numbers so
* the arithmetic stays exact.
* @var mixed
*/
private const SIN = 35468;
/**
* inverseDct the four by four inverse transform of a numbered internet
* standard 6386
*
* @param array $self_contained whether the block stands on its own
* @return array what was read
*/
private static function inverseDct(array $self_contained): array
{
$held = array_fill(0, 16, 0);
for ($i = 0; $i < 4; $i++) {
$left_one = $self_contained[$i] + $self_contained[$i + 8];
$bit_one = $self_contained[$i] - $self_contained[$i + 8];
$held_one = ($self_contained[$i + 4] * self::SIN) >> 16;
$held_two = $self_contained[$i + 12] + (($self_contained[$i + 12] *
self::COS_MINUS1) >> 16);
$corner_one = $held_one - $held_two;
$held_one = $self_contained[$i + 4] + (($self_contained[$i + 4] *
self::COS_MINUS1) >> 16);
$held_two = ($self_contained[$i + 12] * self::SIN) >> 16;
$difference_one = $held_one + $held_two;
$held[$i] = $left_one + $difference_one;
$held[$i + 12] = $left_one - $difference_one;
$held[$i + 4] = $bit_one + $corner_one;
$held[$i + 8] = $bit_one - $corner_one;
}
$written = array_fill(0, 16, 0);
for ($i = 0; $i < 4; $i++) {
$origin = $i * 4;
$left_one = $held[$origin] + $held[$origin + 2];
$bit_one = $held[$origin] - $held[$origin + 2];
$held_one = ($held[$origin + 1] * self::SIN) >> 16;
$held_two = $held[$origin + 3]
+ (($held[$origin + 3] * self::COS_MINUS1) >> 16);
$corner_one = $held_one - $held_two;
$held_one = $held[$origin + 1]
+ (($held[$origin + 1] * self::COS_MINUS1) >> 16);
$held_two = ($held[$origin + 3] * self::SIN) >> 16;
$difference_one = $held_one + $held_two;
$written[$origin] = ($left_one + $difference_one + 4) >> 3;
$written[$origin + 3] = ($left_one - $difference_one + 4) >> 3;
$written[$origin + 1] = ($bit_one + $corner_one + 4) >> 3;
$written[$origin + 2] = ($bit_one - $corner_one + 4) >> 3;
}
return $written;
}
/**
* inverseWalsh the second-order Walsh-a transform of sums and differences
* alone transform applied to the luma DC block @param array $self_contained
* whether the block stands on its own @return array what was read.
*/
private static function inverseWalsh(array $self_contained): array
{
$held = array_fill(0, 16, 0);
for ($i = 0; $i < 4; $i++) {
$left_one = $self_contained[$i] + $self_contained[$i + 12];
$bit_one = $self_contained[$i + 4] + $self_contained[$i + 8];
$corner_one = $self_contained[$i + 4] - $self_contained[$i + 8];
$difference_one = $self_contained[$i] - $self_contained[$i + 12];
$held[$i] = $left_one + $bit_one;
$held[$i + 4] = $corner_one + $difference_one;
$held[$i + 8] = $left_one - $bit_one;
$held[$i + 12] = $difference_one - $corner_one;
}
$written = array_fill(0, 16, 0);
for ($i = 0; $i < 4; $i++) {
$origin = $i * 4;
$left_one = $held[$origin] + $held[$origin + 3];
$bit_one = $held[$origin + 1] + $held[$origin + 2];
$corner_one = $held[$origin + 1] - $held[$origin + 2];
$difference_one = $held[$origin] - $held[$origin + 3];
$written[$origin] = ($left_one + $bit_one + 3) >> 3;
$written[$origin + 1] = ($corner_one + $difference_one + 3) >> 3;
$written[$origin + 2] = ($left_one - $bit_one + 3) >> 3;
$written[$origin + 3] = ($difference_one - $corner_one + 3) >> 3;
}
return $written;
}
/**
* holdInsideByte holds a sample inside the range a byte can carry.
*
* @param int $variant which form of the format is in use
* @return int what was read
*/
private static function holdInsideByte(int $variant): int
{
return $variant < 0 ? 0 : ($variant > 255 ? 255 : $variant);
}
/* reconstruction */
/**
* reconstruct turns the prediction and the coefficients of a macroblock
* into samples in the planes.
*
* @param int $macroblock_x which macroblock across
* @param int $macroblock_y which macroblock down
* @param int $y_mode which way the brightness block is guessed
* @param int $color_mode which way the color blocks are guessed
* @param array $values the values the block was coded as
*/
private function reconstruct(int $macroblock_x, int $macroblock_y,
int $y_mode,
int $color_mode,
?array $values): void
{
if ($y_mode === self::B_PRED) {
$this->reconstructB($macroblock_x, $macroblock_y, $values);
} else {
$this->predictBlock(
0, $macroblock_x * 16, $macroblock_y * 16, 16, $y_mode,
$macroblock_x > 0, $macroblock_y > 0);
if ($values !== null) {
$first_value = $values['y2'];
for ($byte = 0; $byte < 16; $byte++) {
$block_at = $values['y'][$byte];
$block_at[0] = $first_value[$byte];
$this->addResidual(0, $macroblock_x * 16
+ ($byte & 3) * 4, $macroblock_y * 16
+ ($byte >> 2) * 4, $block_at);
}
}
}
foreach ([1, 2] as $plane_at) {
$this->predictBlock(
$plane_at, $macroblock_x * 8, $macroblock_y * 8, 8,
$color_mode, $macroblock_x > 0,
$macroblock_y > 0);
if ($values !== null) {
for ($byte = 0; $byte < 4; $byte++) {
$this->addResidual(
$plane_at,
$macroblock_x * 8 + ($byte & 1) * 4,
$macroblock_y * 8 + ($byte >> 1) * 4,
$values['uv'][$plane_at][$byte]
);
}
}
}
}
/**
* addResidual transforms one block of coefficients and adds the result to
* the prediction already in the plane. for color
*
* @param int $plane_at which plane, zero for brightness and one or two
* @param int $block_x how far across the frame the block starts
* @param int $block_y how far down the frame the block starts
* @param array $block the block's values
*/
private function addResidual(int $plane_at, int $block_x, int $block_y,
array $block): void
{
foreach ($block as $variant) {
if ($variant !== 0) {
$run = self::inverseDct($block);
$stride = $this->strides[$plane_at];
for ($down = 0; $down < 4; $down++) {
$row = $this->sampleAt($plane_at, $block_x,
$block_y + $down);
for ($across = 0; $across < 4; $across++) {
$this->planes[$plane_at][$row + $across] =
self::holdInsideByte($this
->planes[$plane_at][$row + $across]
+ $run[$down * 4 + $across]);
}
}
return;
}
}
}
/**
* predictBlock whole-block prediction for sixteen by sixteen luma and eight
* by eight chroma for color
*
* @param int $plane_at which plane, zero for brightness and one or two
* @param int $block_x how far across the frame the block starts
* @param int $block_y how far down the frame the block starts
* @param int $size how many bytes
* @param int $mode which way the block is guessed from its neighbors
* @param bool $has_left whether the block to the left is there to read
* @param bool $has_top whether the block above is there to read
*/
private function predictBlock(int $plane_at, int $block_x, int $block_y,
int $size,
int $mode, bool $has_left, bool $has_top): void
{
$stride = $this->strides[$plane_at];
$plane = &$this->planes[$plane_at];
$above = [];
$left = [];
for ($i = 0; $i < $size; $i++) {
$above[$i] = $plane[$this->sampleAt($plane_at, $block_x + $i,
$block_y - 1)];
$left[$i] = $plane[$this->sampleAt($plane_at, $block_x - 1,
$block_y +
$i)];
}
$corner = $plane[$this->sampleAt($plane_at, $block_x - 1,
$block_y - 1)];
switch ($mode) {
case self::DC_PRED:
if ($has_top && $has_left) {
$first_value = (array_sum($above) + array_sum($left) +
$size)
>> (int) (log($size, 2) + 1);
} elseif ($has_top) {
$first_value = (array_sum($above) + $size / 2)
>> (int) log($size, 2);
} elseif ($has_left) {
$first_value = (array_sum($left) + $size /
2) >> (int) log($size, 2);
} else {
$first_value = 128;
}
$first_value = (int) $first_value;
for ($down = 0; $down < $size; $down++) {
$row = $this->sampleAt($plane_at, $block_x,
$block_y + $down);
for ($across = 0; $across < $size; $across++) {
$plane[$row + $across] = $first_value;
}
}
break;
case self::V_PRED:
for ($down = 0; $down < $size; $down++) {
$row = $this->sampleAt($plane_at, $block_x,
$block_y + $down);
for ($across = 0; $across < $size; $across++) {
$plane[$row + $across] = $above[$across];
}
}
break;
case self::H_PRED:
for ($down = 0; $down < $size; $down++) {
$row = $this->sampleAt($plane_at, $block_x,
$block_y + $down);
for ($across = 0; $across < $size; $across++) {
$plane[$row + $across] = $left[$down];
}
}
break;
case self::TM_PRED:
for ($down = 0; $down < $size; $down++) {
$row = $this->sampleAt($plane_at, $block_x,
$block_y + $down);
for ($across = 0; $across < $size; $across++) {
$plane[$row + $across]
= self::holdInsideByte(
$left[$down] + $above[$across] - $corner);
}
}
break;
default:
throw new VideoException("bad VP8 prediction mode $mode");
}
unset($plane);
}
/**
* reconstructB rebuilds a macroblock predicted in four sample squares, each
* with its own mode.
*
* @param int $macroblock_x which macroblock across
* @param int $macroblock_y which macroblock down
* @param array $values the values the block was coded as
*/
private function reconstructB(int $macroblock_x, int $macroblock_y,
?array $values): void
{
$stride = $this->strides[0];
$block_stride = $this->macroblock_width * 4;
$wide = $this->macroblock_width * 16;
/* the four samples above and to the right of the macroblock, reused by
*/
/* every sub-block in the right-hand column whatever its row */
$top_right = [];
for ($k = 0; $k < 4; $k++) {
$top_right[$k] = ($macroblock_x === $this
->macroblock_width - 1 && $macroblock_y > 0)
? $this->planes[0][$this->sampleAt(0, $wide - 1,
$macroblock_y * 16 - 1)]
: $this->planes[0][$this->sampleAt(0,
$macroblock_x * 16 + 16 + $k,
$macroblock_y * 16
- 1)];
}
for ($block_y = 0; $block_y < 4; $block_y++) {
for ($block_x = 0; $block_x < 4; $block_x++) {
$sample_x = $macroblock_x * 16 + $block_x * 4;
$sample_y = $macroblock_y * 16 + $block_y * 4;
$mode
= $this
->block_modes[($macroblock_y * 4 + $block_y) *
$block_stride + $macroblock_x * 4
+ $block_x];
$above_run = [];
for ($k = 0; $k < 4; $k++) {
$above_run[$k]
= $this->planes[0][$this->sampleAt(0, $sample_x + $k,
$sample_y - 1)];
}
if ($block_x === 3) {
for ($k = 0; $k < 4; $k++) {
$above_run[4 + $k] = $top_right[$k];
}
} else {
for ($k = 0; $k < 4; $k++) {
$above_run[4 + $k]
= $this->planes[0][
$this->sampleAt(0, $sample_x + 4 + $k,
$sample_y - 1)];
}
}
$left_run = [];
for ($k = 0; $k < 4; $k++) {
$left_run[$k]
= $this->planes[0][$this->sampleAt(0, $sample_x - 1,
$sample_y + $k)];
}
$prior = $this->planes[0][$this->sampleAt(0, $sample_x - 1,
$sample_y - 1)];
$guess = self::predictSubBlock(
$mode, $above_run, $left_run, $prior);
for ($down = 0; $down < 4; $down++) {
$row = $this->sampleAt(0, $sample_x, $sample_y + $down);
for ($across = 0; $across < 4; $across++) {
$this->planes[0][$row + $across]
= $guess[$down * 4 + $across];
}
}
if ($values !== null) {
$this->addResidual(0, $sample_x, $sample_y,
$values['y'][$block_y * 4
+ $block_x]);
}
}
}
}
/**
* predictSubBlock the ten sub-block predictors of a numbered internet
* standard 6386. $above_run holds the four samples above plus four above-
* right, $left_run the four to the left, $prior the corner.
*
* @param int $mode which way the block is guessed from its neighbors
* @param array $above_run how many the row above skipped
* @param array $left_run how many the column to the left skipped
* @param int $prior what was read before
* @return array what was read
*/
private static function predictSubBlock(int $mode, array $above_run,
array $left_run, int $prior): array
{
$below = array_fill(0, 16, 0);
$set
= static function (int $run, int $chunk,
int $variant) use (&$below): void {
$below[$run * 4 + $chunk] = $variant;
};
$average_of_two = static fn(int $amount, int $byte): int
=> ($amount + $byte + 1) >> 1;
$average_of_three = static fn(int $amount, int $byte, int $chunk): int
=> ($amount + 2 * $byte + $chunk + 2) >> 2;
/* E indexes the left column, corner and above row as one run */
$east
= [$left_run[3], $left_run[2], $left_run[1], $left_run[0], $prior,
$above_run[0], $above_run[1], $above_run[2], $above_run[3]];
switch ($mode) {
case self::B_DC:
$sum = $above_run[0] + $above_run[1] + $above_run[2]
+ $above_run[3] + $left_run[0] + $left_run[1] + $left_run[2]
+ $left_run[3] + 4;
$below = array_fill(0, 16, $sum >> 3);
break;
case self::B_TM:
for ($run = 0; $run < 4; $run++) {
for ($chunk = 0; $chunk < 4; $chunk++) {
$set($run, $chunk, self::holdInsideByte($left_run[$run]
+ $above_run[$chunk] - $prior));
}
}
break;
case self::B_VE:
$variant = [
$average_of_three($prior, $above_run[0], $above_run[1]),
$average_of_three($above_run[0], $above_run[1],
$above_run[2]),
$average_of_three($above_run[1], $above_run[2],
$above_run[3]),
$average_of_three($above_run[2], $above_run[3],
$above_run[4]),
];
for ($run = 0; $run < 4; $run++) {
for ($chunk = 0; $chunk < 4; $chunk++) {
$set($run, $chunk, $variant[$chunk]);
}
}
break;
case self::B_HE:
$variant = [
$average_of_three($prior, $left_run[0], $left_run[1]),
$average_of_three($left_run[0], $left_run[1], $left_run[2]),
$average_of_three($left_run[1], $left_run[2], $left_run[3]),
$average_of_three($left_run[2], $left_run[3], $left_run[3]),
];
for ($run = 0; $run < 4; $run++) {
for ($chunk = 0; $chunk < 4; $chunk++) {
$set($run, $chunk, $variant[$run]);
}
}
break;
case self::B_LD:
for ($run = 0; $run < 4; $run++) {
for ($chunk = 0; $chunk < 4; $chunk++) {
$i = $run + $chunk;
$set($run, $chunk, $i < 6
? $average_of_three(
$above_run[$i], $above_run[$i + 1],
$above_run[$i + 2])
: $average_of_three($above_run[6], $above_run[7],
$above_run[7]));
}
}
break;
case self::B_RD:
for ($run = 0; $run < 4; $run++) {
for ($chunk = 0; $chunk < 4; $chunk++) {
$i = $chunk - $run + 3;
$set($run, $chunk, $average_of_three($east[$i], $east[$i
+ 1], $east[$i + 2]));
}
}
break;
case self::B_VR:
$set(3, 0, $average_of_three($east[1], $east[2], $east[3]));
$set(2, 0, $average_of_three($east[2], $east[3], $east[4]));
$set(3, 1, $average_of_three($east[3], $east[4], $east[5]));
$set(1, 0, $average_of_three($east[3], $east[4], $east[5]));
$set(2, 1, $average_of_two($east[4], $east[5]));
$set(0, 0, $average_of_two($east[4], $east[5]));
$set(3, 2, $average_of_three($east[4], $east[5], $east[6]));
$set(1, 1, $average_of_three($east[4], $east[5], $east[6]));
$set(2, 2, $average_of_two($east[5], $east[6]));
$set(0, 1, $average_of_two($east[5], $east[6]));
$set(3, 3, $average_of_three($east[5], $east[6], $east[7]));
$set(1, 2, $average_of_three($east[5], $east[6], $east[7]));
$set(2, 3, $average_of_two($east[6], $east[7]));
$set(0, 2, $average_of_two($east[6], $east[7]));
$set(1, 3, $average_of_three($east[6], $east[7], $east[8]));
$set(0, 3, $average_of_two($east[7], $east[8]));
break;
case self::B_VL:
$set(0, 0, $average_of_two($above_run[0], $above_run[1]));
$set(1, 0, $average_of_three($above_run[0], $above_run[1],
$above_run[2]));
$set(2, 0, $average_of_two($above_run[1], $above_run[2]));
$set(0, 1, $average_of_two($above_run[1], $above_run[2]));
$set(1, 1, $average_of_three($above_run[1], $above_run[2],
$above_run[3]));
$set(3, 0, $average_of_three($above_run[1], $above_run[2],
$above_run[3]));
$set(2, 1, $average_of_two($above_run[2], $above_run[3]));
$set(0, 2, $average_of_two($above_run[2], $above_run[3]));
$set(3, 1, $average_of_three($above_run[2], $above_run[3],
$above_run[4]));
$set(1, 2, $average_of_three($above_run[2], $above_run[3],
$above_run[4]));
$set(2, 2, $average_of_two($above_run[3], $above_run[4]));
$set(0, 3, $average_of_two($above_run[3], $above_run[4]));
$set(3, 2, $average_of_three($above_run[3], $above_run[4],
$above_run[5]));
$set(1, 3, $average_of_three($above_run[3], $above_run[4],
$above_run[5]));
$set(2, 3, $average_of_three($above_run[4], $above_run[5],
$above_run[6]));
$set(3, 3, $average_of_three($above_run[5], $above_run[6],
$above_run[7]));
break;
case self::B_HD:
$set(3, 0, $average_of_two($east[0], $east[1]));
$set(3, 1, $average_of_three($east[0], $east[1], $east[2]));
$set(2, 0, $average_of_two($east[1], $east[2]));
$set(3, 2, $average_of_two($east[1], $east[2]));
$set(2, 1, $average_of_three($east[1], $east[2], $east[3]));
$set(3, 3, $average_of_three($east[1], $east[2], $east[3]));
$set(2, 2, $average_of_two($east[2], $east[3]));
$set(1, 0, $average_of_two($east[2], $east[3]));
$set(2, 3, $average_of_three($east[2], $east[3], $east[4]));
$set(1, 1, $average_of_three($east[2], $east[3], $east[4]));
$set(1, 2, $average_of_two($east[3], $east[4]));
$set(0, 0, $average_of_two($east[3], $east[4]));
$set(1, 3, $average_of_three($east[3], $east[4], $east[5]));
$set(0, 1, $average_of_three($east[3], $east[4], $east[5]));
$set(0, 2, $average_of_three($east[4], $east[5], $east[6]));
$set(0, 3, $average_of_three($east[5], $east[6], $east[7]));
break;
case self::B_HU:
$set(0, 0, $average_of_two($left_run[0], $left_run[1]));
$set(0, 1, $average_of_three($left_run[0], $left_run[1],
$left_run[2]));
$set(0, 2, $average_of_two($left_run[1], $left_run[2]));
$set(1, 0, $average_of_two($left_run[1], $left_run[2]));
$set(0, 3, $average_of_three($left_run[1], $left_run[2],
$left_run[3]));
$set(1, 1, $average_of_three($left_run[1], $left_run[2],
$left_run[3]));
$set(1, 2, $average_of_two($left_run[2], $left_run[3]));
$set(2, 0, $average_of_two($left_run[2], $left_run[3]));
$set(1, 3, $average_of_three($left_run[2], $left_run[3],
$left_run[3]));
$set(2, 1, $average_of_three($left_run[2], $left_run[3],
$left_run[3]));
foreach ([[2, 2], [2, 3], [3, 0], [3, 1], [3, 2],
[3, 3]] as [$run, $checksum]) {
$set($run, $checksum, $left_run[3]);
}
break;
default:
throw new VideoException("bad VP8 sub-block mode $mode");
}
return $below;
}
/* loop filter */
/**
* loopFilter smooths the sample values either side of every block edge, so
* that quantization does not leave a visible seam.
*/
private function loopFilter(): void
{
if ($this->filter_level === 0) {
return;
}
for ($macroblock_y = 0; $macroblock_y < $this
->macroblock_height; $macroblock_y++) {
for ($macroblock_x = 0; $macroblock_x < $this
->macroblock_width; $macroblock_x++) {
$position = $macroblock_y * $this
->macroblock_width + $macroblock_x;
$level = $this->filterLevelFor($position);
if ($level === 0) {
continue;
}
$interior = $level;
if ($this->sharpness > 0) {
$interior >>= ($this->sharpness > 4) ? 2 : 1;
if ($interior > 9 - $this->sharpness) {
$interior = 9 - $this->sharpness;
}
}
if ($interior < 1) {
$interior = 1;
}
$macroblock_limit = 2 * ($level + 2) + $interior;
$b_limit = 2 * $level + $interior;
$sharp_edge = $level >= 40 ? 2 : ($level >= 15 ? 1 : 0);
$inner = $this->macroblock_has_values[$position] === 1
|| $this->macroblock_y_mode[$position] === self::B_PRED;
$this->filterMacroblock(
$macroblock_x, $macroblock_y, $macroblock_limit,
$b_limit, $interior,
$sharp_edge, $inner);
}
}
}
/**
* filterLevelFor works out how strongly one macroblock should be filtered,
* given the frame's setting and any adjustment its segment or mode carries.
*
* @param int $position where the block sits in the frame
* @return int what was read
*/
private function filterLevelFor(int $position): int
{
$level = $this->filter_level;
if ($this->segment_enabled) {
$seg = $this->macroblock_segment[$position];
$level = $this->segment_absolute
? $this->segment_filter[$seg]
: $level + $this->segment_filter[$seg];
$level = max(0, min(63, $level));
}
if ($this->smoothing_delta_enabled) {
/* intra frame */
$level += $this->reference_smoothing_deltas[0];
if ($this->macroblock_y_mode[$position] === self::B_PRED) {
$level += $this->mode_smoothing_deltas[0];
}
$level = max(0, min(63, $level));
}
return $level;
}
/**
* filterMacroblock filters the edges of one macroblock, the outer ones more
* widely than the ones inside it.
*
* @param int $macroblock_x which macroblock across
* @param int $macroblock_y which macroblock down
* @param int $macroblock_limit how far a value at a macroblock edge may be
* moved
* @param int $b_limit how far a value inside a macroblock may be moved
* @param int $interior how far an inside value may be moved
* @param int $sharp_edge whether the edge is too sharp to smooth
* @param bool $inner whether the inside edges are smoothed too
*/
private function filterMacroblock(
int $macroblock_x, int $macroblock_y, int $macroblock_limit,
int $b_limit, int $interior,
int $sharp_edge,
bool $inner
): void {
/* the simple filter touches luma only */
$planes = $this->filter_simple
? [[0, 16, 16]]
: [[0, 16, 16], [1, 8, 8], [2, 8, 8]];
foreach ($planes as [$plane_at, $size, $length]) {
$stride = $this->strides[$plane_at];
$block_x = $macroblock_x * $size;
$block_y = $macroblock_y * $size;
$step = ($plane_at === 0) ? 4 : 4;
$inners = ($plane_at === 0) ? [4, 8, 12] : [4];
if ($macroblock_x > 0) {
for ($k = 0; $k < $length; $k++) {
$this->filterEdge($plane_at, $this->sampleAt($plane_at,
$block_x, $block_y
+ $k), 1, $macroblock_limit, $interior, $sharp_edge,
true);
}
}
if ($inner) {
foreach ($inners as $step_across) {
for ($k = 0; $k < $length; $k++) {
$this->filterEdge($plane_at, $this->sampleAt($plane_at,
$block_x + $step_across, $block_y
+ $k), 1, $b_limit, $interior, $sharp_edge, false);
}
}
}
if ($macroblock_y > 0) {
for ($k = 0; $k < $length; $k++) {
$this->filterEdge($plane_at, $this->sampleAt($plane_at,
$block_x
+ $k, $block_y), $stride, $macroblock_limit, $interior,
$sharp_edge, true);
}
}
if ($inner) {
foreach ($inners as $step_down) {
for ($k = 0; $k < $length; $k++) {
$this->filterEdge($plane_at, $this->sampleAt($plane_at,
$block_x + $k, $block_y
+ $step_down), $stride, $b_limit, $interior,
$sharp_edge, false);
}
}
}
}
}
/**
* holdInsideSignedByte holds a value inside the range a signed byte can
* carry.
*
* @param int $variant which form of the format is in use
* @return int what was read
*/
private static function holdInsideSignedByte(int $variant): int
{
return $variant < -128 ? -128 : ($variant > 127 ? 127 : $variant);
}
/**
* filterEdge filters one line of samples crossing a block edge. for color
* above
*
* @param int $plane_at which plane, zero for brightness and one or two
* @param int $base the value the rest are measured from
* @param int $step how far to move each time
* @param int $limit the most that may be read
* @param int $interior how far an inside value may be moved
* @param int $sharp_edge_threshold the sharpness an edge is left alone
* @param bool $macroblock_edge whether this is the edge between macroblocks
*/
private function filterEdge(
int $plane_at, int $base, int $step, int $limit, int $interior,
int $sharp_edge_threshold, bool $macroblock_edge
): void {
$plane = &$this->planes[$plane_at];
$before_edge_three = $plane[$base - 4 * $step];
$before_edge_two = $plane[$base - 3 * $step];
$before_edge_one = $plane[$base - 2 * $step];
$before_edge = $plane[$base - $step];
$after_edge = $plane[$base];
$after_edge_one = $plane[$base + $step];
$after_edge_two = $plane[$base + 2 * $step];
$after_edge_three = $plane[$base + 3 * $step];
if ($this->filter_simple) {
if ((abs($before_edge - $after_edge) * 2 +
intdiv(abs($before_edge_one - $after_edge_one),
2)) <= $limit) {
self::commonAdjust($plane, $base, $step, true);
}
unset($plane);
return;
}
$ok = (abs($before_edge - $after_edge) * 2 +
intdiv(abs($before_edge_one - $after_edge_one),
2)) <= $limit
&& abs($before_edge_three - $before_edge_two) <= $interior &&
abs($before_edge_two - $before_edge_one) <= $interior
&& abs($before_edge_one - $before_edge) <= $interior &&
abs($after_edge_three - $after_edge_two) <= $interior
&& abs($after_edge_two - $after_edge_one) <= $interior &&
abs($after_edge_one - $after_edge) <=
$interior;
if (!$ok) {
unset($plane);
return;
}
$high_edge = abs($before_edge_one - $before_edge) >
$sharp_edge_threshold || abs($after_edge_one -
$after_edge) > $sharp_edge_threshold;
if (!$macroblock_edge) {
$amount = self::commonAdjust($plane, $base, $step, $high_edge);
if (!$high_edge) {
$amount = ($amount + 1) >> 1;
$plane[$base + $step] = self::shiftBackFromSigned(
self::shiftToSigned($after_edge_one) - $amount);
$plane[$base - 2 * $step] = self::shiftBackFromSigned(
self::shiftToSigned($before_edge_one) + $amount);
}
unset($plane);
return;
}
if ($high_edge) {
self::commonAdjust($plane, $base, $step, true);
unset($plane);
return;
}
$before_edge_signed_one = self::shiftToSigned($before_edge_one);
$before_edge_signed = self::shiftToSigned($before_edge);
$after_edge_signed = self::shiftToSigned($after_edge);
$after_edge_signed_one = self::shiftToSigned($after_edge_one);
$across_edge = self::holdInsideSignedByte(
$before_edge_signed_one - $after_edge_signed_one);
$wide = self::holdInsideSignedByte($across_edge
+ 3 * ($after_edge_signed - $before_edge_signed));
$amount = (27 * $wide + 63) >> 7;
$plane[$base] = self::shiftBackFromSigned($after_edge_signed - $amount);
$plane[$base - $step] =
self::shiftBackFromSigned($before_edge_signed + $amount);
$amount = (18 * $wide + 63) >> 7;
$plane[$base + $step] =
self::shiftBackFromSigned($after_edge_signed_one - $amount);
$plane[$base - 2 * $step] =
self::shiftBackFromSigned($before_edge_signed_one + $amount);
$amount = (9 * $wide + 63) >> 7;
$plane[$base + 2 * $step] = self::shiftBackFromSigned(
self::shiftToSigned($after_edge_two) - $amount);
$plane[$base - 3 * $step] = self::shiftBackFromSigned(
self::shiftToSigned($before_edge_two) + $amount);
unset($plane);
}
/**
* shiftToSigned shifts a sample so that its middle value sits at zero,
* which is how the filter arithmetic is defined.
*
* @param int $variant which form of the format is in use
* @return int what was read
*/
private static function shiftToSigned(int $variant): int
{
return $variant - 128;
}
/**
* shiftBackFromSigned shifts a filtered value back into the range a sample
* uses.
*
* @param int $variant which form of the format is in use
* @return int what was read
*/
private static function shiftBackFromSigned(int $variant): int
{
return self::holdInsideByte(self::holdInsideSignedByte($variant) + 128);
}
/**
* commonAdjust moves the two samples either side of an edge toward each
* other by the amount the filter calls for.
*
* @param array & $plane zero for luma, one and two for the chroma planes
* @param int $base the value the rest are measured from
* @param int $step how far to move each time
* @param bool $use_outer whether the outer setting is used
* @return int what was read
*/
private static function commonAdjust(array
&$plane, int $base, int $step, bool $use_outer): int
{
$before_edge_one = self::shiftToSigned($plane[$base - 2 * $step]);
$before_edge = self::shiftToSigned($plane[$base - $step]);
$after_edge = self::shiftToSigned($plane[$base]);
$after_edge_one = self::shiftToSigned($plane[$base + $step]);
$amount = self::holdInsideSignedByte(($use_outer
? self::holdInsideSignedByte($before_edge_one -
$after_edge_one) : 0)
+ 3 * ($after_edge - $before_edge));
$field = self::holdInsideSignedByte($amount + 4) >> 3;
$entry = self::holdInsideSignedByte($amount + 3) >> 3;
$plane[$base] = self::shiftBackFromSigned($after_edge - $field);
$plane[$base - $step] = self::shiftBackFromSigned($before_edge +
$entry);
return $field;
}
/* output */
/**
* toPicture hands back the decoded planes as a picture.
*
* @return VideoPicture what was read
*/
private function toPicture(): VideoPicture
{
$line_width = $this->macroblock_width * 16;
$left_half = $this->macroblock_height * 16;
$code_word = $this->macroblock_width * 8;
$channel = $this->macroblock_height * 8;
$luma = array_fill(0, $line_width * $left_half, 0);
for ($down = 0; $down < $left_half; $down++) {
$source = $this->sampleAt(0, 0, $down);
$target = $down * $line_width;
for ($across = 0; $across < $line_width; $across++) {
$luma[$target + $across] = $this->planes[0][$source + $across];
}
}
$blue = array_fill(0, $code_word * $channel, 0);
$red = array_fill(0, $code_word * $channel, 0);
for ($down = 0; $down < $channel; $down++) {
$sum_one = $this->sampleAt(1, 0, $down);
$sum_two = $this->sampleAt(2, 0, $down);
$target = $down * $code_word;
for ($across = 0; $across < $code_word; $across++) {
$blue[$target + $across] = $this->planes[1][$sum_one + $across];
$red[$target + $across] = $this->planes[2][$sum_two + $across];
}
}
return new VideoPicture(
$luma, $blue, $red, $this->frame_width, $this->frame_height,
$line_width,
$code_word, 0, 0);
}
}
(c) 2026 Seekquarry - Open Source Search Engine Software