34 #define BITSTREAM_READER_LE
37 #define BINK_FLAG_ALPHA 0x00100000
38 #define BINK_FLAG_GRAY 0x00020000
61 4, 8, 8, 5, 5, 11, 11, 4, 4, 7
65 0, 0, 0, 1, 1, 0, 1, 0, 0, 0
96 #define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\
97 bink_trees[(tree).vlc_num].bits, 1)]
230 }
while (size && size2);
246 uint8_t tmp1[16] = { 0 }, tmp2[16], *
in = tmp1, *
out = tmp2;
251 for (i = 0; i < 16; i++)
257 for (i = 0; i <=
len; i++) {
259 tmp1[tree->
syms[i]] = 1;
261 for (i = 0; i < 16 && len < 16 - 1; i++)
266 for (i = 0; i < 16; i++)
268 for (i = 0; i <=
len; i++) {
270 for (t = 0; t < 16; t += size << 1)
271 merge(gb, out + t, in + t, size);
274 memcpy(tree->
syms, in, 16);
290 for (i = 0; i < 16; i++)
307 #define CHECK_READ_VAL(gb, b, t) \
308 if (!b->cur_dec || (b->cur_dec > b->cur_ptr)) \
310 t = get_bits(gb, b->len); \
353 v = (v ^ sign) - sign;
362 v = (v ^ sign) - sign;
397 if (dec_end - b->
cur_dec < run)
443 sign = ((int8_t) v) >> 7;
444 v = ((v & 0x7F) ^ sign) - sign;
455 sign = ((int8_t) v) >> 7;
456 v = ((v & 0x7F) ^ sign) - sign;
466 #define DC_START_BITS 11
469 int start_bits,
int has_sign)
471 int i, j,
len, len2, bsize, sign,
v, v2;
472 int16_t *dst = (int16_t*)b->
cur_dec;
473 int16_t *dst_end = (int16_t*)b->
data_end;
476 v =
get_bits(gb, start_bits - has_sign);
479 v = (v ^ sign) - sign;
481 if (dst_end - dst < 1)
485 for (i = 0; i <
len; i += 8) {
486 len2 =
FFMIN(len - i, 8);
487 if (dst_end - dst < len2)
491 for (j = 0; j < len2; j++) {
495 v2 = (v2 ^ sign) - sign;
499 if (v < -32768 || v > 32767) {
505 for (j = 0; j < len2; j++)
550 const int mask = 1 << (bits - 1);
560 for (i = 0; i <
len; i++)
563 for (i = 0; i <
len; i++)
567 int16_t *dst = (int16_t*)b->
cur_dec;
570 for (i = 0; i <
len; i++)
573 for (i = 0; i <
len; i++)
605 const int32_t quant_matrices[16][64],
int q)
610 int list_start = 64, list_end = 64, list_pos;
616 coef_list[list_end] = 4; mode_list[list_end++] = 0;
617 coef_list[list_end] = 24; mode_list[list_end++] = 0;
618 coef_list[list_end] = 44; mode_list[list_end++] = 0;
619 coef_list[list_end] = 1; mode_list[list_end++] = 3;
620 coef_list[list_end] = 2; mode_list[list_end++] = 3;
621 coef_list[list_end] = 3; mode_list[list_end++] = 3;
623 for (bits =
get_bits(gb, 4) - 1; bits >= 0; bits--) {
624 list_pos = list_start;
625 while (list_pos < list_end) {
626 if (!(mode_list[list_pos] | coef_list[list_pos]) || !
get_bits1(gb)) {
630 ccoef = coef_list[list_pos];
631 mode = mode_list[list_pos];
634 coef_list[list_pos] = ccoef + 4;
635 mode_list[list_pos] = 1;
638 coef_list[list_pos] = 0;
639 mode_list[list_pos++] = 0;
641 for (i = 0; i < 4; i++, ccoef++) {
643 coef_list[--list_start] = ccoef;
644 mode_list[ list_start] = 3;
651 t = (t ^ sign) - sign;
653 block[scan[ccoef]] = t;
654 coef_idx[coef_count++] = ccoef;
659 mode_list[list_pos] = 2;
660 for (i = 0; i < 3; i++) {
662 coef_list[list_end] = ccoef;
663 mode_list[list_end++] = 2;
672 t = (t ^ sign) - sign;
674 block[scan[ccoef]] = t;
675 coef_idx[coef_count++] = ccoef;
676 coef_list[list_pos] = 0;
677 mode_list[list_pos++] = 0;
687 if (quant_idx > 15
U) {
693 quant = quant_matrices[quant_idx];
695 block[0] = (block[0] * quant[0]) >> 11;
696 for (i = 0; i < coef_count; i++) {
697 int idx = coef_idx[i];
698 block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11;
717 int list_start = 64, list_end = 64, list_pos;
719 int nz_coeff_count = 0;
721 coef_list[list_end] = 4; mode_list[list_end++] = 0;
722 coef_list[list_end] = 24; mode_list[list_end++] = 0;
723 coef_list[list_end] = 44; mode_list[list_end++] = 0;
724 coef_list[list_end] = 0; mode_list[list_end++] = 2;
727 for (i = 0; i < nz_coeff_count; i++) {
730 if (block[nz_coeff[i]] < 0)
731 block[nz_coeff[i]] -=
mask;
733 block[nz_coeff[i]] +=
mask;
738 list_pos = list_start;
739 while (list_pos < list_end) {
740 if (!(coef_list[list_pos] | mode_list[list_pos]) || !
get_bits1(gb)) {
744 ccoef = coef_list[list_pos];
745 mode = mode_list[list_pos];
748 coef_list[list_pos] = ccoef + 4;
749 mode_list[list_pos] = 1;
752 coef_list[list_pos] = 0;
753 mode_list[list_pos++] = 0;
755 for (i = 0; i < 4; i++, ccoef++) {
757 coef_list[--list_start] = ccoef;
758 mode_list[ list_start] = 3;
760 nz_coeff[nz_coeff_count++] =
bink_scan[ccoef];
762 block[
bink_scan[ccoef]] = (mask ^ sign) - sign;
770 mode_list[list_pos] = 2;
771 for (i = 0; i < 3; i++) {
773 coef_list[list_end] = ccoef;
774 mode_list[list_end++] = 2;
778 nz_coeff[nz_coeff_count++] =
bink_scan[ccoef];
780 block[
bink_scan[ccoef]] = (mask ^ sign) - sign;
781 coef_list[list_pos] = 0;
782 mode_list[list_pos++] = 0;
801 for (i = 0; i < 8; i++)
802 memcpy(tmp + i*8, src + i*stride, 8);
803 for (i = 0; i < 8; i++)
804 memcpy(dst + i*stride, tmp + i*8, 8);
808 int plane_idx,
int is_key,
int is_chroma)
812 uint8_t *dst, *ref, *ref_start, *ref_end;
819 int ybias = is_key ? -15 : 0;
827 ref_start = frame->
data[plane_idx];
828 ref_end = frame->
data[plane_idx] + (bh * frame->
linesize[plane_idx] + bw) * 8;
830 for (i = 0; i < 64; i++)
831 coordmap[i] = (i & 7) + (i >> 3) * stride;
833 for (by = 0; by < bh; by++) {
840 for (bx = 0; bx < bw; bx++, dst += 8) {
861 for (j = 0; j <
run; j++)
862 dst[coordmap[*scan++]] = v;
864 for (j = 0; j <
run; j++)
872 memset(dctblock, 0,
sizeof(*dctblock) * 64);
881 ref = dst + xoff + yoff *
stride;
882 if (ref < ref_start || ref + 8*stride > ref_end) {
897 ref = dst + xoff + yoff *
stride;
898 if (ref < ref_start || ref + 8 * stride > ref_end) {
905 memset(dctblock, 0,
sizeof(*dctblock) * 64);
916 for (i = 0; i < 2; i++)
918 for (i = 0; i < 8; i++) {
920 for (j = 0; j < 8; j++, v >>= 1)
921 dst[i*stride + j] = col[v & 1];
927 ref = dst + xoff + yoff *
stride;
928 if (ref < ref_start || ref + 8 * stride > ref_end) {
937 for (i = 0; i < 8; i++)
961 if (ref < ref_start || ref > ref_end) {
972 int plane_idx,
int is_chroma)
976 uint8_t *dst, *prev, *ref_start, *ref_end;
994 : frame->
data[plane_idx];
996 + (bw - 1 + c->
last->
linesize[plane_idx] * (bh - 1)) * 8;
998 for (i = 0; i < 64; i++)
999 coordmap[i] = (i & 7) + (i >> 3) * stride;
1001 for (by = 0; by < bh; by++) {
1025 : frame->
data[plane_idx]) + 8*by*stride;
1026 for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
1055 for (j = 0; j <
run; j++)
1056 ublock[*scan++] = v;
1058 for (j = 0; j <
run; j++)
1066 memset(dctblock, 0,
sizeof(*dctblock) * 64);
1076 for (i = 0; i < 2; i++)
1078 for (j = 0; j < 8; j++) {
1080 for (i = 0; i < 8; i++, v >>= 1)
1081 ublock[i + j*8] = col[v & 1];
1085 for (j = 0; j < 8; j++)
1086 for (i = 0; i < 8; i++)
1101 ref_start, ref_end);
1118 for (j = 0; j <
run; j++)
1119 dst[coordmap[*scan++]] = v;
1121 for (j = 0; j <
run; j++)
1130 ref_start, ref_end);
1139 memset(dctblock, 0,
sizeof(*dctblock) * 64);
1150 ref_start, ref_end);
1153 memset(dctblock, 0,
sizeof(*dctblock) * 64);
1159 for (i = 0; i < 2; i++)
1161 for (i = 0; i < 8; i++) {
1163 for (j = 0; j < 8; j++, v >>= 1)
1164 dst[i*stride + j] = col[v & 1];
1168 for (i = 0; i < 8; i++)
1190 int bits_count = pkt->
size << 3;
1214 for (plane = 0; plane < 3; plane++) {
1215 plane_idx = (!plane || !c->
swap_planes) ? plane : (plane ^ 3);
1248 static const int s[64]={
1249 1073741824,1489322693,1402911301,1262586814,1073741824, 843633538, 581104888, 296244703,
1250 1489322693,2065749918,1945893874,1751258219,1489322693,1170153332, 806015634, 410903207,
1251 1402911301,1945893874,1832991949,1649649171,1402911301,1102260336, 759250125, 387062357,
1252 1262586814,1751258219,1649649171,1484645031,1262586814, 992008094, 683307060, 348346918,
1253 1073741824,1489322693,1402911301,1262586814,1073741824, 843633538, 581104888, 296244703,
1254 843633538,1170153332,1102260336, 992008094, 843633538, 662838617, 456571181, 232757969,
1255 581104888, 806015634, 759250125, 683307060, 581104888, 456571181, 314491699, 160326478,
1256 296244703, 410903207, 387062357, 348346918, 296244703, 232757969, 160326478, 81733730,
1260 for (i = 0; i < 64; i++)
1263 for (j = 0; j < 16; j++) {
1264 for (i = 0; i < 64; i++) {
1265 int k = inv_bink_scan[i];
1278 static int binkb_initialised = 0;
1290 if (!bink_trees[15].table) {
1291 for (i = 0; i < 16; i++) {
1293 bink_trees[i].
table = table + i*128;
1295 init_vlc(&bink_trees[i], maxbits, 16,
1321 if (!binkb_initialised) {
1323 binkb_initialised = 1;
1348 .
name =
"binkvideo",
const char const char void * val
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static const uint8_t bink_tree_lens[16][16]
8-bit values for 2-colour pattern fill
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
av_cold void ff_binkdsp_init(BinkDSPContext *c)
static const uint8_t bink_tree_bits[16][16]
void(* clear_block)(int16_t *block)
#define CHECK_READ_VAL(gb, b, t)
common check before starting decoding bundle data
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
void(* scale_block)(const uint8_t src[64], uint8_t *dst, int linesize)
static void skip_bits_long(GetBitContext *s, int n)
static av_cold int init(AVCodecContext *avctx)
static const uint8_t binkb_den[16]
static int read_residue(GetBitContext *gb, int16_t block[64], int masks_count)
Read 8x8 block with residue after motion compensation.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
8-bit values for 2-colour pattern fill
static const uint8_t bink_scan[64]
Bink DCT and residue 8x8 block scan order.
Tree col_high[16]
trees for decoding high nibble in "colours" data type
16x16 block types (a subset of 8x8 block types)
void(* add_pixels8)(uint8_t *pixels, int16_t *block, int line_size)
int len
length of number of entries to decode (in bits)
Macro definitions for various function/variable attributes.
static int32_t binkb_inter_quant[16][64]
quantizer values for interblocks with DCT
static av_cold void binkb_init_bundle(BinkContext *c, int bundle_num)
static int read_patterns(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
X components of motion value.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
motion block with DCT applied to the difference
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static int binkb_get_value(BinkContext *c, int bundle_num)
static void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride)
Copy 8x8 block from source to destination, where src and dst may be overlapped.
Tree tree
Huffman tree-related data.
BlockTypes
Bink video block types.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static const int32_t bink_inter_quant[16][64]
static int get_bits_count(const GetBitContext *s)
int vlc_num
tree number (in bink_trees[])
bitstream reader API header.
static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
data structure used for decoding single Bink data type
static const uint8_t bink_patterns[16][64]
uint8_t * data
buffer for decoded symbols
block is copied from previous frame with some offset
static int read_dct_coeffs(GetBitContext *gb, int32_t block[64], const uint8_t *scan, const int32_t quant_matrices[16][64], int q)
Read 8x8 block of DCT coefficients.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t * data_end
buffer end
static const uint16_t mask[17]
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static const struct endianess table[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_cold void free_bundles(BinkContext *c)
Free memory used by bundles.
const char * name
Name of the codec implementation.
int col_lastval
value of last decoded high nibble in "colours" data type
Libavcodec external API header.
DC values for interblocks with DCT.
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
block is composed from runs of colours with custom scan order
common internal API header
block is filled with single colour
static av_cold void binkb_calc_quant(void)
Caclulate quantization tables for version b.
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
int width
picture width / height.
static int binkb_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb, int plane_idx, int is_key, int is_chroma)
Y components of motion value.
number of coefficients for residue blocks
static const uint8_t binkb_inter_seed[64]
#define INIT_VLC_USE_NEW_STATIC
static const uint8_t binkb_runbits[64]
static int bink_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb, int plane_idx, int is_chroma)
data needed to decode 4-bit Huffman-coded value
uint8_t * cur_dec
pointer to the not yet decoded part of the buffer
quantizer values for intrablocks with DCT
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
#define DC_START_BITS
number of bits used to store first DC value in bundle
main external API structure.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
static av_cold int decode_init(AVCodecContext *avctx)
static unsigned int get_bits1(GetBitContext *s)
static const int32_t bink_intra_quant[16][64]
DC values for interblocks with DCT.
Sources
IDs for different data types used in Bink video codec.
block is filled with two colours following custom pattern
static av_cold void binkb_init_bundles(BinkContext *c)
static int32_t binkb_intra_quant[16][64]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static const uint8_t binkb_num[16]
#define GET_HUFF(gb, tree)
run lengths for special fill block
Y components of motion value.
static VLC bink_trees[16]
static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)
Merge two consequent lists of equal size depending on bits read.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Bundle bundle[BINKB_NB_SRC]
bundles for decoding all data types
static void flush(AVCodecContext *avctx)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
pixel values used for different block types
void(* idct_add)(uint8_t *dest, int line_size, int32_t *block)
X components of motion value.
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
uint8_t * cur_ptr
pointer to the data that is not read from buffer yet
GLint GLenum GLboolean GLsizei stride
static const uint8_t binkb_intra_seed[64]
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num)
common internal api header.
static void init_lengths(BinkContext *c, int width, int bw)
Initialize length in all bundles.
static av_cold int init_bundles(BinkContext *c)
Allocate memory for bundles.
static int read_colors(GetBitContext *gb, Bundle *b, BinkContext *c)
static int read_block_types(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
static void read_tree(GetBitContext *gb, Tree *tree)
Read information about Huffman tree used to decode data.
uint8_t syms[16]
leaf value to symbol mapping
static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b, int start_bits, int has_sign)
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
DC values for intrablocks with DCT.
static int read_motion_values(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
motion block with some difference added
VLC_TYPE(* table)[2]
code, bits
void(* idct_put)(uint8_t *dest, int line_size, int32_t *block)
static int bink_put_pixels(BinkContext *c, uint8_t *dst, uint8_t *prev, int stride, uint8_t *ref_start, uint8_t *ref_end)
static const int binkb_bundle_sizes[BINKB_NB_SRC]
int version
internal Bink file version
static const int binkb_bundle_signed[BINKB_NB_SRC]
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
static av_cold int decode_end(AVCodecContext *avctx)
#define LOCAL_ALIGNED_16(t, v,...)
#define FFSWAP(type, a, b)
static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num)
Prepare bundle for decoding data.
static const uint8_t bink_rlelens[4]
pixel values used for different block types
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
static int get_value(BinkContext *c, int bundle)
Retrieve next value from bundle.
This structure stores compressed data.
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
DC values for intrablocks with DCT.
OldSources
IDs for different data types used in old version of Bink video codec.
op_fill_func fill_block_tab[2]