Go to the documentation of this file.
23 #define UNCHECKED_BITSTREAM_READER 1
25 #include "config_components.h"
53 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
54 #define IS_3IV1 (s->codec_tag == AV_RL32("3IV1"))
63 #define SPRITE_TRAJ_VLC_BITS 6
65 #define MB_TYPE_B_VLC_BITS 4
66 #define STUDIO_INTRA_BITS 9
85 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
86 uint8_t *
const *ref_picture)
89 int src_x, src_y, motion_x, motion_y;
90 ptrdiff_t
offset, linesize, uvlinesize;
93 motion_x =
ctx->sprite_offset[0][0];
94 motion_y =
ctx->sprite_offset[0][1];
95 src_x =
s->mb_x * 16 + (motion_x >> (
ctx->sprite_warping_accuracy + 1));
96 src_y =
s->mb_y * 16 + (motion_y >> (
ctx->sprite_warping_accuracy + 1));
97 motion_x *= 1 << (3 -
ctx->sprite_warping_accuracy);
98 motion_y *= 1 << (3 -
ctx->sprite_warping_accuracy);
99 src_x =
av_clip(src_x, -16,
s->width);
100 if (src_x ==
s->width)
102 src_y =
av_clip(src_y, -16,
s->height);
103 if (src_y ==
s->height)
106 linesize =
s->linesize;
107 uvlinesize =
s->uvlinesize;
109 ptr = ref_picture[0] + src_y * linesize + src_x;
111 if ((
unsigned)src_x >=
FFMAX(
s->h_edge_pos - 17, 0) ||
112 (
unsigned)src_y >=
FFMAX(
s->v_edge_pos - 17, 0)) {
113 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr,
117 s->h_edge_pos,
s->v_edge_pos);
118 ptr =
s->sc.edge_emu_buffer;
121 if ((motion_x | motion_y) & 7) {
122 ctx->mdsp.gmc1(dest_y, ptr, linesize, 16,
123 motion_x & 15, motion_y & 15, 128 -
s->no_rounding);
124 ctx->mdsp.gmc1(dest_y + 8, ptr + 8, linesize, 16,
125 motion_x & 15, motion_y & 15, 128 -
s->no_rounding);
129 dxy = ((motion_x >> 3) & 1) | ((motion_y >> 2) & 2);
130 if (
s->no_rounding) {
131 s->hdsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
133 s->hdsp.put_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
140 motion_x =
ctx->sprite_offset[1][0];
141 motion_y =
ctx->sprite_offset[1][1];
142 src_x =
s->mb_x * 8 + (motion_x >> (
ctx->sprite_warping_accuracy + 1));
143 src_y =
s->mb_y * 8 + (motion_y >> (
ctx->sprite_warping_accuracy + 1));
144 motion_x *= 1 << (3 -
ctx->sprite_warping_accuracy);
145 motion_y *= 1 << (3 -
ctx->sprite_warping_accuracy);
146 src_x =
av_clip(src_x, -8,
s->width >> 1);
147 if (src_x ==
s->width >> 1)
149 src_y =
av_clip(src_y, -8,
s->height >> 1);
150 if (src_y ==
s->height >> 1)
153 offset = (src_y * uvlinesize) + src_x;
154 ptr = ref_picture[1] +
offset;
155 if ((
unsigned)src_x >=
FFMAX((
s->h_edge_pos >> 1) - 9, 0) ||
156 (unsigned)src_y >=
FFMAX((
s->v_edge_pos >> 1) - 9, 0)) {
157 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr,
158 uvlinesize, uvlinesize,
161 s->h_edge_pos >> 1,
s->v_edge_pos >> 1);
162 ptr =
s->sc.edge_emu_buffer;
165 ctx->mdsp.gmc1(dest_cb, ptr, uvlinesize, 8,
166 motion_x & 15, motion_y & 15, 128 -
s->no_rounding);
168 ptr = ref_picture[2] +
offset;
170 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr,
171 uvlinesize, uvlinesize,
174 s->h_edge_pos >> 1,
s->v_edge_pos >> 1);
175 ptr =
s->sc.edge_emu_buffer;
177 ctx->mdsp.gmc1(dest_cr, ptr, uvlinesize, 8,
178 motion_x & 15, motion_y & 15, 128 -
s->no_rounding);
182 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
183 uint8_t *
const *ref_picture)
186 int linesize, uvlinesize;
187 const int a =
ctx->sprite_warping_accuracy;
190 linesize =
s->linesize;
191 uvlinesize =
s->uvlinesize;
193 ptr = ref_picture[0];
195 ox =
ctx->sprite_offset[0][0] +
ctx->sprite_delta[0][0] *
s->mb_x * 16 +
196 ctx->sprite_delta[0][1] *
s->mb_y * 16;
197 oy =
ctx->sprite_offset[0][1] +
ctx->sprite_delta[1][0] *
s->mb_x * 16 +
198 ctx->sprite_delta[1][1] *
s->mb_y * 16;
200 ctx->mdsp.gmc(dest_y, ptr, linesize, 16,
202 ctx->sprite_delta[0][0],
ctx->sprite_delta[0][1],
203 ctx->sprite_delta[1][0],
ctx->sprite_delta[1][1],
204 a + 1, (1 << (2 *
a + 1)) -
s->no_rounding,
205 s->h_edge_pos,
s->v_edge_pos);
206 ctx->mdsp.gmc(dest_y + 8, ptr, linesize, 16,
207 ox +
ctx->sprite_delta[0][0] * 8,
208 oy +
ctx->sprite_delta[1][0] * 8,
209 ctx->sprite_delta[0][0],
ctx->sprite_delta[0][1],
210 ctx->sprite_delta[1][0],
ctx->sprite_delta[1][1],
211 a + 1, (1 << (2 *
a + 1)) -
s->no_rounding,
212 s->h_edge_pos,
s->v_edge_pos);
217 ox =
ctx->sprite_offset[1][0] +
ctx->sprite_delta[0][0] *
s->mb_x * 8 +
218 ctx->sprite_delta[0][1] *
s->mb_y * 8;
219 oy =
ctx->sprite_offset[1][1] +
ctx->sprite_delta[1][0] *
s->mb_x * 8 +
220 ctx->sprite_delta[1][1] *
s->mb_y * 8;
222 ptr = ref_picture[1];
223 ctx->mdsp.gmc(dest_cb, ptr, uvlinesize, 8,
225 ctx->sprite_delta[0][0],
ctx->sprite_delta[0][1],
226 ctx->sprite_delta[1][0],
ctx->sprite_delta[1][1],
227 a + 1, (1 << (2 *
a + 1)) -
s->no_rounding,
228 (
s->h_edge_pos + 1) >> 1, (
s->v_edge_pos + 1) >> 1);
230 ptr = ref_picture[2];
231 ctx->mdsp.gmc(dest_cr, ptr, uvlinesize, 8,
233 ctx->sprite_delta[0][0],
ctx->sprite_delta[0][1],
234 ctx->sprite_delta[1][0],
ctx->sprite_delta[1][1],
235 a + 1, (1 << (2 *
a + 1)) -
s->no_rounding,
236 (
s->h_edge_pos + 1) >> 1, (
s->v_edge_pos + 1) >> 1);
240 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
241 uint8_t *
const *ref_picture)
245 if (
ctx->real_sprite_warping_points == 1) {
255 uint8_t *dest_cr,
int block_size,
int uvlinesize,
256 int dct_linesize,
int dct_offset)
259 const int act_block_size = block_size * 2;
261 if (
ctx->dpcm_direction == 0) {
262 s->idsp.idct_put(dest_y, dct_linesize, (int16_t*)
ctx->block32[0]);
263 s->idsp.idct_put(dest_y + act_block_size, dct_linesize, (int16_t*)
ctx->block32[1]);
264 s->idsp.idct_put(dest_y + dct_offset, dct_linesize, (int16_t*)
ctx->block32[2]);
265 s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)
ctx->block32[3]);
267 dct_linesize = uvlinesize <<
s->interlaced_dct;
268 dct_offset =
s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
270 s->idsp.idct_put(dest_cb, dct_linesize, (int16_t*)
ctx->block32[4]);
271 s->idsp.idct_put(dest_cr, dct_linesize, (int16_t*)
ctx->block32[5]);
272 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)
ctx->block32[6]);
273 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)
ctx->block32[7]);
274 if (!
s->chroma_x_shift){
275 s->idsp.idct_put(dest_cb + act_block_size, dct_linesize, (int16_t*)
ctx->block32[8]);
276 s->idsp.idct_put(dest_cr + act_block_size, dct_linesize, (int16_t*)
ctx->block32[9]);
277 s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)
ctx->block32[10]);
278 s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)
ctx->block32[11]);
280 }
else if (
ctx->dpcm_direction == 1) {
281 uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
282 int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
283 for (
int i = 0;
i < 3;
i++) {
284 const uint16_t *
src =
ctx->dpcm_macroblock[
i];
285 int vsub =
i ?
s->chroma_y_shift : 0;
286 int hsub =
i ?
s->chroma_x_shift : 0;
289 for (
int h = 0;
h < (16 >> (vsub +
lowres));
h++){
291 dest_pcm[
i][
w] =
src[idx];
292 dest_pcm[
i] += linesize[
i] / 2;
297 uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
298 int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
300 for (
int i = 0;
i < 3;
i++) {
301 const uint16_t *
src =
ctx->dpcm_macroblock[
i];
302 int vsub =
i ?
s->chroma_y_shift : 0;
303 int hsub =
i ?
s->chroma_x_shift : 0;
306 dest_pcm[
i] += (linesize[
i] / 2) * ((16 >> vsub +
lowres) - 1);
307 for (
int h = (16 >> (vsub +
lowres)) - 1;
h >= 0;
h--){
309 dest_pcm[
i][
w] =
src[idx];
311 dest_pcm[
i] -= linesize[
i] / 2;
325 int16_t *ac_val, *ac_val1;
326 int8_t *
const qscale_table =
s->cur_pic.qscale_table;
329 ac_val = &
s->ac_val[0][0][0] +
s->block_index[n] * 16;
333 const int xy =
s->mb_x - 1 +
s->mb_y *
s->mb_stride;
337 if (
s->mb_x == 0 ||
s->qscale == qscale_table[xy] ||
340 for (
i = 1;
i < 8;
i++)
341 block[
s->idsp.idct_permutation[
i << 3]] += ac_val[
i];
344 for (
i = 1;
i < 8;
i++)
345 block[
s->idsp.idct_permutation[
i << 3]] +=
ROUNDED_DIV(ac_val[
i] * qscale_table[xy],
s->qscale);
348 const int xy =
s->mb_x +
s->mb_y *
s->mb_stride -
s->mb_stride;
350 ac_val -= 16 *
s->block_wrap[n];
352 if (
s->mb_y == 0 ||
s->qscale == qscale_table[xy] ||
355 for (
i = 1;
i < 8;
i++)
356 block[
s->idsp.idct_permutation[
i]] += ac_val[
i + 8];
359 for (
i = 1;
i < 8;
i++)
365 for (
i = 1;
i < 8;
i++)
366 ac_val1[
i] =
block[
s->idsp.idct_permutation[
i << 3]];
370 ac_val1[8 +
i] =
block[
s->idsp.idct_permutation[
i]];
388 (v >> (8 -
s->pict_type) != 1) ||
s->partitioned_frame)
391 bits_count += 8 +
s->pict_type;
395 if (bits_count + 8 >=
s->gb.size_in_bits) {
397 v |= 0x7F >> (7 - (bits_count & 7));
402 static const uint16_t mpeg4_resync_prefix[8] = {
403 0x7F00, 0x7E00, 0x7C00, 0x7800, 0x7000, 0x6000, 0x4000, 0x0000
406 if (v == mpeg4_resync_prefix[bits_count & 7]) {
408 int mb_num_bits =
av_log2(
s->mb_num - 1) + 1;
419 if (!mb_num || mb_num >
s->mb_num ||
get_bits_count(&
s->gb)+6 >
s->gb.size_in_bits)
434 int a = 2 <<
ctx->sprite_warping_accuracy;
435 int rho = 3 -
ctx->sprite_warping_accuracy;
441 int min_ab,
i, w2, h2, w3, h3;
442 int sprite_ref[4][2];
443 int virtual_ref[2][2];
448 const int vop_ref[4][2] = { { 0, 0 }, {
s->width, 0 },
449 { 0,
s->height }, {
s->width,
s->height } };
450 int d[4][2] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
452 if (
w <= 0 ||
h <= 0)
455 for (
i = 0;
i <
ctx->num_sprite_warping_points;
i++) {
463 if (!(
ctx->divx_version == 500 &&
ctx->divx_build == 413))
471 ctx->sprite_traj[
i][0] = d[
i][0] = x;
472 ctx->sprite_traj[
i][1] = d[
i][1] = y;
475 ctx->sprite_traj[
i][0] =
ctx->sprite_traj[
i][1] = 0;
479 while ((1 << beta) <
h)
485 if (
ctx->divx_version == 500 &&
ctx->divx_build == 413) {
486 sprite_ref[0][0] =
a * vop_ref[0][0] + d[0][0];
487 sprite_ref[0][1] =
a * vop_ref[0][1] + d[0][1];
488 sprite_ref[1][0] =
a * vop_ref[1][0] + d[0][0] + d[1][0];
489 sprite_ref[1][1] =
a * vop_ref[1][1] + d[0][1] + d[1][1];
490 sprite_ref[2][0] =
a * vop_ref[2][0] + d[0][0] + d[2][0];
491 sprite_ref[2][1] =
a * vop_ref[2][1] + d[0][1] + d[2][1];
493 sprite_ref[0][0] = (
a >> 1) * (2 * vop_ref[0][0] + d[0][0]);
494 sprite_ref[0][1] = (
a >> 1) * (2 * vop_ref[0][1] + d[0][1]);
495 sprite_ref[1][0] = (
a >> 1) * (2 * vop_ref[1][0] + d[0][0] + d[1][0]);
496 sprite_ref[1][1] = (
a >> 1) * (2 * vop_ref[1][1] + d[0][1] + d[1][1]);
497 sprite_ref[2][0] = (
a >> 1) * (2 * vop_ref[2][0] + d[0][0] + d[2][0]);
498 sprite_ref[2][1] = (
a >> 1) * (2 * vop_ref[2][1] + d[0][1] + d[2][1]);
508 virtual_ref[0][0] = 16 * (vop_ref[0][0] + w2) +
510 (
r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
511 w2 * (
r * sprite_ref[1][0] - 16LL * vop_ref[1][0])),
w);
512 virtual_ref[0][1] = 16 * vop_ref[0][1] +
514 (
r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
515 w2 * (
r * sprite_ref[1][1] - 16LL * vop_ref[1][1])),
w);
516 virtual_ref[1][0] = 16 * vop_ref[0][0] +
517 ROUNDED_DIV(((
h - h2) * (
r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
518 h2 * (
r * sprite_ref[2][0] - 16LL * vop_ref[2][0])),
h);
519 virtual_ref[1][1] = 16 * (vop_ref[0][1] + h2) +
520 ROUNDED_DIV(((
h - h2) * (
r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
521 h2 * (
r * sprite_ref[2][1] - 16LL * vop_ref[2][1])),
h);
523 switch (
ctx->num_sprite_warping_points) {
525 sprite_offset[0][0] =
526 sprite_offset[0][1] =
527 sprite_offset[1][0] =
528 sprite_offset[1][1] = 0;
529 sprite_delta[0][0] =
a;
531 sprite_delta[1][0] = 0;
532 sprite_delta[1][1] =
a;
533 ctx->sprite_shift[0] =
534 ctx->sprite_shift[1] = 0;
537 sprite_offset[0][0] = sprite_ref[0][0] -
a * vop_ref[0][0];
538 sprite_offset[0][1] = sprite_ref[0][1] -
a * vop_ref[0][1];
539 sprite_offset[1][0] = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -
540 a * (vop_ref[0][0] / 2);
541 sprite_offset[1][1] = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -
542 a * (vop_ref[0][1] / 2);
543 sprite_delta[0][0] =
a;
545 sprite_delta[1][0] = 0;
546 sprite_delta[1][1] =
a;
547 ctx->sprite_shift[0] =
548 ctx->sprite_shift[1] = 0;
551 sprite_offset[0][0] = ((
int64_t) sprite_ref[0][0] * (1 <<
alpha + rho)) +
552 ((
int64_t) -
r * sprite_ref[0][0] + virtual_ref[0][0]) *
554 ((
int64_t)
r * sprite_ref[0][1] - virtual_ref[0][1]) *
556 sprite_offset[0][1] = ((
int64_t) sprite_ref[0][1] * (1 <<
alpha + rho)) +
557 ((
int64_t) -
r * sprite_ref[0][1] + virtual_ref[0][1]) *
559 ((
int64_t) -
r * sprite_ref[0][0] + virtual_ref[0][0]) *
561 sprite_offset[1][0] = (((
int64_t)-
r * sprite_ref[0][0] + virtual_ref[0][0]) *
562 ((
int64_t)-2 * vop_ref[0][0] + 1) +
563 ((
int64_t)
r * sprite_ref[0][1] - virtual_ref[0][1]) *
564 ((
int64_t)-2 * vop_ref[0][1] + 1) + 2 * w2 *
r *
565 (
int64_t) sprite_ref[0][0] - 16 * w2 + (1 << (
alpha + rho + 1)));
566 sprite_offset[1][1] = (((
int64_t)-
r * sprite_ref[0][1] + virtual_ref[0][1]) *
567 ((
int64_t)-2 * vop_ref[0][0] + 1) +
568 ((
int64_t)-
r * sprite_ref[0][0] + virtual_ref[0][0]) *
569 ((
int64_t)-2 * vop_ref[0][1] + 1) + 2 * w2 *
r *
570 (
int64_t) sprite_ref[0][1] - 16 * w2 + (1 << (
alpha + rho + 1)));
571 sprite_delta[0][0] = (-
r * sprite_ref[0][0] + virtual_ref[0][0]);
572 sprite_delta[0][1] = (+
r * sprite_ref[0][1] - virtual_ref[0][1]);
573 sprite_delta[1][0] = (-
r * sprite_ref[0][1] + virtual_ref[0][1]);
574 sprite_delta[1][1] = (-
r * sprite_ref[0][0] + virtual_ref[0][0]);
577 ctx->sprite_shift[1] =
alpha + rho + 2;
583 sprite_offset[0][0] = ((
int64_t)sprite_ref[0][0] * (1 << (
alpha + beta + rho - min_ab))) +
584 ((
int64_t)-
r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-vop_ref[0][0]) +
585 ((
int64_t)-
r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-vop_ref[0][1]) +
587 sprite_offset[0][1] = ((
int64_t)sprite_ref[0][1] * (1 << (
alpha + beta + rho - min_ab))) +
588 ((
int64_t)-
r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-vop_ref[0][0]) +
589 ((
int64_t)-
r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-vop_ref[0][1]) +
591 sprite_offset[1][0] = ((
int64_t)-
r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-2 * vop_ref[0][0] + 1) +
592 ((
int64_t)-
r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-2 * vop_ref[0][1] + 1) +
593 (
int64_t)2 * w2 * h3 *
r * sprite_ref[0][0] - 16 * w2 * h3 +
595 sprite_offset[1][1] = ((
int64_t)-
r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-2 * vop_ref[0][0] + 1) +
596 ((
int64_t)-
r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-2 * vop_ref[0][1] + 1) +
597 (
int64_t)2 * w2 * h3 *
r * sprite_ref[0][1] - 16 * w2 * h3 +
599 sprite_delta[0][0] = (-
r * (
int64_t)sprite_ref[0][0] + virtual_ref[0][0]) * h3;
600 sprite_delta[0][1] = (-
r * (
int64_t)sprite_ref[0][0] + virtual_ref[1][0]) * w3;
601 sprite_delta[1][0] = (-
r * (
int64_t)sprite_ref[0][1] + virtual_ref[0][1]) * h3;
602 sprite_delta[1][1] = (-
r * (
int64_t)sprite_ref[0][1] + virtual_ref[1][1]) * w3;
604 ctx->sprite_shift[0] =
alpha + beta + rho - min_ab;
605 ctx->sprite_shift[1] =
alpha + beta + rho - min_ab + 2;
611 if (sprite_delta[0][0] ==
a <<
ctx->sprite_shift[0] &&
612 sprite_delta[0][1] == 0 &&
613 sprite_delta[1][0] == 0 &&
614 sprite_delta[1][1] ==
a <<
ctx->sprite_shift[0]) {
615 sprite_offset[0][0] >>=
ctx->sprite_shift[0];
616 sprite_offset[0][1] >>=
ctx->sprite_shift[0];
617 sprite_offset[1][0] >>=
ctx->sprite_shift[1];
618 sprite_offset[1][1] >>=
ctx->sprite_shift[1];
619 sprite_delta[0][0] =
a;
620 sprite_delta[0][1] = 0;
621 sprite_delta[1][0] = 0;
622 sprite_delta[1][1] =
a;
623 ctx->sprite_shift[0] = 0;
624 ctx->sprite_shift[1] = 0;
625 ctx->real_sprite_warping_points = 1;
627 int shift_y = 16 -
ctx->sprite_shift[0];
628 int shift_c = 16 -
ctx->sprite_shift[1];
630 for (
i = 0;
i < 2;
i++) {
631 if (shift_c < 0 || shift_y < 0 ||
632 FFABS( sprite_offset[0][
i]) >= INT_MAX >> shift_y ||
633 FFABS( sprite_offset[1][
i]) >= INT_MAX >> shift_c ||
634 FFABS( sprite_delta[0][
i]) >= INT_MAX >> shift_y ||
635 FFABS( sprite_delta[1][
i]) >= INT_MAX >> shift_y
642 for (
i = 0;
i < 2;
i++) {
643 sprite_offset[0][
i] *= 1 << shift_y;
644 sprite_offset[1][
i] *= 1 << shift_c;
645 sprite_delta[0][
i] *= 1 << shift_y;
646 sprite_delta[1][
i] *= 1 << shift_y;
647 ctx->sprite_shift[
i] = 16;
650 for (
i = 0;
i < 2;
i++) {
652 sprite_delta[
i][0] -
a * (1LL<<16),
653 sprite_delta[
i][1] -
a * (1LL<<16)
656 if (llabs(sprite_offset[0][
i] + sprite_delta[
i][0] * (
w+16LL)) >= INT_MAX ||
657 llabs(sprite_offset[0][
i] + sprite_delta[
i][1] * (
h+16LL)) >= INT_MAX ||
658 llabs(sprite_offset[0][
i] + sprite_delta[
i][0] * (
w+16LL) + sprite_delta[
i][1] * (
h+16LL)) >= INT_MAX ||
659 llabs(sprite_delta[
i][0] * (
w+16LL)) >= INT_MAX ||
660 llabs(sprite_delta[
i][1] * (
h+16LL)) >= INT_MAX ||
661 llabs(sd[0]) >= INT_MAX ||
662 llabs(sd[1]) >= INT_MAX ||
663 llabs(sprite_offset[0][
i] + sd[0] * (
w+16LL)) >= INT_MAX ||
664 llabs(sprite_offset[0][
i] + sd[1] * (
h+16LL)) >= INT_MAX ||
665 llabs(sprite_offset[0][
i] + sd[0] * (
w+16LL) + sd[1] * (
h+16LL)) >= INT_MAX
671 ctx->real_sprite_warping_points =
ctx->num_sprite_warping_points;
674 for (
i = 0;
i < 4;
i++) {
675 ctx->sprite_offset[
i&1][
i>>1] = sprite_offset[
i&1][
i>>1];
676 ctx->sprite_delta [
i&1][
i>>1] = sprite_delta [
i&1][
i>>1];
681 memset(
ctx->sprite_offset, 0,
sizeof(
ctx->sprite_offset));
682 memset(
ctx->sprite_delta, 0,
sizeof(
ctx->sprite_delta));
706 int mb_num_bits =
av_log2(
s->mb_num - 1) + 1;
707 int header_extension = 0, mb_num,
len;
728 if (mb_num >=
s->mb_num || !mb_num) {
730 "illegal mb_num in video packet (%d %d) \n", mb_num,
s->mb_num);
734 s->mb_x = mb_num %
s->mb_width;
735 s->mb_y = mb_num /
s->mb_width;
740 s->chroma_qscale =
s->qscale = qscale;
746 if (header_extension) {
750 check_marker(
s->avctx, &
s->gb,
"before time_increment in video packed header");
752 check_marker(
s->avctx, &
s->gb,
"before vop_coding_type in video packed header");
773 "Error, video packet header damaged (f_code=0)\n");
779 "Error, video packet header damaged (b_code=0)\n");
794 s->last_dc[2] = 1 << (
s->avctx->bits_per_raw_sample +
s->dct_precision +
s->intra_dc_precision - 1);
809 vlc_len =
av_log2(
s->mb_width *
s->mb_height) + 1;
812 if (mb_num >=
s->mb_num)
815 s->mb_x = mb_num %
s->mb_width;
816 s->mb_y = mb_num /
s->mb_width;
846 int x, y, mb_v, sum, dx, dy,
shift;
847 int len = 1 << (
ctx->f_code + 4);
848 const int a =
ctx->sprite_warping_accuracy;
851 len >>=
s->quarter_sample;
853 if (
ctx->real_sprite_warping_points == 1) {
854 if (
ctx->divx_version == 500 &&
ctx->divx_build == 413 &&
a >=
s->quarter_sample)
855 sum =
ctx->sprite_offset[0][n] / (1 << (
a -
s->quarter_sample));
857 sum =
RSHIFT(
ctx->sprite_offset[0][n] * (1 <<
s->quarter_sample),
a);
859 dx =
ctx->sprite_delta[n][0];
860 dy =
ctx->sprite_delta[n][1];
863 dy -= 1 << (
shift +
a + 1);
865 dx -= 1 << (
shift +
a + 1);
866 mb_v =
ctx->sprite_offset[0][n] + dx *
s->mb_x * 16
U + dy *
s->mb_y * 16
U;
869 for (y = 0; y < 16; y++) {
872 v = mb_v + (unsigned)dy * y;
874 for (x = 0; x < 16; x++) {
879 sum =
RSHIFT(sum,
a + 8 -
s->quarter_sample);
892 int scale = n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
904 if (
level & (~2047)) {
908 "dc<0 at %dx%d\n",
s->mb_x,
s->mb_y);
913 "dc overflow at %dx%d\n",
s->mb_x,
s->mb_y);
922 s->dc_val[0][
s->block_index[n]] =
level;
985 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
988 s->first_slice_line = 1;
989 for (;
s->mb_y <
s->mb_height;
s->mb_y++) {
991 for (;
s->mb_x <
s->mb_width;
s->mb_x++) {
992 const int xy =
s->mb_x +
s->mb_y *
s->mb_stride;
998 if (
s->mb_x ==
s->resync_mb_x &&
s->mb_y ==
s->resync_mb_y + 1)
999 s->first_slice_line = 0;
1011 "mcbpc corrupted at %d %d\n",
s->mb_x,
s->mb_y);
1014 }
while (cbpc == 8);
1016 s->cbp_table[xy] = cbpc & 3;
1023 s->cur_pic.qscale_table[xy] =
s->qscale;
1025 s->mbintra_table[xy] = 1;
1026 for (
i = 0;
i < 6;
i++) {
1031 "DC corrupted at %d %d\n",
s->mb_x,
s->mb_y);
1038 s->pred_dir_table[xy] = dir;
1041 int16_t *
const mot_val =
s->cur_pic.motion_val[0][
s->block_index[0]];
1042 const int stride =
s->b8_stride * 2;
1050 if (
bits & 0x10000) {
1075 if (
s->mbintra_table[xy])
1083 "mcbpc corrupted at %d %d\n",
s->mb_x,
s->mb_y);
1089 s->cbp_table[xy] = cbpc & (8 + 3);
1091 s->mb_intra = ((cbpc & 4) != 0);
1095 s->mbintra_table[xy] = 1;
1105 if (
s->mbintra_table[xy])
1115 if ((cbpc & 16) == 0) {
1149 for (
i = 0;
i < 4;
i++) {
1178 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1180 s->mb_x =
s->resync_mb_x;
1181 s->first_slice_line = 1;
1182 for (
s->mb_y =
s->resync_mb_y; mb_num < mb_count; s->mb_y++) {
1184 for (; mb_num < mb_count &&
s->mb_x <
s->mb_width;
s->mb_x++) {
1185 const int xy =
s->mb_x +
s->mb_y *
s->mb_stride;
1189 if (
s->mb_x ==
s->resync_mb_x &&
s->mb_y ==
s->resync_mb_y + 1)
1190 s->first_slice_line = 0;
1197 "cbpy corrupted at %d %d\n",
s->mb_x,
s->mb_y);
1201 s->cbp_table[xy] |= cbpy << 2;
1212 "I cbpy corrupted at %d %d\n",
s->mb_x,
s->mb_y);
1216 if (
s->cbp_table[xy] & 8)
1218 s->cur_pic.qscale_table[xy] =
s->qscale;
1220 for (
i = 0;
i < 6;
i++) {
1225 "DC corrupted at %d %d\n",
s->mb_x,
s->mb_y);
1232 s->cbp_table[xy] &= 3;
1233 s->cbp_table[xy] |= cbpy << 2;
1235 s->pred_dir_table[xy] = dir;
1236 }
else if (
IS_SKIP(
s->cur_pic.mb_type[xy])) {
1237 s->cur_pic.qscale_table[xy] =
s->qscale;
1238 s->cbp_table[xy] = 0;
1244 "P cbpy corrupted at %d %d\n",
s->mb_x,
s->mb_y);
1248 if (
s->cbp_table[xy] & 8)
1250 s->cur_pic.qscale_table[xy] =
s->qscale;
1252 s->cbp_table[xy] &= 3;
1253 s->cbp_table[xy] |= (cbpy ^ 0xf) << 2;
1257 if (mb_num >= mb_count)
1279 s->mb_x,
s->mb_y, part_a_error);
1283 if (
s->resync_mb_x +
s->resync_mb_y *
s->mb_width + mb_num >
s->mb_num) {
1286 s->mb_x,
s->mb_y, part_a_error);
1290 s->mb_num_left = mb_num;
1297 "marker missing after first I partition at %d %d\n",
1306 "marker missing after first P partition at %d %d\n",
1312 s->mb_x - 1,
s->mb_y, part_a_end);
1334 int n,
int coded,
int intra,
1335 int use_intra_dc_vlc,
int rvlc)
1342 const uint8_t *scan_table;
1348 if (use_intra_dc_vlc) {
1350 if (
s->partitioned_frame) {
1351 level =
s->dc_val[0][
s->block_index[n]];
1356 dc_pred_dir = (
s->pred_dir_table[
s->mb_x +
s->mb_y *
s->mb_stride] << n) & 32;
1379 if (dc_pred_dir == 0)
1380 scan_table =
s->permutated_intra_v_scantable;
1382 scan_table =
s->permutated_intra_h_scantable;
1384 scan_table =
s->intra_scantable.permutated;
1391 s->block_last_index[n] =
i;
1399 scan_table =
s->intra_scantable.permutated;
1401 if (
s->mpeg_quant) {
1409 qmul =
s->qscale << 1;
1410 qadd = (
s->qscale - 1) | 1;
1427 "1. marker bit missing in rvlc esc\n");
1440 "2. marker bit missing in rvlc esc\n");
1466 cache ^= 0xC0000000;
1468 if (cache & 0x80000000) {
1469 if (cache & 0x40000000) {
1484 "1. marker bit missing in 3. esc\n");
1495 "2. marker bit missing in 3. esc\n");
1504 if (
s->error_recognition >= FF_ER_COMPLIANT) {
1507 const int run1=
run - rl->
max_run[last][abs_level] - 1;
1508 if (abs_level <= rl->max_level[last][
run]) {
1512 if (
s->error_recognition > FF_ER_COMPLIANT) {
1513 if (abs_level <= rl->max_level[last][
run]*2) {
1517 if (run1 >= 0 && abs_level <= rl->max_level[last][run1]) {
1530 if ((
unsigned)(
level + 2048) > 4095) {
1534 "|level| overflow in 3. esc, qp=%d\n",
1568 ff_tlog(
s->avctx,
"dct[%d][%d] = %- 4d end?:%d\n", scan_table[
i&63]&7, scan_table[
i&63] >> 3,
level,
i>62);
1573 "ac-tex damaged at %d %d\n",
s->mb_x,
s->mb_y);
1588 if (!use_intra_dc_vlc) {
1598 s->block_last_index[n] =
i;
1609 int cbp, mb_type, use_intra_dc_vlc;
1610 const int xy =
s->mb_x +
s->mb_y *
s->mb_stride;
1614 mb_type =
s->cur_pic.mb_type[xy];
1615 cbp =
s->cbp_table[xy];
1617 use_intra_dc_vlc =
s->qscale <
ctx->intra_dc_threshold;
1619 if (
s->cur_pic.qscale_table[xy] !=
s->qscale)
1625 for (
i = 0;
i < 4;
i++) {
1626 s->mv[0][
i][0] =
s->cur_pic.motion_val[0][
s->block_index[
i]][0];
1627 s->mv[0][
i][1] =
s->cur_pic.motion_val[0][
s->block_index[
i]][1];
1633 for (
i = 0;
i < 6;
i++)
1634 s->block_last_index[
i] = -1;
1641 s->cur_pic.mbskip_table[xy] = 0;
1645 s->cur_pic.mbskip_table[xy] = 1;
1647 }
else if (
s->mb_intra) {
1649 }
else if (!
s->mb_intra) {
1666 s->bdsp.clear_blocks(
s->block[0]);
1668 for (
i = 0;
i < 6;
i++) {
1670 use_intra_dc_vlc,
ctx->rvlc) < 0) {
1672 "texture corrupted at %d %d %d\n",
1673 s->mb_x,
s->mb_y,
s->mb_intra);
1681 if (--
s->mb_num_left <= 0) {
1688 const int delta =
s->mb_x + 1 ==
s->mb_width ? 2 : 1;
1689 if (
s->cbp_table[xy +
delta])
1699 int cbpc, cbpy,
i, cbp, pred_x, pred_y,
mx,
my, dquant;
1700 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1701 const int xy =
s->mb_x +
s->mb_y *
s->mb_stride;
1713 for (
i = 0;
i < 6;
i++)
1714 s->block_last_index[
i] = -1;
1726 s->cur_pic.mbskip_table[xy] = 0;
1734 s->cur_pic.mbskip_table[xy] = 1;
1742 "mcbpc damaged at %d %d\n",
s->mb_x,
s->mb_y);
1745 }
while (cbpc == 20);
1747 s->bdsp.clear_blocks(
s->block[0]);
1749 s->mb_intra = ((cbpc & 4) != 0);
1761 "P cbpy damaged at %d %d\n",
s->mb_x,
s->mb_y);
1765 cbp = (cbpc & 3) | (cbpy << 2);
1768 if ((!
s->progressive_sequence) &&
1773 if ((cbpc & 16) == 0) {
1781 s->mv[0][0][0] =
mx;
1782 s->mv[0][0][1] =
my;
1783 }
else if ((!
s->progressive_sequence) &&
get_bits1(&
s->gb)) {
1794 for (
i = 0;
i < 2;
i++) {
1803 s->mv[0][
i][0] =
mx;
1804 s->mv[0][
i][1] =
my;
1820 s->mv[0][0][0] =
mx;
1821 s->mv[0][0][1] =
my;
1826 for (
i = 0;
i < 4;
i++) {
1835 s->mv[0][
i][0] =
mx;
1836 s->mv[0][
i][1] =
my;
1850 for (
i = 0;
i < 2;
i++) {
1851 s->last_mv[
i][0][0] =
1852 s->last_mv[
i][0][1] =
1853 s->last_mv[
i][1][0] =
1854 s->last_mv[
i][1][1] = 0;
1861 s->mb_skipped =
s->next_pic.mbskip_table[
s->mb_y *
s->mb_stride +
s->mb_x];
1863 if (
s->mb_skipped) {
1865 for (
i = 0;
i < 6;
i++)
1866 s->block_last_index[
i] = -1;
1895 s->bdsp.clear_blocks(
s->block[0]);
1904 if (!
s->progressive_sequence) {
1932 s->last_mv[0][1][0] =
1933 s->last_mv[0][0][0] =
1934 s->mv[0][0][0] =
mx;
1935 s->last_mv[0][1][1] =
1936 s->last_mv[0][0][1] =
1937 s->mv[0][0][1] =
my;
1945 s->last_mv[1][1][0] =
1946 s->last_mv[1][0][0] =
1947 s->mv[1][0][0] =
mx;
1948 s->last_mv[1][1][1] =
1949 s->last_mv[1][0][1] =
1950 s->mv[1][0][1] =
my;
1958 for (
i = 0;
i < 2;
i++) {
1961 s->last_mv[0][
i][0] =
1962 s->mv[0][
i][0] =
mx;
1963 s->last_mv[0][
i][1] = (
s->mv[0][
i][1] =
my) * 2;
1970 for (
i = 0;
i < 2;
i++) {
1973 s->last_mv[1][
i][0] =
1974 s->mv[1][
i][0] =
mx;
1975 s->last_mv[1][
i][1] = (
s->mv[1][
i][1] =
my) * 2;
1993 s->cur_pic.mb_type[xy] = mb_type;
1995 int use_intra_dc_vlc;
2001 "I cbpc damaged at %d %d\n",
s->mb_x,
s->mb_y);
2004 }
while (cbpc == 8);
2019 "I cbpy damaged at %d %d\n",
s->mb_x,
s->mb_y);
2022 cbp = (cbpc & 3) | (cbpy << 2);
2024 use_intra_dc_vlc =
s->qscale <
ctx->intra_dc_threshold;
2029 if (!
s->progressive_sequence)
2032 s->bdsp.clear_blocks(
s->block[0]);
2034 for (
i = 0;
i < 6;
i++) {
2036 1, use_intra_dc_vlc, 0) < 0)
2044 for (
i = 0;
i < 6;
i++) {
2054 if (
s->mb_x +
s->mb_y*
s->mb_width + 1 > next && (
s->avctx->err_recognition &
AV_EF_AGGRESSIVE)) {
2056 }
else if (
s->mb_x +
s->mb_y*
s->mb_width + 1 >= next)
2060 const int delta =
s->mb_x + 1 ==
s->mb_width ? 2 : 1;
2062 (
s->mb_x +
delta >=
s->mb_width)
2063 ?
FFMIN(
s->mb_y + 1,
s->mb_height - 1)
2065 if (
s->next_pic.mbskip_table[xy +
delta])
2116 int cc, dct_dc_size, dct_diff,
code, j, idx = 1, group = 0,
run = 0,
2117 additional_code_len, sign, mismatch;
2119 const uint8_t *
const scantable =
s->intra_scantable.permutated;
2120 const uint16_t *quant_matrix;
2122 const int min = -1 * (1 << (
s->avctx->bits_per_raw_sample + 6));
2123 const int max = ((1 << (
s->avctx->bits_per_raw_sample + 6)) - 1);
2124 int shift = 3 -
s->dct_precision;
2133 quant_matrix =
s->intra_matrix;
2140 quant_matrix =
s->chroma_intra_matrix;
2143 if (dct_dc_size == 0) {
2148 if (dct_dc_size > 8) {
2155 s->last_dc[cc] += dct_diff;
2158 block[0] =
s->last_dc[cc] * (8 >>
s->intra_dc_precision);
2160 block[0] =
s->last_dc[cc] * (8 >>
s->intra_dc_precision) * (8 >>
s->dct_precision);
2164 mismatch ^=
block[0];
2181 }
else if (group >= 1 && group <= 6) {
2183 run = 1 << additional_code_len;
2184 if (additional_code_len)
2188 }
else if (group >= 7 && group <= 12) {
2193 run = (1 << (additional_code_len - 1)) +
code;
2197 j = scantable[idx++];
2198 block[j] = sign ? 1 : -1;
2199 }
else if (group >= 13 && group <= 20) {
2203 j = scantable[idx++];
2205 }
else if (group == 21) {
2209 j = scantable[idx++];
2210 additional_code_len =
s->avctx->bits_per_raw_sample +
s->dct_precision + 4;
2211 flc =
get_bits(&
s->gb, additional_code_len);
2212 if (flc >> (additional_code_len-1))
2213 block[j] = -1 * (( flc ^ ((1 << additional_code_len) -1)) + 1);
2219 mismatch ^=
block[j];
2222 block[63] ^= mismatch & 1;
2229 int i, j,
w,
h, idx = 0;
2230 int block_mean, rice_parameter, rice_prefix_code, rice_suffix_code,
2231 dpcm_residual,
left, top, topleft, min_left_top, max_left_top, p, p2,
output;
2232 h = 16 >> (n ?
s->chroma_y_shift : 0);
2233 w = 16 >> (n ?
s->chroma_x_shift : 0);
2235 block_mean =
get_bits(&
s->gb,
s->avctx->bits_per_raw_sample);
2236 if (block_mean == 0){
2240 s->last_dc[n] = block_mean * (1 << (
s->dct_precision +
s->intra_dc_precision));
2243 if (rice_parameter == 0) {
2248 if (rice_parameter == 15)
2251 if (rice_parameter > 11) {
2256 for (
i = 0;
i <
h;
i++) {
2257 output = 1 << (
s->avctx->bits_per_raw_sample - 1);
2258 top = 1 << (
s->avctx->bits_per_raw_sample - 1);
2260 for (j = 0; j <
w; j++) {
2267 if (rice_prefix_code == 11)
2268 dpcm_residual =
get_bits(&
s->gb,
s->avctx->bits_per_raw_sample);
2270 if (rice_prefix_code == 12) {
2274 rice_suffix_code =
get_bitsz(&
s->gb, rice_parameter);
2275 dpcm_residual = (rice_prefix_code << rice_parameter) + rice_suffix_code;
2279 if (dpcm_residual & 1)
2280 dpcm_residual = (-1 * dpcm_residual) >> 1;
2282 dpcm_residual = (dpcm_residual >> 1);
2285 top = macroblock[idx-
w];
2287 p =
left + top - topleft;
2289 if (p < min_left_top)
2293 if (p > max_left_top)
2296 p2 = (
FFMIN(min_left_top, topleft) +
FFMAX(max_left_top, topleft)) >> 1;
2301 dpcm_residual *= -1;
2303 macroblock[idx++] =
output = (dpcm_residual + p) & ((1 <<
s->avctx->bits_per_raw_sample) - 1);
2315 ctx->dpcm_direction = 0;
2336 for (
i = 0;
i < 3;
i++) {
2360 int hours, minutes, seconds;
2372 s->time_base = seconds + 60*(minutes + 60*hours);
2396 int visual_object_type;
2397 int is_visual_object_identifier =
get_bits1(gb);
2399 if (is_visual_object_identifier) {
2402 visual_object_type =
get_bits(gb, 4);
2407 if (video_signal_type) {
2408 int video_range, color_description;
2415 if (color_description) {
2416 s->avctx->color_primaries =
get_bits(gb, 8);
2431 for (
i = 0;
i < 64;
i++) {
2432 int j =
s->idsp.idct_permutation[
i];
2434 s->intra_matrix[j] = v;
2435 s->chroma_intra_matrix[j] = v;
2438 s->inter_matrix[j] = v;
2439 s->chroma_inter_matrix[j] = v;
2451 for (
i = 0;
i < 64;
i++) {
2454 s->intra_matrix[j] = v;
2455 s->chroma_intra_matrix[j] = v;
2463 for (
i = 0;
i < 64;
i++) {
2472 for (
i = 0;
i < 64;
i++) {
2475 s->chroma_intra_matrix[j] = v;
2483 for (
i = 0;
i < 64;
i++) {
2495 uint8_t extension_type;
2513 int bits_per_raw_sample;
2514 int rgb, chroma_format;
2534 bits_per_raw_sample =
get_bits(gb, 4);
2535 if (bits_per_raw_sample == 10) {
2545 if (
rgb !=
ctx->rgb ||
s->chroma_format != chroma_format)
2546 s->context_reinit = 1;
2547 s->avctx->bits_per_raw_sample = bits_per_raw_sample;
2549 s->chroma_format = chroma_format;
2552 check_marker(
s->avctx, gb,
"before video_object_layer_width");
2554 check_marker(
s->avctx, gb,
"before video_object_layer_height");
2556 check_marker(
s->avctx, gb,
"after video_object_layer_height");
2560 if (
s->width &&
s->height &&
2562 s->context_reinit = 1;
2567 aspect_ratio_info =
get_bits(gb, 4);
2569 s->avctx->sample_aspect_ratio.num =
get_bits(gb, 8);
2570 s->avctx->sample_aspect_ratio.den =
get_bits(gb, 8);
2580 check_marker(
s->avctx, gb,
"after first_half_vbv_buffer_size");
2583 check_marker(
s->avctx, gb,
"after first_half_vbv_buffer_size");
2585 check_marker(
s->avctx, gb,
"after latter_half_vbv_occupancy");
2613 s->studio_profile = 1;
2616 }
else if (
s->studio_profile) {
2626 aspect_ratio_info =
get_bits(gb, 4);
2628 s->avctx->sample_aspect_ratio.num =
get_bits(gb, 8);
2629 s->avctx->sample_aspect_ratio.den =
get_bits(gb, 8);
2635 int chroma_format =
get_bits(gb, 2);
2646 check_marker(
s->avctx, gb,
"after first_half_vbv_buffer_size");
2649 check_marker(
s->avctx, gb,
"after first_half_vbv_occupancy");
2651 check_marker(
s->avctx, gb,
"after latter_half_vbv_occupancy");
2656 if (
s->picture_number == 0) {
2657 switch (
ctx->vo_type) {
2676 check_marker(
s->avctx, gb,
"before time_increment_resolution");
2678 s->avctx->framerate.num =
get_bits(gb, 16);
2679 if (!
s->avctx->framerate.num) {
2684 ctx->time_increment_bits =
av_log2(
s->avctx->framerate.num - 1) + 1;
2685 if (
ctx->time_increment_bits < 1)
2686 ctx->time_increment_bits = 1;
2691 s->avctx->framerate.den =
get_bits(gb,
ctx->time_increment_bits);
2693 s->avctx->framerate.den = 1;
2705 !(
s->width &&
s->codec_tag ==
AV_RL32(
"MP4S"))) {
2706 if (
s->width &&
s->height &&
2708 s->context_reinit = 1;
2714 s->progressive_sequence =
2716 s->interlaced_dct = 0;
2719 "MPEG-4 OBMC not supported (very likely buggy encoder)\n");
2740 if (
ctx->num_sprite_warping_points > 3) {
2742 "%d sprite_warping_points\n",
2743 ctx->num_sprite_warping_points);
2744 ctx->num_sprite_warping_points = 0;
2758 if (
ctx->quant_precision != 5)
2760 "quant precision %d\n",
ctx->quant_precision);
2761 if (
ctx->quant_precision < 3 ||
ctx->quant_precision > 9)
2762 ctx->quant_precision = 5;
2764 ctx->quant_precision = 5;
2777 for (
i = 0;
i < 64;
i++) {
2789 s->intra_matrix[j] = last;
2793 for (;
i < 64;
i++) {
2795 s->intra_matrix[j] = last;
2802 for (
i = 0;
i < 64;
i++) {
2814 s->inter_matrix[j] = v;
2818 for (;
i < 64;
i++) {
2820 s->inter_matrix[j] = last;
2830 s->quarter_sample = 0;
2839 int estimation_method =
get_bits(gb, 2);
2840 if (estimation_method < 2) {
2855 if (!
check_marker(
s->avctx, gb,
"in complexity estimation part 1")) {
2873 if (!
check_marker(
s->avctx, gb,
"in complexity estimation part 2")) {
2877 if (estimation_method == 1) {
2883 "Invalid Complexity estimation method %d\n",
2888 ctx->cplx_estimation_trash_i =
2889 ctx->cplx_estimation_trash_p =
2890 ctx->cplx_estimation_trash_b = 0;
2896 if (
s->data_partitioning)
2899 if (vo_ver_id != 1) {
2901 if (
ctx->new_pred) {
2908 "reduced resolution VOP not supported\n");
2915 if (
ctx->scalability) {
2917 int h_sampling_factor_n;
2918 int h_sampling_factor_m;
2919 int v_sampling_factor_n;
2920 int v_sampling_factor_m;
2925 h_sampling_factor_n =
get_bits(gb, 5);
2926 h_sampling_factor_m =
get_bits(gb, 5);
2927 v_sampling_factor_n =
get_bits(gb, 5);
2928 v_sampling_factor_m =
get_bits(gb, 5);
2931 if (h_sampling_factor_n == 0 || h_sampling_factor_m == 0 ||
2932 v_sampling_factor_n == 0 || v_sampling_factor_m == 0) {
2935 ctx->scalability = 0;
2945 av_log(
s->avctx,
AV_LOG_DEBUG,
"tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d, low_delay:%d %s%s%s%s\n",
2946 s->avctx->framerate.den,
s->avctx->framerate.num,
2947 ctx->time_increment_bits,
2948 ctx->quant_precision,
2949 s->progressive_sequence,
2951 ctx->scalability ?
"scalability " :
"" ,
s->quarter_sample ?
"qpel " :
"",
2952 s->data_partitioning ?
"partition " :
"",
ctx->rvlc ?
"rvlc " :
""
2969 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
2980 e = sscanf(buf,
"DivX%dBuild%d%c", &ver, &build, &last);
2982 e = sscanf(buf,
"DivX%db%d%c", &ver, &build, &last);
2984 ctx->divx_version = ver;
2985 ctx->divx_build = build;
2986 s->divx_packed = e == 3 && last ==
'p';
2990 e = sscanf(buf,
"FFmpe%*[^b]b%d", &build) + 3;
2992 e = sscanf(buf,
"FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
2994 e = sscanf(buf,
"Lavc%d.%d.%d", &ver, &ver2, &ver3) + 1;
2996 if (ver > 0xFFU || ver2 > 0xFFU || ver3 > 0xFFU) {
2998 "Unknown Lavc version string encountered, %d.%d.%d; "
2999 "clamping sub-version values to 8-bits.\n",
3002 build = ((ver & 0xFF) << 16) + ((ver2 & 0xFF) << 8) + (ver3 & 0xFF);
3006 if (strcmp(buf,
"ffmpeg") == 0)
3007 ctx->lavc_build = 4600;
3010 ctx->lavc_build = build;
3013 e = sscanf(buf,
"XviD%d", &build);
3015 ctx->xvid_build = build;
3021 const uint8_t new_perm[64],
3022 const uint8_t old_perm[64])
3027 for (
int i = 0;
i < 64; ++
i)
3034 uint8_t old_permutation[64];
3036 memcpy(old_permutation,
s->idsp.idct_permutation,
sizeof(old_permutation));
3042 s->idsp.idct_permutation);
3054 if (
ctx->xvid_build == -1 &&
ctx->divx_version == -1 &&
ctx->lavc_build == -1) {
3055 if (
s->codec_tag ==
AV_RL32(
"XVID") ||
3060 ctx->xvid_build = 0;
3063 if (
ctx->xvid_build == -1 &&
ctx->divx_version == -1 &&
ctx->lavc_build == -1)
3064 if (
s->codec_tag ==
AV_RL32(
"DIVX") &&
ctx->vo_type == 0 &&
3065 ctx->vol_control_parameters == 0)
3066 ctx->divx_version = 400;
3068 if (
ctx->xvid_build >= 0 &&
ctx->divx_version >= 0) {
3070 ctx->divx_build = -1;
3074 if (
s->codec_tag ==
AV_RL32(
"XVIX"))
3077 if (
s->codec_tag ==
AV_RL32(
"UMP4"))
3080 if (
ctx->divx_version >= 500 &&
ctx->divx_build < 1814)
3083 if (
ctx->divx_version > 502 &&
ctx->divx_build < 1814)
3086 if (
ctx->xvid_build <= 3
U)
3087 s->padding_bug_score = 256 * 256 * 256 * 64;
3089 if (
ctx->xvid_build <= 1
U)
3092 if (
ctx->xvid_build <= 12
U)
3095 if (
ctx->xvid_build <= 32
U)
3098 #define SET_QPEL_FUNC(postfix1, postfix2) \
3099 s->qdsp.put_ ## postfix1 = ff_put_ ## postfix2; \
3100 s->qdsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2; \
3101 s->qdsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
3103 if (
ctx->lavc_build < 4653
U)
3106 if (
ctx->lavc_build < 4655
U)
3109 if (
ctx->lavc_build < 4670
U)
3112 if (
ctx->lavc_build <= 4712
U)
3115 if ((
ctx->lavc_build&0xFF) >= 100) {
3116 if (
ctx->lavc_build > 3621476 &&
ctx->lavc_build < 3752552 &&
3117 (
ctx->lavc_build < 3752037 ||
ctx->lavc_build > 3752191)
3122 if (
ctx->divx_version >= 0)
3124 if (
ctx->divx_version == 501 &&
ctx->divx_build == 20020416)
3125 s->padding_bug_score = 256 * 256 * 256 * 64;
3127 if (
ctx->divx_version < 500
U)
3130 if (
ctx->divx_version >= 0)
3152 "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
3153 s->workaround_bugs,
ctx->lavc_build,
ctx->xvid_build,
3154 ctx->divx_version,
ctx->divx_build,
s->divx_packed ?
"p" :
"");
3156 if (CONFIG_MPEG4_DECODER &&
ctx->xvid_build >= 0 &&
3166 int time_incr, time_increment;
3178 if (
s->partitioned_frame)
3189 if (
ctx->time_increment_bits == 0 ||
3192 "time_increment_bits %d is invalid in relation to the current bitstream, this is likely caused by a missing VOL header\n",
ctx->time_increment_bits);
3194 for (
ctx->time_increment_bits = 1;
3195 ctx->time_increment_bits < 16;
3196 ctx->time_increment_bits++) {
3200 if ((
show_bits(gb,
ctx->time_increment_bits + 6) & 0x37) == 0x30)
3202 }
else if ((
show_bits(gb,
ctx->time_increment_bits + 5) & 0x1F) == 0x18)
3207 "time_increment_bits set to %d bits, based on bitstream analysis\n",
ctx->time_increment_bits);
3213 time_increment =
get_bits(gb,
ctx->time_increment_bits);
3216 s->last_time_base =
s->time_base;
3217 s->time_base += time_incr;
3218 s->time =
s->time_base * (
int64_t)
s->avctx->framerate.num + time_increment;
3220 if (
s->time <
s->last_non_b_time) {
3224 s->time +=
s->avctx->framerate.num;
3227 s->pp_time =
s->time -
s->last_non_b_time;
3228 s->last_non_b_time =
s->time;
3230 s->time = (
s->last_time_base + time_incr) * (
int64_t)
s->avctx->framerate.num + time_increment;
3231 s->pb_time =
s->pp_time - (
s->last_non_b_time -
s->time);
3232 if (
s->pp_time <=
s->pb_time ||
3233 s->pp_time <=
s->pp_time -
s->pb_time ||
3240 if (
ctx->t_frame == 0)
3241 ctx->t_frame =
s->pb_time;
3242 if (
ctx->t_frame == 0)
3248 if (
s->pp_field_time <=
s->pb_field_time ||
s->pb_field_time <= 1) {
3249 s->pb_field_time = 2;
3250 s->pp_field_time = 4;
3251 if (!
s->progressive_sequence)
3256 if (
s->avctx->framerate.den)
3268 s->skipped_last_frame = 1;
3315 if (!
s->progressive_sequence) {
3319 s->alternate_scan = 0;
3327 if (
s->alternate_scan) {
3330 s->idsp.idct_permutation);
3334 s->idsp.idct_permutation);
3337 s->idsp.idct_permutation);
3344 if (
ctx->sprite_brightness_change)
3346 "sprite_brightness_change not supported\n");
3350 memset(
ctx->sprite_offset, 0,
sizeof(
ctx->sprite_offset));
3351 memset(
ctx->sprite_delta, 0,
sizeof(
ctx->sprite_delta));
3358 s->chroma_qscale =
s->qscale =
get_bits(gb,
ctx->quant_precision);
3359 if (
s->qscale == 0) {
3361 "Error, header damaged or not MPEG-4 header (qscale=0)\n");
3367 if (
ctx->f_code == 0) {
3369 "Error, header damaged or not MPEG-4 header (f_code=0)\n");
3377 if (
ctx->b_code == 0) {
3379 "Error, header damaged or not MPEG4 header (b_code=0)\n");
3387 "qp:%d fc:%d,%d %c size:%d pro:%d alt:%d top:%d %cpel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d time:%"PRId64
" tincr:%d\n",
3388 s->qscale,
ctx->f_code,
ctx->b_code,
3391 s->top_field_first,
s->quarter_sample ?
'q' :
'h',
3392 s->data_partitioning,
ctx->resync_marker,
3393 ctx->num_sprite_warping_points,
ctx->sprite_warping_accuracy,
3394 1 -
s->no_rounding,
ctx->vo_type,
3395 ctx->vol_control_parameters ?
" VOLC" :
" ",
ctx->intra_dc_threshold,
3396 ctx->cplx_estimation_trash_i,
ctx->cplx_estimation_trash_p,
3397 ctx->cplx_estimation_trash_b,
3403 if (!
ctx->scalability) {
3407 if (
ctx->enhancement_type) {
3408 int load_backward_shape =
get_bits1(gb);
3409 if (load_backward_shape)
3411 "load backward shape isn't supported\n");
3417 s->dct_unquantize_intra =
s->mpeg_quant ?
ctx->dct_unquantize_mpeg2_intra
3418 :
ctx->dct_unquantize_h263_intra;
3424 if (
ctx->vo_type == 0 &&
ctx->vol_control_parameters == 0 &&
3425 ctx->divx_version == -1 &&
s->picture_number == 0) {
3427 "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
3431 s->picture_number++;
3434 s->h_edge_pos =
s->width;
3435 s->v_edge_pos =
s->height;
3466 s->partitioned_frame = 0;
3467 s->interlaced_dct = 0;
3490 s->intra_dc_precision =
get_bits(gb, 2);
3508 int visual_object_type;
3511 visual_object_type =
get_bits(gb, 4);
3534 int header,
int parse_only)
3537 unsigned startcode, v;
3547 if (!
s->studio_profile &&
s->avctx->bits_per_raw_sample != 8)
3548 s->avctx->bits_per_raw_sample = 0;
3560 (
ctx->divx_version >= 0 ||
ctx->xvid_build >= 0) ||
s->codec_tag ==
AV_RL32(
"QMP4")) {
3571 startcode = ((startcode << 8) | v) & 0xffffffff;
3573 if ((startcode & 0xFFFFFF00) != 0x100)
3578 if (startcode <= 0x11F)
3579 name =
"Video Object Start";
3580 else if (startcode <= 0x12F)
3581 name =
"Video Object Layer Start";
3582 else if (startcode <= 0x13F)
3584 else if (startcode <= 0x15F)
3585 name =
"FGS bp start";
3586 else if (startcode <= 0x1AF)
3588 else if (startcode == 0x1B0)
3589 name =
"Visual Object Seq Start";
3590 else if (startcode == 0x1B1)
3591 name =
"Visual Object Seq End";
3592 else if (startcode == 0x1B2)
3594 else if (startcode == 0x1B3)
3595 name =
"Group of VOP start";
3596 else if (startcode == 0x1B4)
3597 name =
"Video Session Error";
3598 else if (startcode == 0x1B5)
3599 name =
"Visual Object Start";
3600 else if (startcode == 0x1B6)
3601 name =
"Video Object Plane start";
3602 else if (startcode == 0x1B7)
3603 name =
"slice start";
3604 else if (startcode == 0x1B8)
3605 name =
"extension start";
3606 else if (startcode == 0x1B9)
3608 else if (startcode == 0x1BA)
3609 name =
"FBA Object start";
3610 else if (startcode == 0x1BB)
3611 name =
"FBA Object Plane start";
3612 else if (startcode == 0x1BC)
3613 name =
"Mesh Object start";
3614 else if (startcode == 0x1BD)
3615 name =
"Mesh Object Plane start";
3616 else if (startcode == 0x1BE)
3617 name =
"Still Texture Object start";
3618 else if (startcode == 0x1BF)
3619 name =
"Texture Spatial Layer start";
3620 else if (startcode == 0x1C0)
3621 name =
"Texture SNR Layer start";
3622 else if (startcode == 0x1C1)
3623 name =
"Texture Tile start";
3624 else if (startcode == 0x1C2)
3625 name =
"Texture Shape Layer start";
3626 else if (startcode == 0x1C3)
3627 name =
"stuffing start";
3628 else if (startcode <= 0x1C5)
3630 else if (startcode <= 0x1FF)
3631 name =
"System start";
3636 if (startcode >= 0x120 && startcode <= 0x12F) {
3653 s->studio_profile = 1;
3656 }
else if (
s->studio_profile) {
3663 if (
s->studio_profile) {
3680 if (
s->studio_profile) {
3681 if (!
s->avctx->bits_per_raw_sample) {
3694 s->skipped_last_frame = 0;
3696 if (
ctx->bitstream_buffer) {
3698 int bitstream_buffer_size =
ctx->bitstream_buffer->size;
3699 const uint8_t *buf =
s->gb.buffer;
3701 if (
s->divx_packed) {
3702 for (
int i = 0;
i < buf_size - 3;
i++) {
3703 if (buf[
i] == 0 && buf[
i+1] == 0 && buf[
i+2] == 1) {
3704 if (buf[
i+3] == 0xB0) {
3706 bitstream_buffer_size = 0;
3712 ctx->bitstream_buffer->size = 0;
3713 if (bitstream_buffer_size && (
s->divx_packed || buf_size <=
MAX_NVOP_SIZE)) {
3715 bitstream_buffer_size);
3734 if (
s->divx_packed) {
3735 int current_pos =
ctx->bitstream_buffer &&
s->gb.buffer ==
ctx->bitstream_buffer->data ? 0 : (
get_bits_count(&
s->gb) >> 3);
3736 int startcode_found = 0;
3740 if (buf_size - current_pos > 7) {
3743 for (
i = current_pos;
i < buf_size - 4;
i++)
3748 buf[
i + 3] == 0xB6) {
3749 startcode_found = !(buf[
i + 4] & 0x40);
3754 if (startcode_found) {
3755 if (!
ctx->showed_packed_warning) {
3757 "wasteful way to store B-frames ('packed B-frames'). "
3758 "Consider using the mpeg4_unpack_bframes bitstream filter without encoding but stream copy to fix it.\n");
3759 ctx->showed_packed_warning = 1;
3765 ctx->bitstream_buffer->data = buf + current_pos;
3766 ctx->bitstream_buffer->size = buf_size - current_pos;
3773 #if CONFIG_MPEG4_DECODER
3777 memset(&
s->buffer_pools, 0,
sizeof(
s->buffer_pools));
3778 memset(&
s->next_pic, 0,
sizeof(
s->next_pic));
3779 memset(&
s->last_pic, 0,
sizeof(
s->last_pic));
3780 memset(&
s->cur_pic, 0,
sizeof(
s->cur_pic));
3782 memset(
s->thread_context, 0,
sizeof(
s->thread_context));
3786 s->ac_val_base =
NULL;
3790 memset(&
s->sc, 0,
sizeof(
s->sc));
3792 s->p_field_mv_table_base =
NULL;
3793 for (
int i = 0;
i < 2;
i++)
3794 for (
int j = 0; j < 2; j++)
3795 s->p_field_mv_table[
i][j] =
NULL;
3797 s->dc_val_base =
NULL;
3798 s->coded_block_base =
NULL;
3799 s->mbintra_table =
NULL;
3800 s->cbp_table =
NULL;
3801 s->pred_dir_table =
NULL;
3803 s->mbskip_table =
NULL;
3805 s->er.error_status_table =
NULL;
3806 s->er.er_temp_buffer =
NULL;
3807 s->mb_index2xy =
NULL;
3809 s->context_initialized = 0;
3810 s->context_reinit = 0;
3818 memcpy(
s, s1,
sizeof(*
s));
3836 int init =
s->m.context_initialized;
3840 ret = update_mpvctx(&
s->m, &s1->
m);
3900 static av_cold void mpeg4_init_static(
void)
3916 for (
unsigned i = 0;
i < 12;
i++) {
3956 ctx->lavc_build = -1;
3976 ctx->time_increment_bits = 4;
3977 ctx->quant_precision = 5;
4014 #define OFFSET(x) offsetof(MpegEncContext, x)
4015 #define FLAGS AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY
4022 static const AVClass mpeg4_class = {
4037 .close = mpeg4_close,
4042 .flush = mpeg4_flush,
4047 .p.priv_class = &mpeg4_class,
4049 #if CONFIG_MPEG4_NVDEC_HWACCEL
4052 #if CONFIG_MPEG4_VAAPI_HWACCEL
4055 #if CONFIG_MPEG4_VDPAU_HWACCEL
4058 #if CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
const AVProfile ff_mpeg4_video_profiles[]
#define MV_TYPE_16X16
1 vector for the whole mb
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
VLCElem ff_h263_cbpy_vlc[]
#define FF_ASPECT_EXTENDED
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
int sprite_warping_accuracy
int data_partitioning
data partitioning flag from header
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
static int get_bits_left(GetBitContext *gb)
av_cold void ff_xvid_idct_init(IDCTDSPContext *c, AVCodecContext *avctx)
int showed_packed_warning
flag for having shown the warning about invalid Divx B-frames
static const uint8_t mpeg4_block_count[4]
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
const uint8_t ff_sprite_trajectory_lens[15]
static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, int parse_only)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
static int get_bits_count(const GetBitContext *s)
static const uint8_t ac_state_tab[22][2]
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
@ AVCOL_RANGE_JPEG
Full range content.
static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64])
int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
Decode the next video packet.
static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
#define CORE_STUDIO_VO_TYPE
static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb)
#define AV_LOG_VERBOSE
Detailed information.
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac for the current non-intra MB.
static av_cold void switch_to_xvid_idct(AVCodecContext *const avctx, MpegEncContext *const s)
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
void ff_init_block_index(MpegEncContext *s)
#define UPDATE_CACHE(name, gb)
int ff_mpeg4_get_video_packet_prefix_length(enum AVPictureType pict_type, int f_code, int b_code)
const FFCodec ff_mpeg4_decoder
#define FF_BUG_HPEL_CHROMA
static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb)
static int mpeg4_decode_visual_object(MpegEncContext *s, GetBitContext *gb)
av_cold void ff_mpeg4_init_rl_intra(void)
#define FF_DEBUG_PICT_INFO
static int mpeg4_get_level_dc(MpegEncContext *s, int n, int pred, int level)
#define GET_CACHE(name, gb)
static void skip_bits(GetBitContext *s, int n)
static VLCElem studio_luma_dc[528]
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
int is_copy
When using frame-threaded decoding, this field is set for the first worker thread (e....
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
Decode the user data stuff in the header.
#define SKIP_CACHE(name, gb, num)
AVCodec p
The public AVCodec.
static int get_amv(Mpeg4DecContext *ctx, int n)
Get the average motion vector for a GMC MB.
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
#define MB_TYPE_B_VLC_BITS
#define STUDIO_INTRA_BITS
#define FF_BUG_QPEL_CHROMA2
#define AV_PIX_FMT_GBRP10
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
Predict the ac.
const AVRational ff_h263_pixel_aspect[16]
#define AV_EF_BITSTREAM
detect bitstream specification deviations
static const VLCElem * studio_intra_tab[12]
int flags
AV_CODEC_FLAG_*.
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb, int *profile, int *level)
#define HWACCEL_VDPAU(codec)
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
#define VOT_STILL_TEXTURE_ID
#define SLICE_END
end marker found
#define AV_PIX_FMT_YUV444P10
int ff_h263_decode_motion(MpegEncContext *s, int pred, int f_code)
#define HAS_FORWARD_MV(a)
static int ff_thread_once(char *control, void(*routine)(void))
int sprite_brightness_change
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define INIT_FIRST_VLC_RL(rl, static_size)
int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
Decode the first and second partition.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
#define AV_PROFILE_UNKNOWN
static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id)
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
static VLCElem sprite_trajectory[128]
#define CLOSE_READER(name, gb)
av_cold void ff_mpeg_flush(AVCodecContext *avctx)
#define FF_CODEC_DECODE_CB(func)
int8_t * max_level[2]
encoding & decoding
void(* dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
int cplx_estimation_trash_b
#define SHOW_SBITS(name, gb, num)
#define FF_BUG_NO_PADDING
RLTable ff_mpeg4_rl_intra
#define AV_EF_IGNORE_ERR
ignore errors and continue
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
#define SKIP_BITS(name, gb, num)
AVBufferRef * bitstream_buffer
Divx 5.01 puts several frames in a single one, this is used to reorder them.
#define FF_BUG_DIRECT_BLOCKSIZE
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.
#define CODEC_LONG_NAME(str)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)
static const VLCElem * rl_vlc[2]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
const uint8_t ff_mpeg4_DCtab_lum[13][2]
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
#define LIBAVUTIL_VERSION_INT
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
This function is a no-op in no-op mode; otherwise it waits until other threads have reached a certain...
static void mpeg4_load_default_matrices(MpegEncContext *s)
Describe the class of an AVClass context structure.
static const int16_t mb_type_b_map[4]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
av_cold void ff_mpv_idct_init(MpegEncContext *s)
static int ff_mpeg4_pred_dc(MpegEncContext *s, int n, int *dir_ptr)
Predict the dc.
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
av_cold int ff_mpv_decode_close(AVCodecContext *avctx)
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
decode partition C of one MB.
static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n)
struct AVCodecInternal * internal
Private context used for internal data.
#define SLICE_NOEND
no end marker or error found but mb count exceeded
#define ROUNDED_DIV(a, b)
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PICTURE_TYPE_I
Intra.
static unsigned int get_bits1(GetBitContext *s)
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
#define LAST_SKIP_BITS(name, gb, num)
VLCElem ff_h263_intra_MCBPC_vlc[]
#define SET_QPEL_FUNC(postfix1, postfix2)
#define ff_mpv_unquantize_init(s, bitexact, q_scale_type)
int cplx_estimation_trash_i
#define UPDATE_THREAD_CONTEXT(func)
const uint8_t ff_alternate_horizontal_scan[64]
#define AV_PIX_FMT_YUV422P10
static const AVOption mpeg4_options[]
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
#define VISUAL_OBJ_STARTCODE
const uint8_t ff_mpeg4_dc_threshold[8]
#define HAS_BACKWARD_MV(a)
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
#define ADV_SIMPLE_VO_TYPE
int ff_mpeg4_decode_picture_header(MpegEncContext *s)
static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
Decode first partition.
int t_frame
time distance of first I -> B, used for interlaced B-frames
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
const uint8_t ff_mpeg4_y_dc_scale_table[32]
static int shift(int a, int b)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
int sprite_shift[2]
sprite shift [isChroma]
#define FRAME_SKIPPED
Return value for header parsers if frame is not coded.
static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)
static int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, int n, int coded, int intra, int use_intra_dc_vlc, int rvlc)
Decode a block.
const int16_t ff_mpeg4_default_intra_matrix[64]
static int read_quant_matrix_ext(MpegEncContext *s, GetBitContext *gb)
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
int quarter_sample
1->qpel, 0->half pel ME/MC
static const uint8_t header[24]
int ff_mpeg4_parse_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int header, int parse_only)
Decode MPEG-4 headers.
#define MB_TYPE_INTERLACED
#define OPEN_READER(name, gb)
av_cold void ff_mpeg4videodsp_init(Mpeg4VideoDSPContext *c)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
const int16_t ff_mpeg4_default_non_intra_matrix[64]
void(* dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define MV_TYPE_FIELD
2 vectors, one per field
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
static void skip_bits1(GetBitContext *s)
#define HWACCEL_NVDEC(codec)
uint16_t sprite_traj[4][2]
sprite trajectory points
int cplx_estimation_trash_p
#define AV_LOG_INFO
Standard information.
static void gmc_motion(MpegEncContext *s, const Mpeg4DecContext *ctx, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture)
static av_cold void permute_quant_matrix(uint16_t matrix[64], const uint8_t new_perm[64], const uint8_t old_perm[64])
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
int time_increment_bits
number of bits to represent the fractional part of time
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
static int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
Decode the dc value.
#define SKIP_COUNTER(name, gb, num)
int num_sprite_warping_points
void ff_mpeg4_mcsel_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture)
#define i(width, name, range_min, range_max)
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
const uint8_t ff_alternate_vertical_scan[64]
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
int8_t * max_run[2]
encoding & decoding
int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
Decode the next video packet.
#define INTRA_MCBPC_VLC_BITS
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define FF_BUG_AUTODETECT
autodetection
#define MB_TYPE_BACKWARD_MV
#define FF_DEBUG_STARTCODE
static av_cold int decode_init(AVCodecContext *avctx)
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
const char * name
Name of the codec implementation.
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
int vol_control_parameters
does the stream contain the low_delay flag, used to work around buggy encoders.
#define AV_PROFILE_MPEG4_SIMPLE_STUDIO
#define FF_BUG_QPEL_CHROMA
#define VLC_INIT_STATIC_SPARSE_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, symbols, symbols_wrap, symbols_size, flags)
static void clear_context(SwrContext *s)
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
#define HWACCEL_VIDEOTOOLBOX(codec)
#define SPRITE_TRAJ_VLC_BITS
const uint8_t ff_mpeg4_studio_dc_luma[19][2]
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
const uint8_t ff_zigzag_direct[64]
#define AV_EF_AGGRESSIVE
consider things that a sane encoder/muxer should not do as an error
static const float pred[4]
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
const uint8_t ff_mpeg4_studio_dc_chroma[19][2]
static const uint8_t * align_get_bits(GetBitContext *s)
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
update_thread_context for mpegvideo-based decoders.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int block_size, int uvlinesize, int dct_linesize, int dct_offset)
static VLCElem mb_type_b_vlc[16]
main external API structure.
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
decode second partition.
#define SHOW_UBITS(name, gb, num)
const uint8_t ff_mb_type_b_tab[4][2]
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
int resync_marker
could this stream contain resync markers
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
#define USER_DATA_STARTCODE
static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)
static int mpeg4_is_resync(Mpeg4DecContext *ctx)
check if the next stuff is a resync marker or the end.
void ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
static VLCElem studio_chroma_dc[528]
static int mpeg4_decode_dpcm_macroblock(MpegEncContext *s, int16_t macroblock[256], int n)
@ AV_PICTURE_TYPE_P
Predicted.
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Undefined Behavior In the C some operations are like signed integer overflow
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define FF_BUG_XVID_ILACE
VLCElem ff_h263_inter_MCBPC_vlc[]
#define avpriv_request_sample(...)
static void reset_studio_dc_predictors(MpegEncContext *s)
const uint8_t ff_mpeg4_c_dc_scale_table[32]
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
#define VLC_INIT_RL(rl, static_size)
int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static void next_start_code_studio(GetBitContext *gb)
#define VLC_INIT_STATE(_table)
static const int16_t alpha[]
This structure stores compressed data.
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
Decode the next studio vop header.
static VLCElem dc_chrom[512]
static int mpeg_get_qscale(MpegEncContext *s)
#define HWACCEL_VAAPI(codec)
static VLCElem dc_lum[512]
static void gmc1_motion(MpegEncContext *s, const Mpeg4DecContext *ctx, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture)
static const SheerTable rgb[2]
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
The exact code depends on how similar the blocks are and how related they are to the block
#define UPDATE_THREAD_CONTEXT_FOR_USER(func)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb)
#define QUANT_MATRIX_EXT_ID
@ AV_PICTURE_TYPE_S
S(GMC)-VOP MPEG-4.
#define MB_TYPE_FORWARD_MV
RL_VLC_ELEM * rl_vlc[32]
decoding only
int intra_dc_threshold
QP above which the ac VLC should be used for intra dc.
#define INTER_MCBPC_VLC_BITS
#define SIMPLE_STUDIO_VO_TYPE
const uint8_t ff_mpeg4_studio_intra[12][24][2]