55 int seq,
int slot, uint16_t *tbl)
57 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
58 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
59 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
60 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
62 static const uint8_t l_start[] = { 0, 4, 9, 13, 18, 22, 27, 31, 36, 40 };
63 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
65 static const uint8_t serpent1[] = {
72 static const uint8_t serpent2[] = {
73 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
74 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
79 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
80 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 }, { 10, 0 },
81 { 10, 1 }, { 10, 2 }, { 10, 3 }, { 20, 0 }, { 20, 1 },
82 { 20, 2 }, { 20, 3 }, { 30, 0 }, { 30, 1 }, { 30, 2 },
83 { 30, 3 }, { 40, 0 }, { 40, 1 }, { 40, 2 }, { 40, 3 },
84 { 50, 0 }, { 50, 1 }, { 50, 2 }, { 50, 3 }, { 60, 0 },
85 { 60, 1 }, { 60, 2 }, { 60, 3 }, { 70, 0 }, { 70, 1 },
86 { 70, 2 }, { 70, 3 }, { 0, 64 }, { 0, 65 }, { 0, 66 },
87 { 10, 64 }, { 10, 65 }, { 10, 66 }, { 20, 64 }, { 20, 65 },
88 { 20, 66 }, { 30, 64 }, { 30, 65 }, { 30, 66 }, { 40, 64 },
89 { 40, 65 }, { 40, 66 }, { 50, 64 }, { 50, 65 }, { 50, 66 },
90 { 60, 64 }, { 60, 65 }, { 60, 66 }, { 70, 64 }, { 70, 65 },
91 { 70, 66 }, { 0, 67 }, { 20, 67 }, { 40, 67 }, { 60, 67 }
97 for (m = 0; m < 5; m++) {
100 blk = (chan * 11 + seq) * 27 + slot;
102 if (chan == 0 && seq == 11) {
111 i = (4 * chan + blk + off[m]) % 11;
114 x = shuf1[m] + (chan & 1) * 9 + k % 9;
115 y = (i * 3 + k / 9) * 2 + (chan >> 1) + 1;
117 tbl[m] = (x << 1) | (y << 9);
120 blk = (chan * 10 + seq) * 27 + slot;
122 i = (4 * chan + (seq / 5) + 2 * blk + off[m]) % 10;
125 x = shuf1[m] + (chan & 1) * 9 + k % 9;
126 y = (i * 3 + k / 9) * 2 + (chan >> 1) + 4;
129 x = remap[y][0] + ((x - 80) << (y > 59));
132 tbl[m] = (x << 1) | (y << 9);
135 blk = (chan * 10 + seq) * 27 + slot;
137 i = (4 * chan + (seq / 5) + 2 * blk + off[m]) % 10;
138 k = (blk / 5) % 27 + (i & 1) * 3;
140 x = shuf2[m] + k % 6 + 6 * (chan & 1);
141 y = l_start[
i] + k / 6 + 45 * (chan >> 1);
142 tbl[m] = (x << 1) | (y << 9);
147 x = shuf3[m] + slot / 3;
149 ((((seq + off[m]) % d->
difseg_size) << 1) + chan) * 3;
150 tbl[m] = (x << 1) | (y << 8);
153 x = shuf3[m] + slot / 3;
156 tbl[m] = (x << 1) | (y << 9);
160 k = slot + ((m == 1 || m == 2) ? 3 : 0);
162 x = l_start_shuffled[m] + k / 6;
163 y = serpent2[k] + i * 6;
166 tbl[m] = (x << 2) | (y << 8);
183 for (j = 0; j < 27; j++) {
214 for (i = 0, j = 0; i <
NB_DV_VLC; i++, j++) {
221 new_dv_vlc_bits[j] <<= 1;
235 1, 1, new_dv_vlc_bits, 2, 2, 0);
247 run = new_dv_vlc_run[
code] + 1;
248 level = new_dv_vlc_level[
code];
const uint8_t ff_dv_vlc_len[NB_DV_VLC]
#define DV_PROFILE_IS_1080i50(p)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
#define DV_PROFILE_IS_720p50(p)
enum AVPixelFormat pix_fmt
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
const uint16_t ff_dv_vlc_bits[NB_DV_VLC]
DVwork_chunk work_chunks[4 *12 *27]
uint16_t mb_coordinates[5]
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
common internal API header
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
RL_VLC_ELEM ff_dv_rl_vlc[1664]
Libavcodec external API header.
static const int remap[16]
main external API structure.
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static void dv_calc_mb_coordinates(const AVDVProfile *d, int chan, int seq, int slot, uint16_t *tbl)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
VLC_TYPE(* table)[2]
code, bits
const uint8_t ff_dv_vlc_run[NB_DV_VLC]
void ff_free_vlc(VLC *vlc)
const uint8_t ff_dv_vlc_level[NB_DV_VLC]