Mirrors
/
psxavenc
mirror of https://github.com/WonderfulToolchain/psxavenc.git
2
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

Fix compile errors and warnings, update readme

This commit is contained in:
spicyjpeg 2023-05-15 18:12:07 +02:00
parent e457d59bb1
commit e31da8a4a6
No known key found for this signature in database
GPG Key ID: 5CC87404C01DF393
6 changed files with 175 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
README.md
View File

@ -1,6 +1,22 @@
# psxavenc # psxavenc
psxavenc is an open-source command-line tool allowing for the encoding of PS1-format audio and video data. psxavenc is an open-source command-line tool for encoding audio and video data
into formats commonly used on the original PlayStation.
## Installation
Requirements:
- a recent version of FFmpeg libraries (`libavformat`, `libavcodec`,
`libavutil`, `libswresample`, `libswscale`);
- a recent version of Meson.
```shell
$ meson setup build
$ cd build
$ ninja install
```
## Usage ## Usage
@ -8,21 +24,49 @@ Run `psxavenc`.
### Examples ### Examples
Converting a sound file to a 22050Hz SPU sample: Rescale a video file to ≤320x240 pixels (preserving aspect ratio) and encode it
into a 15fps .STR file with 37800 Hz 4-bit stereo audio and 2352-byte sectors,
meant to be played at 2x CD-ROM speed:
```shell ```shell
$ psxavenc -f 22050 -t spu -c 1 -b 4 sound_file.ogg sound_file.snd $ psxavenc -t str2cd -f 37800 -b 4 -c 2 -s 320x240 -r 15 -x 2 in.mp4 out.str
``` ```
## Installation Convert a mono audio sample to 22050 Hz raw SPU-ADPCM data:
Requirements:
* a recent version of FFmpeg,
* a recent version of Meson.
```shell ```shell
$ meson setup build $ psxavenc -t spu -f 22050 in.ogg out.snd
$ cd build
$ ninja install
``` ```
Convert a stereo audio file to a 44100 Hz interleaved .VAG file with 8192-byte
interleave and loop flags set at the end of each interleaved chunk:
```shell
$ psxavenc -t vagi -f 44100 -c 2 -L -i 8192 in.wav out.vag
```
## Supported formats
| Format | Audio | Channels | Video | Sector size |
| :------- | :--------------- | :------- | :---- | :---------- |
| `xa` | XA-ADPCM | 1 or 2 | None | 2336 bytes |
| `xacd` | XA-ADPCM | 1 or 2 | None | 2352 bytes |
| `spu` | SPU-ADPCM | 1 | None | |
| `spui` | SPU-ADPCM | Any | None | Any |
| `vag` | SPU-ADPCM | 1 | None | |
| `vagi` | SPU-ADPCM | Any | None | Any |
| `str2` | None or XA-ADPCM | 1 or 2 | BS v2 | 2336 bytes |
| `str2cd` | None or XA-ADPCM | 1 or 2 | BS v2 | 2352 bytes |
| `sbs2` | None | | BS v2 | Any |
Notes:
- `vag` and `vagi` are similar to `spu` and `spui` respectively, but add a .VAG
header at the beginning of the file. The header is always 48 bytes long for
`vag` files, while in the case of `vagi` files it is padded to the size
specified using the `-a` option (2048 bytes by default). Note that `vagi`
files with more than 2 channels and/or alignment other than 2048 bytes are not
standardized.
- The `sbs2` format (used in some System 573 games) is simply a series of
concatenated BS v2 frames, each padded to the size specified by the `-a`
option, with no additional headers besides the BS frame headers.

3
libpsxav/adpcm.c
View File

