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 int16_t *block, int n, int qscale);
47 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
48 int16_t *block, int n, int qscale);
49 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
50 int16_t *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
52 int16_t *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
54 int16_t *block, int n, int qscale);
55 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
56 int16_t *block, int n, int qscale);
57 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
58 int16_t *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(int16_t) * 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(int16_t), 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){
588 memset(s, 0, sizeof(MpegEncContext));
595 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
596 s->context_reinit = 0;
597 s->height = s1->height;
598 s->width = s1->width;
599 if ((err = ff_MPV_common_frame_size_change(s)) < 0)
603 s->avctx->coded_height = s1->avctx->coded_height;
604 s->avctx->coded_width = s1->avctx->coded_width;
605 s->avctx->width = s1->avctx->width;
606 s->avctx->height = s1->avctx->height;
608 s->coded_picture_number = s1->coded_picture_number;
609 s->picture_number = s1->picture_number;
610 s->input_picture_number = s1->input_picture_number;
612 av_assert0(!s->picture || s->picture != s1->picture);
613 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
614 memcpy(&s->last_picture, &s1->last_picture,
615 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
617 // reset s->picture[].f.extended_data to s->picture[].f.data
618 for (i = 0; i < s->picture_count; i++) {
619 s->picture[i].f.extended_data = s->picture[i].f.data;
620 s->picture[i].period_since_free ++;
623 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
624 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
625 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
627 // Error/bug resilience
628 s->next_p_frame_damaged = s1->next_p_frame_damaged;
629 s->workaround_bugs = s1->workaround_bugs;
630 s->padding_bug_score = s1->padding_bug_score;
633 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
634 (char *) &s1->shape - (char *) &s1->time_increment_bits);
637 s->max_b_frames = s1->max_b_frames;
638 s->low_delay = s1->low_delay;
639 s->droppable = s1->droppable;
641 // DivX handling (doesn't work)
642 s->divx_packed = s1->divx_packed;
644 if (s1->bitstream_buffer) {
645 if (s1->bitstream_buffer_size +
646 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
647 av_fast_malloc(&s->bitstream_buffer,
648 &s->allocated_bitstream_buffer_size,
649 s1->allocated_bitstream_buffer_size);
650 s->bitstream_buffer_size = s1->bitstream_buffer_size;
651 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
652 s1->bitstream_buffer_size);
653 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
654 FF_INPUT_BUFFER_PADDING_SIZE);
657 // linesize dependend scratch buffer allocation
658 if (!s->edge_emu_buffer)
660 if (ff_mpv_frame_size_alloc(s, s1->linesize) < 0) {
661 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
662 "scratch buffers.\n");
663 return AVERROR(ENOMEM);
666 av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
667 "be allocated due to unknown size.\n");
670 // MPEG2/interlacing info
671 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
672 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
674 if (!s1->first_field) {
675 s->last_pict_type = s1->pict_type;
676 if (s1->current_picture_ptr)
677 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
679 if (s1->pict_type != AV_PICTURE_TYPE_B) {
680 s->last_non_b_pict_type = s1->pict_type;
688 * Set the given MpegEncContext to common defaults
689 * (same for encoding and decoding).
690 * The changed fields will not depend upon the
691 * prior state of the MpegEncContext.
693 void ff_MPV_common_defaults(MpegEncContext *s)
695 s->y_dc_scale_table =
696 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
697 s->chroma_qscale_table = ff_default_chroma_qscale_table;
698 s->progressive_frame = 1;
699 s->progressive_sequence = 1;
700 s->picture_structure = PICT_FRAME;
702 s->coded_picture_number = 0;
703 s->picture_number = 0;
704 s->input_picture_number = 0;
706 s->picture_in_gop_number = 0;
711 s->picture_range_start = 0;
712 s->picture_range_end = MAX_PICTURE_COUNT;
714 s->slice_context_count = 1;
718 * Set the given MpegEncContext to defaults for decoding.
719 * the changed fields will not depend upon
720 * the prior state of the MpegEncContext.
722 void ff_MPV_decode_defaults(MpegEncContext *s)
724 ff_MPV_common_defaults(s);
728 * Initialize and allocates MpegEncContext fields dependent on the resolution.
730 static int init_context_frame(MpegEncContext *s)
732 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
734 s->mb_width = (s->width + 15) / 16;
735 s->mb_stride = s->mb_width + 1;
736 s->b8_stride = s->mb_width * 2 + 1;
737 s->b4_stride = s->mb_width * 4 + 1;
738 mb_array_size = s->mb_height * s->mb_stride;
739 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
741 /* set default edge pos, will be overriden
742 * in decode_header if needed */
743 s->h_edge_pos = s->mb_width * 16;
744 s->v_edge_pos = s->mb_height * 16;
746 s->mb_num = s->mb_width * s->mb_height;
751 s->block_wrap[3] = s->b8_stride;
753 s->block_wrap[5] = s->mb_stride;
755 y_size = s->b8_stride * (2 * s->mb_height + 1);
756 c_size = s->mb_stride * (s->mb_height + 1);
757 yc_size = y_size + 2 * c_size;
759 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
760 for (y = 0; y < s->mb_height; y++)
761 for (x = 0; x < s->mb_width; x++)
762 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
764 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
767 /* Allocate MV tables */
768 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
769 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
770 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
771 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
772 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
773 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
774 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
775 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
776 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
777 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
778 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
779 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
781 /* Allocate MB type table */
782 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
784 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
786 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
787 mb_array_size * sizeof(float), fail);
788 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
789 mb_array_size * sizeof(float), fail);
793 FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
794 mb_array_size * sizeof(uint8_t), fail);
795 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
796 mb_array_size * sizeof(uint8_t), fail);
798 if (s->codec_id == AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)) {
799 /* interlaced direct mode decoding tables */
800 for (i = 0; i < 2; i++) {
802 for (j = 0; j < 2; j++) {
803 for (k = 0; k < 2; k++) {
804 FF_ALLOCZ_OR_GOTO(s->avctx,
805 s->b_field_mv_table_base[i][j][k],
806 mv_table_size * 2 * sizeof(int16_t),
808 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
811 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
812 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
813 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
815 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
818 if (s->out_format == FMT_H263) {
820 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
821 s->coded_block = s->coded_block_base + s->b8_stride + 1;
823 /* cbp, ac_pred, pred_dir */
824 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
825 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
828 if (s->h263_pred || s->h263_plus || !s->encoding) {
830 // MN: we need these for error resilience of intra-frames
831 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
832 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
833 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
834 s->dc_val[2] = s->dc_val[1] + c_size;
835 for (i = 0; i < yc_size; i++)
836 s->dc_val_base[i] = 1024;
839 /* which mb is a intra block */
840 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
841 memset(s->mbintra_table, 1, mb_array_size);
843 /* init macroblock skip table */
844 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
845 // Note the + 1 is for a quicker mpeg4 slice_end detection
849 return AVERROR(ENOMEM);
853 * init common structure for both encoder and decoder.
854 * this assumes that some variables like width/height are already set
856 av_cold int ff_MPV_common_init(MpegEncContext *s)
859 int nb_slices = (HAVE_THREADS &&
860 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
861 s->avctx->thread_count : 1;
863 if (s->encoding && s->avctx->slices)
864 nb_slices = s->avctx->slices;
866 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
867 s->mb_height = (s->height + 31) / 32 * 2;
868 else if (s->codec_id != AV_CODEC_ID_H264)
869 s->mb_height = (s->height + 15) / 16;
871 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
872 av_log(s->avctx, AV_LOG_ERROR,
873 "decoding to AV_PIX_FMT_NONE is not supported.\n");
877 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
880 max_slices = FFMIN(MAX_THREADS, s->mb_height);
882 max_slices = MAX_THREADS;
883 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
884 " reducing to %d\n", nb_slices, max_slices);
885 nb_slices = max_slices;
888 if ((s->width || s->height) &&
889 av_image_check_size(s->width, s->height, 0, s->avctx))
892 ff_dct_common_init(s);
894 s->flags = s->avctx->flags;
895 s->flags2 = s->avctx->flags2;
897 /* set chroma shifts */
898 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
900 /* convert fourcc to upper case */
901 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
902 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
904 s->avctx->coded_frame = &s->current_picture.f;
907 if (s->msmpeg4_version) {
908 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
909 2 * 2 * (MAX_LEVEL + 1) *
910 (MAX_RUN + 1) * 2 * sizeof(int), fail);
912 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
914 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail)
915 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail)
916 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail)
917 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
918 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
919 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
920 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
921 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
923 if (s->avctx->noise_reduction) {
924 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
928 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
929 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
930 s->picture_count * sizeof(Picture), fail);
931 for (i = 0; i < s->picture_count; i++) {
932 avcodec_get_frame_defaults(&s->picture[i].f);
935 if (init_context_frame(s))
938 s->parse_context.state = -1;
940 s->context_initialized = 1;
941 s->thread_context[0] = s;
943 // if (s->width && s->height) {
945 for (i = 1; i < nb_slices; i++) {
946 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
947 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
950 for (i = 0; i < nb_slices; i++) {
951 if (init_duplicate_context(s->thread_context[i], s) < 0)
953 s->thread_context[i]->start_mb_y =
954 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
955 s->thread_context[i]->end_mb_y =
956 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
959 if (init_duplicate_context(s, s) < 0)
962 s->end_mb_y = s->mb_height;
964 s->slice_context_count = nb_slices;
969 ff_MPV_common_end(s);
974 * Frees and resets MpegEncContext fields depending on the resolution.
975 * Is used during resolution changes to avoid a full reinitialization of the
978 static int free_context_frame(MpegEncContext *s)
982 av_freep(&s->mb_type);
983 av_freep(&s->p_mv_table_base);
984 av_freep(&s->b_forw_mv_table_base);
985 av_freep(&s->b_back_mv_table_base);
986 av_freep(&s->b_bidir_forw_mv_table_base);
987 av_freep(&s->b_bidir_back_mv_table_base);
988 av_freep(&s->b_direct_mv_table_base);
989 s->p_mv_table = NULL;
990 s->b_forw_mv_table = NULL;
991 s->b_back_mv_table = NULL;
992 s->b_bidir_forw_mv_table = NULL;
993 s->b_bidir_back_mv_table = NULL;
994 s->b_direct_mv_table = NULL;
995 for (i = 0; i < 2; i++) {
996 for (j = 0; j < 2; j++) {
997 for (k = 0; k < 2; k++) {
998 av_freep(&s->b_field_mv_table_base[i][j][k]);
999 s->b_field_mv_table[i][j][k] = NULL;
1001 av_freep(&s->b_field_select_table[i][j]);
1002 av_freep(&s->p_field_mv_table_base[i][j]);
1003 s->p_field_mv_table[i][j] = NULL;
1005 av_freep(&s->p_field_select_table[i]);
1008 av_freep(&s->dc_val_base);
1009 av_freep(&s->coded_block_base);
1010 av_freep(&s->mbintra_table);
1011 av_freep(&s->cbp_table);
1012 av_freep(&s->pred_dir_table);
1014 av_freep(&s->mbskip_table);
1016 av_freep(&s->error_status_table);
1017 av_freep(&s->er_temp_buffer);
1018 av_freep(&s->mb_index2xy);
1019 av_freep(&s->lambda_table);
1021 av_freep(&s->cplx_tab);
1022 av_freep(&s->bits_tab);
1024 s->linesize = s->uvlinesize = 0;
1026 for (i = 0; i < 3; i++)
1027 av_freep(&s->visualization_buffer[i]);
1032 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1036 if (s->slice_context_count > 1) {
1037 for (i = 0; i < s->slice_context_count; i++) {
1038 free_duplicate_context(s->thread_context[i]);
1040 for (i = 1; i < s->slice_context_count; i++) {
1041 av_freep(&s->thread_context[i]);
1044 free_duplicate_context(s);
1046 free_context_frame(s);
1049 for (i = 0; i < s->picture_count; i++) {
1050 s->picture[i].needs_realloc = 1;
1053 s->last_picture_ptr =
1054 s->next_picture_ptr =
1055 s->current_picture_ptr = NULL;
1058 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1059 s->mb_height = (s->height + 31) / 32 * 2;
1060 else if (s->codec_id != AV_CODEC_ID_H264)
1061 s->mb_height = (s->height + 15) / 16;
1063 if ((s->width || s->height) &&
1064 av_image_check_size(s->width, s->height, 0, s->avctx))
1065 return AVERROR_INVALIDDATA;
1067 if ((err = init_context_frame(s)))
1070 s->thread_context[0] = s;
1072 if (s->width && s->height) {
1073 int nb_slices = s->slice_context_count;
1074 if (nb_slices > 1) {
1075 for (i = 1; i < nb_slices; i++) {
1076 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1077 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1080 for (i = 0; i < nb_slices; i++) {
1081 if (init_duplicate_context(s->thread_context[i], s) < 0)
1083 s->thread_context[i]->start_mb_y =
1084 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1085 s->thread_context[i]->end_mb_y =
1086 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1089 if (init_duplicate_context(s, s) < 0)
1092 s->end_mb_y = s->mb_height;
1094 s->slice_context_count = nb_slices;
1099 ff_MPV_common_end(s);
1103 /* init common structure for both encoder and decoder */
1104 void ff_MPV_common_end(MpegEncContext *s)
1108 if (s->slice_context_count > 1) {
1109 for (i = 0; i < s->slice_context_count; i++) {
1110 free_duplicate_context(s->thread_context[i]);
1112 for (i = 1; i < s->slice_context_count; i++) {
1113 av_freep(&s->thread_context[i]);
1115 s->slice_context_count = 1;
1116 } else free_duplicate_context(s);
1118 av_freep(&s->parse_context.buffer);
1119 s->parse_context.buffer_size = 0;
1121 av_freep(&s->bitstream_buffer);
1122 s->allocated_bitstream_buffer_size = 0;
1124 av_freep(&s->avctx->stats_out);
1125 av_freep(&s->ac_stats);
1127 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1128 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1129 s->q_chroma_intra_matrix= NULL;
1130 s->q_chroma_intra_matrix16= NULL;
1131 av_freep(&s->q_intra_matrix);
1132 av_freep(&s->q_inter_matrix);
1133 av_freep(&s->q_intra_matrix16);
1134 av_freep(&s->q_inter_matrix16);
1135 av_freep(&s->input_picture);
1136 av_freep(&s->reordered_input_picture);
1137 av_freep(&s->dct_offset);
1139 if (s->picture && !s->avctx->internal->is_copy) {
1140 for (i = 0; i < s->picture_count; i++) {
1141 free_picture(s, &s->picture[i]);
1144 av_freep(&s->picture);
1146 free_context_frame(s);
1148 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
1149 avcodec_default_free_buffers(s->avctx);
1151 s->context_initialized = 0;
1152 s->last_picture_ptr =
1153 s->next_picture_ptr =
1154 s->current_picture_ptr = NULL;
1155 s->linesize = s->uvlinesize = 0;
1158 void ff_init_rl(RLTable *rl,
1159 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1161 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1162 uint8_t index_run[MAX_RUN + 1];
1163 int last, run, level, start, end, i;
1165 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1166 if (static_store && rl->max_level[0])
1169 /* compute max_level[], max_run[] and index_run[] */
1170 for (last = 0; last < 2; last++) {
1179 memset(max_level, 0, MAX_RUN + 1);
1180 memset(max_run, 0, MAX_LEVEL + 1);
1181 memset(index_run, rl->n, MAX_RUN + 1);
1182 for (i = start; i < end; i++) {
1183 run = rl->table_run[i];
1184 level = rl->table_level[i];
1185 if (index_run[run] == rl->n)
1187 if (level > max_level[run])
1188 max_level[run] = level;
1189 if (run > max_run[level])
1190 max_run[level] = run;
1193 rl->max_level[last] = static_store[last];
1195 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1196 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1198 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1200 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1201 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1203 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1205 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1206 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1210 void ff_init_vlc_rl(RLTable *rl)
1214 for (q = 0; q < 32; q++) {
1216 int qadd = (q - 1) | 1;
1222 for (i = 0; i < rl->vlc.table_size; i++) {
1223 int code = rl->vlc.table[i][0];
1224 int len = rl->vlc.table[i][1];
1227 if (len == 0) { // illegal code
1230 } else if (len < 0) { // more bits needed
1234 if (code == rl->n) { // esc
1238 run = rl->table_run[code] + 1;
1239 level = rl->table_level[code] * qmul + qadd;
1240 if (code >= rl->last) run += 192;
1243 rl->rl_vlc[q][i].len = len;
1244 rl->rl_vlc[q][i].level = level;
1245 rl->rl_vlc[q][i].run = run;
1250 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1254 /* release non reference frames */
1255 for (i = 0; i < s->picture_count; i++) {
1256 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1257 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1258 (remove_current || &s->picture[i] != s->current_picture_ptr)
1259 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1260 free_frame_buffer(s, &s->picture[i]);
1265 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1267 if ( (s->avctx->active_thread_type & FF_THREAD_FRAME)
1268 && pic->f.qscale_table //check if the frame has anything allocated
1269 && pic->period_since_free < s->avctx->thread_count)
1271 if (pic->f.data[0] == NULL)
1273 if (pic->needs_realloc && !(pic->f.reference & DELAYED_PIC_REF))
1274 if (!pic->owner2 || pic->owner2 == s)
1279 static int find_unused_picture(MpegEncContext *s, int shared)
1284 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1285 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1289 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1290 if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1293 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1294 if (pic_is_unused(s, &s->picture[i]))
1299 av_log(s->avctx, AV_LOG_FATAL,
1300 "Internal error, picture buffer overflow\n");
1301 /* We could return -1, but the codec would crash trying to draw into a
1302 * non-existing frame anyway. This is safer than waiting for a random crash.
1303 * Also the return of this is never useful, an encoder must only allocate
1304 * as much as allowed in the specification. This has no relationship to how
1305 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1306 * enough for such valid streams).
1307 * Plus, a decoder has to check stream validity and remove frames if too
1308 * many reference frames are around. Waiting for "OOM" is not correct at
1309 * all. Similarly, missing reference frames have to be replaced by
1310 * interpolated/MC frames, anything else is a bug in the codec ...
1316 int ff_find_unused_picture(MpegEncContext *s, int shared)
1318 int ret = find_unused_picture(s, shared);
1320 if (ret >= 0 && ret < s->picture_range_end) {
1321 if (s->picture[ret].needs_realloc) {
1322 s->picture[ret].needs_realloc = 0;
1323 free_picture(s, &s->picture[ret]);
1324 avcodec_get_frame_defaults(&s->picture[ret].f);
1330 static void update_noise_reduction(MpegEncContext *s)
1334 for (intra = 0; intra < 2; intra++) {
1335 if (s->dct_count[intra] > (1 << 16)) {
1336 for (i = 0; i < 64; i++) {
1337 s->dct_error_sum[intra][i] >>= 1;
1339 s->dct_count[intra] >>= 1;
1342 for (i = 0; i < 64; i++) {
1343 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1344 s->dct_count[intra] +
1345 s->dct_error_sum[intra][i] / 2) /
1346 (s->dct_error_sum[intra][i] + 1);
1352 * generic function for encode/decode called after coding/decoding
1353 * the header and before a frame is coded/decoded.
1355 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1361 if (!ff_thread_can_start_frame(avctx)) {
1362 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1366 /* mark & release old frames */
1367 if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1368 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1369 s->last_picture_ptr != s->next_picture_ptr &&
1370 s->last_picture_ptr->f.data[0]) {
1371 if (s->last_picture_ptr->owner2 == s)
1372 free_frame_buffer(s, s->last_picture_ptr);
1375 /* release forgotten pictures */
1376 /* if (mpeg124/h263) */
1378 for (i = 0; i < s->picture_count; i++) {
1379 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1380 &s->picture[i] != s->last_picture_ptr &&
1381 &s->picture[i] != s->next_picture_ptr &&
1382 s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1383 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1384 av_log(avctx, AV_LOG_ERROR,
1385 "releasing zombie picture\n");
1386 free_frame_buffer(s, &s->picture[i]);
1393 ff_release_unused_pictures(s, 1);
1395 if (s->current_picture_ptr &&
1396 s->current_picture_ptr->f.data[0] == NULL) {
1397 // we already have a unused image
1398 // (maybe it was set before reading the header)
1399 pic = s->current_picture_ptr;
1401 i = ff_find_unused_picture(s, 0);
1403 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1406 pic = &s->picture[i];
1409 pic->f.reference = 0;
1410 if (!s->droppable) {
1411 if (s->codec_id == AV_CODEC_ID_H264)
1412 pic->f.reference = s->picture_structure;
1413 else if (s->pict_type != AV_PICTURE_TYPE_B)
1414 pic->f.reference = 3;
1417 pic->f.coded_picture_number = s->coded_picture_number++;
1419 if (ff_alloc_picture(s, pic, 0) < 0)
1422 s->current_picture_ptr = pic;
1423 // FIXME use only the vars from current_pic
1424 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1425 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1426 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1427 if (s->picture_structure != PICT_FRAME)
1428 s->current_picture_ptr->f.top_field_first =
1429 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1431 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1432 !s->progressive_sequence;
1433 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1436 s->current_picture_ptr->f.pict_type = s->pict_type;
1437 // if (s->flags && CODEC_FLAG_QSCALE)
1438 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1439 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1441 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1443 if (s->pict_type != AV_PICTURE_TYPE_B) {
1444 s->last_picture_ptr = s->next_picture_ptr;
1446 s->next_picture_ptr = s->current_picture_ptr;
1448 av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1449 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1450 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1451 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1452 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1453 s->pict_type, s->droppable);
1455 if (s->codec_id != AV_CODEC_ID_H264) {
1456 if ((s->last_picture_ptr == NULL ||
1457 s->last_picture_ptr->f.data[0] == NULL) &&
1458 (s->pict_type != AV_PICTURE_TYPE_I ||
1459 s->picture_structure != PICT_FRAME)) {
1460 if (s->pict_type != AV_PICTURE_TYPE_I)
1461 av_log(avctx, AV_LOG_ERROR,
1462 "warning: first frame is no keyframe\n");
1463 else if (s->picture_structure != PICT_FRAME)
1464 av_log(avctx, AV_LOG_INFO,
1465 "allocate dummy last picture for field based first keyframe\n");
1467 /* Allocate a dummy frame */
1468 i = ff_find_unused_picture(s, 0);
1470 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1473 s->last_picture_ptr = &s->picture[i];
1474 s->last_picture_ptr->f.key_frame = 0;
1475 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1476 s->last_picture_ptr = NULL;
1480 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1481 for(i=0; i<avctx->height; i++)
1482 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1485 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1486 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1487 s->last_picture_ptr->f.reference = 3;
1489 if ((s->next_picture_ptr == NULL ||
1490 s->next_picture_ptr->f.data[0] == NULL) &&
1491 s->pict_type == AV_PICTURE_TYPE_B) {
1492 /* Allocate a dummy frame */
1493 i = ff_find_unused_picture(s, 0);
1495 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1498 s->next_picture_ptr = &s->picture[i];
1499 s->next_picture_ptr->f.key_frame = 0;
1500 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1501 s->next_picture_ptr = NULL;
1504 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1505 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1506 s->next_picture_ptr->f.reference = 3;
1510 memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1511 memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1512 if (s->last_picture_ptr)
1513 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1514 if (s->next_picture_ptr)
1515 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1517 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) {
1518 if (s->next_picture_ptr)
1519 s->next_picture_ptr->owner2 = s;
1520 if (s->last_picture_ptr)
1521 s->last_picture_ptr->owner2 = s;
1524 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1525 s->last_picture_ptr->f.data[0]));
1527 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1529 for (i = 0; i < 4; i++) {
1530 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1531 s->current_picture.f.data[i] +=
1532 s->current_picture.f.linesize[i];
1534 s->current_picture.f.linesize[i] *= 2;
1535 s->last_picture.f.linesize[i] *= 2;
1536 s->next_picture.f.linesize[i] *= 2;
1540 s->err_recognition = avctx->err_recognition;
1542 /* set dequantizer, we can't do it during init as
1543 * it might change for mpeg4 and we can't do it in the header
1544 * decode as init is not called for mpeg4 there yet */
1545 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1546 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1547 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1548 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1549 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1550 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1552 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1553 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1556 if (s->dct_error_sum) {
1557 assert(s->avctx->noise_reduction && s->encoding);
1558 update_noise_reduction(s);
1561 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1562 return ff_xvmc_field_start(s, avctx);
1567 /* generic function for encode/decode called after a
1568 * frame has been coded/decoded. */
1569 void ff_MPV_frame_end(MpegEncContext *s)
1572 /* redraw edges for the frame if decoding didn't complete */
1573 // just to make sure that all data is rendered.
1574 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1575 ff_xvmc_field_end(s);
1576 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1577 !s->avctx->hwaccel &&
1578 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1579 s->unrestricted_mv &&
1580 s->current_picture.f.reference &&
1582 !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1585 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1586 int hshift = desc->log2_chroma_w;
1587 int vshift = desc->log2_chroma_h;
1588 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1589 s->h_edge_pos, s->v_edge_pos,
1590 EDGE_WIDTH, EDGE_WIDTH,
1591 EDGE_TOP | EDGE_BOTTOM);
1592 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1593 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1594 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1595 EDGE_TOP | EDGE_BOTTOM);
1596 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1597 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1598 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1599 EDGE_TOP | EDGE_BOTTOM);
1604 s->last_pict_type = s->pict_type;
1605 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1606 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1607 s->last_non_b_pict_type = s->pict_type;
1610 /* copy back current_picture variables */
1611 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1612 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1613 s->picture[i] = s->current_picture;
1617 assert(i < MAX_PICTURE_COUNT);
1621 /* release non-reference frames */
1622 for (i = 0; i < s->picture_count; i++) {
1623 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1624 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1625 free_frame_buffer(s, &s->picture[i]);
1629 // clear copies, to avoid confusion
1631 memset(&s->last_picture, 0, sizeof(Picture));
1632 memset(&s->next_picture, 0, sizeof(Picture));
1633 memset(&s->current_picture, 0, sizeof(Picture));
1635 s->avctx->coded_frame = &s->current_picture_ptr->f;
1637 if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1638 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1643 * Draw a line from (ex, ey) -> (sx, sy).
1644 * @param w width of the image
1645 * @param h height of the image
1646 * @param stride stride/linesize of the image
1647 * @param color color of the arrow
1649 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1650 int w, int h, int stride, int color)
1654 sx = av_clip(sx, 0, w - 1);
1655 sy = av_clip(sy, 0, h - 1);
1656 ex = av_clip(ex, 0, w - 1);
1657 ey = av_clip(ey, 0, h - 1);
1659 buf[sy * stride + sx] += color;
1661 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1663 FFSWAP(int, sx, ex);
1664 FFSWAP(int, sy, ey);
1666 buf += sx + sy * stride;
1668 f = ((ey - sy) << 16) / ex;
1669 for (x = 0; x <= ex; x++) {
1671 fr = (x * f) & 0xFFFF;
1672 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1673 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1677 FFSWAP(int, sx, ex);
1678 FFSWAP(int, sy, ey);
1680 buf += sx + sy * stride;
1683 f = ((ex - sx) << 16) / ey;
1686 for(y= 0; y <= ey; y++){
1688 fr = (y*f) & 0xFFFF;
1689 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1690 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1696 * Draw an arrow from (ex, ey) -> (sx, sy).
1697 * @param w width of the image
1698 * @param h height of the image
1699 * @param stride stride/linesize of the image
1700 * @param color color of the arrow
1702 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1703 int ey, int w, int h, int stride, int color)
1707 sx = av_clip(sx, -100, w + 100);
1708 sy = av_clip(sy, -100, h + 100);
1709 ex = av_clip(ex, -100, w + 100);
1710 ey = av_clip(ey, -100, h + 100);
1715 if (dx * dx + dy * dy > 3 * 3) {
1718 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1720 // FIXME subpixel accuracy
1721 rx = ROUNDED_DIV(rx * 3 << 4, length);
1722 ry = ROUNDED_DIV(ry * 3 << 4, length);
1724 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1725 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1727 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1731 * Print debugging info for the given picture.
1733 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1735 if ( s->avctx->hwaccel || !pict || !pict->mb_type
1736 || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1740 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1743 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1744 av_get_picture_type_char(pict->pict_type));
1745 for (y = 0; y < s->mb_height; y++) {
1746 for (x = 0; x < s->mb_width; x++) {
1747 if (s->avctx->debug & FF_DEBUG_SKIP) {
1748 int count = s->mbskip_table[x + y * s->mb_stride];
1751 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1753 if (s->avctx->debug & FF_DEBUG_QP) {
1754 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1755 pict->qscale_table[x + y * s->mb_stride]);
1757 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1758 int mb_type = pict->mb_type[x + y * s->mb_stride];
1759 // Type & MV direction
1760 if (IS_PCM(mb_type))
1761 av_log(s->avctx, AV_LOG_DEBUG, "P");
1762 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1763 av_log(s->avctx, AV_LOG_DEBUG, "A");
1764 else if (IS_INTRA4x4(mb_type))
1765 av_log(s->avctx, AV_LOG_DEBUG, "i");
1766 else if (IS_INTRA16x16(mb_type))
1767 av_log(s->avctx, AV_LOG_DEBUG, "I");
1768 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1769 av_log(s->avctx, AV_LOG_DEBUG, "d");
1770 else if (IS_DIRECT(mb_type))
1771 av_log(s->avctx, AV_LOG_DEBUG, "D");
1772 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1773 av_log(s->avctx, AV_LOG_DEBUG, "g");
1774 else if (IS_GMC(mb_type))
1775 av_log(s->avctx, AV_LOG_DEBUG, "G");
1776 else if (IS_SKIP(mb_type))
1777 av_log(s->avctx, AV_LOG_DEBUG, "S");
1778 else if (!USES_LIST(mb_type, 1))
1779 av_log(s->avctx, AV_LOG_DEBUG, ">");
1780 else if (!USES_LIST(mb_type, 0))
1781 av_log(s->avctx, AV_LOG_DEBUG, "<");
1783 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1784 av_log(s->avctx, AV_LOG_DEBUG, "X");
1788 if (IS_8X8(mb_type))
1789 av_log(s->avctx, AV_LOG_DEBUG, "+");
1790 else if (IS_16X8(mb_type))
1791 av_log(s->avctx, AV_LOG_DEBUG, "-");
1792 else if (IS_8X16(mb_type))
1793 av_log(s->avctx, AV_LOG_DEBUG, "|");
1794 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1795 av_log(s->avctx, AV_LOG_DEBUG, " ");
1797 av_log(s->avctx, AV_LOG_DEBUG, "?");
1800 if (IS_INTERLACED(mb_type))
1801 av_log(s->avctx, AV_LOG_DEBUG, "=");
1803 av_log(s->avctx, AV_LOG_DEBUG, " ");
1806 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1810 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1811 (s->avctx->debug_mv)) {
1812 const int shift = 1 + s->quarter_sample;
1816 int h_chroma_shift, v_chroma_shift, block_height;
1817 const int width = s->avctx->width;
1818 const int height = s->avctx->height;
1819 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1820 const int mv_stride = (s->mb_width << mv_sample_log2) +
1821 (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1822 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1824 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1826 for (i = 0; i < 3; i++) {
1827 size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1828 pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1829 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1830 memcpy(s->visualization_buffer[i], pict->data[i], size);
1831 pict->data[i] = s->visualization_buffer[i];
1833 pict->type = FF_BUFFER_TYPE_COPY;
1835 ptr = pict->data[0];
1836 block_height = 16 >> v_chroma_shift;
1838 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1840 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1841 const int mb_index = mb_x + mb_y * s->mb_stride;
1842 if ((s->avctx->debug_mv) && pict->motion_val[0]) {
1844 for (type = 0; type < 3; type++) {
1848 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1849 (pict->pict_type!= AV_PICTURE_TYPE_P))
1854 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1855 (pict->pict_type!= AV_PICTURE_TYPE_B))
1860 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1861 (pict->pict_type!= AV_PICTURE_TYPE_B))
1866 if (!USES_LIST(pict->mb_type[mb_index], direction))
1869 if (IS_8X8(pict->mb_type[mb_index])) {
1871 for (i = 0; i < 4; i++) {
1872 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1873 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1874 int xy = (mb_x * 2 + (i & 1) +
1875 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1876 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1877 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1878 draw_arrow(ptr, sx, sy, mx, my, width,
1879 height, s->linesize, 100);
1881 } else if (IS_16X8(pict->mb_type[mb_index])) {
1883 for (i = 0; i < 2; i++) {
1884 int sx = mb_x * 16 + 8;
1885 int sy = mb_y * 16 + 4 + 8 * i;
1886 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1887 int mx = (pict->motion_val[direction][xy][0] >> shift);
1888 int my = (pict->motion_val[direction][xy][1] >> shift);
1890 if (IS_INTERLACED(pict->mb_type[mb_index]))
1893 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1894 height, s->linesize, 100);
1896 } else if (IS_8X16(pict->mb_type[mb_index])) {
1898 for (i = 0; i < 2; i++) {
1899 int sx = mb_x * 16 + 4 + 8 * i;
1900 int sy = mb_y * 16 + 8;
1901 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1902 int mx = pict->motion_val[direction][xy][0] >> shift;
1903 int my = pict->motion_val[direction][xy][1] >> shift;
1905 if (IS_INTERLACED(pict->mb_type[mb_index]))
1908 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1909 height, s->linesize, 100);
1912 int sx= mb_x * 16 + 8;
1913 int sy= mb_y * 16 + 8;
1914 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1915 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1916 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1917 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1921 if ((s->avctx->debug & FF_DEBUG_VIS_QP)) {
1922 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1923 0x0101010101010101ULL;
1925 for (y = 0; y < block_height; y++) {
1926 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1927 (block_height * mb_y + y) *
1928 pict->linesize[1]) = c;
1929 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1930 (block_height * mb_y + y) *
1931 pict->linesize[2]) = c;
1934 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1935 pict->motion_val[0]) {
1936 int mb_type = pict->mb_type[mb_index];
1939 #define COLOR(theta, r) \
1940 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1941 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1945 if (IS_PCM(mb_type)) {
1947 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1948 IS_INTRA16x16(mb_type)) {
1950 } else if (IS_INTRA4x4(mb_type)) {
1952 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1954 } else if (IS_DIRECT(mb_type)) {
1956 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1958 } else if (IS_GMC(mb_type)) {
1960 } else if (IS_SKIP(mb_type)) {
1962 } else if (!USES_LIST(mb_type, 1)) {
1964 } else if (!USES_LIST(mb_type, 0)) {
1967 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1971 u *= 0x0101010101010101ULL;
1972 v *= 0x0101010101010101ULL;
1973 for (y = 0; y < block_height; y++) {
1974 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1975 (block_height * mb_y + y) * pict->linesize[1]) = u;
1976 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1977 (block_height * mb_y + y) * pict->linesize[2]) = v;
1981 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1982 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1983 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1984 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1985 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1987 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1988 for (y = 0; y < 16; y++)
1989 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1990 pict->linesize[0]] ^= 0x80;
1992 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1993 int dm = 1 << (mv_sample_log2 - 2);
1994 for (i = 0; i < 4; i++) {
1995 int sx = mb_x * 16 + 8 * (i & 1);
1996 int sy = mb_y * 16 + 8 * (i >> 1);
1997 int xy = (mb_x * 2 + (i & 1) +
1998 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2000 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
2001 if (mv[0] != mv[dm] ||
2002 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2003 for (y = 0; y < 8; y++)
2004 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2005 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2006 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2007 pict->linesize[0]) ^= 0x8080808080808080ULL;
2011 if (IS_INTERLACED(mb_type) &&
2012 s->codec_id == AV_CODEC_ID_H264) {
2016 s->mbskip_table[mb_index] = 0;
2022 static inline int hpel_motion_lowres(MpegEncContext *s,
2023 uint8_t *dest, uint8_t *src,
2024 int field_based, int field_select,
2025 int src_x, int src_y,
2026 int width, int height, int stride,
2027 int h_edge_pos, int v_edge_pos,
2028 int w, int h, h264_chroma_mc_func *pix_op,
2029 int motion_x, int motion_y)
2031 const int lowres = s->avctx->lowres;
2032 const int op_index = FFMIN(lowres, 2);
2033 const int s_mask = (2 << lowres) - 1;
2037 if (s->quarter_sample) {
2042 sx = motion_x & s_mask;
2043 sy = motion_y & s_mask;
2044 src_x += motion_x >> lowres + 1;
2045 src_y += motion_y >> lowres + 1;
2047 src += src_y * stride + src_x;
2049 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2050 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2051 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2052 (h + 1) << field_based, src_x,
2053 src_y << field_based,
2056 src = s->edge_emu_buffer;
2060 sx = (sx << 2) >> lowres;
2061 sy = (sy << 2) >> lowres;
2064 pix_op[op_index](dest, src, stride, h, sx, sy);
2068 /* apply one mpeg motion vector to the three components */
2069 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2076 uint8_t **ref_picture,
2077 h264_chroma_mc_func *pix_op,
2078 int motion_x, int motion_y,
2081 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2082 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2084 const int lowres = s->avctx->lowres;
2085 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
2086 const int block_s = 8>>lowres;
2087 const int s_mask = (2 << lowres) - 1;
2088 const int h_edge_pos = s->h_edge_pos >> lowres;
2089 const int v_edge_pos = s->v_edge_pos >> lowres;
2090 linesize = s->current_picture.f.linesize[0] << field_based;
2091 uvlinesize = s->current_picture.f.linesize[1] << field_based;
2093 // FIXME obviously not perfect but qpel will not work in lowres anyway
2094 if (s->quarter_sample) {
2100 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2103 sx = motion_x & s_mask;
2104 sy = motion_y & s_mask;
2105 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2106 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2108 if (s->out_format == FMT_H263) {
2109 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2110 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2111 uvsrc_x = src_x >> 1;
2112 uvsrc_y = src_y >> 1;
2113 } else if (s->out_format == FMT_H261) {
2114 // even chroma mv's are full pel in H261
2117 uvsx = (2 * mx) & s_mask;
2118 uvsy = (2 * my) & s_mask;
2119 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2120 uvsrc_y = mb_y * block_s + (my >> lowres);
2122 if(s->chroma_y_shift){
2127 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2128 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2130 if(s->chroma_x_shift){
2134 uvsy = motion_y & s_mask;
2136 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2139 uvsx = motion_x & s_mask;
2140 uvsy = motion_y & s_mask;
2147 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2148 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2149 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2151 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
2152 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2153 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2154 linesize >> field_based, 17, 17 + field_based,
2155 src_x, src_y << field_based, h_edge_pos,
2157 ptr_y = s->edge_emu_buffer;
2158 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2159 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2160 s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2162 uvsrc_x, uvsrc_y << field_based,
2163 h_edge_pos >> 1, v_edge_pos >> 1);
2164 s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2166 uvsrc_x, uvsrc_y << field_based,
2167 h_edge_pos >> 1, v_edge_pos >> 1);
2169 ptr_cr = uvbuf + 16;
2173 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2175 dest_y += s->linesize;
2176 dest_cb += s->uvlinesize;
2177 dest_cr += s->uvlinesize;
2181 ptr_y += s->linesize;
2182 ptr_cb += s->uvlinesize;
2183 ptr_cr += s->uvlinesize;
2186 sx = (sx << 2) >> lowres;
2187 sy = (sy << 2) >> lowres;
2188 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2190 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2191 uvsx = (uvsx << 2) >> lowres;
2192 uvsy = (uvsy << 2) >> lowres;
2193 if (h >> s->chroma_y_shift) {
2194 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2195 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2198 // FIXME h261 lowres loop filter
2201 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2202 uint8_t *dest_cb, uint8_t *dest_cr,
2203 uint8_t **ref_picture,
2204 h264_chroma_mc_func * pix_op,
2207 const int lowres = s->avctx->lowres;
2208 const int op_index = FFMIN(lowres, 2);
2209 const int block_s = 8 >> lowres;
2210 const int s_mask = (2 << lowres) - 1;
2211 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2212 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2213 int emu = 0, src_x, src_y, offset, sx, sy;
2216 if (s->quarter_sample) {
2221 /* In case of 8X8, we construct a single chroma motion vector
2222 with a special rounding */
2223 mx = ff_h263_round_chroma(mx);
2224 my = ff_h263_round_chroma(my);
2228 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2229 src_y = s->mb_y * block_s + (my >> lowres + 1);
2231 offset = src_y * s->uvlinesize + src_x;
2232 ptr = ref_picture[1] + offset;
2233 if (s->flags & CODEC_FLAG_EMU_EDGE) {
2234 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2235 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2236 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2237 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2238 ptr = s->edge_emu_buffer;
2242 sx = (sx << 2) >> lowres;
2243 sy = (sy << 2) >> lowres;
2244 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2246 ptr = ref_picture[2] + offset;
2248 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2249 src_x, src_y, h_edge_pos, v_edge_pos);
2250 ptr = s->edge_emu_buffer;
2252 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2256 * motion compensation of a single macroblock
2258 * @param dest_y luma destination pointer
2259 * @param dest_cb chroma cb/u destination pointer
2260 * @param dest_cr chroma cr/v destination pointer
2261 * @param dir direction (0->forward, 1->backward)
2262 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2263 * @param pix_op halfpel motion compensation function (average or put normally)
2264 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2266 static inline void MPV_motion_lowres(MpegEncContext *s,
2267 uint8_t *dest_y, uint8_t *dest_cb,
2269 int dir, uint8_t **ref_picture,
2270 h264_chroma_mc_func *pix_op)
2274 const int lowres = s->avctx->lowres;
2275 const int block_s = 8 >>lowres;
2280 switch (s->mv_type) {
2282 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2284 ref_picture, pix_op,
2285 s->mv[dir][0][0], s->mv[dir][0][1],
2291 for (i = 0; i < 4; i++) {
2292 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2293 s->linesize) * block_s,
2294 ref_picture[0], 0, 0,
2295 (2 * mb_x + (i & 1)) * block_s,
2296 (2 * mb_y + (i >> 1)) * block_s,
2297 s->width, s->height, s->linesize,
2298 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2299 block_s, block_s, pix_op,
2300 s->mv[dir][i][0], s->mv[dir][i][1]);
2302 mx += s->mv[dir][i][0];
2303 my += s->mv[dir][i][1];
2306 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2307 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2311 if (s->picture_structure == PICT_FRAME) {
2313 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2314 1, 0, s->field_select[dir][0],
2315 ref_picture, pix_op,
2316 s->mv[dir][0][0], s->mv[dir][0][1],
2319 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2320 1, 1, s->field_select[dir][1],
2321 ref_picture, pix_op,
2322 s->mv[dir][1][0], s->mv[dir][1][1],
2325 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2326 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2327 ref_picture = s->current_picture_ptr->f.data;
2330 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2331 0, 0, s->field_select[dir][0],
2332 ref_picture, pix_op,
2334 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2338 for (i = 0; i < 2; i++) {
2339 uint8_t **ref2picture;
2341 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2342 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2343 ref2picture = ref_picture;
2345 ref2picture = s->current_picture_ptr->f.data;
2348 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2349 0, 0, s->field_select[dir][i],
2350 ref2picture, pix_op,
2351 s->mv[dir][i][0], s->mv[dir][i][1] +
2352 2 * block_s * i, block_s, mb_y >> 1);
2354 dest_y += 2 * block_s * s->linesize;
2355 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2356 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2360 if (s->picture_structure == PICT_FRAME) {
2361 for (i = 0; i < 2; i++) {
2363 for (j = 0; j < 2; j++) {
2364 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2366 ref_picture, pix_op,
2367 s->mv[dir][2 * i + j][0],
2368 s->mv[dir][2 * i + j][1],
2371 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2374 for (i = 0; i < 2; i++) {
2375 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2376 0, 0, s->picture_structure != i + 1,
2377 ref_picture, pix_op,
2378 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2379 2 * block_s, mb_y >> 1);
2381 // after put we make avg of the same block
2382 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2384 // opposite parity is always in the same
2385 // frame if this is second field
2386 if (!s->first_field) {
2387 ref_picture = s->current_picture_ptr->f.data;
2398 * find the lowest MB row referenced in the MVs
2400 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2402 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2403 int my, off, i, mvs;
2405 if (s->picture_structure != PICT_FRAME || s->mcsel)
2408 switch (s->mv_type) {
2422 for (i = 0; i < mvs; i++) {
2423 my = s->mv[dir][i][1]<<qpel_shift;
2424 my_max = FFMAX(my_max, my);
2425 my_min = FFMIN(my_min, my);
2428 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2430 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2432 return s->mb_height-1;
2435 /* put block[] to dest[] */
2436 static inline void put_dct(MpegEncContext *s,
2437 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2439 s->dct_unquantize_intra(s, block, i, qscale);
2440 s->dsp.idct_put (dest, line_size, block);
2443 /* add block[] to dest[] */
2444 static inline void add_dct(MpegEncContext *s,
2445 int16_t *block, int i, uint8_t *dest, int line_size)
2447 if (s->block_last_index[i] >= 0) {
2448 s->dsp.idct_add (dest, line_size, block);
2452 static inline void add_dequant_dct(MpegEncContext *s,
2453 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2455 if (s->block_last_index[i] >= 0) {
2456 s->dct_unquantize_inter(s, block, i, qscale);
2458 s->dsp.idct_add (dest, line_size, block);
2463 * Clean dc, ac, coded_block for the current non-intra MB.
2465 void ff_clean_intra_table_entries(MpegEncContext *s)
2467 int wrap = s->b8_stride;
2468 int xy = s->block_index[0];
2471 s->dc_val[0][xy + 1 ] =
2472 s->dc_val[0][xy + wrap] =
2473 s->dc_val[0][xy + 1 + wrap] = 1024;
2475 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2476 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2477 if (s->msmpeg4_version>=3) {
2478 s->coded_block[xy ] =
2479 s->coded_block[xy + 1 ] =
2480 s->coded_block[xy + wrap] =
2481 s->coded_block[xy + 1 + wrap] = 0;
2484 wrap = s->mb_stride;
2485 xy = s->mb_x + s->mb_y * wrap;
2487 s->dc_val[2][xy] = 1024;
2489 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2490 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2492 s->mbintra_table[xy]= 0;
2495 /* generic function called after a macroblock has been parsed by the
2496 decoder or after it has been encoded by the encoder.
2498 Important variables used:
2499 s->mb_intra : true if intra macroblock
2500 s->mv_dir : motion vector direction
2501 s->mv_type : motion vector type
2502 s->mv : motion vector
2503 s->interlaced_dct : true if interlaced dct used (mpeg2)
2505 static av_always_inline
2506 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2507 int lowres_flag, int is_mpeg12)
2509 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2510 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2511 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2515 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2516 /* save DCT coefficients */
2518 int16_t *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2519 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2521 for(j=0; j<64; j++){
2522 *dct++ = block[i][s->dsp.idct_permutation[j]];
2523 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2525 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2529 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2531 /* update DC predictors for P macroblocks */
2533 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2534 if(s->mbintra_table[mb_xy])
2535 ff_clean_intra_table_entries(s);
2539 s->last_dc[2] = 128 << s->intra_dc_precision;
2542 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2543 s->mbintra_table[mb_xy]=1;
2545 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
2546 uint8_t *dest_y, *dest_cb, *dest_cr;
2547 int dct_linesize, dct_offset;
2548 op_pixels_func (*op_pix)[4];
2549 qpel_mc_func (*op_qpix)[16];
2550 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2551 const int uvlinesize = s->current_picture.f.linesize[1];
2552 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2553 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2555 /* avoid copy if macroblock skipped in last frame too */
2556 /* skip only during decoding as we might trash the buffers during encoding a bit */
2558 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2560 if (s->mb_skipped) {
2562 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2564 } else if(!s->current_picture.f.reference) {
2567 *mbskip_ptr = 0; /* not skipped */
2571 dct_linesize = linesize << s->interlaced_dct;
2572 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2576 dest_cb= s->dest[1];
2577 dest_cr= s->dest[2];
2579 dest_y = s->b_scratchpad;
2580 dest_cb= s->b_scratchpad+16*linesize;
2581 dest_cr= s->b_scratchpad+32*linesize;
2585 /* motion handling */
2586 /* decoding or more than one mb_type (MC was already done otherwise) */
2589 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2590 if (s->mv_dir & MV_DIR_FORWARD) {
2591 ff_thread_await_progress(&s->last_picture_ptr->f,
2592 ff_MPV_lowest_referenced_row(s, 0),
2595 if (s->mv_dir & MV_DIR_BACKWARD) {
2596 ff_thread_await_progress(&s->next_picture_ptr->f,
2597 ff_MPV_lowest_referenced_row(s, 1),
2603 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2605 if (s->mv_dir & MV_DIR_FORWARD) {
2606 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2607 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2609 if (s->mv_dir & MV_DIR_BACKWARD) {
2610 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2613 op_qpix= s->me.qpel_put;
2614 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2615 op_pix = s->dsp.put_pixels_tab;
2617 op_pix = s->dsp.put_no_rnd_pixels_tab;
2619 if (s->mv_dir & MV_DIR_FORWARD) {
2620 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2621 op_pix = s->dsp.avg_pixels_tab;
2622 op_qpix= s->me.qpel_avg;
2624 if (s->mv_dir & MV_DIR_BACKWARD) {
2625 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2630 /* skip dequant / idct if we are really late ;) */
2631 if(s->avctx->skip_idct){
2632 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2633 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2634 || s->avctx->skip_idct >= AVDISCARD_ALL)
2638 /* add dct residue */
2639 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2640 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2641 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2642 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2643 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2644 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2646 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2647 if (s->chroma_y_shift){
2648 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2649 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2653 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2654 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2655 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2656 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2659 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2660 add_dct(s, block[0], 0, dest_y , dct_linesize);
2661 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2662 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2663 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2665 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2666 if(s->chroma_y_shift){//Chroma420
2667 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2668 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2671 dct_linesize = uvlinesize << s->interlaced_dct;
2672 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2674 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2675 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2676 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2677 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2678 if(!s->chroma_x_shift){//Chroma444
2679 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2680 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2681 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2682 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2687 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2688 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2691 /* dct only in intra block */
2692 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2693 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2694 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2695 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2696 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2698 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2699 if(s->chroma_y_shift){
2700 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2701 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2705 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2706 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2707 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2708 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2712 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2713 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2714 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2715 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2717 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2718 if(s->chroma_y_shift){
2719 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2720 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2723 dct_linesize = uvlinesize << s->interlaced_dct;
2724 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2726 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2727 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2728 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2729 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2730 if(!s->chroma_x_shift){//Chroma444
2731 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2732 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2733 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2734 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2742 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2743 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2744 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2749 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2751 if(s->out_format == FMT_MPEG1) {
2752 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2753 else MPV_decode_mb_internal(s, block, 0, 1);
2756 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2757 else MPV_decode_mb_internal(s, block, 0, 0);
2761 * @param h is the normal height, this will be reduced automatically if needed for the last row
2763 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2764 const int field_pic= s->picture_structure != PICT_FRAME;
2770 if (!s->avctx->hwaccel
2771 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2772 && s->unrestricted_mv
2773 && s->current_picture.f.reference
2775 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2776 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
2777 int sides = 0, edge_h;
2778 int hshift = desc->log2_chroma_w;
2779 int vshift = desc->log2_chroma_h;
2780 if (y==0) sides |= EDGE_TOP;
2781 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2783 edge_h= FFMIN(h, s->v_edge_pos - y);
2785 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2786 s->linesize, s->h_edge_pos, edge_h,
2787 EDGE_WIDTH, EDGE_WIDTH, sides);
2788 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2789 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2790 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2791 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2792 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2793 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2796 h= FFMIN(h, s->avctx->height - y);
2798 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2800 if (s->avctx->draw_horiz_band) {
2802 int offset[AV_NUM_DATA_POINTERS];
2805 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2806 src = &s->current_picture_ptr->f;
2807 else if(s->last_picture_ptr)
2808 src = &s->last_picture_ptr->f;
2812 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2813 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2816 offset[0]= y * s->linesize;
2818 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2819 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2825 s->avctx->draw_horiz_band(s->avctx, src, offset,
2826 y, s->picture_structure, h);
2830 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2831 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2832 const int uvlinesize = s->current_picture.f.linesize[1];
2833 const int mb_size= 4 - s->avctx->lowres;
2835 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2836 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2837 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2838 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2839 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2840 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;
2841 //block_index is not used by mpeg2, so it is not affected by chroma_format
2843 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2844 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2845 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2847 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2849 if(s->picture_structure==PICT_FRAME){
2850 s->dest[0] += s->mb_y * linesize << mb_size;
2851 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2852 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2854 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2855 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2856 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2857 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2862 void ff_mpeg_flush(AVCodecContext *avctx){
2864 MpegEncContext *s = avctx->priv_data;
2866 if(s==NULL || s->picture==NULL)
2869 for(i=0; i<s->picture_count; i++){
2870 if (s->picture[i].f.data[0] &&
2871 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2872 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2873 free_frame_buffer(s, &s->picture[i]);
2875 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2877 s->mb_x= s->mb_y= 0;
2880 s->parse_context.state= -1;
2881 s->parse_context.frame_start_found= 0;
2882 s->parse_context.overread= 0;
2883 s->parse_context.overread_index= 0;
2884 s->parse_context.index= 0;
2885 s->parse_context.last_index= 0;
2886 s->bitstream_buffer_size=0;
2890 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2891 int16_t *block, int n, int qscale)
2893 int i, level, nCoeffs;
2894 const uint16_t *quant_matrix;
2896 nCoeffs= s->block_last_index[n];
2898 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2899 /* XXX: only mpeg1 */
2900 quant_matrix = s->intra_matrix;
2901 for(i=1;i<=nCoeffs;i++) {
2902 int j= s->intra_scantable.permutated[i];
2907 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2908 level = (level - 1) | 1;
2911 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2912 level = (level - 1) | 1;
2919 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2920 int16_t *block, int n, int qscale)
2922 int i, level, nCoeffs;
2923 const uint16_t *quant_matrix;
2925 nCoeffs= s->block_last_index[n];
2927 quant_matrix = s->inter_matrix;
2928 for(i=0; i<=nCoeffs; i++) {
2929 int j= s->intra_scantable.permutated[i];
2934 level = (((level << 1) + 1) * qscale *
2935 ((int) (quant_matrix[j]))) >> 4;
2936 level = (level - 1) | 1;
2939 level = (((level << 1) + 1) * qscale *
2940 ((int) (quant_matrix[j]))) >> 4;
2941 level = (level - 1) | 1;
2948 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2949 int16_t *block, int n, int qscale)
2951 int i, level, nCoeffs;
2952 const uint16_t *quant_matrix;
2954 if(s->alternate_scan) nCoeffs= 63;
2955 else nCoeffs= s->block_last_index[n];
2957 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2958 quant_matrix = s->intra_matrix;
2959 for(i=1;i<=nCoeffs;i++) {
2960 int j= s->intra_scantable.permutated[i];
2965 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2968 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2975 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2976 int16_t *block, int n, int qscale)
2978 int i, level, nCoeffs;
2979 const uint16_t *quant_matrix;
2982 if(s->alternate_scan) nCoeffs= 63;
2983 else nCoeffs= s->block_last_index[n];
2985 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2987 quant_matrix = s->intra_matrix;
2988 for(i=1;i<=nCoeffs;i++) {
2989 int j= s->intra_scantable.permutated[i];
2994 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2997 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3006 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
3007 int16_t *block, int n, int qscale)
3009 int i, level, nCoeffs;
3010 const uint16_t *quant_matrix;
3013 if(s->alternate_scan) nCoeffs= 63;
3014 else nCoeffs= s->block_last_index[n];
3016 quant_matrix = s->inter_matrix;
3017 for(i=0; i<=nCoeffs; i++) {
3018 int j= s->intra_scantable.permutated[i];
3023 level = (((level << 1) + 1) * qscale *
3024 ((int) (quant_matrix[j]))) >> 4;
3027 level = (((level << 1) + 1) * qscale *
3028 ((int) (quant_matrix[j]))) >> 4;
3037 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3038 int16_t *block, int n, int qscale)
3040 int i, level, qmul, qadd;
3043 assert(s->block_last_index[n]>=0);
3048 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3049 qadd = (qscale - 1) | 1;
3056 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3058 for(i=1; i<=nCoeffs; i++) {
3062 level = level * qmul - qadd;
3064 level = level * qmul + qadd;
3071 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3072 int16_t *block, int n, int qscale)
3074 int i, level, qmul, qadd;
3077 assert(s->block_last_index[n]>=0);
3079 qadd = (qscale - 1) | 1;
3082 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3084 for(i=0; i<=nCoeffs; i++) {
3088 level = level * qmul - qadd;
3090 level = level * qmul + qadd;
3098 * set qscale and update qscale dependent variables.
3100 void ff_set_qscale(MpegEncContext * s, int qscale)
3104 else if (qscale > 31)
3108 s->chroma_qscale= s->chroma_qscale_table[qscale];
3110 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3111 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3114 void ff_MPV_report_decode_progress(MpegEncContext *s)
3116 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
3117 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);