2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/imgutils.h"
33 #include "h264chroma.h"
36 #include "mpegvideo.h"
39 #include "xvmc_internal.h"
46 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
47 int16_t *block, int n, int qscale);
48 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
49 int16_t *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
51 int16_t *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
53 int16_t *block, int n, int qscale);
54 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
55 int16_t *block, int n, int qscale);
56 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
57 int16_t *block, int n, int qscale);
58 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
59 int16_t *block, int n, int qscale);
65 static const uint8_t ff_default_chroma_qscale_table[32] = {
66 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
67 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
68 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
71 const uint8_t ff_mpeg1_dc_scale_table[128] = {
72 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
73 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
74 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
80 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
83 static const uint8_t mpeg2_dc_scale_table1[128] = {
84 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
85 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
95 static const uint8_t mpeg2_dc_scale_table2[128] = {
96 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
97 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107 static const uint8_t mpeg2_dc_scale_table3[128] = {
108 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
109 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
110 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
113 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
116 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
119 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
120 ff_mpeg1_dc_scale_table,
121 mpeg2_dc_scale_table1,
122 mpeg2_dc_scale_table2,
123 mpeg2_dc_scale_table3,
126 const enum AVPixelFormat ff_pixfmt_list_420[] = {
131 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
133 int mb_x, int mb_y, int mb_intra, int mb_skipped)
135 MpegEncContext *s = opaque;
138 s->mv_type = mv_type;
139 s->mb_intra = mb_intra;
140 s->mb_skipped = mb_skipped;
143 memcpy(s->mv, mv, sizeof(*mv));
145 ff_init_block_index(s);
146 ff_update_block_index(s);
148 s->dsp.clear_blocks(s->block[0]);
150 s->dest[0] = s->current_picture.f.data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16;
151 s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
152 s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
155 ff_MPV_decode_mb(s, s->block);
158 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
160 uint32_t *av_restrict state)
168 for (i = 0; i < 3; i++) {
169 uint32_t tmp = *state << 8;
170 *state = tmp + *(p++);
171 if (tmp == 0x100 || p == end)
176 if (p[-1] > 1 ) p += 3;
177 else if (p[-2] ) p += 2;
178 else if (p[-3]|(p[-1]-1)) p++;
185 p = FFMIN(p, end) - 4;
191 /* init common dct for both encoder and decoder */
192 av_cold int ff_dct_common_init(MpegEncContext *s)
194 ff_dsputil_init(&s->dsp, s->avctx);
195 ff_h264chroma_init(&s->h264chroma, 8); //for lowres
196 ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
198 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
199 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
200 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
201 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
202 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
203 if (s->flags & CODEC_FLAG_BITEXACT)
204 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
205 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
208 ff_MPV_common_init_x86(s);
210 ff_MPV_common_init_axp(s);
212 ff_MPV_common_init_arm(s);
214 ff_MPV_common_init_altivec(s);
216 ff_MPV_common_init_bfin(s);
219 /* load & permutate scantables
220 * note: only wmv uses different ones
222 if (s->alternate_scan) {
223 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
224 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
226 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
227 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
229 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
230 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
235 void ff_copy_picture(Picture *dst, Picture *src)
238 dst->f.type = FF_BUFFER_TYPE_COPY;
242 * Release a frame buffer
244 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
246 pic->period_since_free = 0;
247 /* WM Image / Screen codecs allocate internal buffers with different
248 * dimensions / colorspaces; ignore user-defined callbacks for these. */
249 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
250 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
251 s->codec_id != AV_CODEC_ID_MSS2)
252 ff_thread_release_buffer(s->avctx, &pic->f);
254 avcodec_default_release_buffer(s->avctx, &pic->f);
255 av_freep(&pic->f.hwaccel_picture_private);
258 int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize)
260 int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
262 // edge emu needs blocksize + filter length - 1
263 // (= 17x17 for halfpel / 21x21 for h264)
264 // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
265 // at uvlinesize. It supports only YUV420 so 24x24 is enough
266 // linesize * interlaced * MBsize
267 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 4 * 24,
270 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 4 * 16 * 2,
272 s->me.temp = s->me.scratchpad;
273 s->rd_scratchpad = s->me.scratchpad;
274 s->b_scratchpad = s->me.scratchpad;
275 s->obmc_scratchpad = s->me.scratchpad + 16;
279 av_freep(&s->edge_emu_buffer);
280 return AVERROR(ENOMEM);
284 * Allocate a frame buffer
286 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
290 if (s->avctx->hwaccel) {
291 assert(!pic->f.hwaccel_picture_private);
292 if (s->avctx->hwaccel->priv_data_size) {
293 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
294 if (!pic->f.hwaccel_picture_private) {
295 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
301 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
302 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
303 s->codec_id != AV_CODEC_ID_MSS2)
304 r = ff_thread_get_buffer(s->avctx, &pic->f);
306 r = avcodec_default_get_buffer(s->avctx, &pic->f);
308 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
309 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
310 r, pic->f.type, pic->f.data[0]);
311 av_freep(&pic->f.hwaccel_picture_private);
315 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
316 s->uvlinesize != pic->f.linesize[1])) {
317 av_log(s->avctx, AV_LOG_ERROR,
318 "get_buffer() failed (stride changed)\n");
319 free_frame_buffer(s, pic);
323 if (pic->f.linesize[1] != pic->f.linesize[2]) {
324 av_log(s->avctx, AV_LOG_ERROR,
325 "get_buffer() failed (uv stride mismatch)\n");
326 free_frame_buffer(s, pic);
330 if (!s->edge_emu_buffer &&
331 (ret = ff_mpv_frame_size_alloc(s, pic->f.linesize[0])) < 0) {
332 av_log(s->avctx, AV_LOG_ERROR,
333 "get_buffer() failed to allocate context scratch buffers.\n");
334 free_frame_buffer(s, pic);
342 * Allocate a Picture.
343 * The pixels are allocated/set by calling get_buffer() if shared = 0
345 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
347 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
349 // the + 1 is needed so memset(,,stride*height) does not sig11
351 const int mb_array_size = s->mb_stride * s->mb_height;
352 const int b8_array_size = s->b8_stride * s->mb_height * 2;
353 const int b4_array_size = s->b4_stride * s->mb_height * 4;
358 assert(pic->f.data[0]);
359 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
360 pic->f.type = FF_BUFFER_TYPE_SHARED;
362 assert(!pic->f.data[0]);
364 if (alloc_frame_buffer(s, pic) < 0)
367 s->linesize = pic->f.linesize[0];
368 s->uvlinesize = pic->f.linesize[1];
371 if (pic->f.qscale_table == NULL) {
373 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
374 mb_array_size * sizeof(int16_t), fail)
375 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
376 mb_array_size * sizeof(int16_t), fail)
377 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
378 mb_array_size * sizeof(int8_t ), fail)
381 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
382 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
383 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
384 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
386 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
387 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
389 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
390 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
391 if (s->out_format == FMT_H264) {
392 for (i = 0; i < 2; i++) {
393 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
394 2 * (b4_array_size + 4) * sizeof(int16_t),
396 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
397 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
398 4 * mb_array_size * sizeof(uint8_t), fail)
400 pic->f.motion_subsample_log2 = 2;
401 } else if (s->out_format == FMT_H263 || s->encoding ||
402 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
403 for (i = 0; i < 2; i++) {
404 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
405 2 * (b8_array_size + 4) * sizeof(int16_t),
407 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
408 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
409 4 * mb_array_size * sizeof(uint8_t), fail)
411 pic->f.motion_subsample_log2 = 3;
413 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
414 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
415 64 * mb_array_size * sizeof(int16_t) * 6, fail)
417 pic->f.qstride = s->mb_stride;
418 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
419 1 * sizeof(AVPanScan), fail)
425 fail: // for the FF_ALLOCZ_OR_GOTO macro
427 free_frame_buffer(s, pic);
432 * Deallocate a picture.
434 static void free_picture(MpegEncContext *s, Picture *pic)
438 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
439 free_frame_buffer(s, pic);
442 av_freep(&pic->mb_var);
443 av_freep(&pic->mc_mb_var);
444 av_freep(&pic->mb_mean);
445 av_freep(&pic->f.mbskip_table);
446 av_freep(&pic->qscale_table_base);
447 pic->f.qscale_table = NULL;
448 av_freep(&pic->mb_type_base);
449 pic->f.mb_type = NULL;
450 av_freep(&pic->f.dct_coeff);
451 av_freep(&pic->f.pan_scan);
452 pic->f.mb_type = NULL;
453 for (i = 0; i < 2; i++) {
454 av_freep(&pic->motion_val_base[i]);
455 av_freep(&pic->f.ref_index[i]);
456 pic->f.motion_val[i] = NULL;
459 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
460 for (i = 0; i < 4; i++) {
462 pic->f.data[i] = NULL;
468 static int init_duplicate_context(MpegEncContext *s)
470 int y_size = s->b8_stride * (2 * s->mb_height + 1);
471 int c_size = s->mb_stride * (s->mb_height + 1);
472 int yc_size = y_size + 2 * c_size;
480 s->obmc_scratchpad = NULL;
483 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
484 ME_MAP_SIZE * sizeof(uint32_t), fail)
485 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
486 ME_MAP_SIZE * sizeof(uint32_t), fail)
487 if (s->avctx->noise_reduction) {
488 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
489 2 * 64 * sizeof(int), fail)
492 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
493 s->block = s->blocks[0];
495 for (i = 0; i < 12; i++) {
496 s->pblocks[i] = &s->block[i];
499 if (s->out_format == FMT_H263) {
501 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
502 yc_size * sizeof(int16_t) * 16, fail);
503 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
504 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
505 s->ac_val[2] = s->ac_val[1] + c_size;
510 return -1; // free() through ff_MPV_common_end()
513 static void free_duplicate_context(MpegEncContext *s)
518 av_freep(&s->edge_emu_buffer);
519 av_freep(&s->me.scratchpad);
523 s->obmc_scratchpad = NULL;
525 av_freep(&s->dct_error_sum);
526 av_freep(&s->me.map);
527 av_freep(&s->me.score_map);
528 av_freep(&s->blocks);
529 av_freep(&s->ac_val_base);
533 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
535 #define COPY(a) bak->a = src->a
536 COPY(edge_emu_buffer);
541 COPY(obmc_scratchpad);
548 COPY(me.map_generation);
560 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
564 // FIXME copy only needed parts
566 backup_duplicate_context(&bak, dst);
567 memcpy(dst, src, sizeof(MpegEncContext));
568 backup_duplicate_context(dst, &bak);
569 for (i = 0; i < 12; i++) {
570 dst->pblocks[i] = &dst->block[i];
572 if (!dst->edge_emu_buffer &&
573 (ret = ff_mpv_frame_size_alloc(dst, dst->linesize)) < 0) {
574 av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
575 "scratch buffers.\n");
578 // STOP_TIMER("update_duplicate_context")
579 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
583 int ff_mpeg_update_thread_context(AVCodecContext *dst,
584 const AVCodecContext *src)
588 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
595 // FIXME can parameters change on I-frames?
596 // in that case dst may need a reinit
597 if (!s->context_initialized) {
598 memcpy(s, s1, sizeof(MpegEncContext));
601 s->bitstream_buffer = NULL;
602 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
604 if (s1->context_initialized){
605 s->picture_range_start += MAX_PICTURE_COUNT;
606 s->picture_range_end += MAX_PICTURE_COUNT;
607 if((err = ff_MPV_common_init(s)) < 0){
608 memset(s, 0, sizeof(MpegEncContext));
615 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
616 s->context_reinit = 0;
617 s->height = s1->height;
618 s->width = s1->width;
619 if ((err = ff_MPV_common_frame_size_change(s)) < 0)
623 s->avctx->coded_height = s1->avctx->coded_height;
624 s->avctx->coded_width = s1->avctx->coded_width;
625 s->avctx->width = s1->avctx->width;
626 s->avctx->height = s1->avctx->height;
628 s->coded_picture_number = s1->coded_picture_number;
629 s->picture_number = s1->picture_number;
630 s->input_picture_number = s1->input_picture_number;
632 av_assert0(!s->picture || s->picture != s1->picture);
633 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
634 memcpy(&s->last_picture, &s1->last_picture,
635 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
637 // reset s->picture[].f.extended_data to s->picture[].f.data
638 for (i = 0; i < s->picture_count; i++) {
639 s->picture[i].f.extended_data = s->picture[i].f.data;
640 s->picture[i].period_since_free ++;
643 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
644 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
645 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
647 // Error/bug resilience
648 s->next_p_frame_damaged = s1->next_p_frame_damaged;
649 s->workaround_bugs = s1->workaround_bugs;
650 s->padding_bug_score = s1->padding_bug_score;
653 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
654 (char *) &s1->shape - (char *) &s1->time_increment_bits);
657 s->max_b_frames = s1->max_b_frames;
658 s->low_delay = s1->low_delay;
659 s->droppable = s1->droppable;
661 // DivX handling (doesn't work)
662 s->divx_packed = s1->divx_packed;
664 if (s1->bitstream_buffer) {
665 if (s1->bitstream_buffer_size +
666 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
667 av_fast_malloc(&s->bitstream_buffer,
668 &s->allocated_bitstream_buffer_size,
669 s1->allocated_bitstream_buffer_size);
670 s->bitstream_buffer_size = s1->bitstream_buffer_size;
671 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
672 s1->bitstream_buffer_size);
673 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
674 FF_INPUT_BUFFER_PADDING_SIZE);
677 // linesize dependend scratch buffer allocation
678 if (!s->edge_emu_buffer)
680 if (ff_mpv_frame_size_alloc(s, s1->linesize) < 0) {
681 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
682 "scratch buffers.\n");
683 return AVERROR(ENOMEM);
686 av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
687 "be allocated due to unknown size.\n");
690 // MPEG2/interlacing info
691 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
692 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
694 if (!s1->first_field) {
695 s->last_pict_type = s1->pict_type;
696 if (s1->current_picture_ptr)
697 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
699 if (s1->pict_type != AV_PICTURE_TYPE_B) {
700 s->last_non_b_pict_type = s1->pict_type;
708 * Set the given MpegEncContext to common defaults
709 * (same for encoding and decoding).
710 * The changed fields will not depend upon the
711 * prior state of the MpegEncContext.
713 void ff_MPV_common_defaults(MpegEncContext *s)
715 s->y_dc_scale_table =
716 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
717 s->chroma_qscale_table = ff_default_chroma_qscale_table;
718 s->progressive_frame = 1;
719 s->progressive_sequence = 1;
720 s->picture_structure = PICT_FRAME;
722 s->coded_picture_number = 0;
723 s->picture_number = 0;
724 s->input_picture_number = 0;
726 s->picture_in_gop_number = 0;
731 s->picture_range_start = 0;
732 s->picture_range_end = MAX_PICTURE_COUNT;
734 s->slice_context_count = 1;
738 * Set the given MpegEncContext to defaults for decoding.
739 * the changed fields will not depend upon
740 * the prior state of the MpegEncContext.
742 void ff_MPV_decode_defaults(MpegEncContext *s)
744 ff_MPV_common_defaults(s);
747 static int init_er(MpegEncContext *s)
749 ERContext *er = &s->er;
750 int mb_array_size = s->mb_height * s->mb_stride;
753 er->avctx = s->avctx;
756 er->mb_index2xy = s->mb_index2xy;
757 er->mb_num = s->mb_num;
758 er->mb_width = s->mb_width;
759 er->mb_height = s->mb_height;
760 er->mb_stride = s->mb_stride;
761 er->b8_stride = s->b8_stride;
763 er->er_temp_buffer = av_malloc(s->mb_height * s->mb_stride);
764 er->error_status_table = av_mallocz(mb_array_size);
765 if (!er->er_temp_buffer || !er->error_status_table)
768 er->mbskip_table = s->mbskip_table;
769 er->mbintra_table = s->mbintra_table;
771 for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
772 er->dc_val[i] = s->dc_val[i];
774 er->decode_mb = mpeg_er_decode_mb;
779 av_freep(&er->er_temp_buffer);
780 av_freep(&er->error_status_table);
781 return AVERROR(ENOMEM);
785 * Initialize and allocates MpegEncContext fields dependent on the resolution.
787 static int init_context_frame(MpegEncContext *s)
789 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
791 s->mb_width = (s->width + 15) / 16;
792 s->mb_stride = s->mb_width + 1;
793 s->b8_stride = s->mb_width * 2 + 1;
794 s->b4_stride = s->mb_width * 4 + 1;
795 mb_array_size = s->mb_height * s->mb_stride;
796 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
798 /* set default edge pos, will be overriden
799 * in decode_header if needed */
800 s->h_edge_pos = s->mb_width * 16;
801 s->v_edge_pos = s->mb_height * 16;
803 s->mb_num = s->mb_width * s->mb_height;
808 s->block_wrap[3] = s->b8_stride;
810 s->block_wrap[5] = s->mb_stride;
812 y_size = s->b8_stride * (2 * s->mb_height + 1);
813 c_size = s->mb_stride * (s->mb_height + 1);
814 yc_size = y_size + 2 * c_size;
816 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
817 for (y = 0; y < s->mb_height; y++)
818 for (x = 0; x < s->mb_width; x++)
819 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
821 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
824 /* Allocate MV tables */
825 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
826 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
827 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
828 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
829 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
830 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
831 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
832 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
833 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
834 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
835 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
836 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
838 /* Allocate MB type table */
839 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
841 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
843 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
844 mb_array_size * sizeof(float), fail);
845 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
846 mb_array_size * sizeof(float), fail);
850 if (s->codec_id == AV_CODEC_ID_MPEG4 ||
851 (s->flags & CODEC_FLAG_INTERLACED_ME)) {
852 /* interlaced direct mode decoding tables */
853 for (i = 0; i < 2; i++) {
855 for (j = 0; j < 2; j++) {
856 for (k = 0; k < 2; k++) {
857 FF_ALLOCZ_OR_GOTO(s->avctx,
858 s->b_field_mv_table_base[i][j][k],
859 mv_table_size * 2 * sizeof(int16_t),
861 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
864 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
865 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
866 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
868 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
871 if (s->out_format == FMT_H263) {
873 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
874 s->coded_block = s->coded_block_base + s->b8_stride + 1;
876 /* cbp, ac_pred, pred_dir */
877 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
878 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
881 if (s->h263_pred || s->h263_plus || !s->encoding) {
883 // MN: we need these for error resilience of intra-frames
884 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
885 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
886 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
887 s->dc_val[2] = s->dc_val[1] + c_size;
888 for (i = 0; i < yc_size; i++)
889 s->dc_val_base[i] = 1024;
892 /* which mb is a intra block */
893 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
894 memset(s->mbintra_table, 1, mb_array_size);
896 /* init macroblock skip table */
897 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
898 // Note the + 1 is for a quicker mpeg4 slice_end detection
902 return AVERROR(ENOMEM);
906 * init common structure for both encoder and decoder.
907 * this assumes that some variables like width/height are already set
909 av_cold int ff_MPV_common_init(MpegEncContext *s)
912 int nb_slices = (HAVE_THREADS &&
913 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
914 s->avctx->thread_count : 1;
916 if (s->encoding && s->avctx->slices)
917 nb_slices = s->avctx->slices;
919 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
920 s->mb_height = (s->height + 31) / 32 * 2;
921 else if (s->codec_id != AV_CODEC_ID_H264)
922 s->mb_height = (s->height + 15) / 16;
924 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
925 av_log(s->avctx, AV_LOG_ERROR,
926 "decoding to AV_PIX_FMT_NONE is not supported.\n");
930 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
933 max_slices = FFMIN(MAX_THREADS, s->mb_height);
935 max_slices = MAX_THREADS;
936 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
937 " reducing to %d\n", nb_slices, max_slices);
938 nb_slices = max_slices;
941 if ((s->width || s->height) &&
942 av_image_check_size(s->width, s->height, 0, s->avctx))
945 ff_dct_common_init(s);
947 s->flags = s->avctx->flags;
948 s->flags2 = s->avctx->flags2;
950 /* set chroma shifts */
951 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
953 /* convert fourcc to upper case */
954 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
955 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
957 s->avctx->coded_frame = &s->current_picture.f;
960 if (s->msmpeg4_version) {
961 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
962 2 * 2 * (MAX_LEVEL + 1) *
963 (MAX_RUN + 1) * 2 * sizeof(int), fail);
965 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
967 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail)
968 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail)
969 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail)
970 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
971 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
972 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
973 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
974 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
976 if (s->avctx->noise_reduction) {
977 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
981 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
982 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
983 s->picture_count * sizeof(Picture), fail);
984 for (i = 0; i < s->picture_count; i++) {
985 avcodec_get_frame_defaults(&s->picture[i].f);
988 if (init_context_frame(s))
991 s->parse_context.state = -1;
993 s->context_initialized = 1;
994 s->thread_context[0] = s;
996 // if (s->width && s->height) {
998 for (i = 1; i < nb_slices; i++) {
999 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1000 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1003 for (i = 0; i < nb_slices; i++) {
1004 if (init_duplicate_context(s->thread_context[i]) < 0)
1006 s->thread_context[i]->start_mb_y =
1007 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1008 s->thread_context[i]->end_mb_y =
1009 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1012 if (init_duplicate_context(s) < 0)
1015 s->end_mb_y = s->mb_height;
1017 s->slice_context_count = nb_slices;
1022 ff_MPV_common_end(s);
1027 * Frees and resets MpegEncContext fields depending on the resolution.
1028 * Is used during resolution changes to avoid a full reinitialization of the
1031 static int free_context_frame(MpegEncContext *s)
1035 av_freep(&s->mb_type);
1036 av_freep(&s->p_mv_table_base);
1037 av_freep(&s->b_forw_mv_table_base);
1038 av_freep(&s->b_back_mv_table_base);
1039 av_freep(&s->b_bidir_forw_mv_table_base);
1040 av_freep(&s->b_bidir_back_mv_table_base);
1041 av_freep(&s->b_direct_mv_table_base);
1042 s->p_mv_table = NULL;
1043 s->b_forw_mv_table = NULL;
1044 s->b_back_mv_table = NULL;
1045 s->b_bidir_forw_mv_table = NULL;
1046 s->b_bidir_back_mv_table = NULL;
1047 s->b_direct_mv_table = NULL;
1048 for (i = 0; i < 2; i++) {
1049 for (j = 0; j < 2; j++) {
1050 for (k = 0; k < 2; k++) {
1051 av_freep(&s->b_field_mv_table_base[i][j][k]);
1052 s->b_field_mv_table[i][j][k] = NULL;
1054 av_freep(&s->b_field_select_table[i][j]);
1055 av_freep(&s->p_field_mv_table_base[i][j]);
1056 s->p_field_mv_table[i][j] = NULL;
1058 av_freep(&s->p_field_select_table[i]);
1061 av_freep(&s->dc_val_base);
1062 av_freep(&s->coded_block_base);
1063 av_freep(&s->mbintra_table);
1064 av_freep(&s->cbp_table);
1065 av_freep(&s->pred_dir_table);
1067 av_freep(&s->mbskip_table);
1069 av_freep(&s->er.error_status_table);
1070 av_freep(&s->er.er_temp_buffer);
1071 av_freep(&s->mb_index2xy);
1072 av_freep(&s->lambda_table);
1074 av_freep(&s->cplx_tab);
1075 av_freep(&s->bits_tab);
1077 s->linesize = s->uvlinesize = 0;
1079 for (i = 0; i < 3; i++)
1080 av_freep(&s->visualization_buffer[i]);
1085 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1089 if (s->slice_context_count > 1) {
1090 for (i = 0; i < s->slice_context_count; i++) {
1091 free_duplicate_context(s->thread_context[i]);
1093 for (i = 1; i < s->slice_context_count; i++) {
1094 av_freep(&s->thread_context[i]);
1097 free_duplicate_context(s);
1099 free_context_frame(s);
1102 for (i = 0; i < s->picture_count; i++) {
1103 s->picture[i].needs_realloc = 1;
1106 s->last_picture_ptr =
1107 s->next_picture_ptr =
1108 s->current_picture_ptr = NULL;
1111 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1112 s->mb_height = (s->height + 31) / 32 * 2;
1113 else if (s->codec_id != AV_CODEC_ID_H264)
1114 s->mb_height = (s->height + 15) / 16;
1116 if ((s->width || s->height) &&
1117 av_image_check_size(s->width, s->height, 0, s->avctx))
1118 return AVERROR_INVALIDDATA;
1120 if ((err = init_context_frame(s)))
1123 s->thread_context[0] = s;
1125 if (s->width && s->height) {
1126 int nb_slices = s->slice_context_count;
1127 if (nb_slices > 1) {
1128 for (i = 1; i < nb_slices; i++) {
1129 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1130 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1133 for (i = 0; i < nb_slices; i++) {
1134 if (init_duplicate_context(s->thread_context[i]) < 0)
1136 s->thread_context[i]->start_mb_y =
1137 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1138 s->thread_context[i]->end_mb_y =
1139 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1142 if (init_duplicate_context(s) < 0)
1145 s->end_mb_y = s->mb_height;
1147 s->slice_context_count = nb_slices;
1152 ff_MPV_common_end(s);
1156 /* init common structure for both encoder and decoder */
1157 void ff_MPV_common_end(MpegEncContext *s)
1161 if (s->slice_context_count > 1) {
1162 for (i = 0; i < s->slice_context_count; i++) {
1163 free_duplicate_context(s->thread_context[i]);
1165 for (i = 1; i < s->slice_context_count; i++) {
1166 av_freep(&s->thread_context[i]);
1168 s->slice_context_count = 1;
1169 } else free_duplicate_context(s);
1171 av_freep(&s->parse_context.buffer);
1172 s->parse_context.buffer_size = 0;
1174 av_freep(&s->bitstream_buffer);
1175 s->allocated_bitstream_buffer_size = 0;
1177 av_freep(&s->avctx->stats_out);
1178 av_freep(&s->ac_stats);
1180 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1181 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1182 s->q_chroma_intra_matrix= NULL;
1183 s->q_chroma_intra_matrix16= NULL;
1184 av_freep(&s->q_intra_matrix);
1185 av_freep(&s->q_inter_matrix);
1186 av_freep(&s->q_intra_matrix16);
1187 av_freep(&s->q_inter_matrix16);
1188 av_freep(&s->input_picture);
1189 av_freep(&s->reordered_input_picture);
1190 av_freep(&s->dct_offset);
1192 if (s->picture && !s->avctx->internal->is_copy) {
1193 for (i = 0; i < s->picture_count; i++) {
1194 free_picture(s, &s->picture[i]);
1197 av_freep(&s->picture);
1199 free_context_frame(s);
1201 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
1202 avcodec_default_free_buffers(s->avctx);
1204 s->context_initialized = 0;
1205 s->last_picture_ptr =
1206 s->next_picture_ptr =
1207 s->current_picture_ptr = NULL;
1208 s->linesize = s->uvlinesize = 0;
1211 void ff_init_rl(RLTable *rl,
1212 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1214 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1215 uint8_t index_run[MAX_RUN + 1];
1216 int last, run, level, start, end, i;
1218 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1219 if (static_store && rl->max_level[0])
1222 /* compute max_level[], max_run[] and index_run[] */
1223 for (last = 0; last < 2; last++) {
1232 memset(max_level, 0, MAX_RUN + 1);
1233 memset(max_run, 0, MAX_LEVEL + 1);
1234 memset(index_run, rl->n, MAX_RUN + 1);
1235 for (i = start; i < end; i++) {
1236 run = rl->table_run[i];
1237 level = rl->table_level[i];
1238 if (index_run[run] == rl->n)
1240 if (level > max_level[run])
1241 max_level[run] = level;
1242 if (run > max_run[level])
1243 max_run[level] = run;
1246 rl->max_level[last] = static_store[last];
1248 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1249 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1251 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1253 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1254 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1256 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1258 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1259 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1263 void ff_init_vlc_rl(RLTable *rl)
1267 for (q = 0; q < 32; q++) {
1269 int qadd = (q - 1) | 1;
1275 for (i = 0; i < rl->vlc.table_size; i++) {
1276 int code = rl->vlc.table[i][0];
1277 int len = rl->vlc.table[i][1];
1280 if (len == 0) { // illegal code
1283 } else if (len < 0) { // more bits needed
1287 if (code == rl->n) { // esc
1291 run = rl->table_run[code] + 1;
1292 level = rl->table_level[code] * qmul + qadd;
1293 if (code >= rl->last) run += 192;
1296 rl->rl_vlc[q][i].len = len;
1297 rl->rl_vlc[q][i].level = level;
1298 rl->rl_vlc[q][i].run = run;
1303 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1307 /* release non reference frames */
1308 for (i = 0; i < s->picture_count; i++) {
1309 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1310 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1311 (remove_current || &s->picture[i] != s->current_picture_ptr)
1312 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1313 free_frame_buffer(s, &s->picture[i]);
1318 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1320 if ( (s->avctx->active_thread_type & FF_THREAD_FRAME)
1321 && pic->f.qscale_table //check if the frame has anything allocated
1322 && pic->period_since_free < s->avctx->thread_count)
1324 if (pic->f.data[0] == NULL)
1326 if (pic->needs_realloc && !(pic->f.reference & DELAYED_PIC_REF))
1327 if (!pic->owner2 || pic->owner2 == s)
1332 static int find_unused_picture(MpegEncContext *s, int shared)
1337 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1338 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1342 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1343 if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1346 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1347 if (pic_is_unused(s, &s->picture[i]))
1352 av_log(s->avctx, AV_LOG_FATAL,
1353 "Internal error, picture buffer overflow\n");
1354 /* We could return -1, but the codec would crash trying to draw into a
1355 * non-existing frame anyway. This is safer than waiting for a random crash.
1356 * Also the return of this is never useful, an encoder must only allocate
1357 * as much as allowed in the specification. This has no relationship to how
1358 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1359 * enough for such valid streams).
1360 * Plus, a decoder has to check stream validity and remove frames if too
1361 * many reference frames are around. Waiting for "OOM" is not correct at
1362 * all. Similarly, missing reference frames have to be replaced by
1363 * interpolated/MC frames, anything else is a bug in the codec ...
1369 int ff_find_unused_picture(MpegEncContext *s, int shared)
1371 int ret = find_unused_picture(s, shared);
1373 if (ret >= 0 && ret < s->picture_range_end) {
1374 if (s->picture[ret].needs_realloc) {
1375 s->picture[ret].needs_realloc = 0;
1376 free_picture(s, &s->picture[ret]);
1377 avcodec_get_frame_defaults(&s->picture[ret].f);
1383 static void update_noise_reduction(MpegEncContext *s)
1387 for (intra = 0; intra < 2; intra++) {
1388 if (s->dct_count[intra] > (1 << 16)) {
1389 for (i = 0; i < 64; i++) {
1390 s->dct_error_sum[intra][i] >>= 1;
1392 s->dct_count[intra] >>= 1;
1395 for (i = 0; i < 64; i++) {
1396 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1397 s->dct_count[intra] +
1398 s->dct_error_sum[intra][i] / 2) /
1399 (s->dct_error_sum[intra][i] + 1);
1405 * generic function for encode/decode called after coding/decoding
1406 * the header and before a frame is coded/decoded.
1408 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1414 if (!ff_thread_can_start_frame(avctx)) {
1415 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1419 /* mark & release old frames */
1420 if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1421 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1422 s->last_picture_ptr != s->next_picture_ptr &&
1423 s->last_picture_ptr->f.data[0]) {
1424 if (s->last_picture_ptr->owner2 == s)
1425 free_frame_buffer(s, s->last_picture_ptr);
1428 /* release forgotten pictures */
1429 /* if (mpeg124/h263) */
1431 for (i = 0; i < s->picture_count; i++) {
1432 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1433 &s->picture[i] != s->last_picture_ptr &&
1434 &s->picture[i] != s->next_picture_ptr &&
1435 s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1436 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1437 av_log(avctx, AV_LOG_ERROR,
1438 "releasing zombie picture\n");
1439 free_frame_buffer(s, &s->picture[i]);
1446 ff_release_unused_pictures(s, 1);
1448 if (s->current_picture_ptr &&
1449 s->current_picture_ptr->f.data[0] == NULL) {
1450 // we already have a unused image
1451 // (maybe it was set before reading the header)
1452 pic = s->current_picture_ptr;
1454 i = ff_find_unused_picture(s, 0);
1456 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1459 pic = &s->picture[i];
1462 pic->f.reference = 0;
1463 if (!s->droppable) {
1464 if (s->codec_id == AV_CODEC_ID_H264)
1465 pic->f.reference = s->picture_structure;
1466 else if (s->pict_type != AV_PICTURE_TYPE_B)
1467 pic->f.reference = 3;
1470 pic->f.coded_picture_number = s->coded_picture_number++;
1472 if (ff_alloc_picture(s, pic, 0) < 0)
1475 s->current_picture_ptr = pic;
1476 // FIXME use only the vars from current_pic
1477 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1478 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1479 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1480 if (s->picture_structure != PICT_FRAME)
1481 s->current_picture_ptr->f.top_field_first =
1482 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1484 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1485 !s->progressive_sequence;
1486 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1489 s->current_picture_ptr->f.pict_type = s->pict_type;
1490 // if (s->flags && CODEC_FLAG_QSCALE)
1491 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1492 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1494 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1496 if (s->pict_type != AV_PICTURE_TYPE_B) {
1497 s->last_picture_ptr = s->next_picture_ptr;
1499 s->next_picture_ptr = s->current_picture_ptr;
1501 av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1502 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1503 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1504 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1505 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1506 s->pict_type, s->droppable);
1508 if (s->codec_id != AV_CODEC_ID_H264) {
1509 if ((s->last_picture_ptr == NULL ||
1510 s->last_picture_ptr->f.data[0] == NULL) &&
1511 (s->pict_type != AV_PICTURE_TYPE_I ||
1512 s->picture_structure != PICT_FRAME)) {
1513 int h_chroma_shift, v_chroma_shift;
1514 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1515 &h_chroma_shift, &v_chroma_shift);
1516 if (s->pict_type != AV_PICTURE_TYPE_I)
1517 av_log(avctx, AV_LOG_ERROR,
1518 "warning: first frame is no keyframe\n");
1519 else if (s->picture_structure != PICT_FRAME)
1520 av_log(avctx, AV_LOG_INFO,
1521 "allocate dummy last picture for field based first keyframe\n");
1523 /* Allocate a dummy frame */
1524 i = ff_find_unused_picture(s, 0);
1526 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1529 s->last_picture_ptr = &s->picture[i];
1530 s->last_picture_ptr->f.key_frame = 0;
1531 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1532 s->last_picture_ptr = NULL;
1536 memset(s->last_picture_ptr->f.data[0], 0x80,
1537 avctx->height * s->last_picture_ptr->f.linesize[0]);
1538 memset(s->last_picture_ptr->f.data[1], 0x80,
1539 (avctx->height >> v_chroma_shift) *
1540 s->last_picture_ptr->f.linesize[1]);
1541 memset(s->last_picture_ptr->f.data[2], 0x80,
1542 (avctx->height >> v_chroma_shift) *
1543 s->last_picture_ptr->f.linesize[2]);
1545 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1546 for(i=0; i<avctx->height; i++)
1547 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1550 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1551 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1552 s->last_picture_ptr->f.reference = 3;
1554 if ((s->next_picture_ptr == NULL ||
1555 s->next_picture_ptr->f.data[0] == NULL) &&
1556 s->pict_type == AV_PICTURE_TYPE_B) {
1557 /* Allocate a dummy frame */
1558 i = ff_find_unused_picture(s, 0);
1560 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1563 s->next_picture_ptr = &s->picture[i];
1564 s->next_picture_ptr->f.key_frame = 0;
1565 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1566 s->next_picture_ptr = NULL;
1569 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1570 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1571 s->next_picture_ptr->f.reference = 3;
1575 memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1576 memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1577 if (s->last_picture_ptr)
1578 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1579 if (s->next_picture_ptr)
1580 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1582 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) {
1583 if (s->next_picture_ptr)
1584 s->next_picture_ptr->owner2 = s;
1585 if (s->last_picture_ptr)
1586 s->last_picture_ptr->owner2 = s;
1589 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1590 s->last_picture_ptr->f.data[0]));
1592 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1594 for (i = 0; i < 4; i++) {
1595 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1596 s->current_picture.f.data[i] +=
1597 s->current_picture.f.linesize[i];
1599 s->current_picture.f.linesize[i] *= 2;
1600 s->last_picture.f.linesize[i] *= 2;
1601 s->next_picture.f.linesize[i] *= 2;
1605 s->err_recognition = avctx->err_recognition;
1607 /* set dequantizer, we can't do it during init as
1608 * it might change for mpeg4 and we can't do it in the header
1609 * decode as init is not called for mpeg4 there yet */
1610 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1611 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1612 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1613 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1614 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1615 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1617 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1618 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1621 if (s->dct_error_sum) {
1622 assert(s->avctx->noise_reduction && s->encoding);
1623 update_noise_reduction(s);
1626 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1627 return ff_xvmc_field_start(s, avctx);
1632 /* generic function for encode/decode called after a
1633 * frame has been coded/decoded. */
1634 void ff_MPV_frame_end(MpegEncContext *s)
1637 /* redraw edges for the frame if decoding didn't complete */
1638 // just to make sure that all data is rendered.
1639 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1640 ff_xvmc_field_end(s);
1641 } else if ((s->er.error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1642 !s->avctx->hwaccel &&
1643 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1644 s->unrestricted_mv &&
1645 s->current_picture.f.reference &&
1647 !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1650 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1651 int hshift = desc->log2_chroma_w;
1652 int vshift = desc->log2_chroma_h;
1653 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1654 s->h_edge_pos, s->v_edge_pos,
1655 EDGE_WIDTH, EDGE_WIDTH,
1656 EDGE_TOP | EDGE_BOTTOM);
1657 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1658 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1659 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1660 EDGE_TOP | EDGE_BOTTOM);
1661 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1662 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1663 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1664 EDGE_TOP | EDGE_BOTTOM);
1669 s->last_pict_type = s->pict_type;
1670 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1671 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1672 s->last_non_b_pict_type = s->pict_type;
1675 /* copy back current_picture variables */
1676 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1677 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1678 s->picture[i] = s->current_picture;
1682 assert(i < MAX_PICTURE_COUNT);
1686 /* release non-reference frames */
1687 for (i = 0; i < s->picture_count; i++) {
1688 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1689 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1690 free_frame_buffer(s, &s->picture[i]);
1694 // clear copies, to avoid confusion
1696 memset(&s->last_picture, 0, sizeof(Picture));
1697 memset(&s->next_picture, 0, sizeof(Picture));
1698 memset(&s->current_picture, 0, sizeof(Picture));
1700 s->avctx->coded_frame = &s->current_picture_ptr->f;
1702 if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1703 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1708 * Draw a line from (ex, ey) -> (sx, sy).
1709 * @param w width of the image
1710 * @param h height of the image
1711 * @param stride stride/linesize of the image
1712 * @param color color of the arrow
1714 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1715 int w, int h, int stride, int color)
1719 sx = av_clip(sx, 0, w - 1);
1720 sy = av_clip(sy, 0, h - 1);
1721 ex = av_clip(ex, 0, w - 1);
1722 ey = av_clip(ey, 0, h - 1);
1724 buf[sy * stride + sx] += color;
1726 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1728 FFSWAP(int, sx, ex);
1729 FFSWAP(int, sy, ey);
1731 buf += sx + sy * stride;
1733 f = ((ey - sy) << 16) / ex;
1734 for (x = 0; x <= ex; x++) {
1736 fr = (x * f) & 0xFFFF;
1737 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1738 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1742 FFSWAP(int, sx, ex);
1743 FFSWAP(int, sy, ey);
1745 buf += sx + sy * stride;
1748 f = ((ex - sx) << 16) / ey;
1751 for(y= 0; y <= ey; y++){
1753 fr = (y*f) & 0xFFFF;
1754 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1755 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1761 * Draw an arrow from (ex, ey) -> (sx, sy).
1762 * @param w width of the image
1763 * @param h height of the image
1764 * @param stride stride/linesize of the image
1765 * @param color color of the arrow
1767 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1768 int ey, int w, int h, int stride, int color)
1772 sx = av_clip(sx, -100, w + 100);
1773 sy = av_clip(sy, -100, h + 100);
1774 ex = av_clip(ex, -100, w + 100);
1775 ey = av_clip(ey, -100, h + 100);
1780 if (dx * dx + dy * dy > 3 * 3) {
1783 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1785 // FIXME subpixel accuracy
1786 rx = ROUNDED_DIV(rx * 3 << 4, length);
1787 ry = ROUNDED_DIV(ry * 3 << 4, length);
1789 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1790 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1792 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1796 * Print debugging info for the given picture.
1798 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1800 if ( s->avctx->hwaccel || !pict || !pict->mb_type
1801 || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1805 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1808 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1809 av_get_picture_type_char(pict->pict_type));
1810 for (y = 0; y < s->mb_height; y++) {
1811 for (x = 0; x < s->mb_width; x++) {
1812 if (s->avctx->debug & FF_DEBUG_SKIP) {
1813 int count = s->mbskip_table[x + y * s->mb_stride];
1816 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1818 if (s->avctx->debug & FF_DEBUG_QP) {
1819 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1820 pict->qscale_table[x + y * s->mb_stride]);
1822 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1823 int mb_type = pict->mb_type[x + y * s->mb_stride];
1824 // Type & MV direction
1825 if (IS_PCM(mb_type))
1826 av_log(s->avctx, AV_LOG_DEBUG, "P");
1827 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1828 av_log(s->avctx, AV_LOG_DEBUG, "A");
1829 else if (IS_INTRA4x4(mb_type))
1830 av_log(s->avctx, AV_LOG_DEBUG, "i");
1831 else if (IS_INTRA16x16(mb_type))
1832 av_log(s->avctx, AV_LOG_DEBUG, "I");
1833 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1834 av_log(s->avctx, AV_LOG_DEBUG, "d");
1835 else if (IS_DIRECT(mb_type))
1836 av_log(s->avctx, AV_LOG_DEBUG, "D");
1837 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1838 av_log(s->avctx, AV_LOG_DEBUG, "g");
1839 else if (IS_GMC(mb_type))
1840 av_log(s->avctx, AV_LOG_DEBUG, "G");
1841 else if (IS_SKIP(mb_type))
1842 av_log(s->avctx, AV_LOG_DEBUG, "S");
1843 else if (!USES_LIST(mb_type, 1))
1844 av_log(s->avctx, AV_LOG_DEBUG, ">");
1845 else if (!USES_LIST(mb_type, 0))
1846 av_log(s->avctx, AV_LOG_DEBUG, "<");
1848 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1849 av_log(s->avctx, AV_LOG_DEBUG, "X");
1853 if (IS_8X8(mb_type))
1854 av_log(s->avctx, AV_LOG_DEBUG, "+");
1855 else if (IS_16X8(mb_type))
1856 av_log(s->avctx, AV_LOG_DEBUG, "-");
1857 else if (IS_8X16(mb_type))
1858 av_log(s->avctx, AV_LOG_DEBUG, "|");
1859 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1860 av_log(s->avctx, AV_LOG_DEBUG, " ");
1862 av_log(s->avctx, AV_LOG_DEBUG, "?");
1865 if (IS_INTERLACED(mb_type))
1866 av_log(s->avctx, AV_LOG_DEBUG, "=");
1868 av_log(s->avctx, AV_LOG_DEBUG, " ");
1871 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1875 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1876 (s->avctx->debug_mv)) {
1877 const int shift = 1 + s->quarter_sample;
1881 int h_chroma_shift, v_chroma_shift, block_height;
1882 const int width = s->avctx->width;
1883 const int height = s->avctx->height;
1884 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1885 const int mv_stride = (s->mb_width << mv_sample_log2) +
1886 (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1887 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1889 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1891 for (i = 0; i < 3; i++) {
1892 size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1893 pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1894 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1895 memcpy(s->visualization_buffer[i], pict->data[i], size);
1896 pict->data[i] = s->visualization_buffer[i];
1898 pict->type = FF_BUFFER_TYPE_COPY;
1900 ptr = pict->data[0];
1901 block_height = 16 >> v_chroma_shift;
1903 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1905 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1906 const int mb_index = mb_x + mb_y * s->mb_stride;
1907 if ((s->avctx->debug_mv) && pict->motion_val[0]) {
1909 for (type = 0; type < 3; type++) {
1913 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1914 (pict->pict_type!= AV_PICTURE_TYPE_P))
1919 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1920 (pict->pict_type!= AV_PICTURE_TYPE_B))
1925 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1926 (pict->pict_type!= AV_PICTURE_TYPE_B))
1931 if (!USES_LIST(pict->mb_type[mb_index], direction))
1934 if (IS_8X8(pict->mb_type[mb_index])) {
1936 for (i = 0; i < 4; i++) {
1937 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1938 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1939 int xy = (mb_x * 2 + (i & 1) +
1940 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1941 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1942 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1943 draw_arrow(ptr, sx, sy, mx, my, width,
1944 height, s->linesize, 100);
1946 } else if (IS_16X8(pict->mb_type[mb_index])) {
1948 for (i = 0; i < 2; i++) {
1949 int sx = mb_x * 16 + 8;
1950 int sy = mb_y * 16 + 4 + 8 * i;
1951 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1952 int mx = (pict->motion_val[direction][xy][0] >> shift);
1953 int my = (pict->motion_val[direction][xy][1] >> shift);
1955 if (IS_INTERLACED(pict->mb_type[mb_index]))
1958 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1959 height, s->linesize, 100);
1961 } else if (IS_8X16(pict->mb_type[mb_index])) {
1963 for (i = 0; i < 2; i++) {
1964 int sx = mb_x * 16 + 4 + 8 * i;
1965 int sy = mb_y * 16 + 8;
1966 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1967 int mx = pict->motion_val[direction][xy][0] >> shift;
1968 int my = pict->motion_val[direction][xy][1] >> shift;
1970 if (IS_INTERLACED(pict->mb_type[mb_index]))
1973 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1974 height, s->linesize, 100);
1977 int sx= mb_x * 16 + 8;
1978 int sy= mb_y * 16 + 8;
1979 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1980 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1981 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1982 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1986 if ((s->avctx->debug & FF_DEBUG_VIS_QP)) {
1987 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1988 0x0101010101010101ULL;
1990 for (y = 0; y < block_height; y++) {
1991 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1992 (block_height * mb_y + y) *
1993 pict->linesize[1]) = c;
1994 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1995 (block_height * mb_y + y) *
1996 pict->linesize[2]) = c;
1999 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2000 pict->motion_val[0]) {
2001 int mb_type = pict->mb_type[mb_index];
2004 #define COLOR(theta, r) \
2005 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2006 v = (int)(128 + r * sin(theta * 3.141592 / 180));
2010 if (IS_PCM(mb_type)) {
2012 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2013 IS_INTRA16x16(mb_type)) {
2015 } else if (IS_INTRA4x4(mb_type)) {
2017 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2019 } else if (IS_DIRECT(mb_type)) {
2021 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2023 } else if (IS_GMC(mb_type)) {
2025 } else if (IS_SKIP(mb_type)) {
2027 } else if (!USES_LIST(mb_type, 1)) {
2029 } else if (!USES_LIST(mb_type, 0)) {
2032 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2036 u *= 0x0101010101010101ULL;
2037 v *= 0x0101010101010101ULL;
2038 for (y = 0; y < block_height; y++) {
2039 *(uint64_t *)(pict->data[1] + 8 * mb_x +
2040 (block_height * mb_y + y) * pict->linesize[1]) = u;
2041 *(uint64_t *)(pict->data[2] + 8 * mb_x +
2042 (block_height * mb_y + y) * pict->linesize[2]) = v;
2046 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2047 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2048 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2049 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2050 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2052 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2053 for (y = 0; y < 16; y++)
2054 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2055 pict->linesize[0]] ^= 0x80;
2057 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2058 int dm = 1 << (mv_sample_log2 - 2);
2059 for (i = 0; i < 4; i++) {
2060 int sx = mb_x * 16 + 8 * (i & 1);
2061 int sy = mb_y * 16 + 8 * (i >> 1);
2062 int xy = (mb_x * 2 + (i & 1) +
2063 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2065 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
2066 if (mv[0] != mv[dm] ||
2067 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2068 for (y = 0; y < 8; y++)
2069 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2070 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2071 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2072 pict->linesize[0]) ^= 0x8080808080808080ULL;
2076 if (IS_INTERLACED(mb_type) &&
2077 s->codec_id == AV_CODEC_ID_H264) {
2081 s->mbskip_table[mb_index] = 0;
2087 static inline int hpel_motion_lowres(MpegEncContext *s,
2088 uint8_t *dest, uint8_t *src,
2089 int field_based, int field_select,
2090 int src_x, int src_y,
2091 int width, int height, int stride,
2092 int h_edge_pos, int v_edge_pos,
2093 int w, int h, h264_chroma_mc_func *pix_op,
2094 int motion_x, int motion_y)
2096 const int lowres = s->avctx->lowres;
2097 const int op_index = FFMIN(lowres, 2);
2098 const int s_mask = (2 << lowres) - 1;
2102 if (s->quarter_sample) {
2107 sx = motion_x & s_mask;
2108 sy = motion_y & s_mask;
2109 src_x += motion_x >> lowres + 1;
2110 src_y += motion_y >> lowres + 1;
2112 src += src_y * stride + src_x;
2114 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2115 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2116 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2117 (h + 1) << field_based, src_x,
2118 src_y << field_based,
2121 src = s->edge_emu_buffer;
2125 sx = (sx << 2) >> lowres;
2126 sy = (sy << 2) >> lowres;
2129 pix_op[op_index](dest, src, stride, h, sx, sy);
2133 /* apply one mpeg motion vector to the three components */
2134 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2141 uint8_t **ref_picture,
2142 h264_chroma_mc_func *pix_op,
2143 int motion_x, int motion_y,
2146 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2147 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2149 const int lowres = s->avctx->lowres;
2150 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
2151 const int block_s = 8>>lowres;
2152 const int s_mask = (2 << lowres) - 1;
2153 const int h_edge_pos = s->h_edge_pos >> lowres;
2154 const int v_edge_pos = s->v_edge_pos >> lowres;
2155 linesize = s->current_picture.f.linesize[0] << field_based;
2156 uvlinesize = s->current_picture.f.linesize[1] << field_based;
2158 // FIXME obviously not perfect but qpel will not work in lowres anyway
2159 if (s->quarter_sample) {
2165 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2168 sx = motion_x & s_mask;
2169 sy = motion_y & s_mask;
2170 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2171 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2173 if (s->out_format == FMT_H263) {
2174 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2175 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2176 uvsrc_x = src_x >> 1;
2177 uvsrc_y = src_y >> 1;
2178 } else if (s->out_format == FMT_H261) {
2179 // even chroma mv's are full pel in H261
2182 uvsx = (2 * mx) & s_mask;
2183 uvsy = (2 * my) & s_mask;
2184 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2185 uvsrc_y = mb_y * block_s + (my >> lowres);
2187 if(s->chroma_y_shift){
2192 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2193 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2195 if(s->chroma_x_shift){
2199 uvsy = motion_y & s_mask;
2201 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2204 uvsx = motion_x & s_mask;
2205 uvsy = motion_y & s_mask;
2212 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2213 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2214 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2216 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
2217 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2218 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2219 linesize >> field_based, 17, 17 + field_based,
2220 src_x, src_y << field_based, h_edge_pos,
2222 ptr_y = s->edge_emu_buffer;
2223 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2224 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2225 s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2227 uvsrc_x, uvsrc_y << field_based,
2228 h_edge_pos >> 1, v_edge_pos >> 1);
2229 s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2231 uvsrc_x, uvsrc_y << field_based,
2232 h_edge_pos >> 1, v_edge_pos >> 1);
2234 ptr_cr = uvbuf + 16;
2238 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2240 dest_y += s->linesize;
2241 dest_cb += s->uvlinesize;
2242 dest_cr += s->uvlinesize;
2246 ptr_y += s->linesize;
2247 ptr_cb += s->uvlinesize;
2248 ptr_cr += s->uvlinesize;
2251 sx = (sx << 2) >> lowres;
2252 sy = (sy << 2) >> lowres;
2253 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2255 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2256 uvsx = (uvsx << 2) >> lowres;
2257 uvsy = (uvsy << 2) >> lowres;
2258 if (h >> s->chroma_y_shift) {
2259 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2260 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2263 // FIXME h261 lowres loop filter
2266 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2267 uint8_t *dest_cb, uint8_t *dest_cr,
2268 uint8_t **ref_picture,
2269 h264_chroma_mc_func * pix_op,
2272 const int lowres = s->avctx->lowres;
2273 const int op_index = FFMIN(lowres, 2);
2274 const int block_s = 8 >> lowres;
2275 const int s_mask = (2 << lowres) - 1;
2276 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2277 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2278 int emu = 0, src_x, src_y, offset, sx, sy;
2281 if (s->quarter_sample) {
2286 /* In case of 8X8, we construct a single chroma motion vector
2287 with a special rounding */
2288 mx = ff_h263_round_chroma(mx);
2289 my = ff_h263_round_chroma(my);
2293 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2294 src_y = s->mb_y * block_s + (my >> lowres + 1);
2296 offset = src_y * s->uvlinesize + src_x;
2297 ptr = ref_picture[1] + offset;
2298 if (s->flags & CODEC_FLAG_EMU_EDGE) {
2299 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2300 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2301 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2302 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2303 ptr = s->edge_emu_buffer;
2307 sx = (sx << 2) >> lowres;
2308 sy = (sy << 2) >> lowres;
2309 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2311 ptr = ref_picture[2] + offset;
2313 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2314 src_x, src_y, h_edge_pos, v_edge_pos);
2315 ptr = s->edge_emu_buffer;
2317 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2321 * motion compensation of a single macroblock
2323 * @param dest_y luma destination pointer
2324 * @param dest_cb chroma cb/u destination pointer
2325 * @param dest_cr chroma cr/v destination pointer
2326 * @param dir direction (0->forward, 1->backward)
2327 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2328 * @param pix_op halfpel motion compensation function (average or put normally)
2329 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2331 static inline void MPV_motion_lowres(MpegEncContext *s,
2332 uint8_t *dest_y, uint8_t *dest_cb,
2334 int dir, uint8_t **ref_picture,
2335 h264_chroma_mc_func *pix_op)
2339 const int lowres = s->avctx->lowres;
2340 const int block_s = 8 >>lowres;
2345 switch (s->mv_type) {
2347 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2349 ref_picture, pix_op,
2350 s->mv[dir][0][0], s->mv[dir][0][1],
2356 for (i = 0; i < 4; i++) {
2357 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2358 s->linesize) * block_s,
2359 ref_picture[0], 0, 0,
2360 (2 * mb_x + (i & 1)) * block_s,
2361 (2 * mb_y + (i >> 1)) * block_s,
2362 s->width, s->height, s->linesize,
2363 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2364 block_s, block_s, pix_op,
2365 s->mv[dir][i][0], s->mv[dir][i][1]);
2367 mx += s->mv[dir][i][0];
2368 my += s->mv[dir][i][1];
2371 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2372 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2376 if (s->picture_structure == PICT_FRAME) {
2378 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2379 1, 0, s->field_select[dir][0],
2380 ref_picture, pix_op,
2381 s->mv[dir][0][0], s->mv[dir][0][1],
2384 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2385 1, 1, s->field_select[dir][1],
2386 ref_picture, pix_op,
2387 s->mv[dir][1][0], s->mv[dir][1][1],
2390 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2391 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2392 ref_picture = s->current_picture_ptr->f.data;
2395 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2396 0, 0, s->field_select[dir][0],
2397 ref_picture, pix_op,
2399 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2403 for (i = 0; i < 2; i++) {
2404 uint8_t **ref2picture;
2406 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2407 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2408 ref2picture = ref_picture;
2410 ref2picture = s->current_picture_ptr->f.data;
2413 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2414 0, 0, s->field_select[dir][i],
2415 ref2picture, pix_op,
2416 s->mv[dir][i][0], s->mv[dir][i][1] +
2417 2 * block_s * i, block_s, mb_y >> 1);
2419 dest_y += 2 * block_s * s->linesize;
2420 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2421 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2425 if (s->picture_structure == PICT_FRAME) {
2426 for (i = 0; i < 2; i++) {
2428 for (j = 0; j < 2; j++) {
2429 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2431 ref_picture, pix_op,
2432 s->mv[dir][2 * i + j][0],
2433 s->mv[dir][2 * i + j][1],
2436 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2439 for (i = 0; i < 2; i++) {
2440 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2441 0, 0, s->picture_structure != i + 1,
2442 ref_picture, pix_op,
2443 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2444 2 * block_s, mb_y >> 1);
2446 // after put we make avg of the same block
2447 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2449 // opposite parity is always in the same
2450 // frame if this is second field
2451 if (!s->first_field) {
2452 ref_picture = s->current_picture_ptr->f.data;
2463 * find the lowest MB row referenced in the MVs
2465 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2467 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2468 int my, off, i, mvs;
2470 if (s->picture_structure != PICT_FRAME || s->mcsel)
2473 switch (s->mv_type) {
2487 for (i = 0; i < mvs; i++) {
2488 my = s->mv[dir][i][1]<<qpel_shift;
2489 my_max = FFMAX(my_max, my);
2490 my_min = FFMIN(my_min, my);
2493 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2495 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2497 return s->mb_height-1;
2500 /* put block[] to dest[] */
2501 static inline void put_dct(MpegEncContext *s,
2502 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2504 s->dct_unquantize_intra(s, block, i, qscale);
2505 s->dsp.idct_put (dest, line_size, block);
2508 /* add block[] to dest[] */
2509 static inline void add_dct(MpegEncContext *s,
2510 int16_t *block, int i, uint8_t *dest, int line_size)
2512 if (s->block_last_index[i] >= 0) {
2513 s->dsp.idct_add (dest, line_size, block);
2517 static inline void add_dequant_dct(MpegEncContext *s,
2518 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2520 if (s->block_last_index[i] >= 0) {
2521 s->dct_unquantize_inter(s, block, i, qscale);
2523 s->dsp.idct_add (dest, line_size, block);
2528 * Clean dc, ac, coded_block for the current non-intra MB.
2530 void ff_clean_intra_table_entries(MpegEncContext *s)
2532 int wrap = s->b8_stride;
2533 int xy = s->block_index[0];
2536 s->dc_val[0][xy + 1 ] =
2537 s->dc_val[0][xy + wrap] =
2538 s->dc_val[0][xy + 1 + wrap] = 1024;
2540 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2541 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2542 if (s->msmpeg4_version>=3) {
2543 s->coded_block[xy ] =
2544 s->coded_block[xy + 1 ] =
2545 s->coded_block[xy + wrap] =
2546 s->coded_block[xy + 1 + wrap] = 0;
2549 wrap = s->mb_stride;
2550 xy = s->mb_x + s->mb_y * wrap;
2552 s->dc_val[2][xy] = 1024;
2554 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2555 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2557 s->mbintra_table[xy]= 0;
2560 /* generic function called after a macroblock has been parsed by the
2561 decoder or after it has been encoded by the encoder.
2563 Important variables used:
2564 s->mb_intra : true if intra macroblock
2565 s->mv_dir : motion vector direction
2566 s->mv_type : motion vector type
2567 s->mv : motion vector
2568 s->interlaced_dct : true if interlaced dct used (mpeg2)
2570 static av_always_inline
2571 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2572 int lowres_flag, int is_mpeg12)
2574 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2575 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2576 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2580 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2581 /* save DCT coefficients */
2583 int16_t *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2584 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2586 for(j=0; j<64; j++){
2587 *dct++ = block[i][s->dsp.idct_permutation[j]];
2588 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2590 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2594 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2596 /* update DC predictors for P macroblocks */
2598 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2599 if(s->mbintra_table[mb_xy])
2600 ff_clean_intra_table_entries(s);
2604 s->last_dc[2] = 128 << s->intra_dc_precision;
2607 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2608 s->mbintra_table[mb_xy]=1;
2610 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2611 uint8_t *dest_y, *dest_cb, *dest_cr;
2612 int dct_linesize, dct_offset;
2613 op_pixels_func (*op_pix)[4];
2614 qpel_mc_func (*op_qpix)[16];
2615 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2616 const int uvlinesize = s->current_picture.f.linesize[1];
2617 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2618 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2620 /* avoid copy if macroblock skipped in last frame too */
2621 /* skip only during decoding as we might trash the buffers during encoding a bit */
2623 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2625 if (s->mb_skipped) {
2627 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2629 } else if(!s->current_picture.f.reference) {
2632 *mbskip_ptr = 0; /* not skipped */
2636 dct_linesize = linesize << s->interlaced_dct;
2637 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2641 dest_cb= s->dest[1];
2642 dest_cr= s->dest[2];
2644 dest_y = s->b_scratchpad;
2645 dest_cb= s->b_scratchpad+16*linesize;
2646 dest_cr= s->b_scratchpad+32*linesize;
2650 /* motion handling */
2651 /* decoding or more than one mb_type (MC was already done otherwise) */
2654 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2655 if (s->mv_dir & MV_DIR_FORWARD) {
2656 ff_thread_await_progress(&s->last_picture_ptr->f,
2657 ff_MPV_lowest_referenced_row(s, 0),
2660 if (s->mv_dir & MV_DIR_BACKWARD) {
2661 ff_thread_await_progress(&s->next_picture_ptr->f,
2662 ff_MPV_lowest_referenced_row(s, 1),
2668 h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2670 if (s->mv_dir & MV_DIR_FORWARD) {
2671 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2672 op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2674 if (s->mv_dir & MV_DIR_BACKWARD) {
2675 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2678 op_qpix= s->me.qpel_put;
2679 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2680 op_pix = s->dsp.put_pixels_tab;
2682 op_pix = s->dsp.put_no_rnd_pixels_tab;
2684 if (s->mv_dir & MV_DIR_FORWARD) {
2685 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2686 op_pix = s->dsp.avg_pixels_tab;
2687 op_qpix= s->me.qpel_avg;
2689 if (s->mv_dir & MV_DIR_BACKWARD) {
2690 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2695 /* skip dequant / idct if we are really late ;) */
2696 if(s->avctx->skip_idct){
2697 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2698 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2699 || s->avctx->skip_idct >= AVDISCARD_ALL)
2703 /* add dct residue */
2704 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2705 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2706 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2707 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2708 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2709 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2711 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2712 if (s->chroma_y_shift){
2713 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2714 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2718 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2719 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2720 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2721 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2724 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2725 add_dct(s, block[0], 0, dest_y , dct_linesize);
2726 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2727 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2728 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2730 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2731 if(s->chroma_y_shift){//Chroma420
2732 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2733 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2736 dct_linesize = uvlinesize << s->interlaced_dct;
2737 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2739 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2740 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2741 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2742 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2743 if(!s->chroma_x_shift){//Chroma444
2744 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2745 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2746 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2747 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2752 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2753 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2756 /* dct only in intra block */
2757 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2758 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2759 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2760 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2761 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2763 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2764 if(s->chroma_y_shift){
2765 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2766 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2770 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2771 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2772 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2773 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2777 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2778 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2779 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2780 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2782 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2783 if(s->chroma_y_shift){
2784 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2785 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2788 dct_linesize = uvlinesize << s->interlaced_dct;
2789 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2791 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2792 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2793 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2794 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2795 if(!s->chroma_x_shift){//Chroma444
2796 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2797 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2798 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2799 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2807 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2808 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2809 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2814 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2816 if(s->out_format == FMT_MPEG1) {
2817 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2818 else MPV_decode_mb_internal(s, block, 0, 1);
2821 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2822 else MPV_decode_mb_internal(s, block, 0, 0);
2826 * @param h is the normal height, this will be reduced automatically if needed for the last row
2828 void ff_draw_horiz_band(AVCodecContext *avctx, DSPContext *dsp, Picture *cur,
2829 Picture *last, int y, int h, int picture_structure,
2830 int first_field, int draw_edges, int low_delay,
2831 int v_edge_pos, int h_edge_pos)
2833 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2834 int hshift = desc->log2_chroma_w;
2835 int vshift = desc->log2_chroma_h;
2836 const int field_pic = picture_structure != PICT_FRAME;
2842 if (!avctx->hwaccel &&
2843 !(avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
2846 !(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
2847 int *linesize = cur->f.linesize;
2848 int sides = 0, edge_h;
2849 if (y==0) sides |= EDGE_TOP;
2850 if (y + h >= v_edge_pos)
2851 sides |= EDGE_BOTTOM;
2853 edge_h= FFMIN(h, v_edge_pos - y);
2855 dsp->draw_edges(cur->f.data[0] + y * linesize[0],
2856 linesize[0], h_edge_pos, edge_h,
2857 EDGE_WIDTH, EDGE_WIDTH, sides);
2858 dsp->draw_edges(cur->f.data[1] + (y >> vshift) * linesize[1],
2859 linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2860 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2861 dsp->draw_edges(cur->f.data[2] + (y >> vshift) * linesize[2],
2862 linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2863 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2866 h = FFMIN(h, avctx->height - y);
2868 if(field_pic && first_field && !(avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2870 if (avctx->draw_horiz_band) {
2872 int offset[AV_NUM_DATA_POINTERS];
2875 if(cur->f.pict_type == AV_PICTURE_TYPE_B || low_delay ||
2876 (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2883 if (cur->f.pict_type == AV_PICTURE_TYPE_B &&
2884 picture_structure == PICT_FRAME &&
2885 avctx->codec_id != AV_CODEC_ID_H264 &&
2886 avctx->codec_id != AV_CODEC_ID_SVQ3) {
2887 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2890 offset[0]= y * src->linesize[0];
2892 offset[2]= (y >> vshift) * src->linesize[1];
2893 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2899 avctx->draw_horiz_band(avctx, src, offset,
2900 y, picture_structure, h);
2904 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2906 int draw_edges = s->unrestricted_mv && !s->intra_only;
2907 ff_draw_horiz_band(s->avctx, &s->dsp, &s->current_picture,
2908 &s->last_picture, y, h, s->picture_structure,
2909 s->first_field, draw_edges, s->low_delay,
2910 s->v_edge_pos, s->h_edge_pos);
2913 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2914 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2915 const int uvlinesize = s->current_picture.f.linesize[1];
2916 const int mb_size= 4 - s->avctx->lowres;
2918 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2919 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2920 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2921 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2922 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2923 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2924 //block_index is not used by mpeg2, so it is not affected by chroma_format
2926 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2927 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2928 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2930 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2932 if(s->picture_structure==PICT_FRAME){
2933 s->dest[0] += s->mb_y * linesize << mb_size;
2934 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2935 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2937 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2938 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2939 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2940 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2946 * Permute an 8x8 block.
2947 * @param block the block which will be permuted according to the given permutation vector
2948 * @param permutation the permutation vector
2949 * @param last the last non zero coefficient in scantable order, used to speed the permutation up
2950 * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
2951 * (inverse) permutated to scantable order!
2953 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
2959 //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
2961 for(i=0; i<=last; i++){
2962 const int j= scantable[i];
2967 for(i=0; i<=last; i++){
2968 const int j= scantable[i];
2969 const int perm_j= permutation[j];
2970 block[perm_j]= temp[j];
2974 void ff_mpeg_flush(AVCodecContext *avctx){
2976 MpegEncContext *s = avctx->priv_data;
2978 if(s==NULL || s->picture==NULL)
2981 for(i=0; i<s->picture_count; i++){
2982 if (s->picture[i].f.data[0] &&
2983 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2984 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2985 free_frame_buffer(s, &s->picture[i]);
2987 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2989 s->mb_x= s->mb_y= 0;
2992 s->parse_context.state= -1;
2993 s->parse_context.frame_start_found= 0;
2994 s->parse_context.overread= 0;
2995 s->parse_context.overread_index= 0;
2996 s->parse_context.index= 0;
2997 s->parse_context.last_index= 0;
2998 s->bitstream_buffer_size=0;
3002 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
3003 int16_t *block, int n, int qscale)
3005 int i, level, nCoeffs;
3006 const uint16_t *quant_matrix;
3008 nCoeffs= s->block_last_index[n];
3010 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3011 /* XXX: only mpeg1 */
3012 quant_matrix = s->intra_matrix;
3013 for(i=1;i<=nCoeffs;i++) {
3014 int j= s->intra_scantable.permutated[i];
3019 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3020 level = (level - 1) | 1;
3023 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3024 level = (level - 1) | 1;
3031 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
3032 int16_t *block, int n, int qscale)
3034 int i, level, nCoeffs;
3035 const uint16_t *quant_matrix;
3037 nCoeffs= s->block_last_index[n];
3039 quant_matrix = s->inter_matrix;
3040 for(i=0; i<=nCoeffs; i++) {
3041 int j= s->intra_scantable.permutated[i];
3046 level = (((level << 1) + 1) * qscale *
3047 ((int) (quant_matrix[j]))) >> 4;
3048 level = (level - 1) | 1;
3051 level = (((level << 1) + 1) * qscale *
3052 ((int) (quant_matrix[j]))) >> 4;
3053 level = (level - 1) | 1;
3060 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
3061 int16_t *block, int n, int qscale)
3063 int i, level, nCoeffs;
3064 const uint16_t *quant_matrix;
3066 if(s->alternate_scan) nCoeffs= 63;
3067 else nCoeffs= s->block_last_index[n];
3069 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3070 quant_matrix = s->intra_matrix;
3071 for(i=1;i<=nCoeffs;i++) {
3072 int j= s->intra_scantable.permutated[i];
3077 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3080 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3087 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
3088 int16_t *block, int n, int qscale)
3090 int i, level, nCoeffs;
3091 const uint16_t *quant_matrix;
3094 if(s->alternate_scan) nCoeffs= 63;
3095 else nCoeffs= s->block_last_index[n];
3097 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3099 quant_matrix = s->intra_matrix;
3100 for(i=1;i<=nCoeffs;i++) {
3101 int j= s->intra_scantable.permutated[i];
3106 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3109 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3118 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
3119 int16_t *block, int n, int qscale)
3121 int i, level, nCoeffs;
3122 const uint16_t *quant_matrix;
3125 if(s->alternate_scan) nCoeffs= 63;
3126 else nCoeffs= s->block_last_index[n];
3128 quant_matrix = s->inter_matrix;
3129 for(i=0; i<=nCoeffs; i++) {
3130 int j= s->intra_scantable.permutated[i];
3135 level = (((level << 1) + 1) * qscale *
3136 ((int) (quant_matrix[j]))) >> 4;
3139 level = (((level << 1) + 1) * qscale *
3140 ((int) (quant_matrix[j]))) >> 4;
3149 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3150 int16_t *block, int n, int qscale)
3152 int i, level, qmul, qadd;
3155 assert(s->block_last_index[n]>=0);
3160 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3161 qadd = (qscale - 1) | 1;
3168 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3170 for(i=1; i<=nCoeffs; i++) {
3174 level = level * qmul - qadd;
3176 level = level * qmul + qadd;
3183 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3184 int16_t *block, int n, int qscale)
3186 int i, level, qmul, qadd;
3189 assert(s->block_last_index[n]>=0);
3191 qadd = (qscale - 1) | 1;
3194 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3196 for(i=0; i<=nCoeffs; i++) {
3200 level = level * qmul - qadd;
3202 level = level * qmul + qadd;
3210 * set qscale and update qscale dependent variables.
3212 void ff_set_qscale(MpegEncContext * s, int qscale)
3216 else if (qscale > 31)
3220 s->chroma_qscale= s->chroma_qscale_table[qscale];
3222 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3223 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3226 void ff_MPV_report_decode_progress(MpegEncContext *s)
3228 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3229 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);
3232 void ff_mpeg_er_frame_start(MpegEncContext *s)
3234 ERContext *er = &s->er;
3236 er->cur_pic = s->current_picture_ptr;
3237 er->last_pic = s->last_picture_ptr;
3238 er->next_pic = s->next_picture_ptr;
3240 er->pp_time = s->pp_time;
3241 er->pb_time = s->pb_time;
3242 er->quarter_sample = s->quarter_sample;
3243 er->partitioned_frame = s->partitioned_frame;
3245 ff_er_frame_start(er);