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/intmath.h"
31 #include "libavutil/imgutils.h"
35 #include "mpegvideo.h"
38 #include "xvmc_internal.h"
45 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
46 DCTELEM *block, int n, int qscale);
47 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
58 DCTELEM *block, int n, int qscale);
61 /* enable all paranoid tests for rounding, overflows, etc... */
67 static const uint8_t ff_default_chroma_qscale_table[32] = {
68 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
69 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
70 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
73 const uint8_t ff_mpeg1_dc_scale_table[128] = {
74 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
81 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
85 static const uint8_t mpeg2_dc_scale_table1[128] = {
86 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
93 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
97 static const uint8_t mpeg2_dc_scale_table2[128] = {
98 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
105 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
109 static const uint8_t mpeg2_dc_scale_table3[128] = {
110 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
117 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
121 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
122 ff_mpeg1_dc_scale_table,
123 mpeg2_dc_scale_table1,
124 mpeg2_dc_scale_table2,
125 mpeg2_dc_scale_table3,
128 const enum PixelFormat ff_pixfmt_list_420[] = {
133 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
141 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
143 uint32_t *av_restrict state)
151 for (i = 0; i < 3; i++) {
152 uint32_t tmp = *state << 8;
153 *state = tmp + *(p++);
154 if (tmp == 0x100 || p == end)
159 if (p[-1] > 1 ) p += 3;
160 else if (p[-2] ) p += 2;
161 else if (p[-3]|(p[-1]-1)) p++;
168 p = FFMIN(p, end) - 4;
174 /* init common dct for both encoder and decoder */
175 av_cold int ff_dct_common_init(MpegEncContext *s)
177 ff_dsputil_init(&s->dsp, s->avctx);
179 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
180 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
181 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
182 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
183 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
184 if (s->flags & CODEC_FLAG_BITEXACT)
185 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
186 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
189 ff_MPV_common_init_x86(s);
191 ff_MPV_common_init_axp(s);
193 ff_MPV_common_init_mmi(s);
195 ff_MPV_common_init_arm(s);
197 ff_MPV_common_init_altivec(s);
199 ff_MPV_common_init_bfin(s);
202 /* load & permutate scantables
203 * note: only wmv uses different ones
205 if (s->alternate_scan) {
206 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
207 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
209 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
210 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
212 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
213 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
218 void ff_copy_picture(Picture *dst, Picture *src)
221 dst->f.type = FF_BUFFER_TYPE_COPY;
225 * Release a frame buffer
227 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
229 /* Windows Media Image codecs allocate internal buffers with different
230 * dimensions; ignore user defined callbacks for these
232 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE)
233 ff_thread_release_buffer(s->avctx, &pic->f);
235 avcodec_default_release_buffer(s->avctx, &pic->f);
236 av_freep(&pic->f.hwaccel_picture_private);
240 * Allocate a frame buffer
242 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
246 if (s->avctx->hwaccel) {
247 assert(!pic->f.hwaccel_picture_private);
248 if (s->avctx->hwaccel->priv_data_size) {
249 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
250 if (!pic->f.hwaccel_picture_private) {
251 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
257 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE)
258 r = ff_thread_get_buffer(s->avctx, &pic->f);
260 r = avcodec_default_get_buffer(s->avctx, &pic->f);
262 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
263 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
264 r, pic->f.type, pic->f.data[0]);
265 av_freep(&pic->f.hwaccel_picture_private);
269 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
270 s->uvlinesize != pic->f.linesize[1])) {
271 av_log(s->avctx, AV_LOG_ERROR,
272 "get_buffer() failed (stride changed)\n");
273 free_frame_buffer(s, pic);
277 if (pic->f.linesize[1] != pic->f.linesize[2]) {
278 av_log(s->avctx, AV_LOG_ERROR,
279 "get_buffer() failed (uv stride mismatch)\n");
280 free_frame_buffer(s, pic);
288 * Allocate a Picture.
289 * The pixels are allocated/set by calling get_buffer() if shared = 0
291 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
293 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
295 // the + 1 is needed so memset(,,stride*height) does not sig11
297 const int mb_array_size = s->mb_stride * s->mb_height;
298 const int b8_array_size = s->b8_stride * s->mb_height * 2;
299 const int b4_array_size = s->b4_stride * s->mb_height * 4;
304 assert(pic->f.data[0]);
305 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
306 pic->f.type = FF_BUFFER_TYPE_SHARED;
308 assert(!pic->f.data[0]);
310 if (alloc_frame_buffer(s, pic) < 0)
313 s->linesize = pic->f.linesize[0];
314 s->uvlinesize = pic->f.linesize[1];
317 if (pic->f.qscale_table == NULL) {
319 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
320 mb_array_size * sizeof(int16_t), fail)
321 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
322 mb_array_size * sizeof(int16_t), fail)
323 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
324 mb_array_size * sizeof(int8_t ), fail)
327 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
328 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
329 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
330 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
332 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
333 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
335 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
336 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
337 if (s->out_format == FMT_H264) {
338 for (i = 0; i < 2; i++) {
339 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
340 2 * (b4_array_size + 4) * sizeof(int16_t),
342 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
343 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
344 4 * mb_array_size * sizeof(uint8_t), fail)
346 pic->f.motion_subsample_log2 = 2;
347 } else if (s->out_format == FMT_H263 || s->encoding ||
348 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
349 for (i = 0; i < 2; i++) {
350 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
351 2 * (b8_array_size + 4) * sizeof(int16_t),
353 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
354 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
355 4 * mb_array_size * sizeof(uint8_t), fail)
357 pic->f.motion_subsample_log2 = 3;
359 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
360 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
361 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
363 pic->f.qstride = s->mb_stride;
364 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
365 1 * sizeof(AVPanScan), fail)
371 fail: // for the FF_ALLOCZ_OR_GOTO macro
373 free_frame_buffer(s, pic);
378 * Deallocate a picture.
380 static void free_picture(MpegEncContext *s, Picture *pic)
384 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
385 free_frame_buffer(s, pic);
388 av_freep(&pic->mb_var);
389 av_freep(&pic->mc_mb_var);
390 av_freep(&pic->mb_mean);
391 av_freep(&pic->f.mbskip_table);
392 av_freep(&pic->qscale_table_base);
393 av_freep(&pic->mb_type_base);
394 av_freep(&pic->f.dct_coeff);
395 av_freep(&pic->f.pan_scan);
396 pic->f.mb_type = NULL;
397 for (i = 0; i < 2; i++) {
398 av_freep(&pic->motion_val_base[i]);
399 av_freep(&pic->f.ref_index[i]);
402 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
403 for (i = 0; i < 4; i++) {
405 pic->f.data[i] = NULL;
411 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
413 int y_size = s->b8_stride * (2 * s->mb_height + 1);
414 int c_size = s->mb_stride * (s->mb_height + 1);
415 int yc_size = y_size + 2 * c_size;
418 // edge emu needs blocksize + filter length - 1
419 // (= 17x17 for halfpel / 21x21 for h264)
420 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
421 (s->width + 95) * 2 * 21 * 4, fail); // (width + edge + align)*interlaced*MBsize*tolerance
423 // FIXME should be linesize instead of s->width * 2
424 // but that is not known before get_buffer()
425 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
426 (s->width + 95) * 4 * 16 * 2 * sizeof(uint8_t), fail)
427 s->me.temp = s->me.scratchpad;
428 s->rd_scratchpad = s->me.scratchpad;
429 s->b_scratchpad = s->me.scratchpad;
430 s->obmc_scratchpad = s->me.scratchpad + 16;
432 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
433 ME_MAP_SIZE * sizeof(uint32_t), fail)
434 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
435 ME_MAP_SIZE * sizeof(uint32_t), fail)
436 if (s->avctx->noise_reduction) {
437 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
438 2 * 64 * sizeof(int), fail)
441 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
442 s->block = s->blocks[0];
444 for (i = 0; i < 12; i++) {
445 s->pblocks[i] = &s->block[i];
448 if (s->out_format == FMT_H263) {
450 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
451 yc_size * sizeof(int16_t) * 16, fail);
452 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
453 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
454 s->ac_val[2] = s->ac_val[1] + c_size;
459 return -1; // free() through ff_MPV_common_end()
462 static void free_duplicate_context(MpegEncContext *s)
467 av_freep(&s->edge_emu_buffer);
468 av_freep(&s->me.scratchpad);
472 s->obmc_scratchpad = NULL;
474 av_freep(&s->dct_error_sum);
475 av_freep(&s->me.map);
476 av_freep(&s->me.score_map);
477 av_freep(&s->blocks);
478 av_freep(&s->ac_val_base);
482 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
484 #define COPY(a) bak->a = src->a
485 COPY(edge_emu_buffer);
490 COPY(obmc_scratchpad);
497 COPY(me.map_generation);
509 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
513 // FIXME copy only needed parts
515 backup_duplicate_context(&bak, dst);
516 memcpy(dst, src, sizeof(MpegEncContext));
517 backup_duplicate_context(dst, &bak);
518 for (i = 0; i < 12; i++) {
519 dst->pblocks[i] = &dst->block[i];
521 // STOP_TIMER("update_duplicate_context")
522 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
525 int ff_mpeg_update_thread_context(AVCodecContext *dst,
526 const AVCodecContext *src)
528 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
533 // FIXME can parameters change on I-frames?
534 // in that case dst may need a reinit
535 if (!s->context_initialized) {
536 memcpy(s, s1, sizeof(MpegEncContext));
539 s->bitstream_buffer = NULL;
540 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
542 if (s1->context_initialized){
543 s->picture_range_start += MAX_PICTURE_COUNT;
544 s->picture_range_end += MAX_PICTURE_COUNT;
545 ff_MPV_common_init(s);
549 s->avctx->coded_height = s1->avctx->coded_height;
550 s->avctx->coded_width = s1->avctx->coded_width;
551 s->avctx->width = s1->avctx->width;
552 s->avctx->height = s1->avctx->height;
554 s->coded_picture_number = s1->coded_picture_number;
555 s->picture_number = s1->picture_number;
556 s->input_picture_number = s1->input_picture_number;
558 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
559 memcpy(&s->last_picture, &s1->last_picture,
560 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
562 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
563 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
564 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
566 // Error/bug resilience
567 s->next_p_frame_damaged = s1->next_p_frame_damaged;
568 s->workaround_bugs = s1->workaround_bugs;
569 s->padding_bug_score = s1->padding_bug_score;
572 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
573 (char *) &s1->shape - (char *) &s1->time_increment_bits);
576 s->max_b_frames = s1->max_b_frames;
577 s->low_delay = s1->low_delay;
578 s->dropable = s1->dropable;
580 // DivX handling (doesn't work)
581 s->divx_packed = s1->divx_packed;
583 if (s1->bitstream_buffer) {
584 if (s1->bitstream_buffer_size +
585 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
586 av_fast_malloc(&s->bitstream_buffer,
587 &s->allocated_bitstream_buffer_size,
588 s1->allocated_bitstream_buffer_size);
589 s->bitstream_buffer_size = s1->bitstream_buffer_size;
590 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
591 s1->bitstream_buffer_size);
592 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
593 FF_INPUT_BUFFER_PADDING_SIZE);
596 // MPEG2/interlacing info
597 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
598 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
600 if (!s1->first_field) {
601 s->last_pict_type = s1->pict_type;
602 if (s1->current_picture_ptr)
603 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
605 if (s1->pict_type != AV_PICTURE_TYPE_B) {
606 s->last_non_b_pict_type = s1->pict_type;
614 * Set the given MpegEncContext to common defaults
615 * (same for encoding and decoding).
616 * The changed fields will not depend upon the
617 * prior state of the MpegEncContext.
619 void ff_MPV_common_defaults(MpegEncContext *s)
621 s->y_dc_scale_table =
622 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
623 s->chroma_qscale_table = ff_default_chroma_qscale_table;
624 s->progressive_frame = 1;
625 s->progressive_sequence = 1;
626 s->picture_structure = PICT_FRAME;
628 s->coded_picture_number = 0;
629 s->picture_number = 0;
630 s->input_picture_number = 0;
632 s->picture_in_gop_number = 0;
637 s->picture_range_start = 0;
638 s->picture_range_end = MAX_PICTURE_COUNT;
640 s->slice_context_count = 1;
644 * Set the given MpegEncContext to defaults for decoding.
645 * the changed fields will not depend upon
646 * the prior state of the MpegEncContext.
648 void ff_MPV_decode_defaults(MpegEncContext *s)
650 ff_MPV_common_defaults(s);
654 * init common structure for both encoder and decoder.
655 * this assumes that some variables like width/height are already set
657 av_cold int ff_MPV_common_init(MpegEncContext *s)
659 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
660 int nb_slices = (HAVE_THREADS &&
661 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
662 s->avctx->thread_count : 1;
664 if (s->encoding && s->avctx->slices)
665 nb_slices = s->avctx->slices;
667 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
668 s->mb_height = (s->height + 31) / 32 * 2;
669 else if (s->codec_id != AV_CODEC_ID_H264)
670 s->mb_height = (s->height + 15) / 16;
672 if (s->avctx->pix_fmt == PIX_FMT_NONE) {
673 av_log(s->avctx, AV_LOG_ERROR,
674 "decoding to PIX_FMT_NONE is not supported.\n");
678 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
681 max_slices = FFMIN(MAX_THREADS, s->mb_height);
683 max_slices = MAX_THREADS;
684 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
685 " reducing to %d\n", nb_slices, max_slices);
686 nb_slices = max_slices;
689 if ((s->width || s->height) &&
690 av_image_check_size(s->width, s->height, 0, s->avctx))
693 ff_dct_common_init(s);
695 s->flags = s->avctx->flags;
696 s->flags2 = s->avctx->flags2;
698 s->mb_width = (s->width + 15) / 16;
699 s->mb_stride = s->mb_width + 1;
700 s->b8_stride = s->mb_width * 2 + 1;
701 s->b4_stride = s->mb_width * 4 + 1;
702 mb_array_size = s->mb_height * s->mb_stride;
703 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
705 /* set chroma shifts */
706 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
709 /* set default edge pos, will be overridden in decode_header if needed */
710 s->h_edge_pos = s->mb_width * 16;
711 s->v_edge_pos = s->mb_height * 16;
713 s->mb_num = s->mb_width * s->mb_height;
718 s->block_wrap[3] = s->b8_stride;
720 s->block_wrap[5] = s->mb_stride;
722 y_size = s->b8_stride * (2 * s->mb_height + 1);
723 c_size = s->mb_stride * (s->mb_height + 1);
724 yc_size = y_size + 2 * c_size;
726 /* convert fourcc to upper case */
727 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
728 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
730 s->avctx->coded_frame = &s->current_picture.f;
732 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
733 for (y = 0; y < s->mb_height; y++)
734 for (x = 0; x < s->mb_width; x++)
735 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
737 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
740 /* Allocate MV tables */
741 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
742 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
743 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
744 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
745 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
746 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
747 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
748 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
749 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
750 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
751 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
752 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
754 if(s->msmpeg4_version){
755 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
757 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
759 /* Allocate MB type table */
760 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
762 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
764 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
765 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix , 64*32 * sizeof(int), fail)
766 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
767 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
768 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
769 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
770 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
771 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
773 if(s->avctx->noise_reduction){
774 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
777 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
778 mb_array_size * sizeof(float), fail);
779 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
780 mb_array_size * sizeof(float), fail);
783 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
784 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
785 s->picture_count * sizeof(Picture), fail);
786 for (i = 0; i < s->picture_count; i++) {
787 avcodec_get_frame_defaults(&s->picture[i].f);
790 FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
791 mb_array_size * sizeof(uint8_t), fail);
792 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
793 mb_array_size * sizeof(uint8_t), fail);
795 if(s->codec_id==AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
796 /* interlaced direct mode decoding tables */
797 for (i = 0; i < 2; i++) {
799 for (j = 0; j < 2; j++) {
800 for (k = 0; k < 2; k++) {
801 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
802 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
804 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
805 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
806 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
808 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
811 if (s->out_format == FMT_H263) {
813 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
814 s->coded_block = s->coded_block_base + s->b8_stride + 1;
816 /* cbp, ac_pred, pred_dir */
817 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
818 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
821 if (s->h263_pred || s->h263_plus || !s->encoding) {
823 // MN: we need these for error resilience of intra-frames
824 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
825 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
826 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
827 s->dc_val[2] = s->dc_val[1] + c_size;
828 for (i = 0; i < yc_size; i++)
829 s->dc_val_base[i] = 1024;
832 /* which mb is a intra block */
833 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
834 memset(s->mbintra_table, 1, mb_array_size);
836 /* init macroblock skip table */
837 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
838 // Note the + 1 is for a quicker mpeg4 slice_end detection
840 s->parse_context.state = -1;
842 s->context_initialized = 1;
843 s->thread_context[0] = s;
845 // if (s->width && s->height) {
847 for (i = 1; i < nb_slices; i++) {
848 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
849 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
852 for (i = 0; i < nb_slices; i++) {
853 if (init_duplicate_context(s->thread_context[i], s) < 0)
855 s->thread_context[i]->start_mb_y =
856 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
857 s->thread_context[i]->end_mb_y =
858 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
861 if (init_duplicate_context(s, s) < 0)
864 s->end_mb_y = s->mb_height;
866 s->slice_context_count = nb_slices;
871 ff_MPV_common_end(s);
875 /* init common structure for both encoder and decoder */
876 void ff_MPV_common_end(MpegEncContext *s)
880 if (s->slice_context_count > 1) {
881 for (i = 0; i < s->slice_context_count; i++) {
882 free_duplicate_context(s->thread_context[i]);
884 for (i = 1; i < s->slice_context_count; i++) {
885 av_freep(&s->thread_context[i]);
887 s->slice_context_count = 1;
888 } else free_duplicate_context(s);
890 av_freep(&s->parse_context.buffer);
891 s->parse_context.buffer_size = 0;
893 av_freep(&s->mb_type);
894 av_freep(&s->p_mv_table_base);
895 av_freep(&s->b_forw_mv_table_base);
896 av_freep(&s->b_back_mv_table_base);
897 av_freep(&s->b_bidir_forw_mv_table_base);
898 av_freep(&s->b_bidir_back_mv_table_base);
899 av_freep(&s->b_direct_mv_table_base);
900 s->p_mv_table = NULL;
901 s->b_forw_mv_table = NULL;
902 s->b_back_mv_table = NULL;
903 s->b_bidir_forw_mv_table = NULL;
904 s->b_bidir_back_mv_table = NULL;
905 s->b_direct_mv_table = NULL;
906 for (i = 0; i < 2; i++) {
907 for (j = 0; j < 2; j++) {
908 for (k = 0; k < 2; k++) {
909 av_freep(&s->b_field_mv_table_base[i][j][k]);
910 s->b_field_mv_table[i][j][k] = NULL;
912 av_freep(&s->b_field_select_table[i][j]);
913 av_freep(&s->p_field_mv_table_base[i][j]);
914 s->p_field_mv_table[i][j] = NULL;
916 av_freep(&s->p_field_select_table[i]);
919 av_freep(&s->dc_val_base);
920 av_freep(&s->coded_block_base);
921 av_freep(&s->mbintra_table);
922 av_freep(&s->cbp_table);
923 av_freep(&s->pred_dir_table);
925 av_freep(&s->mbskip_table);
926 av_freep(&s->bitstream_buffer);
927 s->allocated_bitstream_buffer_size = 0;
929 av_freep(&s->avctx->stats_out);
930 av_freep(&s->ac_stats);
931 av_freep(&s->error_status_table);
932 av_freep(&s->er_temp_buffer);
933 av_freep(&s->mb_index2xy);
934 av_freep(&s->lambda_table);
935 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
936 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
937 s->q_chroma_intra_matrix= NULL;
938 s->q_chroma_intra_matrix16= NULL;
939 av_freep(&s->q_intra_matrix);
940 av_freep(&s->q_inter_matrix);
941 av_freep(&s->q_intra_matrix16);
942 av_freep(&s->q_inter_matrix16);
943 av_freep(&s->input_picture);
944 av_freep(&s->reordered_input_picture);
945 av_freep(&s->dct_offset);
946 av_freep(&s->cplx_tab);
947 av_freep(&s->bits_tab);
949 if (s->picture && !s->avctx->internal->is_copy) {
950 for (i = 0; i < s->picture_count; i++) {
951 free_picture(s, &s->picture[i]);
954 av_freep(&s->picture);
955 s->context_initialized = 0;
956 s->last_picture_ptr =
957 s->next_picture_ptr =
958 s->current_picture_ptr = NULL;
959 s->linesize = s->uvlinesize = 0;
961 for (i = 0; i < 3; i++)
962 av_freep(&s->visualization_buffer[i]);
964 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
965 avcodec_default_free_buffers(s->avctx);
968 void ff_init_rl(RLTable *rl,
969 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
971 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
972 uint8_t index_run[MAX_RUN + 1];
973 int last, run, level, start, end, i;
975 /* If table is static, we can quit if rl->max_level[0] is not NULL */
976 if (static_store && rl->max_level[0])
979 /* compute max_level[], max_run[] and index_run[] */
980 for (last = 0; last < 2; last++) {
989 memset(max_level, 0, MAX_RUN + 1);
990 memset(max_run, 0, MAX_LEVEL + 1);
991 memset(index_run, rl->n, MAX_RUN + 1);
992 for (i = start; i < end; i++) {
993 run = rl->table_run[i];
994 level = rl->table_level[i];
995 if (index_run[run] == rl->n)
997 if (level > max_level[run])
998 max_level[run] = level;
999 if (run > max_run[level])
1000 max_run[level] = run;
1003 rl->max_level[last] = static_store[last];
1005 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1006 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1008 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1010 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1011 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1013 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1015 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1016 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1020 void ff_init_vlc_rl(RLTable *rl)
1024 for (q = 0; q < 32; q++) {
1026 int qadd = (q - 1) | 1;
1032 for (i = 0; i < rl->vlc.table_size; i++) {
1033 int code = rl->vlc.table[i][0];
1034 int len = rl->vlc.table[i][1];
1037 if (len == 0) { // illegal code
1040 } else if (len < 0) { // more bits needed
1044 if (code == rl->n) { // esc
1048 run = rl->table_run[code] + 1;
1049 level = rl->table_level[code] * qmul + qadd;
1050 if (code >= rl->last) run += 192;
1053 rl->rl_vlc[q][i].len = len;
1054 rl->rl_vlc[q][i].level = level;
1055 rl->rl_vlc[q][i].run = run;
1060 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1064 /* release non reference frames */
1065 for (i = 0; i < s->picture_count; i++) {
1066 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1067 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1068 (remove_current || &s->picture[i] != s->current_picture_ptr)
1069 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1070 free_frame_buffer(s, &s->picture[i]);
1075 int ff_find_unused_picture(MpegEncContext *s, int shared)
1080 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1081 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1085 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1086 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
1089 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1090 if (s->picture[i].f.data[0] == NULL)
1095 av_log(s->avctx, AV_LOG_FATAL,
1096 "Internal error, picture buffer overflow\n");
1097 /* We could return -1, but the codec would crash trying to draw into a
1098 * non-existing frame anyway. This is safer than waiting for a random crash.
1099 * Also the return of this is never useful, an encoder must only allocate
1100 * as much as allowed in the specification. This has no relationship to how
1101 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1102 * enough for such valid streams).
1103 * Plus, a decoder has to check stream validity and remove frames if too
1104 * many reference frames are around. Waiting for "OOM" is not correct at
1105 * all. Similarly, missing reference frames have to be replaced by
1106 * interpolated/MC frames, anything else is a bug in the codec ...
1112 static void update_noise_reduction(MpegEncContext *s)
1116 for (intra = 0; intra < 2; intra++) {
1117 if (s->dct_count[intra] > (1 << 16)) {
1118 for (i = 0; i < 64; i++) {
1119 s->dct_error_sum[intra][i] >>= 1;
1121 s->dct_count[intra] >>= 1;
1124 for (i = 0; i < 64; i++) {
1125 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1126 s->dct_count[intra] +
1127 s->dct_error_sum[intra][i] / 2) /
1128 (s->dct_error_sum[intra][i] + 1);
1134 * generic function for encode/decode called after coding/decoding
1135 * the header and before a frame is coded/decoded.
1137 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1143 if (!ff_thread_can_start_frame(avctx)) {
1144 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1148 /* mark & release old frames */
1149 if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1150 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1151 s->last_picture_ptr != s->next_picture_ptr &&
1152 s->last_picture_ptr->f.data[0]) {
1153 if (s->last_picture_ptr->owner2 == s)
1154 free_frame_buffer(s, s->last_picture_ptr);
1157 /* release forgotten pictures */
1158 /* if (mpeg124/h263) */
1160 for (i = 0; i < s->picture_count; i++) {
1161 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1162 &s->picture[i] != s->last_picture_ptr &&
1163 &s->picture[i] != s->next_picture_ptr &&
1164 s->picture[i].f.reference) {
1165 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1166 av_log(avctx, AV_LOG_ERROR,
1167 "releasing zombie picture\n");
1168 free_frame_buffer(s, &s->picture[i]);
1175 ff_release_unused_pictures(s, 1);
1177 if (s->current_picture_ptr &&
1178 s->current_picture_ptr->f.data[0] == NULL) {
1179 // we already have a unused image
1180 // (maybe it was set before reading the header)
1181 pic = s->current_picture_ptr;
1183 i = ff_find_unused_picture(s, 0);
1186 pic = &s->picture[i];
1189 pic->f.reference = 0;
1191 if (s->codec_id == AV_CODEC_ID_H264)
1192 pic->f.reference = s->picture_structure;
1193 else if (s->pict_type != AV_PICTURE_TYPE_B)
1194 pic->f.reference = 3;
1197 pic->f.coded_picture_number = s->coded_picture_number++;
1199 if (ff_alloc_picture(s, pic, 0) < 0)
1202 s->current_picture_ptr = pic;
1203 // FIXME use only the vars from current_pic
1204 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1205 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1206 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1207 if (s->picture_structure != PICT_FRAME)
1208 s->current_picture_ptr->f.top_field_first =
1209 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1211 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1212 !s->progressive_sequence;
1213 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1216 s->current_picture_ptr->f.pict_type = s->pict_type;
1217 // if (s->flags && CODEC_FLAG_QSCALE)
1218 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1219 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1221 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1223 if (s->pict_type != AV_PICTURE_TYPE_B) {
1224 s->last_picture_ptr = s->next_picture_ptr;
1226 s->next_picture_ptr = s->current_picture_ptr;
1228 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1229 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1230 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1231 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1232 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1233 s->pict_type, s->dropable); */
1235 if (s->codec_id != AV_CODEC_ID_H264) {
1236 if ((s->last_picture_ptr == NULL ||
1237 s->last_picture_ptr->f.data[0] == NULL) &&
1238 (s->pict_type != AV_PICTURE_TYPE_I ||
1239 s->picture_structure != PICT_FRAME)) {
1240 if (s->pict_type != AV_PICTURE_TYPE_I)
1241 av_log(avctx, AV_LOG_ERROR,
1242 "warning: first frame is no keyframe\n");
1243 else if (s->picture_structure != PICT_FRAME)
1244 av_log(avctx, AV_LOG_INFO,
1245 "allocate dummy last picture for field based first keyframe\n");
1247 /* Allocate a dummy frame */
1248 i = ff_find_unused_picture(s, 0);
1251 s->last_picture_ptr = &s->picture[i];
1252 s->last_picture_ptr->f.key_frame = 0;
1253 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1254 s->last_picture_ptr = NULL;
1258 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1259 for(i=0; i<avctx->height; i++)
1260 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1263 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1264 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1265 s->last_picture_ptr->f.reference = 3;
1267 if ((s->next_picture_ptr == NULL ||
1268 s->next_picture_ptr->f.data[0] == NULL) &&
1269 s->pict_type == AV_PICTURE_TYPE_B) {
1270 /* Allocate a dummy frame */
1271 i = ff_find_unused_picture(s, 0);
1274 s->next_picture_ptr = &s->picture[i];
1275 s->next_picture_ptr->f.key_frame = 0;
1276 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1277 s->next_picture_ptr = NULL;
1280 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1281 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1282 s->next_picture_ptr->f.reference = 3;
1286 if (s->last_picture_ptr)
1287 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1288 if (s->next_picture_ptr)
1289 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1291 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1292 (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3)) {
1293 if (s->next_picture_ptr)
1294 s->next_picture_ptr->owner2 = s;
1295 if (s->last_picture_ptr)
1296 s->last_picture_ptr->owner2 = s;
1299 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1300 s->last_picture_ptr->f.data[0]));
1302 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1304 for (i = 0; i < 4; i++) {
1305 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1306 s->current_picture.f.data[i] +=
1307 s->current_picture.f.linesize[i];
1309 s->current_picture.f.linesize[i] *= 2;
1310 s->last_picture.f.linesize[i] *= 2;
1311 s->next_picture.f.linesize[i] *= 2;
1315 s->err_recognition = avctx->err_recognition;
1317 /* set dequantizer, we can't do it during init as
1318 * it might change for mpeg4 and we can't do it in the header
1319 * decode as init is not called for mpeg4 there yet */
1320 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1321 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1322 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1323 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1324 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1325 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1327 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1328 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1331 if (s->dct_error_sum) {
1332 assert(s->avctx->noise_reduction && s->encoding);
1333 update_noise_reduction(s);
1336 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1337 return ff_xvmc_field_start(s, avctx);
1342 /* generic function for encode/decode called after a
1343 * frame has been coded/decoded. */
1344 void ff_MPV_frame_end(MpegEncContext *s)
1347 /* redraw edges for the frame if decoding didn't complete */
1348 // just to make sure that all data is rendered.
1349 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1350 ff_xvmc_field_end(s);
1351 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1352 !s->avctx->hwaccel &&
1353 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1354 s->unrestricted_mv &&
1355 s->current_picture.f.reference &&
1357 !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1360 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1361 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1362 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1363 s->h_edge_pos, s->v_edge_pos,
1364 EDGE_WIDTH, EDGE_WIDTH,
1365 EDGE_TOP | EDGE_BOTTOM);
1366 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1367 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1368 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1369 EDGE_TOP | EDGE_BOTTOM);
1370 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1371 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1372 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1373 EDGE_TOP | EDGE_BOTTOM);
1378 s->last_pict_type = s->pict_type;
1379 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1380 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1381 s->last_non_b_pict_type = s->pict_type;
1384 /* copy back current_picture variables */
1385 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1386 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1387 s->picture[i] = s->current_picture;
1391 assert(i < MAX_PICTURE_COUNT);
1395 /* release non-reference frames */
1396 for (i = 0; i < s->picture_count; i++) {
1397 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1398 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1399 free_frame_buffer(s, &s->picture[i]);
1403 // clear copies, to avoid confusion
1405 memset(&s->last_picture, 0, sizeof(Picture));
1406 memset(&s->next_picture, 0, sizeof(Picture));
1407 memset(&s->current_picture, 0, sizeof(Picture));
1409 s->avctx->coded_frame = &s->current_picture_ptr->f;
1411 if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1412 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1417 * Draw a line from (ex, ey) -> (sx, sy).
1418 * @param w width of the image
1419 * @param h height of the image
1420 * @param stride stride/linesize of the image
1421 * @param color color of the arrow
1423 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1424 int w, int h, int stride, int color)
1428 sx = av_clip(sx, 0, w - 1);
1429 sy = av_clip(sy, 0, h - 1);
1430 ex = av_clip(ex, 0, w - 1);
1431 ey = av_clip(ey, 0, h - 1);
1433 buf[sy * stride + sx] += color;
1435 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1437 FFSWAP(int, sx, ex);
1438 FFSWAP(int, sy, ey);
1440 buf += sx + sy * stride;
1442 f = ((ey - sy) << 16) / ex;
1443 for(x= 0; x <= ex; x++){
1445 fr = (x * f) & 0xFFFF;
1446 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1447 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1451 FFSWAP(int, sx, ex);
1452 FFSWAP(int, sy, ey);
1454 buf += sx + sy * stride;
1457 f = ((ex - sx) << 16) / ey;
1460 for(y= 0; y <= ey; y++){
1462 fr = (y*f) & 0xFFFF;
1463 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1464 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1470 * Draw an arrow from (ex, ey) -> (sx, sy).
1471 * @param w width of the image
1472 * @param h height of the image
1473 * @param stride stride/linesize of the image
1474 * @param color color of the arrow
1476 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1477 int ey, int w, int h, int stride, int color)
1481 sx = av_clip(sx, -100, w + 100);
1482 sy = av_clip(sy, -100, h + 100);
1483 ex = av_clip(ex, -100, w + 100);
1484 ey = av_clip(ey, -100, h + 100);
1489 if (dx * dx + dy * dy > 3 * 3) {
1492 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1494 // FIXME subpixel accuracy
1495 rx = ROUNDED_DIV(rx * 3 << 4, length);
1496 ry = ROUNDED_DIV(ry * 3 << 4, length);
1498 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1499 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1501 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1505 * Print debugging info for the given picture.
1507 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1509 if (s->avctx->hwaccel || !pict || !pict->mb_type)
1512 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1515 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1516 av_get_picture_type_char(pict->pict_type));
1517 for (y = 0; y < s->mb_height; y++) {
1518 for (x = 0; x < s->mb_width; x++) {
1519 if (s->avctx->debug & FF_DEBUG_SKIP) {
1520 int count = s->mbskip_table[x + y * s->mb_stride];
1523 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1525 if (s->avctx->debug & FF_DEBUG_QP) {
1526 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1527 pict->qscale_table[x + y * s->mb_stride]);
1529 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1530 int mb_type = pict->mb_type[x + y * s->mb_stride];
1531 // Type & MV direction
1532 if (IS_PCM(mb_type))
1533 av_log(s->avctx, AV_LOG_DEBUG, "P");
1534 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1535 av_log(s->avctx, AV_LOG_DEBUG, "A");
1536 else if (IS_INTRA4x4(mb_type))
1537 av_log(s->avctx, AV_LOG_DEBUG, "i");
1538 else if (IS_INTRA16x16(mb_type))
1539 av_log(s->avctx, AV_LOG_DEBUG, "I");
1540 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1541 av_log(s->avctx, AV_LOG_DEBUG, "d");
1542 else if (IS_DIRECT(mb_type))
1543 av_log(s->avctx, AV_LOG_DEBUG, "D");
1544 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1545 av_log(s->avctx, AV_LOG_DEBUG, "g");
1546 else if (IS_GMC(mb_type))
1547 av_log(s->avctx, AV_LOG_DEBUG, "G");
1548 else if (IS_SKIP(mb_type))
1549 av_log(s->avctx, AV_LOG_DEBUG, "S");
1550 else if (!USES_LIST(mb_type, 1))
1551 av_log(s->avctx, AV_LOG_DEBUG, ">");
1552 else if (!USES_LIST(mb_type, 0))
1553 av_log(s->avctx, AV_LOG_DEBUG, "<");
1555 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1556 av_log(s->avctx, AV_LOG_DEBUG, "X");
1560 if (IS_8X8(mb_type))
1561 av_log(s->avctx, AV_LOG_DEBUG, "+");
1562 else if (IS_16X8(mb_type))
1563 av_log(s->avctx, AV_LOG_DEBUG, "-");
1564 else if (IS_8X16(mb_type))
1565 av_log(s->avctx, AV_LOG_DEBUG, "|");
1566 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1567 av_log(s->avctx, AV_LOG_DEBUG, " ");
1569 av_log(s->avctx, AV_LOG_DEBUG, "?");
1572 if (IS_INTERLACED(mb_type))
1573 av_log(s->avctx, AV_LOG_DEBUG, "=");
1575 av_log(s->avctx, AV_LOG_DEBUG, " ");
1577 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1579 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1583 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1584 (s->avctx->debug_mv)) {
1585 const int shift = 1 + s->quarter_sample;
1589 int h_chroma_shift, v_chroma_shift, block_height;
1590 const int width = s->avctx->width;
1591 const int height = s->avctx->height;
1592 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1593 const int mv_stride = (s->mb_width << mv_sample_log2) +
1594 (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1595 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1597 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1598 &h_chroma_shift, &v_chroma_shift);
1599 for (i = 0; i < 3; i++) {
1600 size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1601 pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1602 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1603 memcpy(s->visualization_buffer[i], pict->data[i], size);
1604 pict->data[i] = s->visualization_buffer[i];
1606 pict->type = FF_BUFFER_TYPE_COPY;
1608 ptr = pict->data[0];
1609 block_height = 16 >> v_chroma_shift;
1611 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1613 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1614 const int mb_index = mb_x + mb_y * s->mb_stride;
1615 if ((s->avctx->debug_mv) && pict->motion_val) {
1617 for (type = 0; type < 3; type++) {
1621 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1622 (pict->pict_type!= AV_PICTURE_TYPE_P))
1627 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1628 (pict->pict_type!= AV_PICTURE_TYPE_B))
1633 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1634 (pict->pict_type!= AV_PICTURE_TYPE_B))
1639 if (!USES_LIST(pict->mb_type[mb_index], direction))
1642 if (IS_8X8(pict->mb_type[mb_index])) {
1644 for (i = 0; i < 4; i++) {
1645 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1646 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1647 int xy = (mb_x * 2 + (i & 1) +
1648 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1649 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1650 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1651 draw_arrow(ptr, sx, sy, mx, my, width,
1652 height, s->linesize, 100);
1654 } else if (IS_16X8(pict->mb_type[mb_index])) {
1656 for (i = 0; i < 2; i++) {
1657 int sx = mb_x * 16 + 8;
1658 int sy = mb_y * 16 + 4 + 8 * i;
1659 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1660 int mx = (pict->motion_val[direction][xy][0] >> shift);
1661 int my = (pict->motion_val[direction][xy][1] >> shift);
1663 if (IS_INTERLACED(pict->mb_type[mb_index]))
1666 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1667 height, s->linesize, 100);
1669 } else if (IS_8X16(pict->mb_type[mb_index])) {
1671 for (i = 0; i < 2; i++) {
1672 int sx = mb_x * 16 + 4 + 8 * i;
1673 int sy = mb_y * 16 + 8;
1674 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1675 int mx = pict->motion_val[direction][xy][0] >> shift;
1676 int my = pict->motion_val[direction][xy][1] >> shift;
1678 if (IS_INTERLACED(pict->mb_type[mb_index]))
1681 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1682 height, s->linesize, 100);
1685 int sx= mb_x * 16 + 8;
1686 int sy= mb_y * 16 + 8;
1687 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1688 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1689 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1690 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1694 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1695 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1696 0x0101010101010101ULL;
1698 for (y = 0; y < block_height; y++) {
1699 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1700 (block_height * mb_y + y) *
1701 pict->linesize[1]) = c;
1702 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1703 (block_height * mb_y + y) *
1704 pict->linesize[2]) = c;
1707 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1709 int mb_type = pict->mb_type[mb_index];
1712 #define COLOR(theta, r) \
1713 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1714 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1718 if (IS_PCM(mb_type)) {
1720 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1721 IS_INTRA16x16(mb_type)) {
1723 } else if (IS_INTRA4x4(mb_type)) {
1725 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1727 } else if (IS_DIRECT(mb_type)) {
1729 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1731 } else if (IS_GMC(mb_type)) {
1733 } else if (IS_SKIP(mb_type)) {
1735 } else if (!USES_LIST(mb_type, 1)) {
1737 } else if (!USES_LIST(mb_type, 0)) {
1740 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1744 u *= 0x0101010101010101ULL;
1745 v *= 0x0101010101010101ULL;
1746 for (y = 0; y < block_height; y++) {
1747 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1748 (block_height * mb_y + y) * pict->linesize[1]) = u;
1749 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1750 (block_height * mb_y + y) * pict->linesize[2]) = v;
1754 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1755 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1756 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1757 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1758 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1760 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1761 for (y = 0; y < 16; y++)
1762 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1763 pict->linesize[0]] ^= 0x80;
1765 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1766 int dm = 1 << (mv_sample_log2 - 2);
1767 for (i = 0; i < 4; i++) {
1768 int sx = mb_x * 16 + 8 * (i & 1);
1769 int sy = mb_y * 16 + 8 * (i >> 1);
1770 int xy = (mb_x * 2 + (i & 1) +
1771 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1773 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1774 if (mv[0] != mv[dm] ||
1775 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1776 for (y = 0; y < 8; y++)
1777 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1778 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1779 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1780 pict->linesize[0]) ^= 0x8080808080808080ULL;
1784 if (IS_INTERLACED(mb_type) &&
1785 s->codec_id == AV_CODEC_ID_H264) {
1789 s->mbskip_table[mb_index] = 0;
1795 static inline int hpel_motion_lowres(MpegEncContext *s,
1796 uint8_t *dest, uint8_t *src,
1797 int field_based, int field_select,
1798 int src_x, int src_y,
1799 int width, int height, int stride,
1800 int h_edge_pos, int v_edge_pos,
1801 int w, int h, h264_chroma_mc_func *pix_op,
1802 int motion_x, int motion_y)
1804 const int lowres = s->avctx->lowres;
1805 const int op_index = FFMIN(lowres, 2);
1806 const int s_mask = (2 << lowres) - 1;
1810 if (s->quarter_sample) {
1815 sx = motion_x & s_mask;
1816 sy = motion_y & s_mask;
1817 src_x += motion_x >> lowres + 1;
1818 src_y += motion_y >> lowres + 1;
1820 src += src_y * stride + src_x;
1822 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1823 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1824 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1825 (h + 1) << field_based, src_x,
1826 src_y << field_based,
1829 src = s->edge_emu_buffer;
1833 sx = (sx << 2) >> lowres;
1834 sy = (sy << 2) >> lowres;
1837 pix_op[op_index](dest, src, stride, h, sx, sy);
1841 /* apply one mpeg motion vector to the three components */
1842 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1849 uint8_t **ref_picture,
1850 h264_chroma_mc_func *pix_op,
1851 int motion_x, int motion_y,
1854 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1855 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1857 const int lowres = s->avctx->lowres;
1858 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
1859 const int block_s = 8>>lowres;
1860 const int s_mask = (2 << lowres) - 1;
1861 const int h_edge_pos = s->h_edge_pos >> lowres;
1862 const int v_edge_pos = s->v_edge_pos >> lowres;
1863 linesize = s->current_picture.f.linesize[0] << field_based;
1864 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1866 // FIXME obviously not perfect but qpel will not work in lowres anyway
1867 if (s->quarter_sample) {
1873 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1876 sx = motion_x & s_mask;
1877 sy = motion_y & s_mask;
1878 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1879 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1881 if (s->out_format == FMT_H263) {
1882 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1883 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1884 uvsrc_x = src_x >> 1;
1885 uvsrc_y = src_y >> 1;
1886 } else if (s->out_format == FMT_H261) {
1887 // even chroma mv's are full pel in H261
1890 uvsx = (2 * mx) & s_mask;
1891 uvsy = (2 * my) & s_mask;
1892 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1893 uvsrc_y = mb_y * block_s + (my >> lowres);
1895 if(s->chroma_y_shift){
1900 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1901 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1903 if(s->chroma_x_shift){
1907 uvsy = motion_y & s_mask;
1909 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1912 uvsx = motion_x & s_mask;
1913 uvsy = motion_y & s_mask;
1920 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1921 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1922 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1924 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
1925 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1926 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
1927 s->linesize, 17, 17 + field_based,
1928 src_x, src_y << field_based, h_edge_pos,
1930 ptr_y = s->edge_emu_buffer;
1931 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1932 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
1933 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
1935 uvsrc_x, uvsrc_y << field_based,
1936 h_edge_pos >> 1, v_edge_pos >> 1);
1937 s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
1939 uvsrc_x, uvsrc_y << field_based,
1940 h_edge_pos >> 1, v_edge_pos >> 1);
1942 ptr_cr = uvbuf + 16;
1946 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1948 dest_y += s->linesize;
1949 dest_cb += s->uvlinesize;
1950 dest_cr += s->uvlinesize;
1954 ptr_y += s->linesize;
1955 ptr_cb += s->uvlinesize;
1956 ptr_cr += s->uvlinesize;
1959 sx = (sx << 2) >> lowres;
1960 sy = (sy << 2) >> lowres;
1961 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1963 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1964 uvsx = (uvsx << 2) >> lowres;
1965 uvsy = (uvsy << 2) >> lowres;
1966 if (h >> s->chroma_y_shift) {
1967 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1968 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1971 // FIXME h261 lowres loop filter
1974 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1975 uint8_t *dest_cb, uint8_t *dest_cr,
1976 uint8_t **ref_picture,
1977 h264_chroma_mc_func * pix_op,
1980 const int lowres = s->avctx->lowres;
1981 const int op_index = FFMIN(lowres, 2);
1982 const int block_s = 8 >> lowres;
1983 const int s_mask = (2 << lowres) - 1;
1984 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1985 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1986 int emu = 0, src_x, src_y, offset, sx, sy;
1989 if (s->quarter_sample) {
1994 /* In case of 8X8, we construct a single chroma motion vector
1995 with a special rounding */
1996 mx = ff_h263_round_chroma(mx);
1997 my = ff_h263_round_chroma(my);
2001 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2002 src_y = s->mb_y * block_s + (my >> lowres + 1);
2004 offset = src_y * s->uvlinesize + src_x;
2005 ptr = ref_picture[1] + offset;
2006 if (s->flags & CODEC_FLAG_EMU_EDGE) {
2007 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2008 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2009 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2010 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2011 ptr = s->edge_emu_buffer;
2015 sx = (sx << 2) >> lowres;
2016 sy = (sy << 2) >> lowres;
2017 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2019 ptr = ref_picture[2] + offset;
2021 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2022 src_x, src_y, h_edge_pos, v_edge_pos);
2023 ptr = s->edge_emu_buffer;
2025 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2029 * motion compensation of a single macroblock
2031 * @param dest_y luma destination pointer
2032 * @param dest_cb chroma cb/u destination pointer
2033 * @param dest_cr chroma cr/v destination pointer
2034 * @param dir direction (0->forward, 1->backward)
2035 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2036 * @param pix_op halfpel motion compensation function (average or put normally)
2037 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2039 static inline void MPV_motion_lowres(MpegEncContext *s,
2040 uint8_t *dest_y, uint8_t *dest_cb,
2042 int dir, uint8_t **ref_picture,
2043 h264_chroma_mc_func *pix_op)
2047 const int lowres = s->avctx->lowres;
2048 const int block_s = 8 >>lowres;
2053 switch (s->mv_type) {
2055 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2057 ref_picture, pix_op,
2058 s->mv[dir][0][0], s->mv[dir][0][1],
2064 for (i = 0; i < 4; i++) {
2065 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2066 s->linesize) * block_s,
2067 ref_picture[0], 0, 0,
2068 (2 * mb_x + (i & 1)) * block_s,
2069 (2 * mb_y + (i >> 1)) * block_s,
2070 s->width, s->height, s->linesize,
2071 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2072 block_s, block_s, pix_op,
2073 s->mv[dir][i][0], s->mv[dir][i][1]);
2075 mx += s->mv[dir][i][0];
2076 my += s->mv[dir][i][1];
2079 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2080 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2084 if (s->picture_structure == PICT_FRAME) {
2086 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2087 1, 0, s->field_select[dir][0],
2088 ref_picture, pix_op,
2089 s->mv[dir][0][0], s->mv[dir][0][1],
2092 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2093 1, 1, s->field_select[dir][1],
2094 ref_picture, pix_op,
2095 s->mv[dir][1][0], s->mv[dir][1][1],
2098 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2099 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2100 ref_picture = s->current_picture_ptr->f.data;
2103 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2104 0, 0, s->field_select[dir][0],
2105 ref_picture, pix_op,
2107 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2111 for (i = 0; i < 2; i++) {
2112 uint8_t **ref2picture;
2114 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2115 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2116 ref2picture = ref_picture;
2118 ref2picture = s->current_picture_ptr->f.data;
2121 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2122 0, 0, s->field_select[dir][i],
2123 ref2picture, pix_op,
2124 s->mv[dir][i][0], s->mv[dir][i][1] +
2125 2 * block_s * i, block_s, mb_y >> 1);
2127 dest_y += 2 * block_s * s->linesize;
2128 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2129 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2133 if (s->picture_structure == PICT_FRAME) {
2134 for (i = 0; i < 2; i++) {
2136 for (j = 0; j < 2; j++) {
2137 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2139 ref_picture, pix_op,
2140 s->mv[dir][2 * i + j][0],
2141 s->mv[dir][2 * i + j][1],
2144 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2147 for (i = 0; i < 2; i++) {
2148 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2149 0, 0, s->picture_structure != i + 1,
2150 ref_picture, pix_op,
2151 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2152 2 * block_s, mb_y >> 1);
2154 // after put we make avg of the same block
2155 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2157 // opposite parity is always in the same
2158 // frame if this is second field
2159 if (!s->first_field) {
2160 ref_picture = s->current_picture_ptr->f.data;
2171 * find the lowest MB row referenced in the MVs
2173 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2175 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2176 int my, off, i, mvs;
2178 if (s->picture_structure != PICT_FRAME) goto unhandled;
2180 switch (s->mv_type) {
2194 for (i = 0; i < mvs; i++) {
2195 my = s->mv[dir][i][1]<<qpel_shift;
2196 my_max = FFMAX(my_max, my);
2197 my_min = FFMIN(my_min, my);
2200 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2202 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2204 return s->mb_height-1;
2207 /* put block[] to dest[] */
2208 static inline void put_dct(MpegEncContext *s,
2209 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2211 s->dct_unquantize_intra(s, block, i, qscale);
2212 s->dsp.idct_put (dest, line_size, block);
2215 /* add block[] to dest[] */
2216 static inline void add_dct(MpegEncContext *s,
2217 DCTELEM *block, int i, uint8_t *dest, int line_size)
2219 if (s->block_last_index[i] >= 0) {
2220 s->dsp.idct_add (dest, line_size, block);
2224 static inline void add_dequant_dct(MpegEncContext *s,
2225 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2227 if (s->block_last_index[i] >= 0) {
2228 s->dct_unquantize_inter(s, block, i, qscale);
2230 s->dsp.idct_add (dest, line_size, block);
2235 * Clean dc, ac, coded_block for the current non-intra MB.
2237 void ff_clean_intra_table_entries(MpegEncContext *s)
2239 int wrap = s->b8_stride;
2240 int xy = s->block_index[0];
2243 s->dc_val[0][xy + 1 ] =
2244 s->dc_val[0][xy + wrap] =
2245 s->dc_val[0][xy + 1 + wrap] = 1024;
2247 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2248 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2249 if (s->msmpeg4_version>=3) {
2250 s->coded_block[xy ] =
2251 s->coded_block[xy + 1 ] =
2252 s->coded_block[xy + wrap] =
2253 s->coded_block[xy + 1 + wrap] = 0;
2256 wrap = s->mb_stride;
2257 xy = s->mb_x + s->mb_y * wrap;
2259 s->dc_val[2][xy] = 1024;
2261 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2262 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2264 s->mbintra_table[xy]= 0;
2267 /* generic function called after a macroblock has been parsed by the
2268 decoder or after it has been encoded by the encoder.
2270 Important variables used:
2271 s->mb_intra : true if intra macroblock
2272 s->mv_dir : motion vector direction
2273 s->mv_type : motion vector type
2274 s->mv : motion vector
2275 s->interlaced_dct : true if interlaced dct used (mpeg2)
2277 static av_always_inline
2278 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2279 int lowres_flag, int is_mpeg12)
2281 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2282 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2283 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2287 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2288 /* save DCT coefficients */
2290 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2291 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2293 for(j=0; j<64; j++){
2294 *dct++ = block[i][s->dsp.idct_permutation[j]];
2295 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2297 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2301 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2303 /* update DC predictors for P macroblocks */
2305 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2306 if(s->mbintra_table[mb_xy])
2307 ff_clean_intra_table_entries(s);
2311 s->last_dc[2] = 128 << s->intra_dc_precision;
2314 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2315 s->mbintra_table[mb_xy]=1;
2317 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
2318 uint8_t *dest_y, *dest_cb, *dest_cr;
2319 int dct_linesize, dct_offset;
2320 op_pixels_func (*op_pix)[4];
2321 qpel_mc_func (*op_qpix)[16];
2322 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2323 const int uvlinesize = s->current_picture.f.linesize[1];
2324 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2325 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2327 /* avoid copy if macroblock skipped in last frame too */
2328 /* skip only during decoding as we might trash the buffers during encoding a bit */
2330 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2332 if (s->mb_skipped) {
2334 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2336 } else if(!s->current_picture.f.reference) {
2339 *mbskip_ptr = 0; /* not skipped */
2343 dct_linesize = linesize << s->interlaced_dct;
2344 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2348 dest_cb= s->dest[1];
2349 dest_cr= s->dest[2];
2351 dest_y = s->b_scratchpad;
2352 dest_cb= s->b_scratchpad+16*linesize;
2353 dest_cr= s->b_scratchpad+32*linesize;
2357 /* motion handling */
2358 /* decoding or more than one mb_type (MC was already done otherwise) */
2361 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2362 if (s->mv_dir & MV_DIR_FORWARD) {
2363 ff_thread_await_progress(&s->last_picture_ptr->f,
2364 ff_MPV_lowest_referenced_row(s, 0),
2367 if (s->mv_dir & MV_DIR_BACKWARD) {
2368 ff_thread_await_progress(&s->next_picture_ptr->f,
2369 ff_MPV_lowest_referenced_row(s, 1),
2375 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2377 if (s->mv_dir & MV_DIR_FORWARD) {
2378 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2379 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2381 if (s->mv_dir & MV_DIR_BACKWARD) {
2382 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2385 op_qpix= s->me.qpel_put;
2386 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2387 op_pix = s->dsp.put_pixels_tab;
2389 op_pix = s->dsp.put_no_rnd_pixels_tab;
2391 if (s->mv_dir & MV_DIR_FORWARD) {
2392 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2393 op_pix = s->dsp.avg_pixels_tab;
2394 op_qpix= s->me.qpel_avg;
2396 if (s->mv_dir & MV_DIR_BACKWARD) {
2397 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2402 /* skip dequant / idct if we are really late ;) */
2403 if(s->avctx->skip_idct){
2404 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2405 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2406 || s->avctx->skip_idct >= AVDISCARD_ALL)
2410 /* add dct residue */
2411 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2412 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2413 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2414 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2415 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2416 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2418 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2419 if (s->chroma_y_shift){
2420 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2421 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2425 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2426 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2427 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2428 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2431 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2432 add_dct(s, block[0], 0, dest_y , dct_linesize);
2433 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2434 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2435 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2437 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2438 if(s->chroma_y_shift){//Chroma420
2439 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2440 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2443 dct_linesize = uvlinesize << s->interlaced_dct;
2444 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2446 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2447 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2448 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2449 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2450 if(!s->chroma_x_shift){//Chroma444
2451 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2452 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2453 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2454 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2459 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2460 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2463 /* dct only in intra block */
2464 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2465 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2466 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2467 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2468 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2470 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2471 if(s->chroma_y_shift){
2472 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2473 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2477 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2478 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2479 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2480 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2484 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2485 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2486 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2487 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2489 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2490 if(s->chroma_y_shift){
2491 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2492 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2495 dct_linesize = uvlinesize << s->interlaced_dct;
2496 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2498 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2499 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2500 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2501 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2502 if(!s->chroma_x_shift){//Chroma444
2503 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2504 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2505 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2506 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2514 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2515 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2516 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2521 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2523 if(s->out_format == FMT_MPEG1) {
2524 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2525 else MPV_decode_mb_internal(s, block, 0, 1);
2528 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2529 else MPV_decode_mb_internal(s, block, 0, 0);
2533 * @param h is the normal height, this will be reduced automatically if needed for the last row
2535 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2536 const int field_pic= s->picture_structure != PICT_FRAME;
2542 if (!s->avctx->hwaccel
2543 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2544 && s->unrestricted_mv
2545 && s->current_picture.f.reference
2547 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2548 int sides = 0, edge_h;
2549 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2550 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2551 if (y==0) sides |= EDGE_TOP;
2552 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2554 edge_h= FFMIN(h, s->v_edge_pos - y);
2556 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2557 s->linesize, s->h_edge_pos, edge_h,
2558 EDGE_WIDTH, EDGE_WIDTH, sides);
2559 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2560 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2561 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2562 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2563 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2564 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2567 h= FFMIN(h, s->avctx->height - y);
2569 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2571 if (s->avctx->draw_horiz_band) {
2573 int offset[AV_NUM_DATA_POINTERS];
2576 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2577 src = &s->current_picture_ptr->f;
2578 else if(s->last_picture_ptr)
2579 src = &s->last_picture_ptr->f;
2583 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2584 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2587 offset[0]= y * s->linesize;
2589 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2590 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2596 s->avctx->draw_horiz_band(s->avctx, src, offset,
2597 y, s->picture_structure, h);
2601 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2602 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2603 const int uvlinesize = s->current_picture.f.linesize[1];
2604 const int mb_size= 4 - s->avctx->lowres;
2606 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2607 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2608 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2609 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2610 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2611 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;
2612 //block_index is not used by mpeg2, so it is not affected by chroma_format
2614 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2615 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2616 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2618 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2620 if(s->picture_structure==PICT_FRAME){
2621 s->dest[0] += s->mb_y * linesize << mb_size;
2622 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2623 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2625 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2626 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2627 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2628 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2633 void ff_mpeg_flush(AVCodecContext *avctx){
2635 MpegEncContext *s = avctx->priv_data;
2637 if(s==NULL || s->picture==NULL)
2640 for(i=0; i<s->picture_count; i++){
2641 if (s->picture[i].f.data[0] &&
2642 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2643 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2644 free_frame_buffer(s, &s->picture[i]);
2646 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2648 s->mb_x= s->mb_y= 0;
2651 s->parse_context.state= -1;
2652 s->parse_context.frame_start_found= 0;
2653 s->parse_context.overread= 0;
2654 s->parse_context.overread_index= 0;
2655 s->parse_context.index= 0;
2656 s->parse_context.last_index= 0;
2657 s->bitstream_buffer_size=0;
2661 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2662 DCTELEM *block, int n, int qscale)
2664 int i, level, nCoeffs;
2665 const uint16_t *quant_matrix;
2667 nCoeffs= s->block_last_index[n];
2669 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2670 /* XXX: only mpeg1 */
2671 quant_matrix = s->intra_matrix;
2672 for(i=1;i<=nCoeffs;i++) {
2673 int j= s->intra_scantable.permutated[i];
2678 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2679 level = (level - 1) | 1;
2682 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2683 level = (level - 1) | 1;
2690 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2691 DCTELEM *block, int n, int qscale)
2693 int i, level, nCoeffs;
2694 const uint16_t *quant_matrix;
2696 nCoeffs= s->block_last_index[n];
2698 quant_matrix = s->inter_matrix;
2699 for(i=0; i<=nCoeffs; i++) {
2700 int j= s->intra_scantable.permutated[i];
2705 level = (((level << 1) + 1) * qscale *
2706 ((int) (quant_matrix[j]))) >> 4;
2707 level = (level - 1) | 1;
2710 level = (((level << 1) + 1) * qscale *
2711 ((int) (quant_matrix[j]))) >> 4;
2712 level = (level - 1) | 1;
2719 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2720 DCTELEM *block, int n, int qscale)
2722 int i, level, nCoeffs;
2723 const uint16_t *quant_matrix;
2725 if(s->alternate_scan) nCoeffs= 63;
2726 else nCoeffs= s->block_last_index[n];
2728 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2729 quant_matrix = s->intra_matrix;
2730 for(i=1;i<=nCoeffs;i++) {
2731 int j= s->intra_scantable.permutated[i];
2736 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2739 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2746 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2747 DCTELEM *block, int n, int qscale)
2749 int i, level, nCoeffs;
2750 const uint16_t *quant_matrix;
2753 if(s->alternate_scan) nCoeffs= 63;
2754 else nCoeffs= s->block_last_index[n];
2756 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2758 quant_matrix = s->intra_matrix;
2759 for(i=1;i<=nCoeffs;i++) {
2760 int j= s->intra_scantable.permutated[i];
2765 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2768 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2777 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2778 DCTELEM *block, int n, int qscale)
2780 int i, level, nCoeffs;
2781 const uint16_t *quant_matrix;
2784 if(s->alternate_scan) nCoeffs= 63;
2785 else nCoeffs= s->block_last_index[n];
2787 quant_matrix = s->inter_matrix;
2788 for(i=0; i<=nCoeffs; i++) {
2789 int j= s->intra_scantable.permutated[i];
2794 level = (((level << 1) + 1) * qscale *
2795 ((int) (quant_matrix[j]))) >> 4;
2798 level = (((level << 1) + 1) * qscale *
2799 ((int) (quant_matrix[j]))) >> 4;
2808 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2809 DCTELEM *block, int n, int qscale)
2811 int i, level, qmul, qadd;
2814 assert(s->block_last_index[n]>=0);
2819 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2820 qadd = (qscale - 1) | 1;
2827 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2829 for(i=1; i<=nCoeffs; i++) {
2833 level = level * qmul - qadd;
2835 level = level * qmul + qadd;
2842 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2843 DCTELEM *block, int n, int qscale)
2845 int i, level, qmul, qadd;
2848 assert(s->block_last_index[n]>=0);
2850 qadd = (qscale - 1) | 1;
2853 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2855 for(i=0; i<=nCoeffs; i++) {
2859 level = level * qmul - qadd;
2861 level = level * qmul + qadd;
2869 * set qscale and update qscale dependent variables.
2871 void ff_set_qscale(MpegEncContext * s, int qscale)
2875 else if (qscale > 31)
2879 s->chroma_qscale= s->chroma_qscale_table[qscale];
2881 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2882 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2885 void ff_MPV_report_decode_progress(MpegEncContext *s)
2887 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2888 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);