@ -283,7 +283,7 @@ int psx_audio_xa_encode(psx_audio_xa_settings_t settings, psx_audio_encoder_stat
return (((j + 17) / 18) * xa_sector_size); return (((j + 17) / 18) * xa_sector_size);
} }
int psx_audio_xa_encode_finalize(psx_audio_xa_settings_t settings, uint8_t *output, int output_length) { void psx_audio_xa_encode_finalize(psx_audio_xa_settings_t settings, uint8_t *output, int output_length) {
if (output_length >= 2336) { if (output_length >= 2336) {
output[output_length - 2352 + 0x12] |= 0x80; output[output_length - 2352 + 0x12] |= 0x80;
output[output_length - 2352 + 0x18] |= 0x80; output[output_length - 2352 + 0x18] |= 0x80;
@ -301,7 +301,6 @@ int psx_audio_xa_encode_simple(psx_audio_xa_settings_t settings, int16_t* sample
int psx_audio_spu_encode(psx_audio_encoder_channel_state_t *state, int16_t* samples, int sample_count, int pitch, uint8_t *output) { int psx_audio_spu_encode(psx_audio_encoder_channel_state_t *state, int16_t* samples, int sample_count, int pitch, uint8_t *output) {
uint8_t prebuf[28]; uint8_t prebuf[28];
uint8_t *buffer = output; uint8_t *buffer = output;
uint8_t *data;
for (int i = 0; i < sample_count; i += 28, buffer += 16) { for (int i = 0; i < sample_count; i += 28, buffer += 16) {
buffer[0] = encode(state, samples + i * pitch, sample_count - i, pitch, prebuf, 0, 1, SPU_ADPCM_FILTER_COUNT, SHIFT_RANGE_4BPS); buffer[0] = encode(state, samples + i * pitch, sample_count - i, pitch, prebuf, 0, 1, SPU_ADPCM_FILTER_COUNT, SHIFT_RANGE_4BPS);

2
libpsxav/libpsxav.h
View File

@ -72,7 +72,7 @@ int psx_audio_xa_encode(psx_audio_xa_settings_t settings, psx_audio_encoder_stat
int psx_audio_xa_encode_simple(psx_audio_xa_settings_t settings, int16_t* samples, int sample_count, uint8_t *output); int psx_audio_xa_encode_simple(psx_audio_xa_settings_t settings, int16_t* samples, int sample_count, uint8_t *output);
int psx_audio_spu_encode(psx_audio_encoder_channel_state_t *state, int16_t* samples, int sample_count, int pitch, uint8_t *output); int psx_audio_spu_encode(psx_audio_encoder_channel_state_t *state, int16_t* samples, int sample_count, int pitch, uint8_t *output);
int psx_audio_spu_encode_simple(int16_t* samples, int sample_count, uint8_t *output, int loop_start); int psx_audio_spu_encode_simple(int16_t* samples, int sample_count, uint8_t *output, int loop_start);
int psx_audio_xa_encode_finalize(psx_audio_xa_settings_t settings, uint8_t *output, int output_length); void psx_audio_xa_encode_finalize(psx_audio_xa_settings_t settings, uint8_t *output, int output_length);
void psx_audio_spu_set_flag_at_sample(uint8_t* spu_data, int sample_pos, int flag); void psx_audio_spu_set_flag_at_sample(uint8_t* spu_data, int sample_pos, int flag);
// cdrom.c // cdrom.c

4
meson.build
View File

@ -1,5 +1,7 @@
project('psxavenc', 'c', default_options: ['c_std=c11']) project('psxavenc', 'c', default_options: ['c_std=c11'])
libm_dep = meson.get_compiler('c').find_library('m')
ffmpeg = [ ffmpeg = [
dependency('libavformat'), dependency('libavformat'),
dependency('libavcodec'), dependency('libavcodec'),
@ -21,4 +23,4 @@ executable('psxavenc', [
'psxavenc/filefmt.c', 'psxavenc/filefmt.c',
'psxavenc/mdec.c', 'psxavenc/mdec.c',
'psxavenc/psxavenc.c' 'psxavenc/psxavenc.c'
], dependencies: [ffmpeg, libpsxav_dep], install: true) ], dependencies: [libm_dep, ffmpeg, libpsxav_dep], install: true)

4
psxavenc/decoding.c
View File

@ -24,8 +24,6 @@ freely, subject to the following restrictions:
#include "common.h" #include "common.h"
static void poll_av_packet(settings_t *settings, AVPacket *packet);
int decode_frame(AVCodecContext *codec, AVFrame *frame, int *frame_size, AVPacket *packet) { int decode_frame(AVCodecContext *codec, AVFrame *frame, int *frame_size, AVPacket *packet) {
int ret; int ret;
@ -271,7 +269,7 @@ static void poll_av_packet_video(settings_t *settings, AVPacket *packet)
}; };
if (decode_frame(av->video_codec_context, av->frame, &frame_size, packet)) { if (decode_frame(av->video_codec_context, av->frame, &frame_size, packet)) {
if (!av->frame->width || !av->frame->height || !av->frame->data) { if (!av->frame->width || !av->frame->height || !av->frame->data[0]) {
return; return;
} }

226
psxavenc/mdec.c
View File

@ -37,117 +37,117 @@ const struct {
uint16_t u_hword_neg; uint16_t u_hword_neg;
} huffman_lookup[] = { } huffman_lookup[] = {
// Fuck this Huffman tree in particular --GM // Fuck this Huffman tree in particular --GM
2,0x3,MAKE_HUFFMAN_PAIR(0,1), {2,0x3,MAKE_HUFFMAN_PAIR(0,1)},
3,0x3,MAKE_HUFFMAN_PAIR(1,1), {3,0x3,MAKE_HUFFMAN_PAIR(1,1)},
4,0x4,MAKE_HUFFMAN_PAIR(0,2), {4,0x4,MAKE_HUFFMAN_PAIR(0,2)},
4,0x5,MAKE_HUFFMAN_PAIR(2,1), {4,0x5,MAKE_HUFFMAN_PAIR(2,1)},
5,0x05,MAKE_HUFFMAN_PAIR(0,3), {5,0x05,MAKE_HUFFMAN_PAIR(0,3)},
5,0x06,MAKE_HUFFMAN_PAIR(4,1), {5,0x06,MAKE_HUFFMAN_PAIR(4,1)},
5,0x07,MAKE_HUFFMAN_PAIR(3,1), {5,0x07,MAKE_HUFFMAN_PAIR(3,1)},
6,0x04,MAKE_HUFFMAN_PAIR(7,1), {6,0x04,MAKE_HUFFMAN_PAIR(7,1)},
6,0x05,MAKE_HUFFMAN_PAIR(6,1), {6,0x05,MAKE_HUFFMAN_PAIR(6,1)},
6,0x06,MAKE_HUFFMAN_PAIR(1,2), {6,0x06,MAKE_HUFFMAN_PAIR(1,2)},
6,0x07,MAKE_HUFFMAN_PAIR(5,1), {6,0x07,MAKE_HUFFMAN_PAIR(5,1)},
7,0x04,MAKE_HUFFMAN_PAIR(2,2), {7,0x04,MAKE_HUFFMAN_PAIR(2,2)},
7,0x05,MAKE_HUFFMAN_PAIR(9,1), {7,0x05,MAKE_HUFFMAN_PAIR(9,1)},
7,0x06,MAKE_HUFFMAN_PAIR(0,4), {7,0x06,MAKE_HUFFMAN_PAIR(0,4)},
7,0x07,MAKE_HUFFMAN_PAIR(8,1), {7,0x07,MAKE_HUFFMAN_PAIR(8,1)},
8,0x20,MAKE_HUFFMAN_PAIR(13,1), {8,0x20,MAKE_HUFFMAN_PAIR(13,1)},
8,0x21,MAKE_HUFFMAN_PAIR(0,6), {8,0x21,MAKE_HUFFMAN_PAIR(0,6)},
8,0x22,MAKE_HUFFMAN_PAIR(12,1), {8,0x22,MAKE_HUFFMAN_PAIR(12,1)},
8,0x23,MAKE_HUFFMAN_PAIR(11,1), {8,0x23,MAKE_HUFFMAN_PAIR(11,1)},
8,0x24,MAKE_HUFFMAN_PAIR(3,2), {8,0x24,MAKE_HUFFMAN_PAIR(3,2)},
8,0x25,MAKE_HUFFMAN_PAIR(1,3), {8,0x25,MAKE_HUFFMAN_PAIR(1,3)},
8,0x26,MAKE_HUFFMAN_PAIR(0,5), {8,0x26,MAKE_HUFFMAN_PAIR(0,5)},
8,0x27,MAKE_HUFFMAN_PAIR(10,1), {8,0x27,MAKE_HUFFMAN_PAIR(10,1)},
10,0x008,MAKE_HUFFMAN_PAIR(16,1), {10,0x008,MAKE_HUFFMAN_PAIR(16,1)},
10,0x009,MAKE_HUFFMAN_PAIR(5,2), {10,0x009,MAKE_HUFFMAN_PAIR(5,2)},
10,0x00A,MAKE_HUFFMAN_PAIR(0,7), {10,0x00A,MAKE_HUFFMAN_PAIR(0,7)},
10,0x00B,MAKE_HUFFMAN_PAIR(2,3), {10,0x00B,MAKE_HUFFMAN_PAIR(2,3)},
10,0x00C,MAKE_HUFFMAN_PAIR(1,4), {10,0x00C,MAKE_HUFFMAN_PAIR(1,4)},
10,0x00D,MAKE_HUFFMAN_PAIR(15,1), {10,0x00D,MAKE_HUFFMAN_PAIR(15,1)},
10,0x00E,MAKE_HUFFMAN_PAIR(14,1), {10,0x00E,MAKE_HUFFMAN_PAIR(14,1)},
10,0x00F,MAKE_HUFFMAN_PAIR(4,2), {10,0x00F,MAKE_HUFFMAN_PAIR(4,2)},
12,0x010,MAKE_HUFFMAN_PAIR(0,11), {12,0x010,MAKE_HUFFMAN_PAIR(0,11)},
12,0x011,MAKE_HUFFMAN_PAIR(8,2), {12,0x011,MAKE_HUFFMAN_PAIR(8,2)},
12,0x012,MAKE_HUFFMAN_PAIR(4,3), {12,0x012,MAKE_HUFFMAN_PAIR(4,3)},
12,0x013,MAKE_HUFFMAN_PAIR(0,10), {12,0x013,MAKE_HUFFMAN_PAIR(0,10)},
12,0x014,MAKE_HUFFMAN_PAIR(2,4), {12,0x014,MAKE_HUFFMAN_PAIR(2,4)},
12,0x015,MAKE_HUFFMAN_PAIR(7,2), {12,0x015,MAKE_HUFFMAN_PAIR(7,2)},
12,0x016,MAKE_HUFFMAN_PAIR(21,1), {12,0x016,MAKE_HUFFMAN_PAIR(21,1)},
12,0x017,MAKE_HUFFMAN_PAIR(20,1), {12,0x017,MAKE_HUFFMAN_PAIR(20,1)},
12,0x018,MAKE_HUFFMAN_PAIR(0,9), {12,0x018,MAKE_HUFFMAN_PAIR(0,9)},
12,0x019,MAKE_HUFFMAN_PAIR(19,1), {12,0x019,MAKE_HUFFMAN_PAIR(19,1)},
12,0x01A,MAKE_HUFFMAN_PAIR(18,1), {12,0x01A,MAKE_HUFFMAN_PAIR(18,1)},
12,0x01B,MAKE_HUFFMAN_PAIR(1,5), {12,0x01B,MAKE_HUFFMAN_PAIR(1,5)},
12,0x01C,MAKE_HUFFMAN_PAIR(3,3), {12,0x01C,MAKE_HUFFMAN_PAIR(3,3)},
12,0x01D,MAKE_HUFFMAN_PAIR(0,8), {12,0x01D,MAKE_HUFFMAN_PAIR(0,8)},
12,0x01E,MAKE_HUFFMAN_PAIR(6,2), {12,0x01E,MAKE_HUFFMAN_PAIR(6,2)},
12,0x01F,MAKE_HUFFMAN_PAIR(17,1), {12,0x01F,MAKE_HUFFMAN_PAIR(17,1)},
13,0x0010,MAKE_HUFFMAN_PAIR(10,2), {13,0x0010,MAKE_HUFFMAN_PAIR(10,2)},
13,0x0011,MAKE_HUFFMAN_PAIR(9,2), {13,0x0011,MAKE_HUFFMAN_PAIR(9,2)},
13,0x0012,MAKE_HUFFMAN_PAIR(5,3), {13,0x0012,MAKE_HUFFMAN_PAIR(5,3)},
13,0x0013,MAKE_HUFFMAN_PAIR(3,4), {13,0x0013,MAKE_HUFFMAN_PAIR(3,4)},
13,0x0014,MAKE_HUFFMAN_PAIR(2,5), {13,0x0014,MAKE_HUFFMAN_PAIR(2,5)},
13,0x0015,MAKE_HUFFMAN_PAIR(1,7), {13,0x0015,MAKE_HUFFMAN_PAIR(1,7)},
13,0x0016,MAKE_HUFFMAN_PAIR(1,6), {13,0x0016,MAKE_HUFFMAN_PAIR(1,6)},
13,0x0017,MAKE_HUFFMAN_PAIR(0,15), {13,0x0017,MAKE_HUFFMAN_PAIR(0,15)},
13,0x0018,MAKE_HUFFMAN_PAIR(0,14), {13,0x0018,MAKE_HUFFMAN_PAIR(0,14)},
13,0x0019,MAKE_HUFFMAN_PAIR(0,13), {13,0x0019,MAKE_HUFFMAN_PAIR(0,13)},
13,0x001A,MAKE_HUFFMAN_PAIR(0,12), {13,0x001A,MAKE_HUFFMAN_PAIR(0,12)},
13,0x001B,MAKE_HUFFMAN_PAIR(26,1), {13,0x001B,MAKE_HUFFMAN_PAIR(26,1)},
13,0x001C,MAKE_HUFFMAN_PAIR(25,1), {13,0x001C,MAKE_HUFFMAN_PAIR(25,1)},
13,0x001D,MAKE_HUFFMAN_PAIR(24,1), {13,0x001D,MAKE_HUFFMAN_PAIR(24,1)},
13,0x001E,MAKE_HUFFMAN_PAIR(23,1), {13,0x001E,MAKE_HUFFMAN_PAIR(23,1)},
13,0x001F,MAKE_HUFFMAN_PAIR(22,1), {13,0x001F,MAKE_HUFFMAN_PAIR(22,1)},
14,0x0010,MAKE_HUFFMAN_PAIR(0,31), {14,0x0010,MAKE_HUFFMAN_PAIR(0,31)},
14,0x0011,MAKE_HUFFMAN_PAIR(0,30), {14,0x0011,MAKE_HUFFMAN_PAIR(0,30)},
14,0x0012,MAKE_HUFFMAN_PAIR(0,29), {14,0x0012,MAKE_HUFFMAN_PAIR(0,29)},
14,0x0013,MAKE_HUFFMAN_PAIR(0,28), {14,0x0013,MAKE_HUFFMAN_PAIR(0,28)},
14,0x0014,MAKE_HUFFMAN_PAIR(0,27), {14,0x0014,MAKE_HUFFMAN_PAIR(0,27)},
14,0x0015,MAKE_HUFFMAN_PAIR(0,26), {14,0x0015,MAKE_HUFFMAN_PAIR(0,26)},
14,0x0016,MAKE_HUFFMAN_PAIR(0,25), {14,0x0016,MAKE_HUFFMAN_PAIR(0,25)},
14,0x0017,MAKE_HUFFMAN_PAIR(0,24), {14,0x0017,MAKE_HUFFMAN_PAIR(0,24)},
14,0x0018,MAKE_HUFFMAN_PAIR(0,23), {14,0x0018,MAKE_HUFFMAN_PAIR(0,23)},
14,0x0019,MAKE_HUFFMAN_PAIR(0,22), {14,0x0019,MAKE_HUFFMAN_PAIR(0,22)},
14,0x001A,MAKE_HUFFMAN_PAIR(0,21), {14,0x001A,MAKE_HUFFMAN_PAIR(0,21)},
14,0x001B,MAKE_HUFFMAN_PAIR(0,20), {14,0x001B,MAKE_HUFFMAN_PAIR(0,20)},
14,0x001C,MAKE_HUFFMAN_PAIR(0,19), {14,0x001C,MAKE_HUFFMAN_PAIR(0,19)},
14,0x001D,MAKE_HUFFMAN_PAIR(0,18), {14,0x001D,MAKE_HUFFMAN_PAIR(0,18)},
14,0x001E,MAKE_HUFFMAN_PAIR(0,17), {14,0x001E,MAKE_HUFFMAN_PAIR(0,17)},
14,0x001F,MAKE_HUFFMAN_PAIR(0,16), {14,0x001F,MAKE_HUFFMAN_PAIR(0,16)},
15,0x0010,MAKE_HUFFMAN_PAIR(0,40), {15,0x0010,MAKE_HUFFMAN_PAIR(0,40)},
15,0x0011,MAKE_HUFFMAN_PAIR(0,39), {15,0x0011,MAKE_HUFFMAN_PAIR(0,39)},
15,0x0012,MAKE_HUFFMAN_PAIR(0,38), {15,0x0012,MAKE_HUFFMAN_PAIR(0,38)},
15,0x0013,MAKE_HUFFMAN_PAIR(0,37), {15,0x0013,MAKE_HUFFMAN_PAIR(0,37)},
15,0x0014,MAKE_HUFFMAN_PAIR(0,36), {15,0x0014,MAKE_HUFFMAN_PAIR(0,36)},
15,0x0015,MAKE_HUFFMAN_PAIR(0,35), {15,0x0015,MAKE_HUFFMAN_PAIR(0,35)},
15,0x0016,MAKE_HUFFMAN_PAIR(0,34), {15,0x0016,MAKE_HUFFMAN_PAIR(0,34)},
15,0x0017,MAKE_HUFFMAN_PAIR(0,33), {15,0x0017,MAKE_HUFFMAN_PAIR(0,33)},
15,0x0018,MAKE_HUFFMAN_PAIR(0,32), {15,0x0018,MAKE_HUFFMAN_PAIR(0,32)},
15,0x0019,MAKE_HUFFMAN_PAIR(1,14), {15,0x0019,MAKE_HUFFMAN_PAIR(1,14)},
15,0x001A,MAKE_HUFFMAN_PAIR(1,13), {15,0x001A,MAKE_HUFFMAN_PAIR(1,13)},
15,0x001B,MAKE_HUFFMAN_PAIR(1,12), {15,0x001B,MAKE_HUFFMAN_PAIR(1,12)},
15,0x001C,MAKE_HUFFMAN_PAIR(1,11), {15,0x001C,MAKE_HUFFMAN_PAIR(1,11)},
15,0x001D,MAKE_HUFFMAN_PAIR(1,10), {15,0x001D,MAKE_HUFFMAN_PAIR(1,10)},
15,0x001E,MAKE_HUFFMAN_PAIR(1,9), {15,0x001E,MAKE_HUFFMAN_PAIR(1,9)},
15,0x001F,MAKE_HUFFMAN_PAIR(1,8), {15,0x001F,MAKE_HUFFMAN_PAIR(1,8)},
16,0x0010,MAKE_HUFFMAN_PAIR(1,18), {16,0x0010,MAKE_HUFFMAN_PAIR(1,18)},
16,0x0011,MAKE_HUFFMAN_PAIR(1,17), {16,0x0011,MAKE_HUFFMAN_PAIR(1,17)},
16,0x0012,MAKE_HUFFMAN_PAIR(1,16), {16,0x0012,MAKE_HUFFMAN_PAIR(1,16)},
16,0x0013,MAKE_HUFFMAN_PAIR(1,15), {16,0x0013,MAKE_HUFFMAN_PAIR(1,15)},
16,0x0014,MAKE_HUFFMAN_PAIR(6,3), {16,0x0014,MAKE_HUFFMAN_PAIR(6,3)},
16,0x0015,MAKE_HUFFMAN_PAIR(16,2), {16,0x0015,MAKE_HUFFMAN_PAIR(16,2)},
16,0x0016,MAKE_HUFFMAN_PAIR(15,2), {16,0x0016,MAKE_HUFFMAN_PAIR(15,2)},
16,0x0017,MAKE_HUFFMAN_PAIR(14,2), {16,0x0017,MAKE_HUFFMAN_PAIR(14,2)},
16,0x0018,MAKE_HUFFMAN_PAIR(13,2), {16,0x0018,MAKE_HUFFMAN_PAIR(13,2)},
16,0x0019,MAKE_HUFFMAN_PAIR(12,2), {16,0x0019,MAKE_HUFFMAN_PAIR(12,2)},
16,0x001A,MAKE_HUFFMAN_PAIR(11,2), {16,0x001A,MAKE_HUFFMAN_PAIR(11,2)},
16,0x001B,MAKE_HUFFMAN_PAIR(31,1), {16,0x001B,MAKE_HUFFMAN_PAIR(31,1)},
16,0x001C,MAKE_HUFFMAN_PAIR(30,1), {16,0x001C,MAKE_HUFFMAN_PAIR(30,1)},
16,0x001D,MAKE_HUFFMAN_PAIR(29,1), {16,0x001D,MAKE_HUFFMAN_PAIR(29,1)},
16,0x001E,MAKE_HUFFMAN_PAIR(28,1), {16,0x001E,MAKE_HUFFMAN_PAIR(28,1)},
16,0x001F,MAKE_HUFFMAN_PAIR(27,1), {16,0x001F,MAKE_HUFFMAN_PAIR(27,1)},
}; };
#undef MAKE_HUFFMAN_PAIR #undef MAKE_HUFFMAN_PAIR
@ -249,7 +249,7 @@ static bool encode_bits(vid_encoder_state_t *state, int bits, uint32_t val)
uint32_t outval = val; uint32_t outval = val;
outval >>= bits - state->bits_left; outval >>= bits - state->bits_left;
assert(outval < (1<<16)); assert(outval < (1<<16));
uint16_t old_value = state->bits_value; //uint16_t old_value = state->bits_value;
assert((state->bits_value & outval) == 0); assert((state->bits_value & outval) == 0);
state->bits_value |= (uint16_t)outval; state->bits_value |= (uint16_t)outval;
//fprintf(stderr, "trunc %2d %2d %08X %04X %04X\n", bits, state->bits_left, val, old_value, state->bits_value); //fprintf(stderr, "trunc %2d %2d %08X %04X %04X\n", bits, state->bits_left, val, old_value, state->bits_value);
@ -269,7 +269,7 @@ static bool encode_bits(vid_encoder_state_t *state, int bits, uint32_t val)
uint32_t outval = val; uint32_t outval = val;
outval <<= state->bits_left - bits; outval <<= state->bits_left - bits;
assert(outval < (1<<16)); assert(outval < (1<<16));
uint16_t old_value = state->bits_value; //uint16_t old_value = state->bits_value;
assert((state->bits_value & outval) == 0); assert((state->bits_value & outval) == 0);
state->bits_value |= (uint16_t)outval; state->bits_value |= (uint16_t)outval;
//fprintf(stderr, "plop %2d %2d %08X %04X %04X\n", bits, state->bits_left, val, state->bits_value); //fprintf(stderr, "plop %2d %2d %08X %04X %04X\n", bits, state->bits_left, val, state->bits_value);