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"
36 #include "mpegvideo_common.h"
40 #include "xvmc_internal.h"
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58 DCTELEM *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60 DCTELEM *block, int n, int qscale);
63 /* enable all paranoid tests for rounding, overflows, etc... */
69 static const uint8_t ff_default_chroma_qscale_table[32] = {
70 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
71 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
72 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
75 const uint8_t ff_mpeg1_dc_scale_table[128] = {
76 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
83 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
84 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
87 static const uint8_t mpeg2_dc_scale_table1[128] = {
88 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
95 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
96 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
99 static const uint8_t mpeg2_dc_scale_table2[128] = {
100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
111 static const uint8_t mpeg2_dc_scale_table3[128] = {
112 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
119 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
120 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
123 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
124 ff_mpeg1_dc_scale_table,
125 mpeg2_dc_scale_table1,
126 mpeg2_dc_scale_table2,
127 mpeg2_dc_scale_table3,
130 const enum PixelFormat ff_pixfmt_list_420[] = {
135 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
143 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *restrict p,
145 uint32_t * restrict state)
153 for (i = 0; i < 3; i++) {
154 uint32_t tmp = *state << 8;
155 *state = tmp + *(p++);
156 if (tmp == 0x100 || p == end)
161 if (p[-1] > 1 ) p += 3;
162 else if (p[-2] ) p += 2;
163 else if (p[-3]|(p[-1]-1)) p++;
170 p = FFMIN(p, end) - 4;
176 /* init common dct for both encoder and decoder */
177 av_cold int ff_dct_common_init(MpegEncContext *s)
179 ff_dsputil_init(&s->dsp, s->avctx);
181 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
182 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
183 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
184 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
185 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
186 if (s->flags & CODEC_FLAG_BITEXACT)
187 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
188 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
191 ff_MPV_common_init_mmx(s);
193 ff_MPV_common_init_axp(s);
195 ff_MPV_common_init_mmi(s);
197 ff_MPV_common_init_arm(s);
199 ff_MPV_common_init_altivec(s);
201 ff_MPV_common_init_bfin(s);
204 /* load & permutate scantables
205 * note: only wmv uses different ones
207 if (s->alternate_scan) {
208 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
209 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
211 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
212 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
214 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
215 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
220 void ff_copy_picture(Picture *dst, Picture *src)
223 dst->f.type = FF_BUFFER_TYPE_COPY;
227 * Release a frame buffer
229 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
231 /* Windows Media Image codecs allocate internal buffers with different
232 * dimensions; ignore user defined callbacks for these
234 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
235 ff_thread_release_buffer(s->avctx, &pic->f);
237 avcodec_default_release_buffer(s->avctx, &pic->f);
238 av_freep(&pic->f.hwaccel_picture_private);
242 * Allocate a frame buffer
244 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
248 if (s->avctx->hwaccel) {
249 assert(!pic->f.hwaccel_picture_private);
250 if (s->avctx->hwaccel->priv_data_size) {
251 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
252 if (!pic->f.hwaccel_picture_private) {
253 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
259 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
260 r = ff_thread_get_buffer(s->avctx, &pic->f);
262 r = avcodec_default_get_buffer(s->avctx, &pic->f);
264 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
265 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
266 r, pic->f.type, pic->f.data[0]);
267 av_freep(&pic->f.hwaccel_picture_private);
271 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
272 s->uvlinesize != pic->f.linesize[1])) {
273 av_log(s->avctx, AV_LOG_ERROR,
274 "get_buffer() failed (stride changed)\n");
275 free_frame_buffer(s, pic);
279 if (pic->f.linesize[1] != pic->f.linesize[2]) {
280 av_log(s->avctx, AV_LOG_ERROR,
281 "get_buffer() failed (uv stride mismatch)\n");
282 free_frame_buffer(s, pic);
290 * Allocate a Picture.
291 * The pixels are allocated/set by calling get_buffer() if shared = 0
293 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
295 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
297 // the + 1 is needed so memset(,,stride*height) does not sig11
299 const int mb_array_size = s->mb_stride * s->mb_height;
300 const int b8_array_size = s->b8_stride * s->mb_height * 2;
301 const int b4_array_size = s->b4_stride * s->mb_height * 4;
306 assert(pic->f.data[0]);
307 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
308 pic->f.type = FF_BUFFER_TYPE_SHARED;
310 assert(!pic->f.data[0]);
312 if (alloc_frame_buffer(s, pic) < 0)
315 s->linesize = pic->f.linesize[0];
316 s->uvlinesize = pic->f.linesize[1];
319 if (pic->f.qscale_table == NULL) {
321 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
322 mb_array_size * sizeof(int16_t), fail)
323 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
324 mb_array_size * sizeof(int16_t), fail)
325 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
326 mb_array_size * sizeof(int8_t ), fail)
329 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
330 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
331 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
332 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
334 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
335 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
337 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
338 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
339 if (s->out_format == FMT_H264) {
340 for (i = 0; i < 2; i++) {
341 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
342 2 * (b4_array_size + 4) * sizeof(int16_t),
344 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
345 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
346 4 * mb_array_size * sizeof(uint8_t), fail)
348 pic->f.motion_subsample_log2 = 2;
349 } else if (s->out_format == FMT_H263 || s->encoding ||
350 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
351 for (i = 0; i < 2; i++) {
352 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
353 2 * (b8_array_size + 4) * sizeof(int16_t),
355 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
356 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
357 4 * mb_array_size * sizeof(uint8_t), fail)
359 pic->f.motion_subsample_log2 = 3;
361 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
362 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
363 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
365 pic->f.qstride = s->mb_stride;
366 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
367 1 * sizeof(AVPanScan), fail)
373 fail: // for the FF_ALLOCZ_OR_GOTO macro
375 free_frame_buffer(s, pic);
380 * Deallocate a picture.
382 static void free_picture(MpegEncContext *s, Picture *pic)
386 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
387 free_frame_buffer(s, pic);
390 av_freep(&pic->mb_var);
391 av_freep(&pic->mc_mb_var);
392 av_freep(&pic->mb_mean);
393 av_freep(&pic->f.mbskip_table);
394 av_freep(&pic->qscale_table_base);
395 av_freep(&pic->mb_type_base);
396 av_freep(&pic->f.dct_coeff);
397 av_freep(&pic->f.pan_scan);
398 pic->f.mb_type = NULL;
399 for (i = 0; i < 2; i++) {
400 av_freep(&pic->motion_val_base[i]);
401 av_freep(&pic->f.ref_index[i]);
404 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
405 for (i = 0; i < 4; i++) {
407 pic->f.data[i] = NULL;
413 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
415 int y_size = s->b8_stride * (2 * s->mb_height + 1);
416 int c_size = s->mb_stride * (s->mb_height + 1);
417 int yc_size = y_size + 2 * c_size;
420 // edge emu needs blocksize + filter length - 1
421 // (= 17x17 for halfpel / 21x21 for h264)
422 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
423 (s->width + 95) * 2 * 21 * 4, fail); // (width + edge + align)*interlaced*MBsize*tolerance
425 // FIXME should be linesize instead of s->width * 2
426 // but that is not known before get_buffer()
427 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
428 (s->width + 95) * 4 * 16 * 2 * sizeof(uint8_t), fail)
429 s->me.temp = s->me.scratchpad;
430 s->rd_scratchpad = s->me.scratchpad;
431 s->b_scratchpad = s->me.scratchpad;
432 s->obmc_scratchpad = s->me.scratchpad + 16;
434 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
435 ME_MAP_SIZE * sizeof(uint32_t), fail)
436 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
437 ME_MAP_SIZE * sizeof(uint32_t), fail)
438 if (s->avctx->noise_reduction) {
439 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
440 2 * 64 * sizeof(int), fail)
443 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
444 s->block = s->blocks[0];
446 for (i = 0; i < 12; i++) {
447 s->pblocks[i] = &s->block[i];
450 if (s->out_format == FMT_H263) {
452 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
453 yc_size * sizeof(int16_t) * 16, fail);
454 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
455 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
456 s->ac_val[2] = s->ac_val[1] + c_size;
461 return -1; // free() through ff_MPV_common_end()
464 static void free_duplicate_context(MpegEncContext *s)
469 av_freep(&s->edge_emu_buffer);
470 av_freep(&s->me.scratchpad);
474 s->obmc_scratchpad = NULL;
476 av_freep(&s->dct_error_sum);
477 av_freep(&s->me.map);
478 av_freep(&s->me.score_map);
479 av_freep(&s->blocks);
480 av_freep(&s->ac_val_base);
484 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
486 #define COPY(a) bak->a = src->a
487 COPY(edge_emu_buffer);
492 COPY(obmc_scratchpad);
499 COPY(me.map_generation);
511 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
515 // FIXME copy only needed parts
517 backup_duplicate_context(&bak, dst);
518 memcpy(dst, src, sizeof(MpegEncContext));
519 backup_duplicate_context(dst, &bak);
520 for (i = 0; i < 12; i++) {
521 dst->pblocks[i] = &dst->block[i];
523 // STOP_TIMER("update_duplicate_context")
524 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
527 int ff_mpeg_update_thread_context(AVCodecContext *dst,
528 const AVCodecContext *src)
530 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
535 // FIXME can parameters change on I-frames?
536 // in that case dst may need a reinit
537 if (!s->context_initialized) {
538 memcpy(s, s1, sizeof(MpegEncContext));
541 s->bitstream_buffer = NULL;
542 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
544 if (s1->context_initialized){
545 s->picture_range_start += MAX_PICTURE_COUNT;
546 s->picture_range_end += MAX_PICTURE_COUNT;
547 ff_MPV_common_init(s);
551 s->avctx->coded_height = s1->avctx->coded_height;
552 s->avctx->coded_width = s1->avctx->coded_width;
553 s->avctx->width = s1->avctx->width;
554 s->avctx->height = s1->avctx->height;
556 s->coded_picture_number = s1->coded_picture_number;
557 s->picture_number = s1->picture_number;
558 s->input_picture_number = s1->input_picture_number;
560 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
561 memcpy(&s->last_picture, &s1->last_picture,
562 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
564 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
565 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
566 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
568 // Error/bug resilience
569 s->next_p_frame_damaged = s1->next_p_frame_damaged;
570 s->workaround_bugs = s1->workaround_bugs;
571 s->padding_bug_score = s1->padding_bug_score;
574 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
575 (char *) &s1->shape - (char *) &s1->time_increment_bits);
578 s->max_b_frames = s1->max_b_frames;
579 s->low_delay = s1->low_delay;
580 s->dropable = s1->dropable;
582 // DivX handling (doesn't work)
583 s->divx_packed = s1->divx_packed;
585 if (s1->bitstream_buffer) {
586 if (s1->bitstream_buffer_size +
587 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
588 av_fast_malloc(&s->bitstream_buffer,
589 &s->allocated_bitstream_buffer_size,
590 s1->allocated_bitstream_buffer_size);
591 s->bitstream_buffer_size = s1->bitstream_buffer_size;
592 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
593 s1->bitstream_buffer_size);
594 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
595 FF_INPUT_BUFFER_PADDING_SIZE);
598 // MPEG2/interlacing info
599 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
600 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
602 if (!s1->first_field) {
603 s->last_pict_type = s1->pict_type;
604 if (s1->current_picture_ptr)
605 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
607 if (s1->pict_type != AV_PICTURE_TYPE_B) {
608 s->last_non_b_pict_type = s1->pict_type;
616 * Set the given MpegEncContext to common defaults
617 * (same for encoding and decoding).
618 * The changed fields will not depend upon the
619 * prior state of the MpegEncContext.
621 void ff_MPV_common_defaults(MpegEncContext *s)
623 s->y_dc_scale_table =
624 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
625 s->chroma_qscale_table = ff_default_chroma_qscale_table;
626 s->progressive_frame = 1;
627 s->progressive_sequence = 1;
628 s->picture_structure = PICT_FRAME;
630 s->coded_picture_number = 0;
631 s->picture_number = 0;
632 s->input_picture_number = 0;
634 s->picture_in_gop_number = 0;
639 s->picture_range_start = 0;
640 s->picture_range_end = MAX_PICTURE_COUNT;
642 s->slice_context_count = 1;
646 * Set the given MpegEncContext to defaults for decoding.
647 * the changed fields will not depend upon
648 * the prior state of the MpegEncContext.
650 void ff_MPV_decode_defaults(MpegEncContext *s)
652 ff_MPV_common_defaults(s);
656 * init common structure for both encoder and decoder.
657 * this assumes that some variables like width/height are already set
659 av_cold int ff_MPV_common_init(MpegEncContext *s)
661 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
662 int nb_slices = (HAVE_THREADS &&
663 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
664 s->avctx->thread_count : 1;
666 if (s->encoding && s->avctx->slices)
667 nb_slices = s->avctx->slices;
669 if (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
670 s->mb_height = (s->height + 31) / 32 * 2;
671 else if (s->codec_id != CODEC_ID_H264)
672 s->mb_height = (s->height + 15) / 16;
674 if (s->avctx->pix_fmt == PIX_FMT_NONE) {
675 av_log(s->avctx, AV_LOG_ERROR,
676 "decoding to PIX_FMT_NONE is not supported.\n");
680 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
683 max_slices = FFMIN(MAX_THREADS, s->mb_height);
685 max_slices = MAX_THREADS;
686 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
687 " reducing to %d\n", nb_slices, max_slices);
688 nb_slices = max_slices;
691 if ((s->width || s->height) &&
692 av_image_check_size(s->width, s->height, 0, s->avctx))
695 ff_dct_common_init(s);
697 s->flags = s->avctx->flags;
698 s->flags2 = s->avctx->flags2;
700 s->mb_width = (s->width + 15) / 16;
701 s->mb_stride = s->mb_width + 1;
702 s->b8_stride = s->mb_width * 2 + 1;
703 s->b4_stride = s->mb_width * 4 + 1;
704 mb_array_size = s->mb_height * s->mb_stride;
705 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
707 /* set chroma shifts */
708 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
711 /* set default edge pos, will be overriden in decode_header if needed */
712 s->h_edge_pos = s->mb_width * 16;
713 s->v_edge_pos = s->mb_height * 16;
715 s->mb_num = s->mb_width * s->mb_height;
720 s->block_wrap[3] = s->b8_stride;
722 s->block_wrap[5] = s->mb_stride;
724 y_size = s->b8_stride * (2 * s->mb_height + 1);
725 c_size = s->mb_stride * (s->mb_height + 1);
726 yc_size = y_size + 2 * c_size;
728 /* convert fourcc to upper case */
729 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
730 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
732 s->avctx->coded_frame = &s->current_picture.f;
734 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
735 for (y = 0; y < s->mb_height; y++)
736 for (x = 0; x < s->mb_width; x++)
737 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
739 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
742 /* Allocate MV tables */
743 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
744 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
745 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
746 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
747 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
748 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
749 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
750 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
751 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
752 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
753 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
754 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
756 if(s->msmpeg4_version){
757 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
759 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
761 /* Allocate MB type table */
762 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
764 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
766 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
767 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix , 64*32 * sizeof(int), fail)
768 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
769 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
770 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
771 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
772 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
773 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
775 if(s->avctx->noise_reduction){
776 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
780 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
781 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
782 s->picture_count * sizeof(Picture), fail);
783 for (i = 0; i < s->picture_count; i++) {
784 avcodec_get_frame_defaults(&s->picture[i].f);
787 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
789 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
790 /* interlaced direct mode decoding tables */
791 for (i = 0; i < 2; i++) {
793 for (j = 0; j < 2; j++) {
794 for (k = 0; k < 2; k++) {
795 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
796 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
798 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
799 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
800 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
802 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
805 if (s->out_format == FMT_H263) {
807 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
808 s->coded_block = s->coded_block_base + s->b8_stride + 1;
810 /* cbp, ac_pred, pred_dir */
811 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
812 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
815 if (s->h263_pred || s->h263_plus || !s->encoding) {
817 // MN: we need these for error resilience of intra-frames
818 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
819 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
820 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
821 s->dc_val[2] = s->dc_val[1] + c_size;
822 for (i = 0; i < yc_size; i++)
823 s->dc_val_base[i] = 1024;
826 /* which mb is a intra block */
827 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
828 memset(s->mbintra_table, 1, mb_array_size);
830 /* init macroblock skip table */
831 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
832 // Note the + 1 is for a quicker mpeg4 slice_end detection
834 s->parse_context.state = -1;
836 s->context_initialized = 1;
837 s->thread_context[0] = s;
839 // if (s->width && s->height) {
841 for (i = 1; i < nb_slices; i++) {
842 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
843 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
846 for (i = 0; i < nb_slices; i++) {
847 if (init_duplicate_context(s->thread_context[i], s) < 0)
849 s->thread_context[i]->start_mb_y =
850 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
851 s->thread_context[i]->end_mb_y =
852 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
855 if (init_duplicate_context(s, s) < 0)
858 s->end_mb_y = s->mb_height;
860 s->slice_context_count = nb_slices;
865 ff_MPV_common_end(s);
869 /* init common structure for both encoder and decoder */
870 void ff_MPV_common_end(MpegEncContext *s)
874 if (s->slice_context_count > 1) {
875 for (i = 0; i < s->slice_context_count; i++) {
876 free_duplicate_context(s->thread_context[i]);
878 for (i = 1; i < s->slice_context_count; i++) {
879 av_freep(&s->thread_context[i]);
881 s->slice_context_count = 1;
882 } else free_duplicate_context(s);
884 av_freep(&s->parse_context.buffer);
885 s->parse_context.buffer_size = 0;
887 av_freep(&s->mb_type);
888 av_freep(&s->p_mv_table_base);
889 av_freep(&s->b_forw_mv_table_base);
890 av_freep(&s->b_back_mv_table_base);
891 av_freep(&s->b_bidir_forw_mv_table_base);
892 av_freep(&s->b_bidir_back_mv_table_base);
893 av_freep(&s->b_direct_mv_table_base);
894 s->p_mv_table = NULL;
895 s->b_forw_mv_table = NULL;
896 s->b_back_mv_table = NULL;
897 s->b_bidir_forw_mv_table = NULL;
898 s->b_bidir_back_mv_table = NULL;
899 s->b_direct_mv_table = NULL;
900 for (i = 0; i < 2; i++) {
901 for (j = 0; j < 2; j++) {
902 for (k = 0; k < 2; k++) {
903 av_freep(&s->b_field_mv_table_base[i][j][k]);
904 s->b_field_mv_table[i][j][k] = NULL;
906 av_freep(&s->b_field_select_table[i][j]);
907 av_freep(&s->p_field_mv_table_base[i][j]);
908 s->p_field_mv_table[i][j] = NULL;
910 av_freep(&s->p_field_select_table[i]);
913 av_freep(&s->dc_val_base);
914 av_freep(&s->coded_block_base);
915 av_freep(&s->mbintra_table);
916 av_freep(&s->cbp_table);
917 av_freep(&s->pred_dir_table);
919 av_freep(&s->mbskip_table);
920 av_freep(&s->bitstream_buffer);
921 s->allocated_bitstream_buffer_size = 0;
923 av_freep(&s->avctx->stats_out);
924 av_freep(&s->ac_stats);
925 av_freep(&s->error_status_table);
926 av_freep(&s->mb_index2xy);
927 av_freep(&s->lambda_table);
928 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
929 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
930 s->q_chroma_intra_matrix= NULL;
931 s->q_chroma_intra_matrix16= NULL;
932 av_freep(&s->q_intra_matrix);
933 av_freep(&s->q_inter_matrix);
934 av_freep(&s->q_intra_matrix16);
935 av_freep(&s->q_inter_matrix16);
936 av_freep(&s->input_picture);
937 av_freep(&s->reordered_input_picture);
938 av_freep(&s->dct_offset);
940 if (s->picture && !s->avctx->internal->is_copy) {
941 for (i = 0; i < s->picture_count; i++) {
942 free_picture(s, &s->picture[i]);
945 av_freep(&s->picture);
946 s->context_initialized = 0;
947 s->last_picture_ptr =
948 s->next_picture_ptr =
949 s->current_picture_ptr = NULL;
950 s->linesize = s->uvlinesize = 0;
952 for (i = 0; i < 3; i++)
953 av_freep(&s->visualization_buffer[i]);
955 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
956 avcodec_default_free_buffers(s->avctx);
959 void ff_init_rl(RLTable *rl,
960 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
962 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
963 uint8_t index_run[MAX_RUN + 1];
964 int last, run, level, start, end, i;
966 /* If table is static, we can quit if rl->max_level[0] is not NULL */
967 if (static_store && rl->max_level[0])
970 /* compute max_level[], max_run[] and index_run[] */
971 for (last = 0; last < 2; last++) {
980 memset(max_level, 0, MAX_RUN + 1);
981 memset(max_run, 0, MAX_LEVEL + 1);
982 memset(index_run, rl->n, MAX_RUN + 1);
983 for (i = start; i < end; i++) {
984 run = rl->table_run[i];
985 level = rl->table_level[i];
986 if (index_run[run] == rl->n)
988 if (level > max_level[run])
989 max_level[run] = level;
990 if (run > max_run[level])
991 max_run[level] = run;
994 rl->max_level[last] = static_store[last];
996 rl->max_level[last] = av_malloc(MAX_RUN + 1);
997 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
999 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1001 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1002 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1004 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1006 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1007 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1011 void ff_init_vlc_rl(RLTable *rl)
1015 for (q = 0; q < 32; q++) {
1017 int qadd = (q - 1) | 1;
1023 for (i = 0; i < rl->vlc.table_size; i++) {
1024 int code = rl->vlc.table[i][0];
1025 int len = rl->vlc.table[i][1];
1028 if (len == 0) { // illegal code
1031 } else if (len < 0) { // more bits needed
1035 if (code == rl->n) { // esc
1039 run = rl->table_run[code] + 1;
1040 level = rl->table_level[code] * qmul + qadd;
1041 if (code >= rl->last) run += 192;
1044 rl->rl_vlc[q][i].len = len;
1045 rl->rl_vlc[q][i].level = level;
1046 rl->rl_vlc[q][i].run = run;
1051 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1055 /* release non reference frames */
1056 for (i = 0; i < s->picture_count; i++) {
1057 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1058 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1059 (remove_current || &s->picture[i] != s->current_picture_ptr)
1060 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1061 free_frame_buffer(s, &s->picture[i]);
1066 int ff_find_unused_picture(MpegEncContext *s, int shared)
1071 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1072 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1076 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1077 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
1080 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1081 if (s->picture[i].f.data[0] == NULL)
1086 av_log(s->avctx, AV_LOG_FATAL,
1087 "Internal error, picture buffer overflow\n");
1088 /* We could return -1, but the codec would crash trying to draw into a
1089 * non-existing frame anyway. This is safer than waiting for a random crash.
1090 * Also the return of this is never useful, an encoder must only allocate
1091 * as much as allowed in the specification. This has no relationship to how
1092 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1093 * enough for such valid streams).
1094 * Plus, a decoder has to check stream validity and remove frames if too
1095 * many reference frames are around. Waiting for "OOM" is not correct at
1096 * all. Similarly, missing reference frames have to be replaced by
1097 * interpolated/MC frames, anything else is a bug in the codec ...
1103 static void update_noise_reduction(MpegEncContext *s)
1107 for (intra = 0; intra < 2; intra++) {
1108 if (s->dct_count[intra] > (1 << 16)) {
1109 for (i = 0; i < 64; i++) {
1110 s->dct_error_sum[intra][i] >>= 1;
1112 s->dct_count[intra] >>= 1;
1115 for (i = 0; i < 64; i++) {
1116 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1117 s->dct_count[intra] +
1118 s->dct_error_sum[intra][i] / 2) /
1119 (s->dct_error_sum[intra][i] + 1);
1125 * generic function for encode/decode called after coding/decoding
1126 * the header and before a frame is coded/decoded.
1128 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1134 assert(s->last_picture_ptr == NULL || s->out_format != FMT_H264 ||
1135 s->codec_id == CODEC_ID_SVQ3);
1137 if (!ff_thread_can_start_frame(avctx)) {
1138 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1142 /* mark & release old frames */
1143 if (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3) {
1144 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1145 s->last_picture_ptr != s->next_picture_ptr &&
1146 s->last_picture_ptr->f.data[0]) {
1147 if (s->last_picture_ptr->owner2 == s)
1148 free_frame_buffer(s, s->last_picture_ptr);
1151 /* release forgotten pictures */
1152 /* if (mpeg124/h263) */
1154 for (i = 0; i < s->picture_count; i++) {
1155 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1156 &s->picture[i] != s->last_picture_ptr &&
1157 &s->picture[i] != s->next_picture_ptr &&
1158 s->picture[i].f.reference) {
1159 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1160 av_log(avctx, AV_LOG_ERROR,
1161 "releasing zombie picture\n");
1162 free_frame_buffer(s, &s->picture[i]);
1169 ff_release_unused_pictures(s, 1);
1171 if (s->current_picture_ptr &&
1172 s->current_picture_ptr->f.data[0] == NULL) {
1173 // we already have a unused image
1174 // (maybe it was set before reading the header)
1175 pic = s->current_picture_ptr;
1177 i = ff_find_unused_picture(s, 0);
1180 pic = &s->picture[i];
1183 pic->f.reference = 0;
1185 if (s->codec_id == CODEC_ID_H264)
1186 pic->f.reference = s->picture_structure;
1187 else if (s->pict_type != AV_PICTURE_TYPE_B)
1188 pic->f.reference = 3;
1191 pic->f.coded_picture_number = s->coded_picture_number++;
1193 if (ff_alloc_picture(s, pic, 0) < 0)
1196 s->current_picture_ptr = pic;
1197 // FIXME use only the vars from current_pic
1198 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1199 if (s->codec_id == CODEC_ID_MPEG1VIDEO ||
1200 s->codec_id == CODEC_ID_MPEG2VIDEO) {
1201 if (s->picture_structure != PICT_FRAME)
1202 s->current_picture_ptr->f.top_field_first =
1203 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1205 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1206 !s->progressive_sequence;
1207 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1210 s->current_picture_ptr->f.pict_type = s->pict_type;
1211 // if (s->flags && CODEC_FLAG_QSCALE)
1212 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1213 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1215 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1217 if (s->pict_type != AV_PICTURE_TYPE_B) {
1218 s->last_picture_ptr = s->next_picture_ptr;
1220 s->next_picture_ptr = s->current_picture_ptr;
1222 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1223 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1224 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1225 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1226 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1227 s->pict_type, s->dropable); */
1229 if (s->codec_id != CODEC_ID_H264) {
1230 if ((s->last_picture_ptr == NULL ||
1231 s->last_picture_ptr->f.data[0] == NULL) &&
1232 (s->pict_type != AV_PICTURE_TYPE_I ||
1233 s->picture_structure != PICT_FRAME)) {
1234 if (s->pict_type != AV_PICTURE_TYPE_I)
1235 av_log(avctx, AV_LOG_ERROR,
1236 "warning: first frame is no keyframe\n");
1237 else if (s->picture_structure != PICT_FRAME)
1238 av_log(avctx, AV_LOG_INFO,
1239 "allocate dummy last picture for field based first keyframe\n");
1241 /* Allocate a dummy frame */
1242 i = ff_find_unused_picture(s, 0);
1245 s->last_picture_ptr = &s->picture[i];
1246 s->last_picture_ptr->f.key_frame = 0;
1247 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1248 s->last_picture_ptr = NULL;
1252 if(s->codec_id == CODEC_ID_FLV1 || s->codec_id == CODEC_ID_H263){
1253 for(i=0; i<avctx->height; i++)
1254 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1257 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1258 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1259 s->last_picture_ptr->f.reference = 3;
1261 if ((s->next_picture_ptr == NULL ||
1262 s->next_picture_ptr->f.data[0] == NULL) &&
1263 s->pict_type == AV_PICTURE_TYPE_B) {
1264 /* Allocate a dummy frame */
1265 i = ff_find_unused_picture(s, 0);
1268 s->next_picture_ptr = &s->picture[i];
1269 s->next_picture_ptr->f.key_frame = 0;
1270 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1271 s->next_picture_ptr = NULL;
1274 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1275 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1276 s->next_picture_ptr->f.reference = 3;
1280 if (s->last_picture_ptr)
1281 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1282 if (s->next_picture_ptr)
1283 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1285 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1286 (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3)) {
1287 if (s->next_picture_ptr)
1288 s->next_picture_ptr->owner2 = s;
1289 if (s->last_picture_ptr)
1290 s->last_picture_ptr->owner2 = s;
1293 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1294 s->last_picture_ptr->f.data[0]));
1296 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1298 for (i = 0; i < 4; i++) {
1299 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1300 s->current_picture.f.data[i] +=
1301 s->current_picture.f.linesize[i];
1303 s->current_picture.f.linesize[i] *= 2;
1304 s->last_picture.f.linesize[i] *= 2;
1305 s->next_picture.f.linesize[i] *= 2;
1309 s->err_recognition = avctx->err_recognition;
1311 /* set dequantizer, we can't do it during init as
1312 * it might change for mpeg4 and we can't do it in the header
1313 * decode as init is not called for mpeg4 there yet */
1314 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1315 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1316 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1317 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1318 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1319 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1321 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1322 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1325 if (s->dct_error_sum) {
1326 assert(s->avctx->noise_reduction && s->encoding);
1327 update_noise_reduction(s);
1330 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1331 return ff_xvmc_field_start(s, avctx);
1336 /* generic function for encode/decode called after a
1337 * frame has been coded/decoded. */
1338 void ff_MPV_frame_end(MpegEncContext *s)
1341 /* redraw edges for the frame if decoding didn't complete */
1342 // just to make sure that all data is rendered.
1343 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1344 ff_xvmc_field_end(s);
1345 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1346 !s->avctx->hwaccel &&
1347 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1348 s->unrestricted_mv &&
1349 s->current_picture.f.reference &&
1351 !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1352 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1353 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1354 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1355 s->h_edge_pos, s->v_edge_pos,
1356 EDGE_WIDTH, EDGE_WIDTH,
1357 EDGE_TOP | EDGE_BOTTOM);
1358 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1359 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1360 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1361 EDGE_TOP | EDGE_BOTTOM);
1362 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1363 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1364 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1365 EDGE_TOP | EDGE_BOTTOM);
1370 s->last_pict_type = s->pict_type;
1371 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1372 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1373 s->last_non_b_pict_type = s->pict_type;
1376 /* copy back current_picture variables */
1377 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1378 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1379 s->picture[i] = s->current_picture;
1383 assert(i < MAX_PICTURE_COUNT);
1387 /* release non-reference frames */
1388 for (i = 0; i < s->picture_count; i++) {
1389 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1390 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1391 free_frame_buffer(s, &s->picture[i]);
1395 // clear copies, to avoid confusion
1397 memset(&s->last_picture, 0, sizeof(Picture));
1398 memset(&s->next_picture, 0, sizeof(Picture));
1399 memset(&s->current_picture, 0, sizeof(Picture));
1401 s->avctx->coded_frame = &s->current_picture_ptr->f;
1403 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1404 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1409 * Draw a line from (ex, ey) -> (sx, sy).
1410 * @param w width of the image
1411 * @param h height of the image
1412 * @param stride stride/linesize of the image
1413 * @param color color of the arrow
1415 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1416 int w, int h, int stride, int color)
1420 sx = av_clip(sx, 0, w - 1);
1421 sy = av_clip(sy, 0, h - 1);
1422 ex = av_clip(ex, 0, w - 1);
1423 ey = av_clip(ey, 0, h - 1);
1425 buf[sy * stride + sx] += color;
1427 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1429 FFSWAP(int, sx, ex);
1430 FFSWAP(int, sy, ey);
1432 buf += sx + sy * stride;
1434 f = ((ey - sy) << 16) / ex;
1435 for(x= 0; x <= ex; x++){
1437 fr = (x * f) & 0xFFFF;
1438 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1439 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1443 FFSWAP(int, sx, ex);
1444 FFSWAP(int, sy, ey);
1446 buf += sx + sy * stride;
1449 f = ((ex - sx) << 16) / ey;
1452 for(y= 0; y <= ey; y++){
1454 fr = (y*f) & 0xFFFF;
1455 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1456 buf[y * stride + x + 1] += (color * fr ) >> 16;
1462 * Draw an arrow from (ex, ey) -> (sx, sy).
1463 * @param w width of the image
1464 * @param h height of the image
1465 * @param stride stride/linesize of the image
1466 * @param color color of the arrow
1468 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1469 int ey, int w, int h, int stride, int color)
1473 sx = av_clip(sx, -100, w + 100);
1474 sy = av_clip(sy, -100, h + 100);
1475 ex = av_clip(ex, -100, w + 100);
1476 ey = av_clip(ey, -100, h + 100);
1481 if (dx * dx + dy * dy > 3 * 3) {
1484 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1486 // FIXME subpixel accuracy
1487 rx = ROUNDED_DIV(rx * 3 << 4, length);
1488 ry = ROUNDED_DIV(ry * 3 << 4, length);
1490 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1491 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1493 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1497 * Print debugging info for the given picture.
1499 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1501 if (s->avctx->hwaccel || !pict || !pict->mb_type)
1504 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1507 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1508 av_get_picture_type_char(pict->pict_type));
1509 for (y = 0; y < s->mb_height; y++) {
1510 for (x = 0; x < s->mb_width; x++) {
1511 if (s->avctx->debug & FF_DEBUG_SKIP) {
1512 int count = s->mbskip_table[x + y * s->mb_stride];
1515 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1517 if (s->avctx->debug & FF_DEBUG_QP) {
1518 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1519 pict->qscale_table[x + y * s->mb_stride]);
1521 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1522 int mb_type = pict->mb_type[x + y * s->mb_stride];
1523 // Type & MV direction
1524 if (IS_PCM(mb_type))
1525 av_log(s->avctx, AV_LOG_DEBUG, "P");
1526 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1527 av_log(s->avctx, AV_LOG_DEBUG, "A");
1528 else if (IS_INTRA4x4(mb_type))
1529 av_log(s->avctx, AV_LOG_DEBUG, "i");
1530 else if (IS_INTRA16x16(mb_type))
1531 av_log(s->avctx, AV_LOG_DEBUG, "I");
1532 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1533 av_log(s->avctx, AV_LOG_DEBUG, "d");
1534 else if (IS_DIRECT(mb_type))
1535 av_log(s->avctx, AV_LOG_DEBUG, "D");
1536 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1537 av_log(s->avctx, AV_LOG_DEBUG, "g");
1538 else if (IS_GMC(mb_type))
1539 av_log(s->avctx, AV_LOG_DEBUG, "G");
1540 else if (IS_SKIP(mb_type))
1541 av_log(s->avctx, AV_LOG_DEBUG, "S");
1542 else if (!USES_LIST(mb_type, 1))
1543 av_log(s->avctx, AV_LOG_DEBUG, ">");
1544 else if (!USES_LIST(mb_type, 0))
1545 av_log(s->avctx, AV_LOG_DEBUG, "<");
1547 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1548 av_log(s->avctx, AV_LOG_DEBUG, "X");
1552 if (IS_8X8(mb_type))
1553 av_log(s->avctx, AV_LOG_DEBUG, "+");
1554 else if (IS_16X8(mb_type))
1555 av_log(s->avctx, AV_LOG_DEBUG, "-");
1556 else if (IS_8X16(mb_type))
1557 av_log(s->avctx, AV_LOG_DEBUG, "|");
1558 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1559 av_log(s->avctx, AV_LOG_DEBUG, " ");
1561 av_log(s->avctx, AV_LOG_DEBUG, "?");
1564 if (IS_INTERLACED(mb_type))
1565 av_log(s->avctx, AV_LOG_DEBUG, "=");
1567 av_log(s->avctx, AV_LOG_DEBUG, " ");
1569 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1571 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1575 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1576 (s->avctx->debug_mv)) {
1577 const int shift = 1 + s->quarter_sample;
1581 int h_chroma_shift, v_chroma_shift, block_height;
1582 const int width = s->avctx->width;
1583 const int height = s->avctx->height;
1584 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1585 const int mv_stride = (s->mb_width << mv_sample_log2) +
1586 (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1587 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1589 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1590 &h_chroma_shift, &v_chroma_shift);
1591 for (i = 0; i < 3; i++) {
1592 size_t size= (i == 0) ? pict->linesize[i] * height:
1593 pict->linesize[i] * height >> v_chroma_shift;
1594 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1595 memcpy(s->visualization_buffer[i], pict->data[i], size);
1596 pict->data[i] = s->visualization_buffer[i];
1598 pict->type = FF_BUFFER_TYPE_COPY;
1600 ptr = pict->data[0];
1601 block_height = 16 >> v_chroma_shift;
1603 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1605 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1606 const int mb_index = mb_x + mb_y * s->mb_stride;
1607 if ((s->avctx->debug_mv) && pict->motion_val) {
1609 for (type = 0; type < 3; type++) {
1613 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1614 (pict->pict_type!= AV_PICTURE_TYPE_P))
1619 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1620 (pict->pict_type!= AV_PICTURE_TYPE_B))
1625 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1626 (pict->pict_type!= AV_PICTURE_TYPE_B))
1631 if (!USES_LIST(pict->mb_type[mb_index], direction))
1634 if (IS_8X8(pict->mb_type[mb_index])) {
1636 for (i = 0; i < 4; i++) {
1637 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1638 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1639 int xy = (mb_x * 2 + (i & 1) +
1640 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1641 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1642 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1643 draw_arrow(ptr, sx, sy, mx, my, width,
1644 height, s->linesize, 100);
1646 } else if (IS_16X8(pict->mb_type[mb_index])) {
1648 for (i = 0; i < 2; i++) {
1649 int sx = mb_x * 16 + 8;
1650 int sy = mb_y * 16 + 4 + 8 * i;
1651 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1652 int mx = (pict->motion_val[direction][xy][0] >> shift);
1653 int my = (pict->motion_val[direction][xy][1] >> shift);
1655 if (IS_INTERLACED(pict->mb_type[mb_index]))
1658 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1659 height, s->linesize, 100);
1661 } else if (IS_8X16(pict->mb_type[mb_index])) {
1663 for (i = 0; i < 2; i++) {
1664 int sx = mb_x * 16 + 4 + 8 * i;
1665 int sy = mb_y * 16 + 8;
1666 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1667 int mx = pict->motion_val[direction][xy][0] >> shift;
1668 int my = pict->motion_val[direction][xy][1] >> shift;
1670 if (IS_INTERLACED(pict->mb_type[mb_index]))
1673 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1674 height, s->linesize, 100);
1677 int sx= mb_x * 16 + 8;
1678 int sy= mb_y * 16 + 8;
1679 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1680 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1681 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1682 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1686 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1687 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1688 0x0101010101010101ULL;
1690 for (y = 0; y < block_height; y++) {
1691 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1692 (block_height * mb_y + y) *
1693 pict->linesize[1]) = c;
1694 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1695 (block_height * mb_y + y) *
1696 pict->linesize[2]) = c;
1699 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1701 int mb_type = pict->mb_type[mb_index];
1704 #define COLOR(theta, r) \
1705 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1706 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1710 if (IS_PCM(mb_type)) {
1712 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1713 IS_INTRA16x16(mb_type)) {
1715 } else if (IS_INTRA4x4(mb_type)) {
1717 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1719 } else if (IS_DIRECT(mb_type)) {
1721 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1723 } else if (IS_GMC(mb_type)) {
1725 } else if (IS_SKIP(mb_type)) {
1727 } else if (!USES_LIST(mb_type, 1)) {
1729 } else if (!USES_LIST(mb_type, 0)) {
1732 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1736 u *= 0x0101010101010101ULL;
1737 v *= 0x0101010101010101ULL;
1738 for (y = 0; y < block_height; y++) {
1739 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1740 (block_height * mb_y + y) * pict->linesize[1]) = u;
1741 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1742 (block_height * mb_y + y) * pict->linesize[2]) = v;
1746 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1747 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1748 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1749 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1750 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1752 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1753 for (y = 0; y < 16; y++)
1754 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1755 pict->linesize[0]] ^= 0x80;
1757 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1758 int dm = 1 << (mv_sample_log2 - 2);
1759 for (i = 0; i < 4; i++) {
1760 int sx = mb_x * 16 + 8 * (i & 1);
1761 int sy = mb_y * 16 + 8 * (i >> 1);
1762 int xy = (mb_x * 2 + (i & 1) +
1763 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1765 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1766 if (mv[0] != mv[dm] ||
1767 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1768 for (y = 0; y < 8; y++)
1769 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1770 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1771 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1772 pict->linesize[0]) ^= 0x8080808080808080ULL;
1776 if (IS_INTERLACED(mb_type) &&
1777 s->codec_id == CODEC_ID_H264) {
1781 s->mbskip_table[mb_index] = 0;
1787 static inline int hpel_motion_lowres(MpegEncContext *s,
1788 uint8_t *dest, uint8_t *src,
1789 int field_based, int field_select,
1790 int src_x, int src_y,
1791 int width, int height, int stride,
1792 int h_edge_pos, int v_edge_pos,
1793 int w, int h, h264_chroma_mc_func *pix_op,
1794 int motion_x, int motion_y)
1796 const int lowres = s->avctx->lowres;
1797 const int op_index = FFMIN(lowres, 2);
1798 const int s_mask = (2 << lowres) - 1;
1802 if (s->quarter_sample) {
1807 sx = motion_x & s_mask;
1808 sy = motion_y & s_mask;
1809 src_x += motion_x >> lowres + 1;
1810 src_y += motion_y >> lowres + 1;
1812 src += src_y * stride + src_x;
1814 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1815 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1816 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1817 (h + 1) << field_based, src_x,
1818 src_y << field_based,
1821 src = s->edge_emu_buffer;
1825 sx = (sx << 2) >> lowres;
1826 sy = (sy << 2) >> lowres;
1829 pix_op[op_index](dest, src, stride, h, sx, sy);
1833 /* apply one mpeg motion vector to the three components */
1834 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1841 uint8_t **ref_picture,
1842 h264_chroma_mc_func *pix_op,
1843 int motion_x, int motion_y,
1846 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1847 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1849 const int lowres = s->avctx->lowres;
1850 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
1851 const int block_s = 8>>lowres;
1852 const int s_mask = (2 << lowres) - 1;
1853 const int h_edge_pos = s->h_edge_pos >> lowres;
1854 const int v_edge_pos = s->v_edge_pos >> lowres;
1855 linesize = s->current_picture.f.linesize[0] << field_based;
1856 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1858 // FIXME obviously not perfect but qpel will not work in lowres anyway
1859 if (s->quarter_sample) {
1865 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1868 sx = motion_x & s_mask;
1869 sy = motion_y & s_mask;
1870 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1871 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1873 if (s->out_format == FMT_H263) {
1874 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1875 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1876 uvsrc_x = src_x >> 1;
1877 uvsrc_y = src_y >> 1;
1878 } else if (s->out_format == FMT_H261) {
1879 // even chroma mv's are full pel in H261
1882 uvsx = (2 * mx) & s_mask;
1883 uvsy = (2 * my) & s_mask;
1884 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1885 uvsrc_y = mb_y * block_s + (my >> lowres);
1887 if(s->chroma_y_shift){
1892 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1893 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1895 if(s->chroma_x_shift){
1899 uvsy = motion_y & s_mask;
1901 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1904 uvsx = motion_x & s_mask;
1905 uvsy = motion_y & s_mask;
1912 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1913 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1914 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1916 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
1917 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1918 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
1919 s->linesize, 17, 17 + field_based,
1920 src_x, src_y << field_based, h_edge_pos,
1922 ptr_y = s->edge_emu_buffer;
1923 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1924 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
1925 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
1927 uvsrc_x, uvsrc_y << field_based,
1928 h_edge_pos >> 1, v_edge_pos >> 1);
1929 s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
1931 uvsrc_x, uvsrc_y << field_based,
1932 h_edge_pos >> 1, v_edge_pos >> 1);
1934 ptr_cr = uvbuf + 16;
1938 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1940 dest_y += s->linesize;
1941 dest_cb += s->uvlinesize;
1942 dest_cr += s->uvlinesize;
1946 ptr_y += s->linesize;
1947 ptr_cb += s->uvlinesize;
1948 ptr_cr += s->uvlinesize;
1951 sx = (sx << 2) >> lowres;
1952 sy = (sy << 2) >> lowres;
1953 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1955 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1956 uvsx = (uvsx << 2) >> lowres;
1957 uvsy = (uvsy << 2) >> lowres;
1958 if (h >> s->chroma_y_shift) {
1959 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1960 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1963 // FIXME h261 lowres loop filter
1966 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1967 uint8_t *dest_cb, uint8_t *dest_cr,
1968 uint8_t **ref_picture,
1969 h264_chroma_mc_func * pix_op,
1972 const int lowres = s->avctx->lowres;
1973 const int op_index = FFMIN(lowres, 2);
1974 const int block_s = 8 >> lowres;
1975 const int s_mask = (2 << lowres) - 1;
1976 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1977 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1978 int emu = 0, src_x, src_y, offset, sx, sy;
1981 if (s->quarter_sample) {
1986 /* In case of 8X8, we construct a single chroma motion vector
1987 with a special rounding */
1988 mx = ff_h263_round_chroma(mx);
1989 my = ff_h263_round_chroma(my);
1993 src_x = s->mb_x * block_s + (mx >> lowres + 1);
1994 src_y = s->mb_y * block_s + (my >> lowres + 1);
1996 offset = src_y * s->uvlinesize + src_x;
1997 ptr = ref_picture[1] + offset;
1998 if (s->flags & CODEC_FLAG_EMU_EDGE) {
1999 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2000 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2001 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2002 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2003 ptr = s->edge_emu_buffer;
2007 sx = (sx << 2) >> lowres;
2008 sy = (sy << 2) >> lowres;
2009 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2011 ptr = ref_picture[2] + offset;
2013 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2014 src_x, src_y, h_edge_pos, v_edge_pos);
2015 ptr = s->edge_emu_buffer;
2017 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2021 * motion compensation of a single macroblock
2023 * @param dest_y luma destination pointer
2024 * @param dest_cb chroma cb/u destination pointer
2025 * @param dest_cr chroma cr/v destination pointer
2026 * @param dir direction (0->forward, 1->backward)
2027 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2028 * @param pix_op halfpel motion compensation function (average or put normally)
2029 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2031 static inline void MPV_motion_lowres(MpegEncContext *s,
2032 uint8_t *dest_y, uint8_t *dest_cb,
2034 int dir, uint8_t **ref_picture,
2035 h264_chroma_mc_func *pix_op)
2039 const int lowres = s->avctx->lowres;
2040 const int block_s = 8 >>lowres;
2045 switch (s->mv_type) {
2047 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2049 ref_picture, pix_op,
2050 s->mv[dir][0][0], s->mv[dir][0][1],
2056 for (i = 0; i < 4; i++) {
2057 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2058 s->linesize) * block_s,
2059 ref_picture[0], 0, 0,
2060 (2 * mb_x + (i & 1)) * block_s,
2061 (2 * mb_y + (i >> 1)) * block_s,
2062 s->width, s->height, s->linesize,
2063 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2064 block_s, block_s, pix_op,
2065 s->mv[dir][i][0], s->mv[dir][i][1]);
2067 mx += s->mv[dir][i][0];
2068 my += s->mv[dir][i][1];
2071 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2072 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2076 if (s->picture_structure == PICT_FRAME) {
2078 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2079 1, 0, s->field_select[dir][0],
2080 ref_picture, pix_op,
2081 s->mv[dir][0][0], s->mv[dir][0][1],
2084 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2085 1, 1, s->field_select[dir][1],
2086 ref_picture, pix_op,
2087 s->mv[dir][1][0], s->mv[dir][1][1],
2090 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2091 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2092 ref_picture = s->current_picture_ptr->f.data;
2095 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2096 0, 0, s->field_select[dir][0],
2097 ref_picture, pix_op,
2099 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2103 for (i = 0; i < 2; i++) {
2104 uint8_t **ref2picture;
2106 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2107 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2108 ref2picture = ref_picture;
2110 ref2picture = s->current_picture_ptr->f.data;
2113 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2114 0, 0, s->field_select[dir][i],
2115 ref2picture, pix_op,
2116 s->mv[dir][i][0], s->mv[dir][i][1] +
2117 2 * block_s * i, block_s, mb_y >> 1);
2119 dest_y += 2 * block_s * s->linesize;
2120 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2121 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2125 if (s->picture_structure == PICT_FRAME) {
2126 for (i = 0; i < 2; i++) {
2128 for (j = 0; j < 2; j++) {
2129 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2131 ref_picture, pix_op,
2132 s->mv[dir][2 * i + j][0],
2133 s->mv[dir][2 * i + j][1],
2136 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2139 for (i = 0; i < 2; i++) {
2140 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2141 0, 0, s->picture_structure != i + 1,
2142 ref_picture, pix_op,
2143 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2144 2 * block_s, mb_y >> 1);
2146 // after put we make avg of the same block
2147 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2149 // opposite parity is always in the same
2150 // frame if this is second field
2151 if (!s->first_field) {
2152 ref_picture = s->current_picture_ptr->f.data;
2163 * find the lowest MB row referenced in the MVs
2165 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2167 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2168 int my, off, i, mvs;
2170 if (s->picture_structure != PICT_FRAME) goto unhandled;
2172 switch (s->mv_type) {
2186 for (i = 0; i < mvs; i++) {
2187 my = s->mv[dir][i][1]<<qpel_shift;
2188 my_max = FFMAX(my_max, my);
2189 my_min = FFMIN(my_min, my);
2192 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2194 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2196 return s->mb_height-1;
2199 /* put block[] to dest[] */
2200 static inline void put_dct(MpegEncContext *s,
2201 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2203 s->dct_unquantize_intra(s, block, i, qscale);
2204 s->dsp.idct_put (dest, line_size, block);
2207 /* add block[] to dest[] */
2208 static inline void add_dct(MpegEncContext *s,
2209 DCTELEM *block, int i, uint8_t *dest, int line_size)
2211 if (s->block_last_index[i] >= 0) {
2212 s->dsp.idct_add (dest, line_size, block);
2216 static inline void add_dequant_dct(MpegEncContext *s,
2217 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2219 if (s->block_last_index[i] >= 0) {
2220 s->dct_unquantize_inter(s, block, i, qscale);
2222 s->dsp.idct_add (dest, line_size, block);
2227 * Clean dc, ac, coded_block for the current non-intra MB.
2229 void ff_clean_intra_table_entries(MpegEncContext *s)
2231 int wrap = s->b8_stride;
2232 int xy = s->block_index[0];
2235 s->dc_val[0][xy + 1 ] =
2236 s->dc_val[0][xy + wrap] =
2237 s->dc_val[0][xy + 1 + wrap] = 1024;
2239 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2240 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2241 if (s->msmpeg4_version>=3) {
2242 s->coded_block[xy ] =
2243 s->coded_block[xy + 1 ] =
2244 s->coded_block[xy + wrap] =
2245 s->coded_block[xy + 1 + wrap] = 0;
2248 wrap = s->mb_stride;
2249 xy = s->mb_x + s->mb_y * wrap;
2251 s->dc_val[2][xy] = 1024;
2253 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2254 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2256 s->mbintra_table[xy]= 0;
2259 /* generic function called after a macroblock has been parsed by the
2260 decoder or after it has been encoded by the encoder.
2262 Important variables used:
2263 s->mb_intra : true if intra macroblock
2264 s->mv_dir : motion vector direction
2265 s->mv_type : motion vector type
2266 s->mv : motion vector
2267 s->interlaced_dct : true if interlaced dct used (mpeg2)
2269 static av_always_inline
2270 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2271 int lowres_flag, int is_mpeg12)
2273 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2274 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2275 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2279 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2280 /* save DCT coefficients */
2282 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2283 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2285 for(j=0; j<64; j++){
2286 *dct++ = block[i][s->dsp.idct_permutation[j]];
2287 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2289 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2293 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2295 /* update DC predictors for P macroblocks */
2297 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2298 if(s->mbintra_table[mb_xy])
2299 ff_clean_intra_table_entries(s);
2303 s->last_dc[2] = 128 << s->intra_dc_precision;
2306 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2307 s->mbintra_table[mb_xy]=1;
2309 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
2310 uint8_t *dest_y, *dest_cb, *dest_cr;
2311 int dct_linesize, dct_offset;
2312 op_pixels_func (*op_pix)[4];
2313 qpel_mc_func (*op_qpix)[16];
2314 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2315 const int uvlinesize = s->current_picture.f.linesize[1];
2316 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2317 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2319 /* avoid copy if macroblock skipped in last frame too */
2320 /* skip only during decoding as we might trash the buffers during encoding a bit */
2322 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2324 if (s->mb_skipped) {
2326 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2328 } else if(!s->current_picture.f.reference) {
2331 *mbskip_ptr = 0; /* not skipped */
2335 dct_linesize = linesize << s->interlaced_dct;
2336 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2340 dest_cb= s->dest[1];
2341 dest_cr= s->dest[2];
2343 dest_y = s->b_scratchpad;
2344 dest_cb= s->b_scratchpad+16*linesize;
2345 dest_cr= s->b_scratchpad+32*linesize;
2349 /* motion handling */
2350 /* decoding or more than one mb_type (MC was already done otherwise) */
2353 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2354 if (s->mv_dir & MV_DIR_FORWARD) {
2355 ff_thread_await_progress(&s->last_picture_ptr->f,
2356 ff_MPV_lowest_referenced_row(s, 0),
2359 if (s->mv_dir & MV_DIR_BACKWARD) {
2360 ff_thread_await_progress(&s->next_picture_ptr->f,
2361 ff_MPV_lowest_referenced_row(s, 1),
2367 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2369 if (s->mv_dir & MV_DIR_FORWARD) {
2370 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2371 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2373 if (s->mv_dir & MV_DIR_BACKWARD) {
2374 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2377 op_qpix= s->me.qpel_put;
2378 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2379 op_pix = s->dsp.put_pixels_tab;
2381 op_pix = s->dsp.put_no_rnd_pixels_tab;
2383 if (s->mv_dir & MV_DIR_FORWARD) {
2384 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2385 op_pix = s->dsp.avg_pixels_tab;
2386 op_qpix= s->me.qpel_avg;
2388 if (s->mv_dir & MV_DIR_BACKWARD) {
2389 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2394 /* skip dequant / idct if we are really late ;) */
2395 if(s->avctx->skip_idct){
2396 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2397 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2398 || s->avctx->skip_idct >= AVDISCARD_ALL)
2402 /* add dct residue */
2403 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2404 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2405 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2406 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2407 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2408 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2410 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2411 if (s->chroma_y_shift){
2412 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2413 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2417 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2418 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2419 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2420 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2423 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2424 add_dct(s, block[0], 0, dest_y , dct_linesize);
2425 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2426 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2427 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2429 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2430 if(s->chroma_y_shift){//Chroma420
2431 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2432 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2435 dct_linesize = uvlinesize << s->interlaced_dct;
2436 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2438 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2439 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2440 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2441 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2442 if(!s->chroma_x_shift){//Chroma444
2443 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2444 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2445 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2446 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2451 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2452 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2455 /* dct only in intra block */
2456 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2457 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2458 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2459 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2460 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2462 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2463 if(s->chroma_y_shift){
2464 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2465 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2469 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2470 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2471 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2472 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2476 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2477 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2478 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2479 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2481 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2482 if(s->chroma_y_shift){
2483 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2484 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2487 dct_linesize = uvlinesize << s->interlaced_dct;
2488 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2490 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2491 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2492 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2493 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2494 if(!s->chroma_x_shift){//Chroma444
2495 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2496 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2497 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2498 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2506 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2507 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2508 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2513 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2515 if(s->out_format == FMT_MPEG1) {
2516 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2517 else MPV_decode_mb_internal(s, block, 0, 1);
2520 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2521 else MPV_decode_mb_internal(s, block, 0, 0);
2525 * @param h is the normal height, this will be reduced automatically if needed for the last row
2527 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2528 const int field_pic= s->picture_structure != PICT_FRAME;
2534 if (!s->avctx->hwaccel
2535 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2536 && s->unrestricted_mv
2537 && s->current_picture.f.reference
2539 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2540 int sides = 0, edge_h;
2541 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2542 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2543 if (y==0) sides |= EDGE_TOP;
2544 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2546 edge_h= FFMIN(h, s->v_edge_pos - y);
2548 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2549 s->linesize, s->h_edge_pos, edge_h,
2550 EDGE_WIDTH, EDGE_WIDTH, sides);
2551 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2552 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2553 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2554 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2555 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2556 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2559 h= FFMIN(h, s->avctx->height - y);
2561 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2563 if (s->avctx->draw_horiz_band) {
2565 int offset[AV_NUM_DATA_POINTERS];
2568 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2569 src = &s->current_picture_ptr->f;
2570 else if(s->last_picture_ptr)
2571 src = &s->last_picture_ptr->f;
2575 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2576 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2579 offset[0]= y * s->linesize;
2581 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2582 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2588 s->avctx->draw_horiz_band(s->avctx, src, offset,
2589 y, s->picture_structure, h);
2593 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2594 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2595 const int uvlinesize = s->current_picture.f.linesize[1];
2596 const int mb_size= 4 - s->avctx->lowres;
2598 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2599 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2600 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2601 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2602 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2603 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;
2604 //block_index is not used by mpeg2, so it is not affected by chroma_format
2606 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2607 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2608 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2610 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2612 if(s->picture_structure==PICT_FRAME){
2613 s->dest[0] += s->mb_y * linesize << mb_size;
2614 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2615 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2617 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2618 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2619 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2620 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2625 void ff_mpeg_flush(AVCodecContext *avctx){
2627 MpegEncContext *s = avctx->priv_data;
2629 if(s==NULL || s->picture==NULL)
2632 for(i=0; i<s->picture_count; i++){
2633 if (s->picture[i].f.data[0] &&
2634 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2635 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2636 free_frame_buffer(s, &s->picture[i]);
2638 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2640 s->mb_x= s->mb_y= 0;
2643 s->parse_context.state= -1;
2644 s->parse_context.frame_start_found= 0;
2645 s->parse_context.overread= 0;
2646 s->parse_context.overread_index= 0;
2647 s->parse_context.index= 0;
2648 s->parse_context.last_index= 0;
2649 s->bitstream_buffer_size=0;
2653 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2654 DCTELEM *block, int n, int qscale)
2656 int i, level, nCoeffs;
2657 const uint16_t *quant_matrix;
2659 nCoeffs= s->block_last_index[n];
2661 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2662 /* XXX: only mpeg1 */
2663 quant_matrix = s->intra_matrix;
2664 for(i=1;i<=nCoeffs;i++) {
2665 int j= s->intra_scantable.permutated[i];
2670 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2671 level = (level - 1) | 1;
2674 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2675 level = (level - 1) | 1;
2682 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2683 DCTELEM *block, int n, int qscale)
2685 int i, level, nCoeffs;
2686 const uint16_t *quant_matrix;
2688 nCoeffs= s->block_last_index[n];
2690 quant_matrix = s->inter_matrix;
2691 for(i=0; i<=nCoeffs; i++) {
2692 int j= s->intra_scantable.permutated[i];
2697 level = (((level << 1) + 1) * qscale *
2698 ((int) (quant_matrix[j]))) >> 4;
2699 level = (level - 1) | 1;
2702 level = (((level << 1) + 1) * qscale *
2703 ((int) (quant_matrix[j]))) >> 4;
2704 level = (level - 1) | 1;
2711 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2712 DCTELEM *block, int n, int qscale)
2714 int i, level, nCoeffs;
2715 const uint16_t *quant_matrix;
2717 if(s->alternate_scan) nCoeffs= 63;
2718 else nCoeffs= s->block_last_index[n];
2720 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2721 quant_matrix = s->intra_matrix;
2722 for(i=1;i<=nCoeffs;i++) {
2723 int j= s->intra_scantable.permutated[i];
2728 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2731 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2738 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2739 DCTELEM *block, int n, int qscale)
2741 int i, level, nCoeffs;
2742 const uint16_t *quant_matrix;
2745 if(s->alternate_scan) nCoeffs= 63;
2746 else nCoeffs= s->block_last_index[n];
2748 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2750 quant_matrix = s->intra_matrix;
2751 for(i=1;i<=nCoeffs;i++) {
2752 int j= s->intra_scantable.permutated[i];
2757 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2760 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2769 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2770 DCTELEM *block, int n, int qscale)
2772 int i, level, nCoeffs;
2773 const uint16_t *quant_matrix;
2776 if(s->alternate_scan) nCoeffs= 63;
2777 else nCoeffs= s->block_last_index[n];
2779 quant_matrix = s->inter_matrix;
2780 for(i=0; i<=nCoeffs; i++) {
2781 int j= s->intra_scantable.permutated[i];
2786 level = (((level << 1) + 1) * qscale *
2787 ((int) (quant_matrix[j]))) >> 4;
2790 level = (((level << 1) + 1) * qscale *
2791 ((int) (quant_matrix[j]))) >> 4;
2800 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2801 DCTELEM *block, int n, int qscale)
2803 int i, level, qmul, qadd;
2806 assert(s->block_last_index[n]>=0);
2811 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2812 qadd = (qscale - 1) | 1;
2819 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2821 for(i=1; i<=nCoeffs; i++) {
2825 level = level * qmul - qadd;
2827 level = level * qmul + qadd;
2834 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2835 DCTELEM *block, int n, int qscale)
2837 int i, level, qmul, qadd;
2840 assert(s->block_last_index[n]>=0);
2842 qadd = (qscale - 1) | 1;
2845 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2847 for(i=0; i<=nCoeffs; i++) {
2851 level = level * qmul - qadd;
2853 level = level * qmul + qadd;
2861 * set qscale and update qscale dependent variables.
2863 void ff_set_qscale(MpegEncContext * s, int qscale)
2867 else if (qscale > 31)
2871 s->chroma_qscale= s->chroma_qscale_table[qscale];
2873 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2874 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2877 void ff_MPV_report_decode_progress(MpegEncContext *s)
2879 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2880 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);