1473 lines
69 KiB
C++
1473 lines
69 KiB
C++
|
/*
|
||
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
||
|
|
*
|
||
|
|
* Use of this source code is governed by a BSD-style license
|
||
|
|
* that can be found in the LICENSE file in the root of the source
|
||
|
|
* tree. An additional intellectual property rights grant can be found
|
||
|
|
* in the file PATENTS. All contributing project authors may
|
||
|
|
* be found in the AUTHORS file in the root of the source tree.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
#include <cassert>
|
||
|
|
#include "h263_information.h"
|
||
|
|
|
||
|
|
namespace webrtc {
|
||
|
|
// MCBPC ---
|
||
|
|
static const WebRtc_Word32 MCBPC_I_MAX_CODE_LENGTH = 2;
|
||
|
|
static const WebRtc_Word32 MCBPC_I_TABLE_LENGTH = 9;
|
||
|
|
static const WebRtc_UWord8 MCBPC_I_CODE[9][2] = {{0x80,0x00}, //1
|
||
|
|
{0x20,0x00}, //001
|
||
|
|
{0x40,0x00}, //010
|
||
|
|
{0x60,0x00}, //011
|
||
|
|
{0x10,0x00}, //0001
|
||
|
|
{0x04,0x00}, //0000 01
|
||
|
|
{0x08,0x00}, //0000 10
|
||
|
|
{0x0C,0x00}, //0000 11
|
||
|
|
{0x00,0x80}}; //0000 0000 1
|
||
|
|
|
||
|
|
static const WebRtc_UWord8 MCBPC_I_MASK[9][2] = {{0x80,0x00}, //1
|
||
|
|
{0xE0,0x00}, //001
|
||
|
|
{0xE0,0x00}, //010
|
||
|
|
{0xE0,0x00}, //011
|
||
|
|
{0xF0,0x00}, //0001
|
||
|
|
{0xFC,0x00}, //0000 01
|
||
|
|
{0xFC,0x00}, //0000 10
|
||
|
|
{0xFC,0x00}, //0000 11
|
||
|
|
{0xFF,0x80}}; //0000 0000 1
|
||
|
|
|
||
|
|
static const WebRtc_Word32 MCBPC_I_MBTYPE[9] = {3,3,3,3,4,4,4,4,6};
|
||
|
|
static const WebRtc_Word32 MCBPC_I_SIZE[9] = {1,3,3,3,4,6,6,6,9};
|
||
|
|
static const char MCBPC_I_CBPC[9][2] = {{0,0},{0,1},{1,0},{1,1},{0,0},{0,1},{1,0},{1,1},{0,0}};
|
||
|
|
|
||
|
|
static const WebRtc_Word32 MCBPC_P_MAX_CODE_LENGTH = 2;
|
||
|
|
static const WebRtc_Word32 MCBPC_P_TABLE_LENGTH = 25;
|
||
|
|
static const WebRtc_UWord8 MCBPC_P_CODE[25][2] = {{0x80,0x00}, //1
|
||
|
|
{0x30,0x00}, //0011
|
||
|
|
{0x20,0x00}, //0010
|
||
|
|
{0x14,0x00}, //0001 01
|
||
|
|
{0x60,0x00}, //011
|
||
|
|
{0x0E,0x00}, //0000 111
|
||
|
|
{0x0C,0x00}, //0000 110
|
||
|
|
{0x02,0x80}, //0000 0010 1
|
||
|
|
{0x40,0x00}, //010
|
||
|
|
{0x0A,0x00}, //0000 101
|
||
|
|
{0x08,0x00}, //0000 100
|
||
|
|
{0x05,0x00}, //0000 0101
|
||
|
|
{0x18,0x00}, //0001 1
|
||
|
|
{0x04,0x00}, //0000 0100
|
||
|
|
{0x03,0x00}, //0000 0011
|
||
|
|
{0x06,0x00}, //0000 011
|
||
|
|
{0x10,0x00}, //0001 00
|
||
|
|
{0x02,0x00}, //0000 0010 0
|
||
|
|
{0x01,0x80}, //0000 0001 1
|
||
|
|
{0x01,0x00}, //0000 0001 0
|
||
|
|
{0x00,0x80}, //0000 0000 1
|
||
|
|
{0x00,0x40}, //0000 0000 010
|
||
|
|
{0x00,0x60}, //0000 0000 0110 0
|
||
|
|
{0x00,0x70}, //0000 0000 0111 0
|
||
|
|
{0x00,0x78}}; //0000 0000 0111 1
|
||
|
|
|
||
|
|
static const WebRtc_UWord8 MCBPC_P_MASK[25][2] = {{0x80,0x00}, //1
|
||
|
|
{0xF0,0x00}, //0011
|
||
|
|
{0xF0,0x00}, //0010
|
||
|
|
{0xFC,0x00}, //0001 01
|
||
|
|
{0xE0,0x00}, //011
|
||
|
|
{0xFE,0x00}, //0000 111
|
||
|
|
{0xFE,0x00}, //0000 110
|
||
|
|
{0xFF,0x80}, //0000 0010 1
|
||
|
|
{0xE0,0x00}, //010
|
||
|
|
{0xFE,0x00}, //0000 101
|
||
|
|
{0xFE,0x00}, //0000 100
|
||
|
|
{0xFF,0x00}, //0000 0101
|
||
|
|
{0xF8,0x00}, //0001 1
|
||
|
|
{0xFF,0x00}, //0000 0100
|
||
|
|
{0xFF,0x00}, //0000 0011
|
||
|
|
{0xFE,0x00}, //0000 011
|
||
|
|
{0xFC,0x00}, //0001 00
|
||
|
|
{0xFF,0x80}, //0000 0010 0
|
||
|
|
{0xFF,0x80}, //0000 0001 1
|
||
|
|
{0xFF,0x80}, //0000 0001 0
|
||
|
|
{0xFF,0x80}, //0000 0000 1
|
||
|
|
{0xFF,0xE0}, //0000 0000 010
|
||
|
|
{0xFF,0xF8}, //0000 0000 0110 0
|
||
|
|
{0xFF,0xF8}, //0000 0000 0111 0
|
||
|
|
{0xFF,0xF8}}; //0000 0000 0111 1
|
||
|
|
|
||
|
|
static const WebRtc_Word32 MCBPC_P_MBTYPE[25] = {0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,6, 5, 5, 5, 5};
|
||
|
|
static const WebRtc_Word32 MCBPC_P_SIZE[25] = {1,4,4,6,3,7,7,9,3,7,7,8,5,8,8,7,6,9,9,9,9,11,13,13,13};
|
||
|
|
static const char MCBPC_P_CBPC[25][2] = {{0,0},{0,1},{1,0},{1,1},
|
||
|
|
{0,0},{0,1},{1,0},{1,1},
|
||
|
|
{0,0},{0,1},{1,0},{1,1},
|
||
|
|
{0,0},{0,1},{1,0},{1,1},
|
||
|
|
{0,0},{0,1},{1,0},{1,1},
|
||
|
|
{0,0},
|
||
|
|
{0,0},{0,1},{1,0},{1,1}};
|
||
|
|
|
||
|
|
// CBPY ---
|
||
|
|
static const WebRtc_Word32 CBPY_MAX_CODE_LENGTH = 1;
|
||
|
|
static const WebRtc_Word32 CBPY_TABLE_LENGTH = 16;
|
||
|
|
static const WebRtc_UWord8 CBPY_CODE[16][1] = {{0x30}, //0011
|
||
|
|
{0x28}, //0010 1
|
||
|
|
{0x20}, //0010 0
|
||
|
|
{0x90}, //1001
|
||
|
|
{0x18}, //0001 1
|
||
|
|
{0x70}, //0111
|
||
|
|
{0x08}, //0000 10
|
||
|
|
{0xB0}, //1011
|
||
|
|
{0x10}, //0001 0
|
||
|
|
{0x0C}, //0000 11
|
||
|
|
{0x50}, //0101
|
||
|
|
{0xA0}, //1010
|
||
|
|
{0x40}, //0100
|
||
|
|
{0x80}, //1000
|
||
|
|
{0x60}, //0110
|
||
|
|
{0xC0}}; //11
|
||
|
|
|
||
|
|
static const WebRtc_UWord8 CBPY_MASK[16][1] = {{0xF0}, //0011
|
||
|
|
{0xF8}, //0010 1
|
||
|
|
{0xF8}, //0010 0
|
||
|
|
{0xF0}, //1001
|
||
|
|
{0xF8}, //0001 1
|
||
|
|
{0xF0}, //0111
|
||
|
|
{0xFC}, //0000 10
|
||
|
|
{0xF0}, //1011
|
||
|
|
{0xF8}, //0001 0
|
||
|
|
{0xFC}, //0000 11
|
||
|
|
{0xF0}, //0101
|
||
|
|
{0xF0}, //1010
|
||
|
|
{0xF0}, //0100
|
||
|
|
{0xF0}, //1000
|
||
|
|
{0xF0}, //0110
|
||
|
|
{0xC0}}; //11
|
||
|
|
|
||
|
|
static const WebRtc_Word32 CBPY_SIZE[16] = {4,5,5,4,5,4,6,4,5,6,4,4,4,4,4,2};
|
||
|
|
static const char CBPY_CBPY[16][4] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},
|
||
|
|
{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},
|
||
|
|
{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},
|
||
|
|
{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
|
||
|
|
|
||
|
|
// MVD ---
|
||
|
|
static const WebRtc_Word32 MVD_MAX_CODE_LENGTH = 2;
|
||
|
|
static const WebRtc_Word32 MVD_TABLE_LENGTH = 64;
|
||
|
|
static const WebRtc_UWord8 MVD_CODE[64][2] = {{0x00,0x28}, //0000 0000 0010 1
|
||
|
|
{0x00,0x38}, //0000 0000 0011 1
|
||
|
|
{0x00,0x50}, //0000 0000 0101
|
||
|
|
{0x00,0x70}, //0000 0000 0111
|
||
|
|
{0x00,0x90}, //0000 0000 1001
|
||
|
|
{0x00,0xB0}, //0000 0000 1011
|
||
|
|
{0x00,0xD0}, //0000 0000 1101
|
||
|
|
{0x00,0xF0}, //0000 0000 1111
|
||
|
|
{0x01,0x20}, //0000 0001 001
|
||
|
|
{0x01,0x60}, //0000 0001 011
|
||
|
|
{0x01,0xA0}, //0000 0001 101
|
||
|
|
{0x01,0xE0}, //0000 0001 111
|
||
|
|
{0x02,0x20}, //0000 0010 001
|
||
|
|
{0x02,0x60}, //0000 0010 011
|
||
|
|
{0x02,0xA0}, //0000 0010 101
|
||
|
|
{0x02,0xE0}, //0000 0010 111
|
||
|
|
{0x03,0x20}, //0000 0011 001
|
||
|
|
{0x03,0x60}, //0000 0011 011
|
||
|
|
{0x03,0xA0}, //0000 0011 101
|
||
|
|
{0x03,0xE0}, //0000 0011 111
|
||
|
|
{0x04,0x20}, //0000 0100 001
|
||
|
|
{0x04,0x60}, //0000 0100 011
|
||
|
|
{0x04,0xC0}, //0000 0100 11
|
||
|
|
{0x05,0x40}, //0000 0101 01
|
||
|
|
{0x05,0xC0}, //0000 0101 11
|
||
|
|
{0x07,0x00}, //0000 0111
|
||
|
|
{0x09,0x00}, //0000 1001
|
||
|
|
{0x0B,0x00}, //0000 1011
|
||
|
|
{0x0E,0x00}, //0000 111
|
||
|
|
{0x18,0x00}, //0001 1
|
||
|
|
{0x30,0x00}, //0011
|
||
|
|
{0x60,0x00}, //011
|
||
|
|
{0x80,0x00}, //1
|
||
|
|
{0x40,0x00}, //010
|
||
|
|
{0x20,0x00}, //0010
|
||
|
|
{0x10,0x00}, //0001 0
|
||
|
|
{0x0C,0x00}, //0000 110
|
||
|
|
{0x0A,0x00}, //0000 1010
|
||
|
|
{0x08,0x00}, //0000 1000
|
||
|
|
{0x06,0x00}, //0000 0110
|
||
|
|
{0x05,0x80}, //0000 0101 10
|
||
|
|
{0x05,0x00}, //0000 0101 00
|
||
|
|
{0x04,0x80}, //0000 0100 10
|
||
|
|
{0x04,0x40}, //0000 0100 010
|
||
|
|
{0x04,0x00}, //0000 0100 000
|
||
|
|
{0x03,0xC0}, //0000 0011 110
|
||
|
|
{0x03,0x80}, //0000 0011 100
|
||
|
|
{0x03,0x40}, //0000 0011 010
|
||
|
|
{0x03,0x00}, //0000 0011 000
|
||
|
|
{0x02,0xC0}, //0000 0010 110
|
||
|
|
{0x02,0x80}, //0000 0010 100
|
||
|
|
{0x02,0x40}, //0000 0010 010
|
||
|
|
{0x02,0x00}, //0000 0010 000
|
||
|
|
{0x01,0xC0}, //0000 0001 110
|
||
|
|
{0x01,0x80}, //0000 0001 100
|
||
|
|
{0x01,0x40}, //0000 0001 010
|
||
|
|
{0x01,0x00}, //0000 0001 000
|
||
|
|
{0x00,0xE0}, //0000 0000 1110
|
||
|
|
{0x00,0xC0}, //0000 0000 1100
|
||
|
|
{0x00,0xA0}, //0000 0000 1010
|
||
|
|
{0x00,0x80}, //0000 0000 1000
|
||
|
|
{0x00,0x60}, //0000 0000 0110
|
||
|
|
{0x00,0x40}, //0000 0000 0100
|
||
|
|
{0x00,0x30}}; //0000 0000 0011 0
|
||
|
|
|
||
|
|
static const WebRtc_UWord8 MVD_MASK[64][2] = {{0xFF,0xF8}, //0000 0000 0010 1
|
||
|
|
{0xFF,0xF8}, //0000 0000 0011 1
|
||
|
|
{0xFF,0xF0}, //0000 0000 0101
|
||
|
|
{0xFF,0xF0}, //0000 0000 0111
|
||
|
|
{0xFF,0xF0}, //0000 0000 1001
|
||
|
|
{0xFF,0xF0}, //0000 0000 1011
|
||
|
|
{0xFF,0xF0}, //0000 0000 1101
|
||
|
|
{0xFF,0xF0}, //0000 0000 1111
|
||
|
|
{0xFF,0xE0}, //0000 0001 001
|
||
|
|
{0xFF,0xE0}, //0000 0001 011
|
||
|
|
{0xFF,0xE0}, //0000 0001 101
|
||
|
|
{0xFF,0xE0}, //0000 0001 111
|
||
|
|
{0xFF,0xE0}, //0000 0010 001
|
||
|
|
{0xFF,0xE0}, //0000 0010 011
|
||
|
|
{0xFF,0xE0}, //0000 0010 101
|
||
|
|
{0xFF,0xE0}, //0000 0010 111
|
||
|
|
{0xFF,0xE0}, //0000 0011 001
|
||
|
|
{0xFF,0xE0}, //0000 0011 011
|
||
|
|
{0xFF,0xE0}, //0000 0011 101
|
||
|
|
{0xFF,0xE0}, //0000 0011 111
|
||
|
|
{0xFF,0xE0}, //0000 0100 001
|
||
|
|
{0xFF,0xE0}, //0000 0100 011
|
||
|
|
{0xFF,0xC0}, //0000 0100 11
|
||
|
|
{0xFF,0xC0}, //0000 0101 01
|
||
|
|
{0xFF,0xC0}, //0000 0101 11
|
||
|
|
{0xFF,0x00}, //0000 0111
|
||
|
|
{0xFF,0x00}, //0000 1001
|
||
|
|
{0xFF,0x00}, //0000 1011
|
||
|
|
{0xFE,0x00}, //0000 111
|
||
|
|
{0xF8,0x00}, //0001 1
|
||
|
|
{0xF0,0x00}, //0011
|
||
|
|
{0xE0,0x00}, //011
|
||
|
|
{0x80,0x00}, //1
|
||
|
|
{0xE0,0x00}, //010
|
||
|
|
{0xF0,0x00}, //0010
|
||
|
|
{0xF8,0x00}, //0001 0
|
||
|
|
{0xFE,0x00}, //0000 110
|
||
|
|
{0xFF,0x00}, //0000 1010
|
||
|
|
{0xFF,0x00}, //0000 1000
|
||
|
|
{0xFF,0x00}, //0000 0110
|
||
|
|
{0xFF,0xC0}, //0000 0101 10
|
||
|
|
{0xFF,0xC0}, //0000 0101 00
|
||
|
|
{0xFF,0xC0}, //0000 0100 10
|
||
|
|
{0xFF,0xE0}, //0000 0100 010
|
||
|
|
{0xFF,0xE0}, //0000 0100 000
|
||
|
|
{0xFF,0xE0}, //0000 0011 110
|
||
|
|
{0xFF,0xE0}, //0000 0011 100
|
||
|
|
{0xFF,0xE0}, //0000 0011 010
|
||
|
|
{0xFF,0xE0}, //0000 0011 000
|
||
|
|
{0xFF,0xE0}, //0000 0010 110
|
||
|
|
{0xFF,0xE0}, //0000 0010 100
|
||
|
|
{0xFF,0xE0}, //0000 0010 010
|
||
|
|
{0xFF,0xE0}, //0000 0010 000
|
||
|
|
{0xFF,0xE0}, //0000 0001 110
|
||
|
|
{0xFF,0xE0}, //0000 0001 100
|
||
|
|
{0xFF,0xE0}, //0000 0001 010
|
||
|
|
{0xFF,0xE0}, //0000 0001 000
|
||
|
|
{0xFF,0xF0}, //0000 0000 1110
|
||
|
|
{0xFF,0xF0}, //0000 0000 1100
|
||
|
|
{0xFF,0xF0}, //0000 0000 1010
|
||
|
|
{0xFF,0xF0}, //0000 0000 1000
|
||
|
|
{0xFF,0xF0}, //0000 0000 0110
|
||
|
|
{0xFF,0xF0}, //0000 0000 0100
|
||
|
|
{0xFF,0xF8}}; //0000 0000 0011 0
|
||
|
|
|
||
|
|
static const WebRtc_Word32 MVD_SIZE[64] = {13,13,12,12,12,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,
|
||
|
|
11,11,10,10,10, 8, 8, 8, 7, 5, 4, 3, 1, 3, 4, 5, 7, 8, 8, 8,
|
||
|
|
10,10,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,
|
||
|
|
12,12,12,13};
|
||
|
|
|
||
|
|
// TCOEF ---
|
||
|
|
static const WebRtc_Word32 TCOEF_MAX_CODE_LENGTH = 2;
|
||
|
|
static const WebRtc_Word32 TCOEF_TABLE_LENGTH = 103;
|
||
|
|
static const WebRtc_UWord8 TCOEF_CODE[103][2] = {{0x80,0x00}, //10s
|
||
|
|
{0xF0,0x00}, //1111s
|
||
|
|
{0x54,0x00}, //0101 01s
|
||
|
|
{0x2E,0x00}, //0010 111s
|
||
|
|
{0x1F,0x00}, //0001 1111s
|
||
|
|
{0x12,0x80}, //0001 0010 1s
|
||
|
|
{0x12,0x00}, //0001 0010 0s
|
||
|
|
{0x08,0x40}, //0000 1000 01s
|
||
|
|
{0x08,0x00}, //0000 1000 00s
|
||
|
|
{0x00,0xE0}, //0000 0000 111s
|
||
|
|
{0x00,0xC0}, //0000 0000 110s
|
||
|
|
{0x04,0x00}, //0000 0100 000s
|
||
|
|
{0xC0,0x00}, //110s
|
||
|
|
{0x50,0x00}, //0101 00s
|
||
|
|
{0x1E,0x00}, //0001 1110s
|
||
|
|
{0x03,0xC0}, //0000 0011 11s
|
||
|
|
{0x04,0x20}, //0000 0100 001s
|
||
|
|
{0x05,0x00}, //0000 0101 0000s
|
||
|
|
{0xE0,0x00}, //1110s
|
||
|
|
{0x1D,0x00}, //0001 1101s
|
||
|
|
{0x03,0x80}, //0000 0011 10s
|
||
|
|
{0x05,0x10}, //0000 0101 0001s
|
||
|
|
{0x68,0x00}, //0110 1s
|
||
|
|
{0x11,0x80}, //0001 0001 1s
|
||
|
|
{0x03,0x40}, //0000 0011 01s
|
||
|
|
{0x60,0x00}, //0110 0s
|
||
|
|
{0x11,0x00}, //0001 0001 0s
|
||
|
|
{0x05,0x20}, //0000 0101 0010s
|
||
|
|
{0x58,0x00}, //0101 1s
|
||
|
|
{0x03,0x00}, //0000 0011 00s
|
||
|
|
{0x05,0x30}, //0000 0101 0011s
|
||
|
|
{0x4C,0x00}, //0100 11s
|
||
|
|
{0x02,0xC0}, //0000 0010 11s
|
||
|
|
{0x05,0x40}, //0000 0101 0100s
|
||
|
|
{0x48,0x00}, //0100 10s
|
||
|
|
{0x02,0x80}, //0000 0010 10s
|
||
|
|
{0x44,0x00}, //0100 01s
|
||
|
|
{0x02,0x40}, //0000 0010 01s
|
||
|
|
{0x40,0x00}, //0100 00s
|
||
|
|
{0x02,0x00}, //0000 0010 00s
|
||
|
|
{0x2C,0x00}, //0010 110s
|
||
|
|
{0x05,0x50}, //0000 0101 0101s
|
||
|
|
{0x2A,0x00}, //0010 101s
|
||
|
|
{0x28,0x00}, //0010 100s
|
||
|
|
{0x1C,0x00}, //0001 1100s
|
||
|
|
{0x1B,0x00}, //0001 1011s
|
||
|
|
{0x10,0x80}, //0001 0000 1s
|
||
|
|
{0x10,0x00}, //0001 0000 0s
|
||
|
|
{0x0F,0x80}, //0000 1111 1s
|
||
|
|
{0x0F,0x00}, //0000 1111 0s
|
||
|
|
{0x0E,0x80}, //0000 1110 1s
|
||
|
|
{0x0E,0x00}, //0000 1110 0s
|
||
|
|
{0x0D,0x80}, //0000 1101 1s
|
||
|
|
{0x0D,0x00}, //0000 1101 0s
|
||
|
|
{0x04,0x40}, //0000 0100 010s
|
||
|
|
{0x04,0x60}, //0000 0100 011s
|
||
|
|
{0x05,0x60}, //0000 0101 0110s
|
||
|
|
{0x05,0x70}, //0000 0101 0111s
|
||
|
|
{0x70,0x00}, //0111s //last=1 ---------------------
|
||
|
|
{0x0C,0x80}, //0000 1100 1s
|
||
|
|
{0x00,0xA0}, //0000 0000 101s
|
||
|
|
{0x3C,0x00}, //0011 11s
|
||
|
|
{0x00,0x80}, //0000 0000 100s
|
||
|
|
{0x38,0x00}, //0011 10s
|
||
|
|
{0x34,0x00}, //0011 01s
|
||
|
|
{0x30,0x00}, //0011 00s
|
||
|
|
{0x26,0x00}, //0010 011s
|
||
|
|
{0x24,0x00}, //0010 010s
|
||
|
|
{0x22,0x00}, //0010 001s
|
||
|
|
{0x20,0x00}, //0010 000s
|
||
|
|
{0x1A,0x00}, //0001 1010s
|
||
|
|
{0x19,0x00}, //0001 1001s
|
||
|
|
{0x18,0x00}, //0001 1000s
|
||
|
|
{0x17,0x00}, //0001 0111s
|
||
|
|
{0x16,0x00}, //0001 0110s
|
||
|
|
{0x15,0x00}, //0001 0101s
|
||
|
|
{0x14,0x00}, //0001 0100s
|
||
|
|
{0x13,0x00}, //0001 0011s
|
||
|
|
{0x0C,0x00}, //0000 1100 0s
|
||
|
|
{0x0B,0x80}, //0000 1011 1s
|
||
|
|
{0x0B,0x00}, //0000 1011 0s
|
||
|
|
{0x0A,0x80}, //0000 1010 1s
|
||
|
|
{0x0A,0x00}, //0000 1010 0s
|
||
|
|
{0x09,0x80}, //0000 1001 1s
|
||
|
|
{0x09,0x00}, //0000 1001 0s
|
||
|
|
{0x08,0x80}, //0000 1000 1s
|
||
|
|
{0x01,0xC0}, //0000 0001 11s
|
||
|
|
{0x01,0x80}, //0000 0001 10s
|
||
|
|
{0x01,0x40}, //0000 0001 01s
|
||
|
|
{0x01,0x00}, //0000 0001 00s
|
||
|
|
{0x04,0x80}, //0000 0100 100s
|
||
|
|
{0x04,0xA0}, //0000 0100 101s
|
||
|
|
{0x04,0xC0}, //0000 0100 110s
|
||
|
|
{0x04,0xE0}, //0000 0100 111s
|
||
|
|
{0x05,0x80}, //0000 0101 1000s
|
||
|
|
{0x05,0x90}, //0000 0101 1001s
|
||
|
|
{0x05,0xA0}, //0000 0101 1010s
|
||
|
|
{0x05,0xB0}, //0000 0101 1011s
|
||
|
|
{0x05,0xC0}, //0000 0101 1100s
|
||
|
|
{0x05,0xD0}, //0000 0101 1101s
|
||
|
|
{0x05,0xE0}, //0000 0101 1110s
|
||
|
|
{0x05,0xF0}, //0000 0101 1111s
|
||
|
|
{0x06,0x00}}; //0000 011 (escape)
|
||
|
|
|
||
|
|
static const WebRtc_UWord8 TCOEF_MASK[103][2] = {{0xC0,0x00}, //10s
|
||
|
|
{0xF0,0x00}, //1111s
|
||
|
|
{0xFC,0x00}, //0101 01s
|
||
|
|
{0xFE,0x00}, //0010 111s
|
||
|
|
{0xFF,0x00}, //0001 1111s
|
||
|
|
{0xFF,0x80}, //0001 0010 1s
|
||
|
|
{0xFF,0x80}, //0001 0010 0s
|
||
|
|
{0xFF,0xC0}, //0000 1000 01s
|
||
|
|
{0xFF,0xC0}, //0000 1000 00s
|
||
|
|
{0xFF,0xE0}, //0000 0000 111s
|
||
|
|
{0xFF,0xE0}, //0000 0000 110s
|
||
|
|
{0xFF,0xE0}, //0000 0100 000s
|
||
|
|
{0xE0,0x00}, //110s
|
||
|
|
{0xFC,0x00}, //0101 00s
|
||
|
|
{0xFF,0x00}, //0001 1110s
|
||
|
|
{0xFF,0xC0}, //0000 0011 11s
|
||
|
|
{0xFF,0xE0}, //0000 0100 001s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0000s
|
||
|
|
{0xF0,0x00}, //1110s
|
||
|
|
{0xFF,0x00}, //0001 1101s
|
||
|
|
{0xFF,0xC0}, //0000 0011 10s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0001s
|
||
|
|
{0xF8,0x00}, //0110 1s
|
||
|
|
{0xFF,0x80}, //0001 0001 1s
|
||
|
|
{0xFF,0xC0}, //0000 0011 01s
|
||
|
|
{0xF8,0x00}, //0110 0s
|
||
|
|
{0xFF,0x80}, //0001 0001 0s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0010s
|
||
|
|
{0xF8,0x00}, //0101 1s
|
||
|
|
{0xFF,0xC0}, //0000 0011 00s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0011s
|
||
|
|
{0xFC,0x00}, //0100 11s
|
||
|
|
{0xFF,0xC0}, //0000 0010 11s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0100s
|
||
|
|
{0xFC,0x00}, //0100 10s
|
||
|
|
{0xFF,0xC0}, //0000 0010 10s
|
||
|
|
{0xFC,0x00}, //0100 01s
|
||
|
|
{0xFF,0xC0}, //0000 0010 01s
|
||
|
|
{0xFC,0x00}, //0100 00s
|
||
|
|
{0xFF,0xC0}, //0000 0010 00s
|
||
|
|
{0xFE,0x00}, //0010 110s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0101s
|
||
|
|
{0xFE,0x00}, //0010 101s
|
||
|
|
{0xFE,0x00}, //0010 100s
|
||
|
|
{0xFF,0x00}, //0001 1100s
|
||
|
|
{0xFF,0x00}, //0001 1011s
|
||
|
|
{0xFF,0x80}, //0001 0000 1s
|
||
|
|
{0xFF,0x80}, //0001 0000 0s
|
||
|
|
{0xFF,0x80}, //0000 1111 1s
|
||
|
|
{0xFF,0x80}, //0000 1111 0s
|
||
|
|
{0xFF,0x80}, //0000 1110 1s
|
||
|
|
{0xFF,0x80}, //0000 1110 0s
|
||
|
|
{0xFF,0x80}, //0000 1101 1s
|
||
|
|
{0xFF,0x80}, //0000 1101 0s
|
||
|
|
{0xFF,0xE0}, //0000 0100 010s
|
||
|
|
{0xFF,0xE0}, //0000 0100 011s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0110s
|
||
|
|
{0xFF,0xF0}, //0000 0101 0111s
|
||
|
|
{0xF0,0x00}, //0111s //last=1 ----
|
||
|
|
{0xFF,0x80}, //0000 1100 1s
|
||
|
|
{0xFF,0xE0}, //0000 0000 101s
|
||
|
|
{0xFC,0x00}, //0011 11s
|
||
|
|
{0xFF,0xE0}, //0000 0000 100s
|
||
|
|
{0xFC,0x00}, //0011 10s
|
||
|
|
{0xFC,0x00}, //0011 01s
|
||
|
|
{0xFC,0x00}, //0011 00s
|
||
|
|
{0xFE,0x00}, //0010 011s
|
||
|
|
{0xFE,0x00}, //0010 010s
|
||
|
|
{0xFE,0x00}, //0010 001s
|
||
|
|
{0xFE,0x00}, //0010 000s
|
||
|
|
{0xFF,0x00}, //0001 1010s
|
||
|
|
{0xFF,0x00}, //0001 1001s
|
||
|
|
{0xFF,0x00}, //0001 1000s
|
||
|
|
{0xFF,0x00}, //0001 0111s
|
||
|
|
{0xFF,0x00}, //0001 0110s
|
||
|
|
{0xFF,0x00}, //0001 0101s
|
||
|
|
{0xFF,0x00}, //0001 0100s
|
||
|
|
{0xFF,0x00}, //0001 0011s
|
||
|
|
{0xFF,0x80}, //0000 1100 0s
|
||
|
|
{0xFF,0x80}, //0000 1011 1s
|
||
|
|
{0xFF,0x80}, //0000 1011 0s
|
||
|
|
{0xFF,0x80}, //0000 1010 1s
|
||
|
|
{0xFF,0x80}, //0000 1010 0s
|
||
|
|
{0xFF,0x80}, //0000 1001 1s
|
||
|
|
{0xFF,0x80}, //0000 1001 0s
|
||
|
|
{0xFF,0x80}, //0000 1000 1s
|
||
|
|
{0xFF,0xC0}, //0000 0001 11s
|
||
|
|
{0xFF,0xC0}, //0000 0001 10s
|
||
|
|
{0xFF,0xC0}, //0000 0001 01s
|
||
|
|
{0xFF,0xC0}, //0000 0001 00s
|
||
|
|
{0xFF,0xE0}, //0000 0100 100s
|
||
|
|
{0xFF,0xE0}, //0000 0100 101s
|
||
|
|
{0xFF,0xE0}, //0000 0100 110s
|
||
|
|
{0xFF,0xE0}, //0000 0100 111s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1000s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1001s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1010s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1011s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1100s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1101s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1110s
|
||
|
|
{0xFF,0xF0}, //0000 0101 1111s
|
||
|
|
{0xFE,0x00}}; //0000 011 (escape)
|
||
|
|
|
||
|
|
static const WebRtc_Word32 TCOEF_SIZE[103] = { 3, 5, 7, 8, 9,10,10,11,11,12,12,12, 4, 7, 9,11,12,13, 5, 9,
|
||
|
|
11,13, 6,10,11, 6,10,13, 6,11,13, 7,11,13, 7,11, 7,11, 7,11,
|
||
|
|
8,13, 8, 8, 9, 9,10,10,10,10,10,10,10,10,12,12,13,13, 5,10,
|
||
|
|
12, 7,12, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,10,10,
|
||
|
|
10,10,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13,13,13,
|
||
|
|
13,13, 8};
|
||
|
|
|
||
|
|
static const char TCOEF_LAST[103] = {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,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,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,
|
||
|
|
1,1,1,1,1,1,1,1,1,1, 1,1,0};
|
||
|
|
|
||
|
|
// --------------------------------------
|
||
|
|
// --------------------------------------
|
||
|
|
// --------------------------------------
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Info::CalculateMBOffset(const WebRtc_UWord8 numOfGOB) const
|
||
|
|
{
|
||
|
|
// calculate the number of MBs before this GOB
|
||
|
|
|
||
|
|
// sanity
|
||
|
|
if( numOfGOBs < numOfGOB)
|
||
|
|
{
|
||
|
|
assert(false);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
WebRtc_Word32 numMBs = 0;
|
||
|
|
for(WebRtc_UWord8 GOB = 0; GOB< numOfGOB; GOB++)
|
||
|
|
{
|
||
|
|
numMBs += ptrNumOfMBs[GOB];
|
||
|
|
}
|
||
|
|
return numMBs;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
H263Information::H263Information()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
H263Information::~H263Information()
|
||
|
|
{
|
||
|
|
_infoMB.bufferSize = 0;
|
||
|
|
if (_infoMB.ptrBuffer)
|
||
|
|
{
|
||
|
|
delete [] _infoMB.ptrBuffer;
|
||
|
|
delete [] _infoMB.ptrBufferHMV;
|
||
|
|
delete [] _infoMB.ptrBufferVMV;
|
||
|
|
_infoMB.ptrBuffer = 0;
|
||
|
|
_infoMB.ptrBufferHMV = 0;
|
||
|
|
_infoMB.ptrBufferVMV = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
H263Information::Reset()
|
||
|
|
{
|
||
|
|
_info.uiH263PTypeFmt = 0;
|
||
|
|
_info.codecBits = 0;
|
||
|
|
_info.pQuant = 0;
|
||
|
|
_info.numOfGOBs = 0;
|
||
|
|
_info.cpmBit = 0;
|
||
|
|
_info.fType = 0;
|
||
|
|
|
||
|
|
memset(_info.ptrGOBbuffer, 0, sizeof(_info.ptrGOBbuffer));
|
||
|
|
memset(_info.ptrGOBbufferSBit, 0, sizeof(_info.ptrGOBbufferSBit));
|
||
|
|
memset(_info.ptrGQuant, 0, sizeof(_info.ptrGQuant));
|
||
|
|
memset(_info.ptrNumOfMBs, 0, sizeof(_info.ptrNumOfMBs));
|
||
|
|
memset(_info.ptrGroupNum, 0, sizeof(_info.ptrGroupNum));
|
||
|
|
|
||
|
|
if (_infoMB.ptrBuffer)
|
||
|
|
{
|
||
|
|
memset(_infoMB.ptrBuffer, 0, sizeof(WebRtc_UWord32) * _infoMB.bufferSize);
|
||
|
|
memset(_infoMB.ptrBufferHMV, 0, sizeof(WebRtc_UWord8) * _infoMB.bufferSize);
|
||
|
|
memset(_infoMB.ptrBufferVMV, 0, sizeof(WebRtc_UWord8) * _infoMB.bufferSize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* WebRtc_Word32 GetInfo(const WebRtc_UWord8* ptrEncodedBuffer,
|
||
|
|
* const WebRtc_UWord32 length,
|
||
|
|
* const H263Info*& ptrInfo);
|
||
|
|
*
|
||
|
|
* Gets information from an encoded stream.
|
||
|
|
*
|
||
|
|
* Input:
|
||
|
|
* - ptrEncodedBuffer : Pointer to encoded stream.
|
||
|
|
* - length : Length in bytes of encoded stream.
|
||
|
|
*
|
||
|
|
* Output:
|
||
|
|
* - ptrInfo : Pointer to struct with H263 info.
|
||
|
|
*
|
||
|
|
* Return value:
|
||
|
|
* - 0 : ok
|
||
|
|
* - (-1) : Error
|
||
|
|
*/
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::GetInfo(const WebRtc_UWord8* ptrEncodedBuffer,
|
||
|
|
const WebRtc_UWord32 length,
|
||
|
|
const H263Info*& ptrInfo)
|
||
|
|
{
|
||
|
|
if (!ptrEncodedBuffer || length < 8)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!HasInfo(length))
|
||
|
|
{
|
||
|
|
if (-1 == FindInfo(ptrEncodedBuffer, length))
|
||
|
|
{
|
||
|
|
Reset();
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ptrInfo = &_info;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
RtpVideoCodecTypes
|
||
|
|
H263Information::Type()
|
||
|
|
{
|
||
|
|
return kRtpH263Video;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* WebRtc_Word32 GetMBInfo(const WebRtc_UWord8* ptrEncodedBuffer,
|
||
|
|
* const WebRtc_UWord32 length,
|
||
|
|
* WebRtc_Word32 numOfGOB,
|
||
|
|
* const H263MBInfo*& ptrInfoMB);
|
||
|
|
*
|
||
|
|
* Gets macroblock positions for a GOB.
|
||
|
|
* Also, the horizontal and vertical motion vector for each MB are returned.
|
||
|
|
*
|
||
|
|
* Input:
|
||
|
|
* - ptrEncodedBuffer : Pointer to encoded stream.
|
||
|
|
* - length : Length in bytes of encoded stream.
|
||
|
|
* - numOfGOB : Group number of current GOB.
|
||
|
|
*
|
||
|
|
* Output:
|
||
|
|
* - infoMB : Pointer to struct with MB positions in bits for a GOB.
|
||
|
|
* Horizontal and vertical motion vector for each MB.
|
||
|
|
*
|
||
|
|
* Return value:
|
||
|
|
* - 0 : ok
|
||
|
|
* - (-1) : Error
|
||
|
|
*/
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::GetMBInfo(const WebRtc_UWord8* ptrEncodedBuffer,
|
||
|
|
const WebRtc_UWord32 length,
|
||
|
|
const WebRtc_UWord8 numOfGOB,
|
||
|
|
const H263MBInfo*& ptrInfoMB)
|
||
|
|
{
|
||
|
|
if (!ptrEncodedBuffer || numOfGOB > _info.numOfGOBs - 1)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (-1 == VerifyAndAllocateMB())
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (length != _info.ptrGOBbuffer[_info.numOfGOBs])
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (!HasMBInfo(numOfGOB))
|
||
|
|
{
|
||
|
|
if (-1 == FindMBs(ptrEncodedBuffer, numOfGOB, length))
|
||
|
|
{
|
||
|
|
Reset();
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ptrInfoMB = &_infoMB;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool
|
||
|
|
H263Information::HasInfo(const WebRtc_UWord32 length)
|
||
|
|
{
|
||
|
|
if (!_info.ptrGOBbuffer)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (_info.ptrGOBbuffer[0] == 0)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// has info, make sure current length matches info length
|
||
|
|
if (length != _info.ptrGOBbuffer[_info.numOfGOBs - 1])
|
||
|
|
{
|
||
|
|
Reset();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindInfo(const WebRtc_UWord8* ptrEncodedBuffer,
|
||
|
|
const WebRtc_UWord32 length)
|
||
|
|
{
|
||
|
|
_ptrData = ptrEncodedBuffer;
|
||
|
|
|
||
|
|
if (!PictureStartCode())
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Gets picture size
|
||
|
|
if (-1 == FindPTypeFMT())
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
FindFType();
|
||
|
|
FindCodecBits();
|
||
|
|
FindPQUANT();
|
||
|
|
FindCPMbit();
|
||
|
|
|
||
|
|
if (-1 == FindGOBs(length))
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (-1 == SetNumOfMBs())
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::SetNumOfMBs()
|
||
|
|
{
|
||
|
|
// Source format: 000 - forbidden
|
||
|
|
// 001 - SQCIF 1 GOB - one macroblock row
|
||
|
|
// 010 - QCIF 1 GOB - one macroblock row
|
||
|
|
// 011 - CIF 1 GOB - one macroblock row
|
||
|
|
// 100 - 4CIF 1 GOB - two macroblock rows
|
||
|
|
// 101 - 16CIF 1 GOB - four macroblock rows
|
||
|
|
// 110 - reserved
|
||
|
|
// 111 - extended PTYPE
|
||
|
|
|
||
|
|
WebRtc_UWord16 numOfMBsPerGOB = 0;
|
||
|
|
|
||
|
|
switch (_info.uiH263PTypeFmt)
|
||
|
|
{
|
||
|
|
case 1: // SQCIF
|
||
|
|
numOfMBsPerGOB = 8;
|
||
|
|
_info.totalNumOfMBs = 8 * 6; //128x96
|
||
|
|
break;
|
||
|
|
case 2: // QCIF
|
||
|
|
numOfMBsPerGOB = 11;
|
||
|
|
_info.totalNumOfMBs = 11 * 9;
|
||
|
|
break;
|
||
|
|
case 3: // CIF
|
||
|
|
numOfMBsPerGOB = 22;
|
||
|
|
_info.totalNumOfMBs = 22 * 18;
|
||
|
|
break;
|
||
|
|
case 4: // 4CIF
|
||
|
|
numOfMBsPerGOB = 88;
|
||
|
|
_info.totalNumOfMBs = 88 * 18;
|
||
|
|
break;
|
||
|
|
case 5: // 16CIF
|
||
|
|
numOfMBsPerGOB = 352;
|
||
|
|
_info.totalNumOfMBs = 352 * 18;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// loop through all GOBs
|
||
|
|
WebRtc_UWord16 numberOfMBs = 0;
|
||
|
|
for(WebRtc_UWord8 GOB = 0; GOB < (_info.numOfGOBs -1); GOB++)
|
||
|
|
{
|
||
|
|
_info.ptrNumOfMBs[GOB] = numOfMBsPerGOB * (_info.ptrGroupNum[GOB+1] - _info.ptrGroupNum[GOB]);
|
||
|
|
numberOfMBs += _info.ptrNumOfMBs[GOB];
|
||
|
|
}
|
||
|
|
_info.ptrNumOfMBs[_info.numOfGOBs -1] = _info.totalNumOfMBs - numberOfMBs;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool
|
||
|
|
H263Information::PictureStartCode()
|
||
|
|
{
|
||
|
|
// Picture start code (PSC) (22 bits)
|
||
|
|
// ----0--------1-------2----
|
||
|
|
// |00000000|00000000|100000xx|
|
||
|
|
// --------------------------
|
||
|
|
|
||
|
|
if ( _ptrData[0] == 0 &&
|
||
|
|
_ptrData[1] == 0 &&
|
||
|
|
(_ptrData[2] & 0x80) &&
|
||
|
|
(_ptrData[2] & 0x7C) == 0)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindPTypeFMT()
|
||
|
|
{
|
||
|
|
// Type Information (PTYPE) (Variable Length)(8/13 bits)
|
||
|
|
// ----3--------4--------5---
|
||
|
|
// |xxxxxxPP|PPPPPPpp|pppxxxxx|
|
||
|
|
// --------------------------
|
||
|
|
|
||
|
|
// Source format (bits 6-8)
|
||
|
|
_info.uiH263PTypeFmt = (_ptrData[4] >> 2) & 0x07;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
H263Information::FindFType()
|
||
|
|
{
|
||
|
|
// Type Information (PTYPE) (13 bits, source format != 111, not extended PTYPE)
|
||
|
|
// ----3--------4--------5---
|
||
|
|
// |xxxxxxPP|PPPPPPPP|PPPxxxxx|
|
||
|
|
// --------------------------
|
||
|
|
|
||
|
|
// Picture coding type (bit 9)
|
||
|
|
_info.fType = (_ptrData[4] & 0x02) >> 1; // 0 = I-frame, 1 = P-frame
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
H263Information::FindCodecBits()
|
||
|
|
{
|
||
|
|
// Type Information (PTYPE) (13 bits)
|
||
|
|
// ----3--------4--------5---
|
||
|
|
// |xxxxxxPP|PPPPPPPP|PPPxxxxx|
|
||
|
|
// --------------------------
|
||
|
|
|
||
|
|
// Bits 9-12 // bit 10: Unrestricted Motion Vector mode (annex D) 0-off, 1-on
|
||
|
|
_info.codecBits = (_ptrData[4] & 0x03) << 2; // bit 11: Syntax-based Arithmetic Coding mode (annex E)
|
||
|
|
_info.codecBits += (_ptrData[5] & 0xC0) >> 6; // bit 12: Advanced Prediction mode (annex F)
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
H263Information::FindPQUANT()
|
||
|
|
{
|
||
|
|
// Quantizer Information (PQUANT) (5 bits)
|
||
|
|
// ----5---
|
||
|
|
// |xxxQQQQQ|
|
||
|
|
// --------
|
||
|
|
|
||
|
|
_info.pQuant = _ptrData[5] & 0x1F;
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
H263Information::FindCPMbit()
|
||
|
|
{
|
||
|
|
// Continuous presence multipoWebRtc_Word32 and Video multiplex (CPM) (1 bit)
|
||
|
|
// ----6---
|
||
|
|
// |Cxxxxxxx|
|
||
|
|
// --------
|
||
|
|
|
||
|
|
_info.cpmBit = IsBitOne(48); // 0-off, 1-on
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindGOBs(const WebRtc_UWord32 length)
|
||
|
|
{
|
||
|
|
// Group of block layer (GOB).
|
||
|
|
// GOB header followed by data for (one or more rows) of macroblocks.
|
||
|
|
|
||
|
|
// Stuffing (GSTUF) (Variable length) consisting of less than 8 zero-bits. May be
|
||
|
|
// inserted by encoders so that the start of the GBSC is byte aligned.
|
||
|
|
// Group of block start code (GBSC) (17 bits). May be byte aligned.
|
||
|
|
// Group Number (GN) (5 bits). Group numbers 1-17 used for standard picture formats.
|
||
|
|
// 0 used in PSC.
|
||
|
|
// --------------------------------
|
||
|
|
// |GSTUF|00000000|00000000|1GGGGGxx|
|
||
|
|
// --------------------------------
|
||
|
|
|
||
|
|
WebRtc_UWord8 numOfGOB = 0;
|
||
|
|
WebRtc_UWord8 groupNum = 0;
|
||
|
|
WebRtc_UWord8 sBit = 0;
|
||
|
|
|
||
|
|
_info.ptrGroupNum[numOfGOB] = 0;
|
||
|
|
_info.ptrGOBbuffer[numOfGOB] = 0;
|
||
|
|
_info.ptrGOBbufferSBit[numOfGOB] = 0;
|
||
|
|
numOfGOB++;
|
||
|
|
|
||
|
|
for (WebRtc_UWord32 i = 3; (i < length - 2); i++)
|
||
|
|
{
|
||
|
|
if (_ptrData[i] == 0)
|
||
|
|
{
|
||
|
|
if (_ptrData[i + 1] == 0)
|
||
|
|
{
|
||
|
|
if (_ptrData[i + 2] & 0x80)
|
||
|
|
{
|
||
|
|
// GBSC byte aligned
|
||
|
|
groupNum = (_ptrData[i + 2] >> 2) & 0x1f;
|
||
|
|
_info.ptrGroupNum[numOfGOB] = groupNum;
|
||
|
|
_info.ptrGOBbuffer[numOfGOB] = i;
|
||
|
|
_info.ptrGOBbufferSBit[numOfGOB] = 0;
|
||
|
|
numOfGOB++;
|
||
|
|
}
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
// check for non byte aligned GBSC
|
||
|
|
if ((_ptrData[i - 1] & 0x7F) == 0 && (_ptrData[i + 1] & 0xC0) == 0x40)
|
||
|
|
{
|
||
|
|
// |x0000000|00000000|01GGGGGx|
|
||
|
|
sBit = 1;
|
||
|
|
groupNum = (_ptrData[i + 1] >> 1) & 0x1f;
|
||
|
|
}
|
||
|
|
else if ((_ptrData[i - 1] & 0x3F) == 0 && (_ptrData[i + 1] & 0xE0) == 0x20)
|
||
|
|
{
|
||
|
|
// |xx000000|00000000|001GGGGG|
|
||
|
|
sBit = 2;
|
||
|
|
groupNum = (_ptrData[i + 1]) & 0x1f;
|
||
|
|
}
|
||
|
|
else if ((_ptrData[i - 1] & 0x1F) == 0 && (_ptrData[i + 1] & 0xF0) == 0x10)
|
||
|
|
{
|
||
|
|
// |xxx00000|00000000|0001GGGG|G
|
||
|
|
sBit = 3;
|
||
|
|
groupNum = ((_ptrData[i + 1] & 0x0F) << 1) | ((_ptrData[i + 2] >> 7) & 0x01);
|
||
|
|
}
|
||
|
|
else if ((_ptrData[i - 1] & 0x0F) == 0 && (_ptrData[i + 1] & 0xF8) == 0x08)
|
||
|
|
{
|
||
|
|
// |xxxx0000|00000000|00001GGG|GG
|
||
|
|
sBit = 4;
|
||
|
|
groupNum = ((_ptrData[i + 1] & 0x07) << 2) | ((_ptrData[i + 2] >> 6) & 0x03);
|
||
|
|
}
|
||
|
|
else if ((_ptrData[i - 1] & 0x07) == 0 && (_ptrData[i + 1] & 0xFC) == 0x04)
|
||
|
|
{
|
||
|
|
// |xxxxx000|00000000|000001GG|GGG
|
||
|
|
sBit = 5;
|
||
|
|
groupNum = ((_ptrData[i + 1] & 0x03) << 3) | ((_ptrData[i + 2] >> 5) & 0x07);
|
||
|
|
}
|
||
|
|
else if ((_ptrData[i - 1] & 0x03) == 0 && (_ptrData[i + 1] & 0xFE) == 0x02)
|
||
|
|
{
|
||
|
|
// |xxxxxx00|00000000|0000001G|GGGG
|
||
|
|
sBit = 6;
|
||
|
|
groupNum = ((_ptrData[i + 1] & 0x01) << 4) | ((_ptrData[i + 2] >> 4) & 0x0F);
|
||
|
|
}
|
||
|
|
else if ((_ptrData[i - 1] & 0x01) == 0 && _ptrData[i + 1] == 0x01)
|
||
|
|
{
|
||
|
|
// |xxxxxxx0|00000000|00000001|GGGGG
|
||
|
|
sBit = 7;
|
||
|
|
groupNum = (_ptrData[i + 2] >> 3) & 0x1f;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sBit = 0;
|
||
|
|
groupNum = 0;
|
||
|
|
}
|
||
|
|
if (sBit)
|
||
|
|
{
|
||
|
|
_info.ptrGroupNum[numOfGOB] = groupNum;
|
||
|
|
_info.ptrGOBbuffer[numOfGOB] = i - 1;
|
||
|
|
_info.ptrGOBbufferSBit[numOfGOB] = sBit;
|
||
|
|
numOfGOB++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(numOfGOB >= MAX_NUMBER_OF_H263_GOB)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_info.numOfGOBs = numOfGOB;
|
||
|
|
_info.ptrGOBbuffer[numOfGOB] = length;
|
||
|
|
_info.ptrGOBbufferSBit[numOfGOB] = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::VerifyAndAllocateMB()
|
||
|
|
{
|
||
|
|
WebRtc_UWord32 minimumSize = _info.totalNumOfMBs;
|
||
|
|
if (minimumSize == 0)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (minimumSize > _infoMB.bufferSize)
|
||
|
|
{
|
||
|
|
// make sure that our buffer is big enough
|
||
|
|
if (_infoMB.ptrBuffer)
|
||
|
|
{
|
||
|
|
delete [] _infoMB.ptrBuffer;
|
||
|
|
delete [] _infoMB.ptrBufferHMV;
|
||
|
|
delete [] _infoMB.ptrBufferVMV;
|
||
|
|
}
|
||
|
|
_infoMB.ptrBuffer = new WebRtc_UWord32[minimumSize];
|
||
|
|
_infoMB.ptrBufferHMV = new WebRtc_UWord8[minimumSize];
|
||
|
|
_infoMB.ptrBufferVMV = new WebRtc_UWord8[minimumSize];
|
||
|
|
_infoMB.bufferSize = minimumSize;
|
||
|
|
|
||
|
|
// reset memory
|
||
|
|
memset(_infoMB.ptrBuffer, 0, sizeof(WebRtc_UWord32) * _infoMB.bufferSize);
|
||
|
|
memset(_infoMB.ptrBufferHMV, 0, sizeof(WebRtc_UWord8) * _infoMB.bufferSize);
|
||
|
|
memset(_infoMB.ptrBufferVMV, 0, sizeof(WebRtc_UWord8) * _infoMB.bufferSize);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool
|
||
|
|
H263Information::HasMBInfo(const WebRtc_UWord8 numOfGOB)
|
||
|
|
{
|
||
|
|
if (!_infoMB.ptrBuffer)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32 offset = _info.CalculateMBOffset(numOfGOB);
|
||
|
|
|
||
|
|
if (_infoMB.ptrBuffer[offset] == 0)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindMBs(const WebRtc_UWord8 *ptrEncodedBuffer,
|
||
|
|
const WebRtc_UWord8 numOfGOB,
|
||
|
|
const WebRtc_UWord32 length)
|
||
|
|
{
|
||
|
|
_bitCnt = 0;
|
||
|
|
WebRtc_Word32 bitCntOffset = 0;
|
||
|
|
_ptrData = ptrEncodedBuffer;
|
||
|
|
WebRtc_UWord32 payloadBytesToSend = length;
|
||
|
|
|
||
|
|
if (numOfGOB > 0)
|
||
|
|
{
|
||
|
|
// Point at current GOB
|
||
|
|
_ptrData += _info.ptrGOBbuffer[numOfGOB ];
|
||
|
|
payloadBytesToSend -= _info.ptrGOBbuffer[numOfGOB];
|
||
|
|
// Start bits to ignore
|
||
|
|
_bitCnt += _info.ptrGOBbufferSBit[numOfGOB];
|
||
|
|
// Byte with start bits has already been sent, start counting from next byte
|
||
|
|
if (_info.ptrGOBbufferSBit[numOfGOB])
|
||
|
|
{
|
||
|
|
bitCntOffset = 8;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32 offset = _info.CalculateMBOffset(numOfGOB);
|
||
|
|
WebRtc_UWord32 *sizeOfMBs = &_infoMB.ptrBuffer[offset];
|
||
|
|
WebRtc_UWord8 *hmv1 = &_infoMB.ptrBufferHMV[offset];
|
||
|
|
WebRtc_UWord8 *vmv1 = &_infoMB.ptrBufferVMV[offset];
|
||
|
|
|
||
|
|
// Header data
|
||
|
|
if (numOfGOB == 0)
|
||
|
|
{
|
||
|
|
// Picture layer
|
||
|
|
// -----------------------
|
||
|
|
// | Picture header | GOBs | // For GOB number 0, empty GOB header
|
||
|
|
// -----------------------
|
||
|
|
|
||
|
|
_bitCnt = 49;
|
||
|
|
if (_info.cpmBit)
|
||
|
|
{
|
||
|
|
_bitCnt += 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32 peiBit = IsBitOne(_bitCnt);
|
||
|
|
_bitCnt++;
|
||
|
|
if (peiBit)
|
||
|
|
{
|
||
|
|
_bitCnt += 8;
|
||
|
|
peiBit = IsBitOne(_bitCnt);
|
||
|
|
_bitCnt++;
|
||
|
|
if (peiBit)
|
||
|
|
{
|
||
|
|
_bitCnt += 9;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (numOfGOB < _info.numOfGOBs)
|
||
|
|
{
|
||
|
|
// Group of block layer (GOB).
|
||
|
|
// Group of block start code (GBSC) (17 bits).
|
||
|
|
// Group Number (GN) (5 bits).
|
||
|
|
// GOB Sub-Stream Indicator (GSBI) (2 bits). Only present if CPM = 1.
|
||
|
|
// GOB Frame ID (GFID) (2 bits).
|
||
|
|
// Quantizer Information (GQUANT) (5 bits).
|
||
|
|
// ----------------------------------------------------
|
||
|
|
// | GBSC | GN | GSBI | GFID | GQUANT | Macroblock data |
|
||
|
|
// ----------------------------------------------------
|
||
|
|
|
||
|
|
_bitCnt += 24;
|
||
|
|
if (_info.cpmBit)
|
||
|
|
{
|
||
|
|
_bitCnt += 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
FindGQUANT(numOfGOB);
|
||
|
|
|
||
|
|
_bitCnt += 5;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Start of macroblock data
|
||
|
|
// -----------------------
|
||
|
|
// | MB header | blockdata |
|
||
|
|
// -----------------------
|
||
|
|
for (WebRtc_Word32 j = 0; j < _info.ptrNumOfMBs[numOfGOB]; j++)
|
||
|
|
{
|
||
|
|
// MB header
|
||
|
|
// ------------------------------------------------
|
||
|
|
// | COD(inter) | MCBPC | CBPY | DQUANT |MVD(inter) |
|
||
|
|
// ------------------------------------------------
|
||
|
|
WebRtc_Word32 codBit = 0;
|
||
|
|
if (_info.fType)
|
||
|
|
{
|
||
|
|
codBit = IsBitOne(_bitCnt);
|
||
|
|
_bitCnt++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (codBit == 0) // if codBit == 1, no further info transmitted for this MB
|
||
|
|
{
|
||
|
|
WebRtc_Word32 mbType = 0;
|
||
|
|
char cbp[6];
|
||
|
|
|
||
|
|
// Get MB type & coded block pattern for chrominance (MCBPC)
|
||
|
|
WebRtc_Word32 size = FindMCBPC(mbType, cbp);
|
||
|
|
|
||
|
|
_bitCnt += size;
|
||
|
|
|
||
|
|
if (size == -1)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get coded block pattern for luminance (CBPY)
|
||
|
|
size = FindCBPY(mbType, cbp);
|
||
|
|
|
||
|
|
_bitCnt += size;
|
||
|
|
|
||
|
|
if (size == -1)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Quantizer information (DQUANT), change in QUANT
|
||
|
|
if (mbType == 1 || mbType == 4)
|
||
|
|
{
|
||
|
|
_bitCnt += 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get motion vector data (MVD) (inter-frames)
|
||
|
|
if (_info.fType && (mbType < 3 || mbType == 5))
|
||
|
|
{
|
||
|
|
// Horizontal and vertical component
|
||
|
|
for (WebRtc_Word32 k = 0; k < 2; k++)
|
||
|
|
{
|
||
|
|
size = FindMVD(j, k, hmv1, vmv1);
|
||
|
|
|
||
|
|
_bitCnt += size;
|
||
|
|
|
||
|
|
if (size == -1)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Block data. 1MB = 6 blocks (4 luminance blocks + 2 color blocks)
|
||
|
|
// -----------------
|
||
|
|
// | intraDC | TCOEF |
|
||
|
|
// -----------------
|
||
|
|
WebRtc_Word32 numOfBlocks = 6;
|
||
|
|
|
||
|
|
WebRtc_Word32 WebRtc_Word32raDC = 0;
|
||
|
|
if (mbType == 3 || mbType == 4)
|
||
|
|
{
|
||
|
|
WebRtc_Word32raDC = 8;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (WebRtc_Word32 i = 0; i < numOfBlocks; i++)
|
||
|
|
{
|
||
|
|
// Get WebRtc_Word32raDC coefficient
|
||
|
|
_bitCnt += WebRtc_Word32raDC;
|
||
|
|
|
||
|
|
// Get non-WebRtc_Word32RA dc coefficients
|
||
|
|
if (cbp[i]) // presence indicated by CBPY and CBPC
|
||
|
|
{
|
||
|
|
WebRtc_Word32 last = 0;
|
||
|
|
while (last == 0)
|
||
|
|
{
|
||
|
|
// Get transform coefficient (TCOEF)
|
||
|
|
size = FindTCOEF(last);
|
||
|
|
|
||
|
|
_bitCnt += size;
|
||
|
|
|
||
|
|
if (size == -1)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// end of MB
|
||
|
|
sizeOfMBs[j] = _bitCnt - bitCntOffset;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// end of MB
|
||
|
|
sizeOfMBs[j] = _bitCnt - bitCntOffset;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// end of MBs
|
||
|
|
WebRtc_Word32 nextByte = _bitCnt >> 3;
|
||
|
|
WebRtc_Word32 nextByteRem = _bitCnt % 8;
|
||
|
|
if (nextByteRem)
|
||
|
|
{
|
||
|
|
nextByte++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for next GOB/end of picture
|
||
|
|
if (numOfGOB < (_info.numOfGOBs - 1))
|
||
|
|
{
|
||
|
|
// Test with GSTUF, GBSC (0000 0000 0000 0000 1)
|
||
|
|
if (_ptrData[nextByte] == 0 &&
|
||
|
|
_ptrData[nextByte + 1] == 0 &&
|
||
|
|
_ptrData[nextByte + 2] & 0x80)
|
||
|
|
{
|
||
|
|
sizeOfMBs[_info.ptrNumOfMBs[numOfGOB] - 1] = (nextByte << 3) - bitCntOffset;
|
||
|
|
return 1; // ok, next GOB
|
||
|
|
}
|
||
|
|
// ...without GSTUF
|
||
|
|
if (IsGBSC())
|
||
|
|
{
|
||
|
|
return 1; // ok, next GOB
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (numOfGOB == (_info.numOfGOBs - 1))
|
||
|
|
{
|
||
|
|
// Picture end code may be included, (PSTUF (optional), EOS (22bits), ESTUF)
|
||
|
|
if (((WebRtc_UWord32) nextByte == payloadBytesToSend) ||
|
||
|
|
((WebRtc_UWord32)(nextByte + 2) == payloadBytesToSend) ||
|
||
|
|
((WebRtc_UWord32)(nextByte + 3) == payloadBytesToSend))
|
||
|
|
{
|
||
|
|
sizeOfMBs[_info.ptrNumOfMBs[numOfGOB] - 1] = (payloadBytesToSend << 3) - bitCntOffset;
|
||
|
|
return 1; // ok, end of picture layer
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindMCBPC(WebRtc_Word32 &mbType, char *cbp)
|
||
|
|
{
|
||
|
|
if (_info.fType == 0) // intra frame
|
||
|
|
{
|
||
|
|
ByteAlignData(MCBPC_I_MAX_CODE_LENGTH);
|
||
|
|
|
||
|
|
WebRtc_Word32 i;
|
||
|
|
for (i = 0; i < MCBPC_I_TABLE_LENGTH - 1; i++)
|
||
|
|
{
|
||
|
|
if ((_dataShifted[0] & MCBPC_I_MASK[i][0]) == MCBPC_I_CODE[i][0])
|
||
|
|
{
|
||
|
|
cbp[4] = MCBPC_I_CBPC[i][0];
|
||
|
|
cbp[5] = MCBPC_I_CBPC[i][1];
|
||
|
|
mbType = MCBPC_I_MBTYPE[i];
|
||
|
|
|
||
|
|
return MCBPC_I_SIZE[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// last row
|
||
|
|
i = MCBPC_I_TABLE_LENGTH - 1;
|
||
|
|
if ((_dataShifted[0] & MCBPC_I_MASK[i][0]) == MCBPC_I_CODE[i][0] &&
|
||
|
|
(_dataShifted[1] & MCBPC_I_MASK[i][1]) == MCBPC_I_CODE[i][1])
|
||
|
|
{
|
||
|
|
cbp[4] = MCBPC_I_CBPC[i][0];
|
||
|
|
cbp[5] = MCBPC_I_CBPC[i][1];
|
||
|
|
mbType = MCBPC_I_MBTYPE[i];
|
||
|
|
|
||
|
|
return MCBPC_I_SIZE[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
else // inter frame
|
||
|
|
{
|
||
|
|
ByteAlignData(MCBPC_P_MAX_CODE_LENGTH);
|
||
|
|
|
||
|
|
for (WebRtc_Word32 i = 0; i < MCBPC_P_TABLE_LENGTH; i++)
|
||
|
|
{
|
||
|
|
if ((_dataShifted[0] & MCBPC_P_MASK[i][0]) == MCBPC_P_CODE[i][0] &&
|
||
|
|
(_dataShifted[1] & MCBPC_P_MASK[i][1]) == MCBPC_P_CODE[i][1])
|
||
|
|
{
|
||
|
|
cbp[4] = MCBPC_P_CBPC[i][0];
|
||
|
|
cbp[5] = MCBPC_P_CBPC[i][1];
|
||
|
|
mbType = MCBPC_P_MBTYPE[i];
|
||
|
|
|
||
|
|
return MCBPC_P_SIZE[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindCBPY(WebRtc_Word32 mbType, char *cbp)
|
||
|
|
{
|
||
|
|
ByteAlignData(CBPY_MAX_CODE_LENGTH);
|
||
|
|
|
||
|
|
for (WebRtc_Word32 i = 0; i < CBPY_TABLE_LENGTH; i++)
|
||
|
|
{
|
||
|
|
if ((_dataShifted[0] & CBPY_MASK[i][0]) == CBPY_CODE[i][0])
|
||
|
|
{
|
||
|
|
cbp[0] = CBPY_CBPY[i][0];
|
||
|
|
cbp[1] = CBPY_CBPY[i][1];
|
||
|
|
cbp[2] = CBPY_CBPY[i][2];
|
||
|
|
cbp[3] = CBPY_CBPY[i][3];
|
||
|
|
|
||
|
|
if (mbType == 0 || mbType == 1)
|
||
|
|
{
|
||
|
|
for (WebRtc_Word32 k = 0; k < 4; k++)
|
||
|
|
{
|
||
|
|
if (cbp[k])
|
||
|
|
{
|
||
|
|
cbp[k] = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
cbp[k] = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return CBPY_SIZE[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindMVD(WebRtc_Word32 numOfMB, WebRtc_Word32 verORhor, WebRtc_UWord8 *hmv1, WebRtc_UWord8 *vmv1)
|
||
|
|
{
|
||
|
|
ByteAlignData(MVD_MAX_CODE_LENGTH);
|
||
|
|
|
||
|
|
for (WebRtc_Word32 i = 0; i < MVD_TABLE_LENGTH; i++)
|
||
|
|
{
|
||
|
|
if ((_dataShifted[0] & MVD_MASK[i][0]) == MVD_CODE[i][0] &&
|
||
|
|
(_dataShifted[1] & MVD_MASK[i][1]) == MVD_CODE[i][1])
|
||
|
|
{
|
||
|
|
// Store horizontal/vertical motion vector predictor (2's complement number)
|
||
|
|
WebRtc_Word32 index = i - 32;
|
||
|
|
if (index < 0)
|
||
|
|
{
|
||
|
|
index = ~ (-index-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (verORhor == 0)
|
||
|
|
{
|
||
|
|
hmv1[numOfMB] = static_cast<WebRtc_UWord8>(index);
|
||
|
|
|
||
|
|
} else
|
||
|
|
{
|
||
|
|
vmv1[numOfMB] = static_cast<WebRtc_UWord8>(index);
|
||
|
|
}
|
||
|
|
|
||
|
|
return MVD_SIZE[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_Word32
|
||
|
|
H263Information::FindTCOEF(WebRtc_Word32 &last)
|
||
|
|
{
|
||
|
|
ByteAlignData(TCOEF_MAX_CODE_LENGTH);
|
||
|
|
|
||
|
|
for (WebRtc_Word32 i = 0; i < TCOEF_TABLE_LENGTH; i++)
|
||
|
|
{
|
||
|
|
if ((_dataShifted[0] & TCOEF_MASK[i][0]) == TCOEF_CODE[i][0] &&
|
||
|
|
(_dataShifted[1] & TCOEF_MASK[i][1]) == TCOEF_CODE[i][1])
|
||
|
|
{
|
||
|
|
last = TCOEF_LAST[i];
|
||
|
|
if (i == (TCOEF_TABLE_LENGTH - 1))
|
||
|
|
{
|
||
|
|
if (IsBitOne(_bitCnt + 7))
|
||
|
|
{
|
||
|
|
last = 1;
|
||
|
|
}
|
||
|
|
return 22;
|
||
|
|
}
|
||
|
|
return TCOEF_SIZE[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool
|
||
|
|
H263Information::IsGBSC()
|
||
|
|
{
|
||
|
|
// Group of block layer (GOB).
|
||
|
|
// Stuffing (GSTUF) (Variable length) consisting of less than 8 zero-bits. May be
|
||
|
|
// inserted by encoders so that the start of the GBSC is byte aligned.
|
||
|
|
// Group of block start code (GBSC) (17 bits). May be byte aligned.
|
||
|
|
// Group Number (GN) (5 bits). Group numbers 1-17 used for standard picture formats.
|
||
|
|
// --------------------------------
|
||
|
|
// |GSTUF|00000000|00000000|1GGGGGxx|
|
||
|
|
// --------------------------------
|
||
|
|
|
||
|
|
ByteAlignData(3);
|
||
|
|
|
||
|
|
if (_dataShifted[0] == 0 && _dataShifted[1] == 0 && (_dataShifted[2] & 0x80) == 0x80)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
H263Information::FindGQUANT(WebRtc_Word32 numOfGOB)
|
||
|
|
{
|
||
|
|
ByteAlignData(1);
|
||
|
|
|
||
|
|
_info.ptrGQuant[numOfGOB] = (_dataShifted[0] >> 3) & 0x1F;
|
||
|
|
}
|
||
|
|
|
||
|
|
WebRtc_UWord8
|
||
|
|
H263Information::IsBitOne(const WebRtc_Word32 bitCnt) const
|
||
|
|
{
|
||
|
|
WebRtc_Word32 curByte = bitCnt >> 3;
|
||
|
|
WebRtc_Word32 bit = bitCnt % 8;
|
||
|
|
|
||
|
|
switch(bit)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
return _ptrData[curByte] & 0x80;
|
||
|
|
case 1:
|
||
|
|
return _ptrData[curByte] & 0x40;
|
||
|
|
case 2:
|
||
|
|
return _ptrData[curByte] & 0x20;
|
||
|
|
case 3:
|
||
|
|
return _ptrData[curByte] & 0x10;
|
||
|
|
case 4:
|
||
|
|
return _ptrData[curByte] & 0x08;
|
||
|
|
case 5:
|
||
|
|
return _ptrData[curByte] & 0x04;
|
||
|
|
case 6:
|
||
|
|
return _ptrData[curByte] & 0x02;
|
||
|
|
case 7:
|
||
|
|
return _ptrData[curByte] & 0x01;
|
||
|
|
default:
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
H263Information::ByteAlignData(WebRtc_Word32 numOfBytes)
|
||
|
|
{
|
||
|
|
WebRtc_Word32 sByte = _bitCnt >> 3;
|
||
|
|
WebRtc_Word32 sBit = _bitCnt % 8;
|
||
|
|
|
||
|
|
// Shift to byte align
|
||
|
|
WebRtc_Word32 i = 0;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
_dataShifted[i] = _ptrData[sByte] << sBit;
|
||
|
|
_dataShifted[i++] += _ptrData[++sByte] >> (8 - sBit);
|
||
|
|
} while (i < numOfBytes);
|
||
|
|
}
|
||
|
|
} // namespace webrtc
|