2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/imgutils.h"
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);
64 static const uint8_t ff_default_chroma_qscale_table[32] = {
65 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
66 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
67 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
70 const uint8_t ff_mpeg1_dc_scale_table[128] = {
71 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
72 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
73 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
74 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 static const uint8_t mpeg2_dc_scale_table1[128] = {
83 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
84 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94 static const uint8_t mpeg2_dc_scale_table2[128] = {
95 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
96 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
97 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 static const uint8_t mpeg2_dc_scale_table3[128] = {
107 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
109 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
110 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
113 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
119 ff_mpeg1_dc_scale_table,
120 mpeg2_dc_scale_table1,
121 mpeg2_dc_scale_table2,
122 mpeg2_dc_scale_table3,
125 const enum AVPixelFormat ff_pixfmt_list_420[] = {
130 const enum AVPixelFormat ff_hwaccel_pixfmt_list_420[] = {
131 AV_PIX_FMT_DXVA2_VLD,
132 AV_PIX_FMT_VAAPI_VLD,
139 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
141 uint32_t *av_restrict state)
149 for (i = 0; i < 3; i++) {
150 uint32_t tmp = *state << 8;
151 *state = tmp + *(p++);
152 if (tmp == 0x100 || p == end)
157 if (p[-1] > 1 ) p += 3;
158 else if (p[-2] ) p += 2;
159 else if (p[-3]|(p[-1]-1)) p++;
166 p = FFMIN(p, end) - 4;
172 /* init common dct for both encoder and decoder */
173 av_cold int ff_dct_common_init(MpegEncContext *s)
175 ff_dsputil_init(&s->dsp, s->avctx);
176 ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
178 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
179 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
180 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
181 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
182 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
183 if (s->flags & CODEC_FLAG_BITEXACT)
184 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
185 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
188 ff_MPV_common_init_x86(s);
190 ff_MPV_common_init_axp(s);
192 ff_MPV_common_init_arm(s);
194 ff_MPV_common_init_altivec(s);
196 ff_MPV_common_init_bfin(s);
199 /* load & permutate scantables
200 * note: only wmv uses different ones
202 if (s->alternate_scan) {
203 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
204 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
206 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
207 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
209 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
210 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
215 void ff_copy_picture(Picture *dst, Picture *src)
218 dst->f.type = FF_BUFFER_TYPE_COPY;
222 * Release a frame buffer
224 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
226 pic->period_since_free = 0;
227 /* WM Image / Screen codecs allocate internal buffers with different
228 * dimensions / colorspaces; ignore user-defined callbacks for these. */
229 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
230 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
231 s->codec_id != AV_CODEC_ID_MSS2)
232 ff_thread_release_buffer(s->avctx, &pic->f);
234 avcodec_default_release_buffer(s->avctx, &pic->f);
235 av_freep(&pic->f.hwaccel_picture_private);
238 int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize)
240 int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
242 // edge emu needs blocksize + filter length - 1
243 // (= 17x17 for halfpel / 21x21 for h264)
244 // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
245 // at uvlinesize. It supports only YUV420 so 24x24 is enough
246 // linesize * interlaced * MBsize
247 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 4 * 24,
250 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 4 * 16 * 2,
252 s->me.temp = s->me.scratchpad;
253 s->rd_scratchpad = s->me.scratchpad;
254 s->b_scratchpad = s->me.scratchpad;
255 s->obmc_scratchpad = s->me.scratchpad + 16;
259 av_freep(&s->edge_emu_buffer);
260 return AVERROR(ENOMEM);
264 * Allocate a frame buffer
266 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
270 if (s->avctx->hwaccel) {
271 assert(!pic->f.hwaccel_picture_private);
272 if (s->avctx->hwaccel->priv_data_size) {
273 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
274 if (!pic->f.hwaccel_picture_private) {
275 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
281 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
282 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
283 s->codec_id != AV_CODEC_ID_MSS2)
284 r = ff_thread_get_buffer(s->avctx, &pic->f);
286 r = avcodec_default_get_buffer(s->avctx, &pic->f);
288 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
289 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
290 r, pic->f.type, pic->f.data[0]);
291 av_freep(&pic->f.hwaccel_picture_private);
295 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
296 s->uvlinesize != pic->f.linesize[1])) {
297 av_log(s->avctx, AV_LOG_ERROR,
298 "get_buffer() failed (stride changed)\n");
299 free_frame_buffer(s, pic);
303 if (pic->f.linesize[1] != pic->f.linesize[2]) {
304 av_log(s->avctx, AV_LOG_ERROR,
305 "get_buffer() failed (uv stride mismatch)\n");
306 free_frame_buffer(s, pic);
310 if (!s->edge_emu_buffer &&
311 (ret = ff_mpv_frame_size_alloc(s, pic->f.linesize[0])) < 0) {
312 av_log(s->avctx, AV_LOG_ERROR,
313 "get_buffer() failed to allocate context scratch buffers.\n");
314 free_frame_buffer(s, pic);
322 * Allocate a Picture.
323 * The pixels are allocated/set by calling get_buffer() if shared = 0
325 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
327 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
329 // the + 1 is needed so memset(,,stride*height) does not sig11
331 const int mb_array_size = s->mb_stride * s->mb_height;
332 const int b8_array_size = s->b8_stride * s->mb_height * 2;
333 const int b4_array_size = s->b4_stride * s->mb_height * 4;
338 assert(pic->f.data[0]);
339 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
340 pic->f.type = FF_BUFFER_TYPE_SHARED;
342 assert(!pic->f.data[0]);
344 if (alloc_frame_buffer(s, pic) < 0)
347 s->linesize = pic->f.linesize[0];
348 s->uvlinesize = pic->f.linesize[1];
351 if (pic->f.qscale_table == NULL) {
353 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
354 mb_array_size * sizeof(int16_t), fail)
355 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
356 mb_array_size * sizeof(int16_t), fail)
357 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
358 mb_array_size * sizeof(int8_t ), fail)
361 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
362 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
363 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
364 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
366 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
367 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
369 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
370 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
371 if (s->out_format == FMT_H264) {
372 for (i = 0; i < 2; i++) {
373 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
374 2 * (b4_array_size + 4) * sizeof(int16_t),
376 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
377 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
378 4 * mb_array_size * sizeof(uint8_t), fail)
380 pic->f.motion_subsample_log2 = 2;
381 } else if (s->out_format == FMT_H263 || s->encoding ||
382 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
383 for (i = 0; i < 2; i++) {
384 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
385 2 * (b8_array_size + 4) * sizeof(int16_t),
387 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
388 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
389 4 * mb_array_size * sizeof(uint8_t), fail)
391 pic->f.motion_subsample_log2 = 3;
393 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
394 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
395 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
397 pic->f.qstride = s->mb_stride;
398 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
399 1 * sizeof(AVPanScan), fail)
405 fail: // for the FF_ALLOCZ_OR_GOTO macro
407 free_frame_buffer(s, pic);
412 * Deallocate a picture.
414 static void free_picture(MpegEncContext *s, Picture *pic)
418 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
419 free_frame_buffer(s, pic);
422 av_freep(&pic->mb_var);
423 av_freep(&pic->mc_mb_var);
424 av_freep(&pic->mb_mean);
425 av_freep(&pic->f.mbskip_table);
426 av_freep(&pic->qscale_table_base);
427 pic->f.qscale_table = NULL;
428 av_freep(&pic->mb_type_base);
429 pic->f.mb_type = NULL;
430 av_freep(&pic->f.dct_coeff);
431 av_freep(&pic->f.pan_scan);
432 pic->f.mb_type = NULL;
433 for (i = 0; i < 2; i++) {
434 av_freep(&pic->motion_val_base[i]);
435 av_freep(&pic->f.ref_index[i]);
436 pic->f.motion_val[i] = NULL;
439 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
440 for (i = 0; i < 4; i++) {
442 pic->f.data[i] = NULL;
448 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
450 int y_size = s->b8_stride * (2 * s->mb_height + 1);
451 int c_size = s->mb_stride * (s->mb_height + 1);
452 int yc_size = y_size + 2 * c_size;
460 s->obmc_scratchpad = NULL;
463 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
464 ME_MAP_SIZE * sizeof(uint32_t), fail)
465 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
466 ME_MAP_SIZE * sizeof(uint32_t), fail)
467 if (s->avctx->noise_reduction) {
468 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
469 2 * 64 * sizeof(int), fail)
472 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
473 s->block = s->blocks[0];
475 for (i = 0; i < 12; i++) {
476 s->pblocks[i] = &s->block[i];
479 if (s->out_format == FMT_H263) {
481 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
482 yc_size * sizeof(int16_t) * 16, fail);
483 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
484 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
485 s->ac_val[2] = s->ac_val[1] + c_size;
490 return -1; // free() through ff_MPV_common_end()
493 static void free_duplicate_context(MpegEncContext *s)
498 av_freep(&s->edge_emu_buffer);
499 av_freep(&s->me.scratchpad);
503 s->obmc_scratchpad = NULL;
505 av_freep(&s->dct_error_sum);
506 av_freep(&s->me.map);
507 av_freep(&s->me.score_map);
508 av_freep(&s->blocks);
509 av_freep(&s->ac_val_base);
513 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
515 #define COPY(a) bak->a = src->a
516 COPY(edge_emu_buffer);
521 COPY(obmc_scratchpad);
528 COPY(me.map_generation);
540 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
544 // FIXME copy only needed parts
546 backup_duplicate_context(&bak, dst);
547 memcpy(dst, src, sizeof(MpegEncContext));
548 backup_duplicate_context(dst, &bak);
549 for (i = 0; i < 12; i++) {
550 dst->pblocks[i] = &dst->block[i];
552 if (!dst->edge_emu_buffer &&
553 (ret = ff_mpv_frame_size_alloc(dst, dst->linesize)) < 0) {
554 av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
555 "scratch buffers.\n");
558 // STOP_TIMER("update_duplicate_context")
559 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
563 int ff_mpeg_update_thread_context(AVCodecContext *dst,
564 const AVCodecContext *src)
568 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
575 // FIXME can parameters change on I-frames?
576 // in that case dst may need a reinit
577 if (!s->context_initialized) {
578 memcpy(s, s1, sizeof(MpegEncContext));
581 s->bitstream_buffer = NULL;
582 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
584 if (s1->context_initialized){
585 s->picture_range_start += MAX_PICTURE_COUNT;
586 s->picture_range_end += MAX_PICTURE_COUNT;
587 if((err = ff_MPV_common_init(s)) < 0)
592 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
593 s->context_reinit = 0;
594 s->height = s1->height;
595 s->width = s1->width;
596 if ((err = ff_MPV_common_frame_size_change(s)) < 0)
600 s->avctx->coded_height = s1->avctx->coded_height;
601 s->avctx->coded_width = s1->avctx->coded_width;
602 s->avctx->width = s1->avctx->width;
603 s->avctx->height = s1->avctx->height;
605 s->coded_picture_number = s1->coded_picture_number;
606 s->picture_number = s1->picture_number;
607 s->input_picture_number = s1->input_picture_number;
609 av_assert0(!s->picture || s->picture != s1->picture);
610 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
611 memcpy(&s->last_picture, &s1->last_picture,
612 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
614 // reset s->picture[].f.extended_data to s->picture[].f.data
615 for (i = 0; i < s->picture_count; i++) {
616 s->picture[i].f.extended_data = s->picture[i].f.data;
617 s->picture[i].period_since_free ++;
620 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
621 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
622 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
624 // Error/bug resilience
625 s->next_p_frame_damaged = s1->next_p_frame_damaged;
626 s->workaround_bugs = s1->workaround_bugs;
627 s->padding_bug_score = s1->padding_bug_score;
630 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
631 (char *) &s1->shape - (char *) &s1->time_increment_bits);
634 s->max_b_frames = s1->max_b_frames;
635 s->low_delay = s1->low_delay;
636 s->droppable = s1->droppable;
638 // DivX handling (doesn't work)
639 s->divx_packed = s1->divx_packed;
641 if (s1->bitstream_buffer) {
642 if (s1->bitstream_buffer_size +
643 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
644 av_fast_malloc(&s->bitstream_buffer,
645 &s->allocated_bitstream_buffer_size,
646 s1->allocated_bitstream_buffer_size);
647 s->bitstream_buffer_size = s1->bitstream_buffer_size;
648 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
649 s1->bitstream_buffer_size);
650 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
651 FF_INPUT_BUFFER_PADDING_SIZE);
654 // linesize dependend scratch buffer allocation
655 if (!s->edge_emu_buffer)
657 if (ff_mpv_frame_size_alloc(s, s1->linesize) < 0) {
658 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
659 "scratch buffers.\n");
660 return AVERROR(ENOMEM);
663 av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
664 "be allocated due to unknown size.\n");
667 // MPEG2/interlacing info
668 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
669 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
671 if (!s1->first_field) {
672 s->last_pict_type = s1->pict_type;
673 if (s1->current_picture_ptr)
674 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
676 if (s1->pict_type != AV_PICTURE_TYPE_B) {
677 s->last_non_b_pict_type = s1->pict_type;
685 * Set the given MpegEncContext to common defaults
686 * (same for encoding and decoding).
687 * The changed fields will not depend upon the
688 * prior state of the MpegEncContext.
690 void ff_MPV_common_defaults(MpegEncContext *s)
692 s->y_dc_scale_table =
693 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
694 s->chroma_qscale_table = ff_default_chroma_qscale_table;
695 s->progressive_frame = 1;
696 s->progressive_sequence = 1;
697 s->picture_structure = PICT_FRAME;
699 s->coded_picture_number = 0;
700 s->picture_number = 0;
701 s->input_picture_number = 0;
703 s->picture_in_gop_number = 0;
708 s->picture_range_start = 0;
709 s->picture_range_end = MAX_PICTURE_COUNT;
711 s->slice_context_count = 1;
715 * Set the given MpegEncContext to defaults for decoding.
716 * the changed fields will not depend upon
717 * the prior state of the MpegEncContext.
719 void ff_MPV_decode_defaults(MpegEncContext *s)
721 ff_MPV_common_defaults(s);
725 * Initialize and allocates MpegEncContext fields dependent on the resolution.
727 static int init_context_frame(MpegEncContext *s)
729 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
731 s->mb_width = (s->width + 15) / 16;
732 s->mb_stride = s->mb_width + 1;
733 s->b8_stride = s->mb_width * 2 + 1;
734 s->b4_stride = s->mb_width * 4 + 1;
735 mb_array_size = s->mb_height * s->mb_stride;
736 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
738 /* set default edge pos, will be overriden
739 * in decode_header if needed */
740 s->h_edge_pos = s->mb_width * 16;
741 s->v_edge_pos = s->mb_height * 16;
743 s->mb_num = s->mb_width * s->mb_height;
748 s->block_wrap[3] = s->b8_stride;
750 s->block_wrap[5] = s->mb_stride;
752 y_size = s->b8_stride * (2 * s->mb_height + 1);
753 c_size = s->mb_stride * (s->mb_height + 1);
754 yc_size = y_size + 2 * c_size;
756 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
757 for (y = 0; y < s->mb_height; y++)
758 for (x = 0; x < s->mb_width; x++)
759 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
761 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
764 /* Allocate MV tables */
765 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
766 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
767 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
768 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
769 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
770 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
771 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
772 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
773 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
774 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
775 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
776 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
778 /* Allocate MB type table */
779 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
781 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
783 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
784 mb_array_size * sizeof(float), fail);
785 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
786 mb_array_size * sizeof(float), fail);
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,
802 s->b_field_mv_table_base[i][j][k],
803 mv_table_size * 2 * sizeof(int16_t),
805 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
808 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
809 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
810 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
812 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
815 if (s->out_format == FMT_H263) {
817 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
818 s->coded_block = s->coded_block_base + s->b8_stride + 1;
820 /* cbp, ac_pred, pred_dir */
821 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
822 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
825 if (s->h263_pred || s->h263_plus || !s->encoding) {
827 // MN: we need these for error resilience of intra-frames
828 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
829 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
830 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
831 s->dc_val[2] = s->dc_val[1] + c_size;
832 for (i = 0; i < yc_size; i++)
833 s->dc_val_base[i] = 1024;
836 /* which mb is a intra block */
837 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
838 memset(s->mbintra_table, 1, mb_array_size);
840 /* init macroblock skip table */
841 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
842 // Note the + 1 is for a quicker mpeg4 slice_end detection
846 return AVERROR(ENOMEM);
850 * init common structure for both encoder and decoder.
851 * this assumes that some variables like width/height are already set
853 av_cold int ff_MPV_common_init(MpegEncContext *s)
856 int nb_slices = (HAVE_THREADS &&
857 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
858 s->avctx->thread_count : 1;
860 if (s->encoding && s->avctx->slices)
861 nb_slices = s->avctx->slices;
863 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
864 s->mb_height = (s->height + 31) / 32 * 2;
865 else if (s->codec_id != AV_CODEC_ID_H264)
866 s->mb_height = (s->height + 15) / 16;
868 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
869 av_log(s->avctx, AV_LOG_ERROR,
870 "decoding to AV_PIX_FMT_NONE is not supported.\n");
874 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
877 max_slices = FFMIN(MAX_THREADS, s->mb_height);
879 max_slices = MAX_THREADS;
880 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
881 " reducing to %d\n", nb_slices, max_slices);
882 nb_slices = max_slices;
885 if ((s->width || s->height) &&
886 av_image_check_size(s->width, s->height, 0, s->avctx))
889 ff_dct_common_init(s);
891 s->flags = s->avctx->flags;
892 s->flags2 = s->avctx->flags2;
894 /* set chroma shifts */
895 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
897 /* convert fourcc to upper case */
898 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
899 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
901 s->avctx->coded_frame = &s->current_picture.f;
904 if (s->msmpeg4_version) {
905 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
906 2 * 2 * (MAX_LEVEL + 1) *
907 (MAX_RUN + 1) * 2 * sizeof(int), fail);
909 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
911 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail)
912 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail)
913 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail)
914 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
915 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
916 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
917 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
918 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
920 if (s->avctx->noise_reduction) {
921 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
925 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
926 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
927 s->picture_count * sizeof(Picture), fail);
928 for (i = 0; i < s->picture_count; i++) {
929 avcodec_get_frame_defaults(&s->picture[i].f);
932 if (init_context_frame(s))
935 s->parse_context.state = -1;
937 s->context_initialized = 1;
938 s->thread_context[0] = s;
940 // if (s->width && s->height) {
942 for (i = 1; i < nb_slices; i++) {
943 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
944 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
947 for (i = 0; i < nb_slices; i++) {
948 if (init_duplicate_context(s->thread_context[i], s) < 0)
950 s->thread_context[i]->start_mb_y =
951 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
952 s->thread_context[i]->end_mb_y =
953 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
956 if (init_duplicate_context(s, s) < 0)
959 s->end_mb_y = s->mb_height;
961 s->slice_context_count = nb_slices;
966 ff_MPV_common_end(s);
971 * Frees and resets MpegEncContext fields depending on the resolution.
972 * Is used during resolution changes to avoid a full reinitialization of the
975 static int free_context_frame(MpegEncContext *s)
979 av_freep(&s->mb_type);
980 av_freep(&s->p_mv_table_base);
981 av_freep(&s->b_forw_mv_table_base);
982 av_freep(&s->b_back_mv_table_base);
983 av_freep(&s->b_bidir_forw_mv_table_base);
984 av_freep(&s->b_bidir_back_mv_table_base);
985 av_freep(&s->b_direct_mv_table_base);
986 s->p_mv_table = NULL;
987 s->b_forw_mv_table = NULL;
988 s->b_back_mv_table = NULL;
989 s->b_bidir_forw_mv_table = NULL;
990 s->b_bidir_back_mv_table = NULL;
991 s->b_direct_mv_table = NULL;
992 for (i = 0; i < 2; i++) {
993 for (j = 0; j < 2; j++) {
994 for (k = 0; k < 2; k++) {
995 av_freep(&s->b_field_mv_table_base[i][j][k]);
996 s->b_field_mv_table[i][j][k] = NULL;
998 av_freep(&s->b_field_select_table[i][j]);
999 av_freep(&s->p_field_mv_table_base[i][j]);
1000 s->p_field_mv_table[i][j] = NULL;
1002 av_freep(&s->p_field_select_table[i]);
1005 av_freep(&s->dc_val_base);
1006 av_freep(&s->coded_block_base);
1007 av_freep(&s->mbintra_table);
1008 av_freep(&s->cbp_table);
1009 av_freep(&s->pred_dir_table);
1011 av_freep(&s->mbskip_table);
1013 av_freep(&s->error_status_table);
1014 av_freep(&s->er_temp_buffer);
1015 av_freep(&s->mb_index2xy);
1016 av_freep(&s->lambda_table);
1018 av_freep(&s->cplx_tab);
1019 av_freep(&s->bits_tab);
1021 s->linesize = s->uvlinesize = 0;
1023 for (i = 0; i < 3; i++)
1024 av_freep(&s->visualization_buffer[i]);
1029 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1033 if (s->slice_context_count > 1) {
1034 for (i = 0; i < s->slice_context_count; i++) {
1035 free_duplicate_context(s->thread_context[i]);
1037 for (i = 1; i < s->slice_context_count; i++) {
1038 av_freep(&s->thread_context[i]);
1041 free_duplicate_context(s);
1043 free_context_frame(s);
1046 for (i = 0; i < s->picture_count; i++) {
1047 s->picture[i].needs_realloc = 1;
1050 s->last_picture_ptr =
1051 s->next_picture_ptr =
1052 s->current_picture_ptr = NULL;
1055 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1056 s->mb_height = (s->height + 31) / 32 * 2;
1057 else if (s->codec_id != AV_CODEC_ID_H264)
1058 s->mb_height = (s->height + 15) / 16;
1060 if ((s->width || s->height) &&
1061 av_image_check_size(s->width, s->height, 0, s->avctx))
1062 return AVERROR_INVALIDDATA;
1064 if ((err = init_context_frame(s)))
1067 s->thread_context[0] = s;
1069 if (s->width && s->height) {
1070 int nb_slices = s->slice_context_count;
1071 if (nb_slices > 1) {
1072 for (i = 1; i < nb_slices; i++) {
1073 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1074 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1077 for (i = 0; i < nb_slices; i++) {
1078 if (init_duplicate_context(s->thread_context[i], s) < 0)
1080 s->thread_context[i]->start_mb_y =
1081 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1082 s->thread_context[i]->end_mb_y =
1083 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1086 if (init_duplicate_context(s, s) < 0)
1089 s->end_mb_y = s->mb_height;
1091 s->slice_context_count = nb_slices;
1096 ff_MPV_common_end(s);
1100 /* init common structure for both encoder and decoder */
1101 void ff_MPV_common_end(MpegEncContext *s)
1105 if (s->slice_context_count > 1) {
1106 for (i = 0; i < s->slice_context_count; i++) {
1107 free_duplicate_context(s->thread_context[i]);
1109 for (i = 1; i < s->slice_context_count; i++) {
1110 av_freep(&s->thread_context[i]);
1112 s->slice_context_count = 1;
1113 } else free_duplicate_context(s);
1115 av_freep(&s->parse_context.buffer);
1116 s->parse_context.buffer_size = 0;
1118 av_freep(&s->bitstream_buffer);
1119 s->allocated_bitstream_buffer_size = 0;
1121 av_freep(&s->avctx->stats_out);
1122 av_freep(&s->ac_stats);
1124 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1125 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1126 s->q_chroma_intra_matrix= NULL;
1127 s->q_chroma_intra_matrix16= NULL;
1128 av_freep(&s->q_intra_matrix);
1129 av_freep(&s->q_inter_matrix);
1130 av_freep(&s->q_intra_matrix16);
1131 av_freep(&s->q_inter_matrix16);
1132 av_freep(&s->input_picture);
1133 av_freep(&s->reordered_input_picture);
1134 av_freep(&s->dct_offset);
1136 if (s->picture && !s->avctx->internal->is_copy) {
1137 for (i = 0; i < s->picture_count; i++) {
1138 free_picture(s, &s->picture[i]);
1141 av_freep(&s->picture);
1143 free_context_frame(s);
1145 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
1146 avcodec_default_free_buffers(s->avctx);
1148 s->context_initialized = 0;
1149 s->last_picture_ptr =
1150 s->next_picture_ptr =
1151 s->current_picture_ptr = NULL;
1152 s->linesize = s->uvlinesize = 0;
1155 void ff_init_rl(RLTable *rl,
1156 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1158 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1159 uint8_t index_run[MAX_RUN + 1];
1160 int last, run, level, start, end, i;
1162 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1163 if (static_store && rl->max_level[0])
1166 /* compute max_level[], max_run[] and index_run[] */
1167 for (last = 0; last < 2; last++) {
1176 memset(max_level, 0, MAX_RUN + 1);
1177 memset(max_run, 0, MAX_LEVEL + 1);
1178 memset(index_run, rl->n, MAX_RUN + 1);
1179 for (i = start; i < end; i++) {
1180 run = rl->table_run[i];
1181 level = rl->table_level[i];
1182 if (index_run[run] == rl->n)
1184 if (level > max_level[run])
1185 max_level[run] = level;
1186 if (run > max_run[level])
1187 max_run[level] = run;
1190 rl->max_level[last] = static_store[last];
1192 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1193 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1195 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1197 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1198 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1200 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1202 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1203 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1207 void ff_init_vlc_rl(RLTable *rl)
1211 for (q = 0; q < 32; q++) {
1213 int qadd = (q - 1) | 1;
1219 for (i = 0; i < rl->vlc.table_size; i++) {
1220 int code = rl->vlc.table[i][0];
1221 int len = rl->vlc.table[i][1];
1224 if (len == 0) { // illegal code
1227 } else if (len < 0) { // more bits needed
1231 if (code == rl->n) { // esc
1235 run = rl->table_run[code] + 1;
1236 level = rl->table_level[code] * qmul + qadd;
1237 if (code >= rl->last) run += 192;
1240 rl->rl_vlc[q][i].len = len;
1241 rl->rl_vlc[q][i].level = level;
1242 rl->rl_vlc[q][i].run = run;
1247 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1251 /* release non reference frames */
1252 for (i = 0; i < s->picture_count; i++) {
1253 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1254 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1255 (remove_current || &s->picture[i] != s->current_picture_ptr)
1256 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1257 free_frame_buffer(s, &s->picture[i]);
1262 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1264 if ( (s->avctx->active_thread_type & FF_THREAD_FRAME)
1265 && pic->f.qscale_table //check if the frame has anything allocated
1266 && pic->period_since_free < s->avctx->thread_count)
1268 if (pic->f.data[0] == NULL)
1270 if (pic->needs_realloc && !(pic->f.reference & DELAYED_PIC_REF))
1271 if (!pic->owner2 || pic->owner2 == s)
1276 static int find_unused_picture(MpegEncContext *s, int shared)
1281 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1282 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1286 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1287 if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1290 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1291 if (pic_is_unused(s, &s->picture[i]))
1296 av_log(s->avctx, AV_LOG_FATAL,
1297 "Internal error, picture buffer overflow\n");
1298 /* We could return -1, but the codec would crash trying to draw into a
1299 * non-existing frame anyway. This is safer than waiting for a random crash.
1300 * Also the return of this is never useful, an encoder must only allocate
1301 * as much as allowed in the specification. This has no relationship to how
1302 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1303 * enough for such valid streams).
1304 * Plus, a decoder has to check stream validity and remove frames if too
1305 * many reference frames are around. Waiting for "OOM" is not correct at
1306 * all. Similarly, missing reference frames have to be replaced by
1307 * interpolated/MC frames, anything else is a bug in the codec ...
1313 int ff_find_unused_picture(MpegEncContext *s, int shared)
1315 int ret = find_unused_picture(s, shared);
1317 if (ret >= 0 && ret < s->picture_range_end) {
1318 if (s->picture[ret].needs_realloc) {
1319 s->picture[ret].needs_realloc = 0;
1320 free_picture(s, &s->picture[ret]);
1321 avcodec_get_frame_defaults(&s->picture[ret].f);
1327 static void update_noise_reduction(MpegEncContext *s)
1331 for (intra = 0; intra < 2; intra++) {
1332 if (s->dct_count[intra] > (1 << 16)) {
1333 for (i = 0; i < 64; i++) {
1334 s->dct_error_sum[intra][i] >>= 1;
1336 s->dct_count[intra] >>= 1;
1339 for (i = 0; i < 64; i++) {
1340 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1341 s->dct_count[intra] +
1342 s->dct_error_sum[intra][i] / 2) /
1343 (s->dct_error_sum[intra][i] + 1);
1349 * generic function for encode/decode called after coding/decoding
1350 * the header and before a frame is coded/decoded.
1352 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1358 if (!ff_thread_can_start_frame(avctx)) {
1359 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1363 /* mark & release old frames */
1364 if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1365 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1366 s->last_picture_ptr != s->next_picture_ptr &&
1367 s->last_picture_ptr->f.data[0]) {
1368 if (s->last_picture_ptr->owner2 == s)
1369 free_frame_buffer(s, s->last_picture_ptr);
1372 /* release forgotten pictures */
1373 /* if (mpeg124/h263) */
1375 for (i = 0; i < s->picture_count; i++) {
1376 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1377 &s->picture[i] != s->last_picture_ptr &&
1378 &s->picture[i] != s->next_picture_ptr &&
1379 s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1380 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1381 av_log(avctx, AV_LOG_ERROR,
1382 "releasing zombie picture\n");
1383 free_frame_buffer(s, &s->picture[i]);
1390 ff_release_unused_pictures(s, 1);
1392 if (s->current_picture_ptr &&
1393 s->current_picture_ptr->f.data[0] == NULL) {
1394 // we already have a unused image
1395 // (maybe it was set before reading the header)
1396 pic = s->current_picture_ptr;
1398 i = ff_find_unused_picture(s, 0);
1400 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1403 pic = &s->picture[i];
1406 pic->f.reference = 0;
1407 if (!s->droppable) {
1408 if (s->codec_id == AV_CODEC_ID_H264)
1409 pic->f.reference = s->picture_structure;
1410 else if (s->pict_type != AV_PICTURE_TYPE_B)
1411 pic->f.reference = 3;
1414 pic->f.coded_picture_number = s->coded_picture_number++;
1416 if (ff_alloc_picture(s, pic, 0) < 0)
1419 s->current_picture_ptr = pic;
1420 // FIXME use only the vars from current_pic
1421 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1422 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1423 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1424 if (s->picture_structure != PICT_FRAME)
1425 s->current_picture_ptr->f.top_field_first =
1426 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1428 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1429 !s->progressive_sequence;
1430 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1433 s->current_picture_ptr->f.pict_type = s->pict_type;
1434 // if (s->flags && CODEC_FLAG_QSCALE)
1435 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1436 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1438 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1440 if (s->pict_type != AV_PICTURE_TYPE_B) {
1441 s->last_picture_ptr = s->next_picture_ptr;
1443 s->next_picture_ptr = s->current_picture_ptr;
1445 av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1446 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1447 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1448 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1449 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1450 s->pict_type, s->droppable);
1452 if (s->codec_id != AV_CODEC_ID_H264) {
1453 if ((s->last_picture_ptr == NULL ||
1454 s->last_picture_ptr->f.data[0] == NULL) &&
1455 (s->pict_type != AV_PICTURE_TYPE_I ||
1456 s->picture_structure != PICT_FRAME)) {
1457 if (s->pict_type != AV_PICTURE_TYPE_I)
1458 av_log(avctx, AV_LOG_ERROR,
1459 "warning: first frame is no keyframe\n");
1460 else if (s->picture_structure != PICT_FRAME)
1461 av_log(avctx, AV_LOG_INFO,
1462 "allocate dummy last picture for field based first keyframe\n");
1464 /* Allocate a dummy frame */
1465 i = ff_find_unused_picture(s, 0);
1467 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1470 s->last_picture_ptr = &s->picture[i];
1471 s->last_picture_ptr->f.key_frame = 0;
1472 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1473 s->last_picture_ptr = NULL;
1477 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1478 for(i=0; i<avctx->height; i++)
1479 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1482 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1483 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1484 s->last_picture_ptr->f.reference = 3;
1486 if ((s->next_picture_ptr == NULL ||
1487 s->next_picture_ptr->f.data[0] == NULL) &&
1488 s->pict_type == AV_PICTURE_TYPE_B) {
1489 /* Allocate a dummy frame */
1490 i = ff_find_unused_picture(s, 0);
1492 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1495 s->next_picture_ptr = &s->picture[i];
1496 s->next_picture_ptr->f.key_frame = 0;
1497 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1498 s->next_picture_ptr = NULL;
1501 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1502 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1503 s->next_picture_ptr->f.reference = 3;
1507 memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1508 memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1509 if (s->last_picture_ptr)
1510 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1511 if (s->next_picture_ptr)
1512 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1514 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) {
1515 if (s->next_picture_ptr)
1516 s->next_picture_ptr->owner2 = s;
1517 if (s->last_picture_ptr)
1518 s->last_picture_ptr->owner2 = s;
1521 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1522 s->last_picture_ptr->f.data[0]));
1524 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1526 for (i = 0; i < 4; i++) {
1527 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1528 s->current_picture.f.data[i] +=
1529 s->current_picture.f.linesize[i];
1531 s->current_picture.f.linesize[i] *= 2;
1532 s->last_picture.f.linesize[i] *= 2;
1533 s->next_picture.f.linesize[i] *= 2;
1537 s->err_recognition = avctx->err_recognition;
1539 /* set dequantizer, we can't do it during init as
1540 * it might change for mpeg4 and we can't do it in the header
1541 * decode as init is not called for mpeg4 there yet */
1542 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1543 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1544 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1545 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1546 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1547 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1549 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1550 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1553 if (s->dct_error_sum) {
1554 assert(s->avctx->noise_reduction && s->encoding);
1555 update_noise_reduction(s);
1558 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1559 return ff_xvmc_field_start(s, avctx);
1564 /* generic function for encode/decode called after a
1565 * frame has been coded/decoded. */
1566 void ff_MPV_frame_end(MpegEncContext *s)
1569 /* redraw edges for the frame if decoding didn't complete */
1570 // just to make sure that all data is rendered.
1571 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1572 ff_xvmc_field_end(s);
1573 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1574 !s->avctx->hwaccel &&
1575 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1576 s->unrestricted_mv &&
1577 s->current_picture.f.reference &&
1579 !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1582 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1583 int hshift = desc->log2_chroma_w;
1584 int vshift = desc->log2_chroma_h;
1585 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1586 s->h_edge_pos, s->v_edge_pos,
1587 EDGE_WIDTH, EDGE_WIDTH,
1588 EDGE_TOP | EDGE_BOTTOM);
1589 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1590 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1591 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1592 EDGE_TOP | EDGE_BOTTOM);
1593 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1594 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1595 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1596 EDGE_TOP | EDGE_BOTTOM);
1601 s->last_pict_type = s->pict_type;
1602 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1603 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1604 s->last_non_b_pict_type = s->pict_type;
1607 /* copy back current_picture variables */
1608 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1609 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1610 s->picture[i] = s->current_picture;
1614 assert(i < MAX_PICTURE_COUNT);
1618 /* release non-reference frames */
1619 for (i = 0; i < s->picture_count; i++) {
1620 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1621 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1622 free_frame_buffer(s, &s->picture[i]);
1626 // clear copies, to avoid confusion
1628 memset(&s->last_picture, 0, sizeof(Picture));
1629 memset(&s->next_picture, 0, sizeof(Picture));
1630 memset(&s->current_picture, 0, sizeof(Picture));
1632 s->avctx->coded_frame = &s->current_picture_ptr->f;
1634 if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1635 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1640 * Draw a line from (ex, ey) -> (sx, sy).
1641 * @param w width of the image
1642 * @param h height of the image
1643 * @param stride stride/linesize of the image
1644 * @param color color of the arrow
1646 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1647 int w, int h, int stride, int color)
1651 sx = av_clip(sx, 0, w - 1);
1652 sy = av_clip(sy, 0, h - 1);
1653 ex = av_clip(ex, 0, w - 1);
1654 ey = av_clip(ey, 0, h - 1);
1656 buf[sy * stride + sx] += color;
1658 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1660 FFSWAP(int, sx, ex);
1661 FFSWAP(int, sy, ey);
1663 buf += sx + sy * stride;
1665 f = ((ey - sy) << 16) / ex;
1666 for(x= 0; x <= ex; x++){
1668 fr = (x * f) & 0xFFFF;
1669 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1670 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1674 FFSWAP(int, sx, ex);
1675 FFSWAP(int, sy, ey);
1677 buf += sx + sy * stride;
1680 f = ((ex - sx) << 16) / ey;
1683 for(y= 0; y <= ey; y++){
1685 fr = (y*f) & 0xFFFF;
1686 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1687 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1693 * Draw an arrow from (ex, ey) -> (sx, sy).
1694 * @param w width of the image
1695 * @param h height of the image
1696 * @param stride stride/linesize of the image
1697 * @param color color of the arrow
1699 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1700 int ey, int w, int h, int stride, int color)
1704 sx = av_clip(sx, -100, w + 100);
1705 sy = av_clip(sy, -100, h + 100);
1706 ex = av_clip(ex, -100, w + 100);
1707 ey = av_clip(ey, -100, h + 100);
1712 if (dx * dx + dy * dy > 3 * 3) {
1715 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1717 // FIXME subpixel accuracy
1718 rx = ROUNDED_DIV(rx * 3 << 4, length);
1719 ry = ROUNDED_DIV(ry * 3 << 4, length);
1721 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1722 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1724 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1728 * Print debugging info for the given picture.
1730 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1732 if ( s->avctx->hwaccel || !pict || !pict->mb_type
1733 || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1737 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1740 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1741 av_get_picture_type_char(pict->pict_type));
1742 for (y = 0; y < s->mb_height; y++) {
1743 for (x = 0; x < s->mb_width; x++) {
1744 if (s->avctx->debug & FF_DEBUG_SKIP) {
1745 int count = s->mbskip_table[x + y * s->mb_stride];
1748 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1750 if (s->avctx->debug & FF_DEBUG_QP) {
1751 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1752 pict->qscale_table[x + y * s->mb_stride]);
1754 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1755 int mb_type = pict->mb_type[x + y * s->mb_stride];
1756 // Type & MV direction
1757 if (IS_PCM(mb_type))
1758 av_log(s->avctx, AV_LOG_DEBUG, "P");
1759 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1760 av_log(s->avctx, AV_LOG_DEBUG, "A");
1761 else if (IS_INTRA4x4(mb_type))
1762 av_log(s->avctx, AV_LOG_DEBUG, "i");
1763 else if (IS_INTRA16x16(mb_type))
1764 av_log(s->avctx, AV_LOG_DEBUG, "I");
1765 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1766 av_log(s->avctx, AV_LOG_DEBUG, "d");
1767 else if (IS_DIRECT(mb_type))
1768 av_log(s->avctx, AV_LOG_DEBUG, "D");
1769 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1770 av_log(s->avctx, AV_LOG_DEBUG, "g");
1771 else if (IS_GMC(mb_type))
1772 av_log(s->avctx, AV_LOG_DEBUG, "G");
1773 else if (IS_SKIP(mb_type))
1774 av_log(s->avctx, AV_LOG_DEBUG, "S");
1775 else if (!USES_LIST(mb_type, 1))
1776 av_log(s->avctx, AV_LOG_DEBUG, ">");
1777 else if (!USES_LIST(mb_type, 0))
1778 av_log(s->avctx, AV_LOG_DEBUG, "<");
1780 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1781 av_log(s->avctx, AV_LOG_DEBUG, "X");
1785 if (IS_8X8(mb_type))
1786 av_log(s->avctx, AV_LOG_DEBUG, "+");
1787 else if (IS_16X8(mb_type))
1788 av_log(s->avctx, AV_LOG_DEBUG, "-");
1789 else if (IS_8X16(mb_type))
1790 av_log(s->avctx, AV_LOG_DEBUG, "|");
1791 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1792 av_log(s->avctx, AV_LOG_DEBUG, " ");
1794 av_log(s->avctx, AV_LOG_DEBUG, "?");
1797 if (IS_INTERLACED(mb_type))
1798 av_log(s->avctx, AV_LOG_DEBUG, "=");
1800 av_log(s->avctx, AV_LOG_DEBUG, " ");
1803 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1807 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1808 (s->avctx->debug_mv)) {
1809 const int shift = 1 + s->quarter_sample;
1813 int h_chroma_shift, v_chroma_shift, block_height;
1814 const int width = s->avctx->width;
1815 const int height = s->avctx->height;
1816 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1817 const int mv_stride = (s->mb_width << mv_sample_log2) +
1818 (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1819 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1821 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1823 for (i = 0; i < 3; i++) {
1824 size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1825 pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1826 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1827 memcpy(s->visualization_buffer[i], pict->data[i], size);
1828 pict->data[i] = s->visualization_buffer[i];
1830 pict->type = FF_BUFFER_TYPE_COPY;
1832 ptr = pict->data[0];
1833 block_height = 16 >> v_chroma_shift;
1835 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1837 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1838 const int mb_index = mb_x + mb_y * s->mb_stride;
1839 if ((s->avctx->debug_mv) && pict->motion_val[0]) {
1841 for (type = 0; type < 3; type++) {
1845 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1846 (pict->pict_type!= AV_PICTURE_TYPE_P))
1851 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1852 (pict->pict_type!= AV_PICTURE_TYPE_B))
1857 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1858 (pict->pict_type!= AV_PICTURE_TYPE_B))
1863 if (!USES_LIST(pict->mb_type[mb_index], direction))
1866 if (IS_8X8(pict->mb_type[mb_index])) {
1868 for (i = 0; i < 4; i++) {
1869 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1870 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1871 int xy = (mb_x * 2 + (i & 1) +
1872 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1873 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1874 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1875 draw_arrow(ptr, sx, sy, mx, my, width,
1876 height, s->linesize, 100);
1878 } else if (IS_16X8(pict->mb_type[mb_index])) {
1880 for (i = 0; i < 2; i++) {
1881 int sx = mb_x * 16 + 8;
1882 int sy = mb_y * 16 + 4 + 8 * i;
1883 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1884 int mx = (pict->motion_val[direction][xy][0] >> shift);
1885 int my = (pict->motion_val[direction][xy][1] >> shift);
1887 if (IS_INTERLACED(pict->mb_type[mb_index]))
1890 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1891 height, s->linesize, 100);
1893 } else if (IS_8X16(pict->mb_type[mb_index])) {
1895 for (i = 0; i < 2; i++) {
1896 int sx = mb_x * 16 + 4 + 8 * i;
1897 int sy = mb_y * 16 + 8;
1898 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1899 int mx = pict->motion_val[direction][xy][0] >> shift;
1900 int my = pict->motion_val[direction][xy][1] >> shift;
1902 if (IS_INTERLACED(pict->mb_type[mb_index]))
1905 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1906 height, s->linesize, 100);
1909 int sx= mb_x * 16 + 8;
1910 int sy= mb_y * 16 + 8;
1911 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1912 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1913 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1914 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1918 if ((s->avctx->debug & FF_DEBUG_VIS_QP)) {
1919 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1920 0x0101010101010101ULL;
1922 for (y = 0; y < block_height; y++) {
1923 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1924 (block_height * mb_y + y) *
1925 pict->linesize[1]) = c;
1926 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1927 (block_height * mb_y + y) *
1928 pict->linesize[2]) = c;
1931 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1932 pict->motion_val[0]) {
1933 int mb_type = pict->mb_type[mb_index];
1936 #define COLOR(theta, r) \
1937 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1938 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1942 if (IS_PCM(mb_type)) {
1944 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1945 IS_INTRA16x16(mb_type)) {
1947 } else if (IS_INTRA4x4(mb_type)) {
1949 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1951 } else if (IS_DIRECT(mb_type)) {
1953 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1955 } else if (IS_GMC(mb_type)) {
1957 } else if (IS_SKIP(mb_type)) {
1959 } else if (!USES_LIST(mb_type, 1)) {
1961 } else if (!USES_LIST(mb_type, 0)) {
1964 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1968 u *= 0x0101010101010101ULL;
1969 v *= 0x0101010101010101ULL;
1970 for (y = 0; y < block_height; y++) {
1971 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1972 (block_height * mb_y + y) * pict->linesize[1]) = u;
1973 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1974 (block_height * mb_y + y) * pict->linesize[2]) = v;
1978 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1979 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1980 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1981 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1982 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1984 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1985 for (y = 0; y < 16; y++)
1986 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1987 pict->linesize[0]] ^= 0x80;
1989 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1990 int dm = 1 << (mv_sample_log2 - 2);
1991 for (i = 0; i < 4; i++) {
1992 int sx = mb_x * 16 + 8 * (i & 1);
1993 int sy = mb_y * 16 + 8 * (i >> 1);
1994 int xy = (mb_x * 2 + (i & 1) +
1995 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1997 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1998 if (mv[0] != mv[dm] ||
1999 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2000 for (y = 0; y < 8; y++)
2001 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2002 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2003 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2004 pict->linesize[0]) ^= 0x8080808080808080ULL;
2008 if (IS_INTERLACED(mb_type) &&
2009 s->codec_id == AV_CODEC_ID_H264) {
2013 s->mbskip_table[mb_index] = 0;
2019 static inline int hpel_motion_lowres(MpegEncContext *s,
2020 uint8_t *dest, uint8_t *src,
2021 int field_based, int field_select,
2022 int src_x, int src_y,
2023 int width, int height, int stride,
2024 int h_edge_pos, int v_edge_pos,
2025 int w, int h, h264_chroma_mc_func *pix_op,
2026 int motion_x, int motion_y)
2028 const int lowres = s->avctx->lowres;
2029 const int op_index = FFMIN(lowres, 2);
2030 const int s_mask = (2 << lowres) - 1;
2034 if (s->quarter_sample) {
2039 sx = motion_x & s_mask;
2040 sy = motion_y & s_mask;
2041 src_x += motion_x >> lowres + 1;
2042 src_y += motion_y >> lowres + 1;
2044 src += src_y * stride + src_x;
2046 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2047 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2048 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2049 (h + 1) << field_based, src_x,
2050 src_y << field_based,
2053 src = s->edge_emu_buffer;
2057 sx = (sx << 2) >> lowres;
2058 sy = (sy << 2) >> lowres;
2061 pix_op[op_index](dest, src, stride, h, sx, sy);
2065 /* apply one mpeg motion vector to the three components */
2066 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2073 uint8_t **ref_picture,
2074 h264_chroma_mc_func *pix_op,
2075 int motion_x, int motion_y,
2078 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2079 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2081 const int lowres = s->avctx->lowres;
2082 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
2083 const int block_s = 8>>lowres;
2084 const int s_mask = (2 << lowres) - 1;
2085 const int h_edge_pos = s->h_edge_pos >> lowres;
2086 const int v_edge_pos = s->v_edge_pos >> lowres;
2087 linesize = s->current_picture.f.linesize[0] << field_based;
2088 uvlinesize = s->current_picture.f.linesize[1] << field_based;
2090 // FIXME obviously not perfect but qpel will not work in lowres anyway
2091 if (s->quarter_sample) {
2097 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2100 sx = motion_x & s_mask;
2101 sy = motion_y & s_mask;
2102 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2103 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2105 if (s->out_format == FMT_H263) {
2106 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2107 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2108 uvsrc_x = src_x >> 1;
2109 uvsrc_y = src_y >> 1;
2110 } else if (s->out_format == FMT_H261) {
2111 // even chroma mv's are full pel in H261
2114 uvsx = (2 * mx) & s_mask;
2115 uvsy = (2 * my) & s_mask;
2116 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2117 uvsrc_y = mb_y * block_s + (my >> lowres);
2119 if(s->chroma_y_shift){
2124 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2125 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2127 if(s->chroma_x_shift){
2131 uvsy = motion_y & s_mask;
2133 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2136 uvsx = motion_x & s_mask;
2137 uvsy = motion_y & s_mask;
2144 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2145 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2146 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2148 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
2149 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2150 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2151 linesize >> field_based, 17, 17 + field_based,
2152 src_x, src_y << field_based, h_edge_pos,
2154 ptr_y = s->edge_emu_buffer;
2155 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2156 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2157 s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2159 uvsrc_x, uvsrc_y << field_based,
2160 h_edge_pos >> 1, v_edge_pos >> 1);
2161 s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2163 uvsrc_x, uvsrc_y << field_based,
2164 h_edge_pos >> 1, v_edge_pos >> 1);
2166 ptr_cr = uvbuf + 16;
2170 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2172 dest_y += s->linesize;
2173 dest_cb += s->uvlinesize;
2174 dest_cr += s->uvlinesize;
2178 ptr_y += s->linesize;
2179 ptr_cb += s->uvlinesize;
2180 ptr_cr += s->uvlinesize;
2183 sx = (sx << 2) >> lowres;
2184 sy = (sy << 2) >> lowres;
2185 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2187 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2188 uvsx = (uvsx << 2) >> lowres;
2189 uvsy = (uvsy << 2) >> lowres;
2190 if (h >> s->chroma_y_shift) {
2191 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2192 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2195 // FIXME h261 lowres loop filter
2198 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2199 uint8_t *dest_cb, uint8_t *dest_cr,
2200 uint8_t **ref_picture,
2201 h264_chroma_mc_func * pix_op,
2204 const int lowres = s->avctx->lowres;
2205 const int op_index = FFMIN(lowres, 2);
2206 const int block_s = 8 >> lowres;
2207 const int s_mask = (2 << lowres) - 1;
2208 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2209 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2210 int emu = 0, src_x, src_y, offset, sx, sy;
2213 if (s->quarter_sample) {
2218 /* In case of 8X8, we construct a single chroma motion vector
2219 with a special rounding */
2220 mx = ff_h263_round_chroma(mx);
2221 my = ff_h263_round_chroma(my);
2225 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2226 src_y = s->mb_y * block_s + (my >> lowres + 1);
2228 offset = src_y * s->uvlinesize + src_x;
2229 ptr = ref_picture[1] + offset;
2230 if (s->flags & CODEC_FLAG_EMU_EDGE) {
2231 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2232 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2233 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2234 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2235 ptr = s->edge_emu_buffer;
2239 sx = (sx << 2) >> lowres;
2240 sy = (sy << 2) >> lowres;
2241 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2243 ptr = ref_picture[2] + offset;
2245 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2246 src_x, src_y, h_edge_pos, v_edge_pos);
2247 ptr = s->edge_emu_buffer;
2249 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2253 * motion compensation of a single macroblock
2255 * @param dest_y luma destination pointer
2256 * @param dest_cb chroma cb/u destination pointer
2257 * @param dest_cr chroma cr/v destination pointer
2258 * @param dir direction (0->forward, 1->backward)
2259 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2260 * @param pix_op halfpel motion compensation function (average or put normally)
2261 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2263 static inline void MPV_motion_lowres(MpegEncContext *s,
2264 uint8_t *dest_y, uint8_t *dest_cb,
2266 int dir, uint8_t **ref_picture,
2267 h264_chroma_mc_func *pix_op)
2271 const int lowres = s->avctx->lowres;
2272 const int block_s = 8 >>lowres;
2277 switch (s->mv_type) {
2279 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2281 ref_picture, pix_op,
2282 s->mv[dir][0][0], s->mv[dir][0][1],
2288 for (i = 0; i < 4; i++) {
2289 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2290 s->linesize) * block_s,
2291 ref_picture[0], 0, 0,
2292 (2 * mb_x + (i & 1)) * block_s,
2293 (2 * mb_y + (i >> 1)) * block_s,
2294 s->width, s->height, s->linesize,
2295 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2296 block_s, block_s, pix_op,
2297 s->mv[dir][i][0], s->mv[dir][i][1]);
2299 mx += s->mv[dir][i][0];
2300 my += s->mv[dir][i][1];
2303 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2304 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2308 if (s->picture_structure == PICT_FRAME) {
2310 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2311 1, 0, s->field_select[dir][0],
2312 ref_picture, pix_op,
2313 s->mv[dir][0][0], s->mv[dir][0][1],
2316 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2317 1, 1, s->field_select[dir][1],
2318 ref_picture, pix_op,
2319 s->mv[dir][1][0], s->mv[dir][1][1],
2322 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2323 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2324 ref_picture = s->current_picture_ptr->f.data;
2327 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2328 0, 0, s->field_select[dir][0],
2329 ref_picture, pix_op,
2331 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2335 for (i = 0; i < 2; i++) {
2336 uint8_t **ref2picture;
2338 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2339 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2340 ref2picture = ref_picture;
2342 ref2picture = s->current_picture_ptr->f.data;
2345 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2346 0, 0, s->field_select[dir][i],
2347 ref2picture, pix_op,
2348 s->mv[dir][i][0], s->mv[dir][i][1] +
2349 2 * block_s * i, block_s, mb_y >> 1);
2351 dest_y += 2 * block_s * s->linesize;
2352 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2353 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2357 if (s->picture_structure == PICT_FRAME) {
2358 for (i = 0; i < 2; i++) {
2360 for (j = 0; j < 2; j++) {
2361 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2363 ref_picture, pix_op,
2364 s->mv[dir][2 * i + j][0],
2365 s->mv[dir][2 * i + j][1],
2368 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2371 for (i = 0; i < 2; i++) {
2372 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2373 0, 0, s->picture_structure != i + 1,
2374 ref_picture, pix_op,
2375 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2376 2 * block_s, mb_y >> 1);
2378 // after put we make avg of the same block
2379 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2381 // opposite parity is always in the same
2382 // frame if this is second field
2383 if (!s->first_field) {
2384 ref_picture = s->current_picture_ptr->f.data;
2395 * find the lowest MB row referenced in the MVs
2397 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2399 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2400 int my, off, i, mvs;
2402 if (s->picture_structure != PICT_FRAME || s->mcsel)
2405 switch (s->mv_type) {
2419 for (i = 0; i < mvs; i++) {
2420 my = s->mv[dir][i][1]<<qpel_shift;
2421 my_max = FFMAX(my_max, my);
2422 my_min = FFMIN(my_min, my);
2425 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2427 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2429 return s->mb_height-1;
2432 /* put block[] to dest[] */
2433 static inline void put_dct(MpegEncContext *s,
2434 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2436 s->dct_unquantize_intra(s, block, i, qscale);
2437 s->dsp.idct_put (dest, line_size, block);
2440 /* add block[] to dest[] */
2441 static inline void add_dct(MpegEncContext *s,
2442 DCTELEM *block, int i, uint8_t *dest, int line_size)
2444 if (s->block_last_index[i] >= 0) {
2445 s->dsp.idct_add (dest, line_size, block);
2449 static inline void add_dequant_dct(MpegEncContext *s,
2450 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2452 if (s->block_last_index[i] >= 0) {
2453 s->dct_unquantize_inter(s, block, i, qscale);
2455 s->dsp.idct_add (dest, line_size, block);
2460 * Clean dc, ac, coded_block for the current non-intra MB.
2462 void ff_clean_intra_table_entries(MpegEncContext *s)
2464 int wrap = s->b8_stride;
2465 int xy = s->block_index[0];
2468 s->dc_val[0][xy + 1 ] =
2469 s->dc_val[0][xy + wrap] =
2470 s->dc_val[0][xy + 1 + wrap] = 1024;
2472 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2473 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2474 if (s->msmpeg4_version>=3) {
2475 s->coded_block[xy ] =
2476 s->coded_block[xy + 1 ] =
2477 s->coded_block[xy + wrap] =
2478 s->coded_block[xy + 1 + wrap] = 0;
2481 wrap = s->mb_stride;
2482 xy = s->mb_x + s->mb_y * wrap;
2484 s->dc_val[2][xy] = 1024;
2486 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2487 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2489 s->mbintra_table[xy]= 0;
2492 /* generic function called after a macroblock has been parsed by the
2493 decoder or after it has been encoded by the encoder.
2495 Important variables used:
2496 s->mb_intra : true if intra macroblock
2497 s->mv_dir : motion vector direction
2498 s->mv_type : motion vector type
2499 s->mv : motion vector
2500 s->interlaced_dct : true if interlaced dct used (mpeg2)
2502 static av_always_inline
2503 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2504 int lowres_flag, int is_mpeg12)
2506 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2507 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2508 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2512 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2513 /* save DCT coefficients */
2515 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2516 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2518 for(j=0; j<64; j++){
2519 *dct++ = block[i][s->dsp.idct_permutation[j]];
2520 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2522 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2526 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2528 /* update DC predictors for P macroblocks */
2530 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2531 if(s->mbintra_table[mb_xy])
2532 ff_clean_intra_table_entries(s);
2536 s->last_dc[2] = 128 << s->intra_dc_precision;
2539 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2540 s->mbintra_table[mb_xy]=1;
2542 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
2543 uint8_t *dest_y, *dest_cb, *dest_cr;
2544 int dct_linesize, dct_offset;
2545 op_pixels_func (*op_pix)[4];
2546 qpel_mc_func (*op_qpix)[16];
2547 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2548 const int uvlinesize = s->current_picture.f.linesize[1];
2549 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2550 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2552 /* avoid copy if macroblock skipped in last frame too */
2553 /* skip only during decoding as we might trash the buffers during encoding a bit */
2555 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2557 if (s->mb_skipped) {
2559 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2561 } else if(!s->current_picture.f.reference) {
2564 *mbskip_ptr = 0; /* not skipped */
2568 dct_linesize = linesize << s->interlaced_dct;
2569 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2573 dest_cb= s->dest[1];
2574 dest_cr= s->dest[2];
2576 dest_y = s->b_scratchpad;
2577 dest_cb= s->b_scratchpad+16*linesize;
2578 dest_cr= s->b_scratchpad+32*linesize;
2582 /* motion handling */
2583 /* decoding or more than one mb_type (MC was already done otherwise) */
2586 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2587 if (s->mv_dir & MV_DIR_FORWARD) {
2588 ff_thread_await_progress(&s->last_picture_ptr->f,
2589 ff_MPV_lowest_referenced_row(s, 0),
2592 if (s->mv_dir & MV_DIR_BACKWARD) {
2593 ff_thread_await_progress(&s->next_picture_ptr->f,
2594 ff_MPV_lowest_referenced_row(s, 1),
2600 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2602 if (s->mv_dir & MV_DIR_FORWARD) {
2603 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2604 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2606 if (s->mv_dir & MV_DIR_BACKWARD) {
2607 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2610 op_qpix= s->me.qpel_put;
2611 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2612 op_pix = s->dsp.put_pixels_tab;
2614 op_pix = s->dsp.put_no_rnd_pixels_tab;
2616 if (s->mv_dir & MV_DIR_FORWARD) {
2617 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2618 op_pix = s->dsp.avg_pixels_tab;
2619 op_qpix= s->me.qpel_avg;
2621 if (s->mv_dir & MV_DIR_BACKWARD) {
2622 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2627 /* skip dequant / idct if we are really late ;) */
2628 if(s->avctx->skip_idct){
2629 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2630 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2631 || s->avctx->skip_idct >= AVDISCARD_ALL)
2635 /* add dct residue */
2636 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2637 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2638 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2639 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2640 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2641 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2643 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2644 if (s->chroma_y_shift){
2645 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2646 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2650 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2651 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2652 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2653 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2656 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2657 add_dct(s, block[0], 0, dest_y , dct_linesize);
2658 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2659 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2660 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2662 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2663 if(s->chroma_y_shift){//Chroma420
2664 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2665 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2668 dct_linesize = uvlinesize << s->interlaced_dct;
2669 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2671 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2672 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2673 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2674 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2675 if(!s->chroma_x_shift){//Chroma444
2676 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2677 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2678 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2679 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2684 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2685 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2688 /* dct only in intra block */
2689 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2690 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2691 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2692 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2693 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2695 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2696 if(s->chroma_y_shift){
2697 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2698 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2702 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2703 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2704 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2705 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2709 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2710 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2711 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2712 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2714 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2715 if(s->chroma_y_shift){
2716 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2717 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2720 dct_linesize = uvlinesize << s->interlaced_dct;
2721 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2723 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2724 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2725 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2726 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2727 if(!s->chroma_x_shift){//Chroma444
2728 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2729 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2730 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2731 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2739 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2740 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2741 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2746 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2748 if(s->out_format == FMT_MPEG1) {
2749 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2750 else MPV_decode_mb_internal(s, block, 0, 1);
2753 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2754 else MPV_decode_mb_internal(s, block, 0, 0);
2758 * @param h is the normal height, this will be reduced automatically if needed for the last row
2760 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2761 const int field_pic= s->picture_structure != PICT_FRAME;
2767 if (!s->avctx->hwaccel
2768 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2769 && s->unrestricted_mv
2770 && s->current_picture.f.reference
2772 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2773 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
2774 int sides = 0, edge_h;
2775 int hshift = desc->log2_chroma_w;
2776 int vshift = desc->log2_chroma_h;
2777 if (y==0) sides |= EDGE_TOP;
2778 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2780 edge_h= FFMIN(h, s->v_edge_pos - y);
2782 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2783 s->linesize, s->h_edge_pos, edge_h,
2784 EDGE_WIDTH, EDGE_WIDTH, sides);
2785 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2786 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2787 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2788 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2789 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2790 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2793 h= FFMIN(h, s->avctx->height - y);
2795 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2797 if (s->avctx->draw_horiz_band) {
2799 int offset[AV_NUM_DATA_POINTERS];
2802 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2803 src = &s->current_picture_ptr->f;
2804 else if(s->last_picture_ptr)
2805 src = &s->last_picture_ptr->f;
2809 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2810 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2813 offset[0]= y * s->linesize;
2815 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2816 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2822 s->avctx->draw_horiz_band(s->avctx, src, offset,
2823 y, s->picture_structure, h);
2827 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2828 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2829 const int uvlinesize = s->current_picture.f.linesize[1];
2830 const int mb_size= 4 - s->avctx->lowres;
2832 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2833 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2834 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2835 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2836 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2837 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;
2838 //block_index is not used by mpeg2, so it is not affected by chroma_format
2840 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2841 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2842 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2844 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2846 if(s->picture_structure==PICT_FRAME){
2847 s->dest[0] += s->mb_y * linesize << mb_size;
2848 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2849 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2851 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2852 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2853 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2854 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2859 void ff_mpeg_flush(AVCodecContext *avctx){
2861 MpegEncContext *s = avctx->priv_data;
2863 if(s==NULL || s->picture==NULL)
2866 for(i=0; i<s->picture_count; i++){
2867 if (s->picture[i].f.data[0] &&
2868 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2869 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2870 free_frame_buffer(s, &s->picture[i]);
2872 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2874 s->mb_x= s->mb_y= 0;
2877 s->parse_context.state= -1;
2878 s->parse_context.frame_start_found= 0;
2879 s->parse_context.overread= 0;
2880 s->parse_context.overread_index= 0;
2881 s->parse_context.index= 0;
2882 s->parse_context.last_index= 0;
2883 s->bitstream_buffer_size=0;
2887 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2888 DCTELEM *block, int n, int qscale)
2890 int i, level, nCoeffs;
2891 const uint16_t *quant_matrix;
2893 nCoeffs= s->block_last_index[n];
2895 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2896 /* XXX: only mpeg1 */
2897 quant_matrix = s->intra_matrix;
2898 for(i=1;i<=nCoeffs;i++) {
2899 int j= s->intra_scantable.permutated[i];
2904 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2905 level = (level - 1) | 1;
2908 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2909 level = (level - 1) | 1;
2916 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2917 DCTELEM *block, int n, int qscale)
2919 int i, level, nCoeffs;
2920 const uint16_t *quant_matrix;
2922 nCoeffs= s->block_last_index[n];
2924 quant_matrix = s->inter_matrix;
2925 for(i=0; i<=nCoeffs; i++) {
2926 int j= s->intra_scantable.permutated[i];
2931 level = (((level << 1) + 1) * qscale *
2932 ((int) (quant_matrix[j]))) >> 4;
2933 level = (level - 1) | 1;
2936 level = (((level << 1) + 1) * qscale *
2937 ((int) (quant_matrix[j]))) >> 4;
2938 level = (level - 1) | 1;
2945 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2946 DCTELEM *block, int n, int qscale)
2948 int i, level, nCoeffs;
2949 const uint16_t *quant_matrix;
2951 if(s->alternate_scan) nCoeffs= 63;
2952 else nCoeffs= s->block_last_index[n];
2954 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2955 quant_matrix = s->intra_matrix;
2956 for(i=1;i<=nCoeffs;i++) {
2957 int j= s->intra_scantable.permutated[i];
2962 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2965 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2972 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2973 DCTELEM *block, int n, int qscale)
2975 int i, level, nCoeffs;
2976 const uint16_t *quant_matrix;
2979 if(s->alternate_scan) nCoeffs= 63;
2980 else nCoeffs= s->block_last_index[n];
2982 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2984 quant_matrix = s->intra_matrix;
2985 for(i=1;i<=nCoeffs;i++) {
2986 int j= s->intra_scantable.permutated[i];
2991 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2994 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3003 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
3004 DCTELEM *block, int n, int qscale)
3006 int i, level, nCoeffs;
3007 const uint16_t *quant_matrix;
3010 if(s->alternate_scan) nCoeffs= 63;
3011 else nCoeffs= s->block_last_index[n];
3013 quant_matrix = s->inter_matrix;
3014 for(i=0; i<=nCoeffs; i++) {
3015 int j= s->intra_scantable.permutated[i];
3020 level = (((level << 1) + 1) * qscale *
3021 ((int) (quant_matrix[j]))) >> 4;
3024 level = (((level << 1) + 1) * qscale *
3025 ((int) (quant_matrix[j]))) >> 4;
3034 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3035 DCTELEM *block, int n, int qscale)
3037 int i, level, qmul, qadd;
3040 assert(s->block_last_index[n]>=0);
3045 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3046 qadd = (qscale - 1) | 1;
3053 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3055 for(i=1; i<=nCoeffs; i++) {
3059 level = level * qmul - qadd;
3061 level = level * qmul + qadd;
3068 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3069 DCTELEM *block, int n, int qscale)
3071 int i, level, qmul, qadd;
3074 assert(s->block_last_index[n]>=0);
3076 qadd = (qscale - 1) | 1;
3079 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3081 for(i=0; i<=nCoeffs; i++) {
3085 level = level * qmul - qadd;
3087 level = level * qmul + qadd;
3095 * set qscale and update qscale dependent variables.
3097 void ff_set_qscale(MpegEncContext * s, int qscale)
3101 else if (qscale > 31)
3105 s->chroma_qscale= s->chroma_qscale_table[qscale];
3107 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3108 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3111 void ff_MPV_report_decode_progress(MpegEncContext *s)
3113 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
3114 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);