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/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/motion_vector.h"
35 #include "libavutil/timer.h"
38 #include "h264chroma.h"
42 #include "mpegutils.h"
43 #include "mpegvideo.h"
50 static const uint8_t ff_default_chroma_qscale_table[32] = {
51 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
52 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
53 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
56 const uint8_t ff_mpeg1_dc_scale_table[128] = {
57 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
58 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
59 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
60 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
61 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
62 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
63 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
64 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
65 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
68 static const uint8_t mpeg2_dc_scale_table1[128] = {
69 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
70 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
71 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
72 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
73 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
74 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
75 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
80 static const uint8_t mpeg2_dc_scale_table2[128] = {
81 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
82 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
92 static const uint8_t mpeg2_dc_scale_table3[128] = {
93 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
94 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
95 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
97 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
98 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
99 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
100 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
104 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
105 ff_mpeg1_dc_scale_table,
106 mpeg2_dc_scale_table1,
107 mpeg2_dc_scale_table2,
108 mpeg2_dc_scale_table3,
111 const uint8_t ff_alternate_horizontal_scan[64] = {
112 0, 1, 2, 3, 8, 9, 16, 17,
113 10, 11, 4, 5, 6, 7, 15, 14,
114 13, 12, 19, 18, 24, 25, 32, 33,
115 26, 27, 20, 21, 22, 23, 28, 29,
116 30, 31, 34, 35, 40, 41, 48, 49,
117 42, 43, 36, 37, 38, 39, 44, 45,
118 46, 47, 50, 51, 56, 57, 58, 59,
119 52, 53, 54, 55, 60, 61, 62, 63,
122 const uint8_t ff_alternate_vertical_scan[64] = {
123 0, 8, 16, 24, 1, 9, 2, 10,
124 17, 25, 32, 40, 48, 56, 57, 49,
125 41, 33, 26, 18, 3, 11, 4, 12,
126 19, 27, 34, 42, 50, 58, 35, 43,
127 51, 59, 20, 28, 5, 13, 6, 14,
128 21, 29, 36, 44, 52, 60, 37, 45,
129 53, 61, 22, 30, 7, 15, 23, 31,
130 38, 46, 54, 62, 39, 47, 55, 63,
133 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
134 int16_t *block, int n, int qscale)
136 int i, level, nCoeffs;
137 const uint16_t *quant_matrix;
139 nCoeffs= s->block_last_index[n];
141 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
142 /* XXX: only mpeg1 */
143 quant_matrix = s->intra_matrix;
144 for(i=1;i<=nCoeffs;i++) {
145 int j= s->intra_scantable.permutated[i];
150 level = (int)(level * qscale * quant_matrix[j]) >> 3;
151 level = (level - 1) | 1;
154 level = (int)(level * qscale * quant_matrix[j]) >> 3;
155 level = (level - 1) | 1;
162 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
163 int16_t *block, int n, int qscale)
165 int i, level, nCoeffs;
166 const uint16_t *quant_matrix;
168 nCoeffs= s->block_last_index[n];
170 quant_matrix = s->inter_matrix;
171 for(i=0; i<=nCoeffs; i++) {
172 int j= s->intra_scantable.permutated[i];
177 level = (((level << 1) + 1) * qscale *
178 ((int) (quant_matrix[j]))) >> 4;
179 level = (level - 1) | 1;
182 level = (((level << 1) + 1) * qscale *
183 ((int) (quant_matrix[j]))) >> 4;
184 level = (level - 1) | 1;
191 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
192 int16_t *block, int n, int qscale)
194 int i, level, nCoeffs;
195 const uint16_t *quant_matrix;
197 if(s->alternate_scan) nCoeffs= 63;
198 else nCoeffs= s->block_last_index[n];
200 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
201 quant_matrix = s->intra_matrix;
202 for(i=1;i<=nCoeffs;i++) {
203 int j= s->intra_scantable.permutated[i];
208 level = (int)(level * qscale * quant_matrix[j]) >> 3;
211 level = (int)(level * qscale * quant_matrix[j]) >> 3;
218 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
219 int16_t *block, int n, int qscale)
221 int i, level, nCoeffs;
222 const uint16_t *quant_matrix;
225 if(s->alternate_scan) nCoeffs= 63;
226 else nCoeffs= s->block_last_index[n];
228 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
230 quant_matrix = s->intra_matrix;
231 for(i=1;i<=nCoeffs;i++) {
232 int j= s->intra_scantable.permutated[i];
237 level = (int)(level * qscale * quant_matrix[j]) >> 3;
240 level = (int)(level * qscale * quant_matrix[j]) >> 3;
249 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
250 int16_t *block, int n, int qscale)
252 int i, level, nCoeffs;
253 const uint16_t *quant_matrix;
256 if(s->alternate_scan) nCoeffs= 63;
257 else nCoeffs= s->block_last_index[n];
259 quant_matrix = s->inter_matrix;
260 for(i=0; i<=nCoeffs; i++) {
261 int j= s->intra_scantable.permutated[i];
266 level = (((level << 1) + 1) * qscale *
267 ((int) (quant_matrix[j]))) >> 4;
270 level = (((level << 1) + 1) * qscale *
271 ((int) (quant_matrix[j]))) >> 4;
280 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
281 int16_t *block, int n, int qscale)
283 int i, level, qmul, qadd;
286 av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
291 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
292 qadd = (qscale - 1) | 1;
299 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
301 for(i=1; i<=nCoeffs; i++) {
305 level = level * qmul - qadd;
307 level = level * qmul + qadd;
314 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
315 int16_t *block, int n, int qscale)
317 int i, level, qmul, qadd;
320 av_assert2(s->block_last_index[n]>=0);
322 qadd = (qscale - 1) | 1;
325 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
327 for(i=0; i<=nCoeffs; i++) {
331 level = level * qmul - qadd;
333 level = level * qmul + qadd;
340 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
342 int mb_x, int mb_y, int mb_intra, int mb_skipped)
344 MpegEncContext *s = opaque;
347 s->mv_type = mv_type;
348 s->mb_intra = mb_intra;
349 s->mb_skipped = mb_skipped;
352 memcpy(s->mv, mv, sizeof(*mv));
354 ff_init_block_index(s);
355 ff_update_block_index(s);
357 s->bdsp.clear_blocks(s->block[0]);
359 s->dest[0] = s->current_picture.f->data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16;
360 s->dest[1] = s->current_picture.f->data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
361 s->dest[2] = s->current_picture.f->data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
364 av_log(s->avctx, AV_LOG_DEBUG,
365 "Interlaced error concealment is not fully implemented\n");
366 ff_mpv_decode_mb(s, s->block);
369 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
372 memset(dst + h*linesize, 128, 16);
375 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
378 memset(dst + h*linesize, 128, 8);
381 /* init common dct for both encoder and decoder */
382 static av_cold int dct_init(MpegEncContext *s)
384 ff_blockdsp_init(&s->bdsp, s->avctx);
385 ff_h264chroma_init(&s->h264chroma, 8); //for lowres
386 ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
387 ff_mpegvideodsp_init(&s->mdsp);
388 ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
390 if (s->avctx->debug & FF_DEBUG_NOMC) {
392 for (i=0; i<4; i++) {
393 s->hdsp.avg_pixels_tab[0][i] = gray16;
394 s->hdsp.put_pixels_tab[0][i] = gray16;
395 s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
397 s->hdsp.avg_pixels_tab[1][i] = gray8;
398 s->hdsp.put_pixels_tab[1][i] = gray8;
399 s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
403 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
404 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
405 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
406 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
407 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
408 if (s->avctx->flags & CODEC_FLAG_BITEXACT)
409 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
410 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
412 if (HAVE_INTRINSICS_NEON)
413 ff_mpv_common_init_neon(s);
416 ff_mpv_common_init_axp(s);
418 ff_mpv_common_init_arm(s);
420 ff_mpv_common_init_ppc(s);
422 ff_mpv_common_init_x86(s);
427 av_cold void ff_mpv_idct_init(MpegEncContext *s)
429 ff_idctdsp_init(&s->idsp, s->avctx);
431 /* load & permutate scantables
432 * note: only wmv uses different ones
434 if (s->alternate_scan) {
435 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
436 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
438 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
439 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
441 ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
442 ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
445 static int frame_size_alloc(MpegEncContext *s, int linesize)
447 int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
449 if (s->avctx->hwaccel || s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
453 av_log(s->avctx, AV_LOG_ERROR, "Image too small, temporary buffers cannot function\n");
454 return AVERROR_PATCHWELCOME;
457 // edge emu needs blocksize + filter length - 1
458 // (= 17x17 for halfpel / 21x21 for h264)
459 // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
460 // at uvlinesize. It supports only YUV420 so 24x24 is enough
461 // linesize * interlaced * MBsize
462 // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines
463 FF_ALLOCZ_ARRAY_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size, 4 * 68,
466 FF_ALLOCZ_ARRAY_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size, 4 * 16 * 2,
468 s->me.temp = s->me.scratchpad;
469 s->rd_scratchpad = s->me.scratchpad;
470 s->b_scratchpad = s->me.scratchpad;
471 s->obmc_scratchpad = s->me.scratchpad + 16;
475 av_freep(&s->edge_emu_buffer);
476 return AVERROR(ENOMEM);
480 * Allocate a frame buffer
482 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
484 int edges_needed = av_codec_is_encoder(s->avctx->codec);
488 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
489 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
490 s->codec_id != AV_CODEC_ID_MSS2) {
492 pic->f->width = s->avctx->width + 2 * EDGE_WIDTH;
493 pic->f->height = s->avctx->height + 2 * EDGE_WIDTH;
496 r = ff_thread_get_buffer(s->avctx, &pic->tf,
497 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
499 pic->f->width = s->avctx->width;
500 pic->f->height = s->avctx->height;
501 pic->f->format = s->avctx->pix_fmt;
502 r = avcodec_default_get_buffer2(s->avctx, pic->f, 0);
505 if (r < 0 || !pic->f->buf[0]) {
506 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
513 for (i = 0; pic->f->data[i]; i++) {
514 int offset = (EDGE_WIDTH >> (i ? s->chroma_y_shift : 0)) *
515 pic->f->linesize[i] +
516 (EDGE_WIDTH >> (i ? s->chroma_x_shift : 0));
517 pic->f->data[i] += offset;
519 pic->f->width = s->avctx->width;
520 pic->f->height = s->avctx->height;
523 if (s->avctx->hwaccel) {
524 assert(!pic->hwaccel_picture_private);
525 if (s->avctx->hwaccel->frame_priv_data_size) {
526 pic->hwaccel_priv_buf = av_buffer_allocz(s->avctx->hwaccel->frame_priv_data_size);
527 if (!pic->hwaccel_priv_buf) {
528 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
531 pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
535 if (s->linesize && (s->linesize != pic->f->linesize[0] ||
536 s->uvlinesize != pic->f->linesize[1])) {
537 av_log(s->avctx, AV_LOG_ERROR,
538 "get_buffer() failed (stride changed)\n");
539 ff_mpeg_unref_picture(s->avctx, pic);
543 if (pic->f->linesize[1] != pic->f->linesize[2]) {
544 av_log(s->avctx, AV_LOG_ERROR,
545 "get_buffer() failed (uv stride mismatch)\n");
546 ff_mpeg_unref_picture(s->avctx, pic);
550 if (!s->edge_emu_buffer &&
551 (ret = frame_size_alloc(s, pic->f->linesize[0])) < 0) {
552 av_log(s->avctx, AV_LOG_ERROR,
553 "get_buffer() failed to allocate context scratch buffers.\n");
554 ff_mpeg_unref_picture(s->avctx, pic);
561 void ff_free_picture_tables(Picture *pic)
565 pic->alloc_mb_width =
566 pic->alloc_mb_height = 0;
568 av_buffer_unref(&pic->mb_var_buf);
569 av_buffer_unref(&pic->mc_mb_var_buf);
570 av_buffer_unref(&pic->mb_mean_buf);
571 av_buffer_unref(&pic->mbskip_table_buf);
572 av_buffer_unref(&pic->qscale_table_buf);
573 av_buffer_unref(&pic->mb_type_buf);
575 for (i = 0; i < 2; i++) {
576 av_buffer_unref(&pic->motion_val_buf[i]);
577 av_buffer_unref(&pic->ref_index_buf[i]);
581 static int alloc_picture_tables(MpegEncContext *s, Picture *pic)
583 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
584 const int mb_array_size = s->mb_stride * s->mb_height;
585 const int b8_array_size = s->b8_stride * s->mb_height * 2;
589 pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
590 pic->qscale_table_buf = av_buffer_allocz(big_mb_num + s->mb_stride);
591 pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) *
593 if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
594 return AVERROR(ENOMEM);
597 pic->mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
598 pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
599 pic->mb_mean_buf = av_buffer_allocz(mb_array_size);
600 if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
601 return AVERROR(ENOMEM);
604 if (s->out_format == FMT_H263 || s->encoding || s->avctx->debug_mv ||
605 (s->avctx->flags2 & CODEC_FLAG2_EXPORT_MVS)) {
606 int mv_size = 2 * (b8_array_size + 4) * sizeof(int16_t);
607 int ref_index_size = 4 * mb_array_size;
609 for (i = 0; mv_size && i < 2; i++) {
610 pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
611 pic->ref_index_buf[i] = av_buffer_allocz(ref_index_size);
612 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
613 return AVERROR(ENOMEM);
617 pic->alloc_mb_width = s->mb_width;
618 pic->alloc_mb_height = s->mb_height;
623 static int make_tables_writable(Picture *pic)
626 #define MAKE_WRITABLE(table) \
629 (ret = av_buffer_make_writable(&pic->table)) < 0)\
633 MAKE_WRITABLE(mb_var_buf);
634 MAKE_WRITABLE(mc_mb_var_buf);
635 MAKE_WRITABLE(mb_mean_buf);
636 MAKE_WRITABLE(mbskip_table_buf);
637 MAKE_WRITABLE(qscale_table_buf);
638 MAKE_WRITABLE(mb_type_buf);
640 for (i = 0; i < 2; i++) {
641 MAKE_WRITABLE(motion_val_buf[i]);
642 MAKE_WRITABLE(ref_index_buf[i]);
649 * Allocate a Picture.
650 * The pixels are allocated/set by calling get_buffer() if shared = 0
652 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
656 if (pic->qscale_table_buf)
657 if ( pic->alloc_mb_width != s->mb_width
658 || pic->alloc_mb_height != s->mb_height)
659 ff_free_picture_tables(pic);
662 av_assert0(pic->f->data[0]);
665 av_assert0(!pic->f->buf[0]);
667 if (alloc_frame_buffer(s, pic) < 0)
670 s->linesize = pic->f->linesize[0];
671 s->uvlinesize = pic->f->linesize[1];
674 if (!pic->qscale_table_buf)
675 ret = alloc_picture_tables(s, pic);
677 ret = make_tables_writable(pic);
682 pic->mb_var = (uint16_t*)pic->mb_var_buf->data;
683 pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
684 pic->mb_mean = pic->mb_mean_buf->data;
687 pic->mbskip_table = pic->mbskip_table_buf->data;
688 pic->qscale_table = pic->qscale_table_buf->data + 2 * s->mb_stride + 1;
689 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
691 if (pic->motion_val_buf[0]) {
692 for (i = 0; i < 2; i++) {
693 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
694 pic->ref_index[i] = pic->ref_index_buf[i]->data;
700 av_log(s->avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
701 ff_mpeg_unref_picture(s->avctx, pic);
702 ff_free_picture_tables(pic);
703 return AVERROR(ENOMEM);
707 * Deallocate a picture.
709 void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
711 int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
714 /* WM Image / Screen codecs allocate internal buffers with different
715 * dimensions / colorspaces; ignore user-defined callbacks for these. */
716 if (avctx->codec->id != AV_CODEC_ID_WMV3IMAGE &&
717 avctx->codec->id != AV_CODEC_ID_VC1IMAGE &&
718 avctx->codec->id != AV_CODEC_ID_MSS2)
719 ff_thread_release_buffer(avctx, &pic->tf);
721 av_frame_unref(pic->f);
723 av_buffer_unref(&pic->hwaccel_priv_buf);
725 if (pic->needs_realloc)
726 ff_free_picture_tables(pic);
728 memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
731 static int update_picture_tables(Picture *dst, Picture *src)
735 #define UPDATE_TABLE(table)\
738 (!dst->table || dst->table->buffer != src->table->buffer)) {\
739 av_buffer_unref(&dst->table);\
740 dst->table = av_buffer_ref(src->table);\
742 ff_free_picture_tables(dst);\
743 return AVERROR(ENOMEM);\
748 UPDATE_TABLE(mb_var_buf);
749 UPDATE_TABLE(mc_mb_var_buf);
750 UPDATE_TABLE(mb_mean_buf);
751 UPDATE_TABLE(mbskip_table_buf);
752 UPDATE_TABLE(qscale_table_buf);
753 UPDATE_TABLE(mb_type_buf);
754 for (i = 0; i < 2; i++) {
755 UPDATE_TABLE(motion_val_buf[i]);
756 UPDATE_TABLE(ref_index_buf[i]);
759 dst->mb_var = src->mb_var;
760 dst->mc_mb_var = src->mc_mb_var;
761 dst->mb_mean = src->mb_mean;
762 dst->mbskip_table = src->mbskip_table;
763 dst->qscale_table = src->qscale_table;
764 dst->mb_type = src->mb_type;
765 for (i = 0; i < 2; i++) {
766 dst->motion_val[i] = src->motion_val[i];
767 dst->ref_index[i] = src->ref_index[i];
770 dst->alloc_mb_width = src->alloc_mb_width;
771 dst->alloc_mb_height = src->alloc_mb_height;
776 int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
780 av_assert0(!dst->f->buf[0]);
781 av_assert0(src->f->buf[0]);
785 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
789 ret = update_picture_tables(dst, src);
793 if (src->hwaccel_picture_private) {
794 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
795 if (!dst->hwaccel_priv_buf)
797 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
800 dst->field_picture = src->field_picture;
801 dst->mb_var_sum = src->mb_var_sum;
802 dst->mc_mb_var_sum = src->mc_mb_var_sum;
803 dst->b_frame_score = src->b_frame_score;
804 dst->needs_realloc = src->needs_realloc;
805 dst->reference = src->reference;
806 dst->shared = src->shared;
810 ff_mpeg_unref_picture(avctx, dst);
814 static int init_duplicate_context(MpegEncContext *s)
816 int y_size = s->b8_stride * (2 * s->mb_height + 1);
817 int c_size = s->mb_stride * (s->mb_height + 1);
818 int yc_size = y_size + 2 * c_size;
821 if (s->mb_height & 1)
822 yc_size += 2*s->b8_stride + 2*s->mb_stride;
829 s->obmc_scratchpad = NULL;
832 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
833 ME_MAP_SIZE * sizeof(uint32_t), fail)
834 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
835 ME_MAP_SIZE * sizeof(uint32_t), fail)
836 if (s->avctx->noise_reduction) {
837 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
838 2 * 64 * sizeof(int), fail)
841 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
842 s->block = s->blocks[0];
844 for (i = 0; i < 12; i++) {
845 s->pblocks[i] = &s->block[i];
847 if (s->avctx->codec_tag == AV_RL32("VCR2")) {
851 s->pblocks[4] = s->pblocks[5];
855 if (s->out_format == FMT_H263) {
857 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
858 yc_size * sizeof(int16_t) * 16, fail);
859 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
860 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
861 s->ac_val[2] = s->ac_val[1] + c_size;
866 return -1; // free() through ff_mpv_common_end()
869 static void free_duplicate_context(MpegEncContext *s)
874 av_freep(&s->edge_emu_buffer);
875 av_freep(&s->me.scratchpad);
879 s->obmc_scratchpad = NULL;
881 av_freep(&s->dct_error_sum);
882 av_freep(&s->me.map);
883 av_freep(&s->me.score_map);
884 av_freep(&s->blocks);
885 av_freep(&s->ac_val_base);
889 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
891 #define COPY(a) bak->a = src->a
892 COPY(edge_emu_buffer);
897 COPY(obmc_scratchpad);
904 COPY(me.map_generation);
916 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
920 // FIXME copy only needed parts
922 backup_duplicate_context(&bak, dst);
923 memcpy(dst, src, sizeof(MpegEncContext));
924 backup_duplicate_context(dst, &bak);
925 for (i = 0; i < 12; i++) {
926 dst->pblocks[i] = &dst->block[i];
928 if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
931 tmp = dst->pblocks[4];
932 dst->pblocks[4] = dst->pblocks[5];
933 dst->pblocks[5] = tmp;
935 if (!dst->edge_emu_buffer &&
936 (ret = frame_size_alloc(dst, dst->linesize)) < 0) {
937 av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
938 "scratch buffers.\n");
941 // STOP_TIMER("update_duplicate_context")
942 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
946 int ff_mpeg_update_thread_context(AVCodecContext *dst,
947 const AVCodecContext *src)
950 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
957 // FIXME can parameters change on I-frames?
958 // in that case dst may need a reinit
959 if (!s->context_initialized) {
961 memcpy(s, s1, sizeof(MpegEncContext));
964 s->bitstream_buffer = NULL;
965 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
967 if (s1->context_initialized){
968 // s->picture_range_start += MAX_PICTURE_COUNT;
969 // s->picture_range_end += MAX_PICTURE_COUNT;
971 if((err = ff_mpv_common_init(s)) < 0){
972 memset(s, 0, sizeof(MpegEncContext));
979 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
980 s->context_reinit = 0;
981 s->height = s1->height;
982 s->width = s1->width;
983 if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
987 s->avctx->coded_height = s1->avctx->coded_height;
988 s->avctx->coded_width = s1->avctx->coded_width;
989 s->avctx->width = s1->avctx->width;
990 s->avctx->height = s1->avctx->height;
992 s->coded_picture_number = s1->coded_picture_number;
993 s->picture_number = s1->picture_number;
995 av_assert0(!s->picture || s->picture != s1->picture);
997 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
998 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
999 if (s1->picture[i].f->buf[0] &&
1000 (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
1004 #define UPDATE_PICTURE(pic)\
1006 ff_mpeg_unref_picture(s->avctx, &s->pic);\
1007 if (s1->pic.f && s1->pic.f->buf[0])\
1008 ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
1010 ret = update_picture_tables(&s->pic, &s1->pic);\
1015 UPDATE_PICTURE(current_picture);
1016 UPDATE_PICTURE(last_picture);
1017 UPDATE_PICTURE(next_picture);
1019 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
1020 ((pic && pic >= old_ctx->picture && \
1021 pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
1022 &new_ctx->picture[pic - old_ctx->picture] : NULL)
1024 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
1025 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
1026 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
1028 // Error/bug resilience
1029 s->next_p_frame_damaged = s1->next_p_frame_damaged;
1030 s->workaround_bugs = s1->workaround_bugs;
1031 s->padding_bug_score = s1->padding_bug_score;
1033 // MPEG4 timing info
1034 memcpy(&s->last_time_base, &s1->last_time_base,
1035 (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
1036 (char *) &s1->last_time_base);
1039 s->max_b_frames = s1->max_b_frames;
1040 s->low_delay = s1->low_delay;
1041 s->droppable = s1->droppable;
1043 // DivX handling (doesn't work)
1044 s->divx_packed = s1->divx_packed;
1046 if (s1->bitstream_buffer) {
1047 if (s1->bitstream_buffer_size +
1048 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) {
1049 av_fast_malloc(&s->bitstream_buffer,
1050 &s->allocated_bitstream_buffer_size,
1051 s1->allocated_bitstream_buffer_size);
1052 if (!s->bitstream_buffer) {
1053 s->bitstream_buffer_size = 0;
1054 return AVERROR(ENOMEM);
1057 s->bitstream_buffer_size = s1->bitstream_buffer_size;
1058 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
1059 s1->bitstream_buffer_size);
1060 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
1061 FF_INPUT_BUFFER_PADDING_SIZE);
1064 // linesize dependend scratch buffer allocation
1065 if (!s->edge_emu_buffer)
1067 if (frame_size_alloc(s, s1->linesize) < 0) {
1068 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
1069 "scratch buffers.\n");
1070 return AVERROR(ENOMEM);
1073 av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
1074 "be allocated due to unknown size.\n");
1077 // MPEG2/interlacing info
1078 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
1079 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
1081 if (!s1->first_field) {
1082 s->last_pict_type = s1->pict_type;
1083 if (s1->current_picture_ptr)
1084 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
1091 * Set the given MpegEncContext to common defaults
1092 * (same for encoding and decoding).
1093 * The changed fields will not depend upon the
1094 * prior state of the MpegEncContext.
1096 void ff_mpv_common_defaults(MpegEncContext *s)
1098 s->y_dc_scale_table =
1099 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
1100 s->chroma_qscale_table = ff_default_chroma_qscale_table;
1101 s->progressive_frame = 1;
1102 s->progressive_sequence = 1;
1103 s->picture_structure = PICT_FRAME;
1105 s->coded_picture_number = 0;
1106 s->picture_number = 0;
1111 s->slice_context_count = 1;
1115 * Set the given MpegEncContext to defaults for decoding.
1116 * the changed fields will not depend upon
1117 * the prior state of the MpegEncContext.
1119 void ff_mpv_decode_defaults(MpegEncContext *s)
1121 ff_mpv_common_defaults(s);
1124 void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
1127 s->width = avctx->coded_width;
1128 s->height = avctx->coded_height;
1129 s->codec_id = avctx->codec->id;
1130 s->workaround_bugs = avctx->workaround_bugs;
1132 /* convert fourcc to upper case */
1133 s->codec_tag = avpriv_toupper4(avctx->codec_tag);
1136 static int init_er(MpegEncContext *s)
1138 ERContext *er = &s->er;
1139 int mb_array_size = s->mb_height * s->mb_stride;
1142 er->avctx = s->avctx;
1144 er->mb_index2xy = s->mb_index2xy;
1145 er->mb_num = s->mb_num;
1146 er->mb_width = s->mb_width;
1147 er->mb_height = s->mb_height;
1148 er->mb_stride = s->mb_stride;
1149 er->b8_stride = s->b8_stride;
1151 er->er_temp_buffer = av_malloc(s->mb_height * s->mb_stride);
1152 er->error_status_table = av_mallocz(mb_array_size);
1153 if (!er->er_temp_buffer || !er->error_status_table)
1156 er->mbskip_table = s->mbskip_table;
1157 er->mbintra_table = s->mbintra_table;
1159 for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
1160 er->dc_val[i] = s->dc_val[i];
1162 er->decode_mb = mpeg_er_decode_mb;
1167 av_freep(&er->er_temp_buffer);
1168 av_freep(&er->error_status_table);
1169 return AVERROR(ENOMEM);
1173 * Initialize and allocates MpegEncContext fields dependent on the resolution.
1175 static int init_context_frame(MpegEncContext *s)
1177 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
1179 s->mb_width = (s->width + 15) / 16;
1180 s->mb_stride = s->mb_width + 1;
1181 s->b8_stride = s->mb_width * 2 + 1;
1182 mb_array_size = s->mb_height * s->mb_stride;
1183 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
1185 /* set default edge pos, will be overridden
1186 * in decode_header if needed */
1187 s->h_edge_pos = s->mb_width * 16;
1188 s->v_edge_pos = s->mb_height * 16;
1190 s->mb_num = s->mb_width * s->mb_height;
1195 s->block_wrap[3] = s->b8_stride;
1197 s->block_wrap[5] = s->mb_stride;
1199 y_size = s->b8_stride * (2 * s->mb_height + 1);
1200 c_size = s->mb_stride * (s->mb_height + 1);
1201 yc_size = y_size + 2 * c_size;
1203 if (s->mb_height & 1)
1204 yc_size += 2*s->b8_stride + 2*s->mb_stride;
1206 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
1207 for (y = 0; y < s->mb_height; y++)
1208 for (x = 0; x < s->mb_width; x++)
1209 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
1211 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
1214 /* Allocate MV tables */
1215 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1216 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1217 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1218 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1219 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1220 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1221 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
1222 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
1223 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
1224 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
1225 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
1226 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
1228 /* Allocate MB type table */
1229 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
1231 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
1233 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
1234 mb_array_size * sizeof(float), fail);
1235 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
1236 mb_array_size * sizeof(float), fail);
1240 if (s->codec_id == AV_CODEC_ID_MPEG4 ||
1241 (s->avctx->flags & CODEC_FLAG_INTERLACED_ME)) {
1242 /* interlaced direct mode decoding tables */
1243 for (i = 0; i < 2; i++) {
1245 for (j = 0; j < 2; j++) {
1246 for (k = 0; k < 2; k++) {
1247 FF_ALLOCZ_OR_GOTO(s->avctx,
1248 s->b_field_mv_table_base[i][j][k],
1249 mv_table_size * 2 * sizeof(int16_t),
1251 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
1254 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
1255 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
1256 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
1258 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
1261 if (s->out_format == FMT_H263) {
1263 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
1264 s->coded_block = s->coded_block_base + s->b8_stride + 1;
1266 /* cbp, ac_pred, pred_dir */
1267 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
1268 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
1271 if (s->h263_pred || s->h263_plus || !s->encoding) {
1273 // MN: we need these for error resilience of intra-frames
1274 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
1275 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
1276 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
1277 s->dc_val[2] = s->dc_val[1] + c_size;
1278 for (i = 0; i < yc_size; i++)
1279 s->dc_val_base[i] = 1024;
1282 /* which mb is a intra block */
1283 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
1284 memset(s->mbintra_table, 1, mb_array_size);
1286 /* init macroblock skip table */
1287 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
1288 // Note the + 1 is for a quicker mpeg4 slice_end detection
1292 return AVERROR(ENOMEM);
1296 * init common structure for both encoder and decoder.
1297 * this assumes that some variables like width/height are already set
1299 av_cold int ff_mpv_common_init(MpegEncContext *s)
1302 int nb_slices = (HAVE_THREADS &&
1303 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
1304 s->avctx->thread_count : 1;
1306 if (s->encoding && s->avctx->slices)
1307 nb_slices = s->avctx->slices;
1309 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1310 s->mb_height = (s->height + 31) / 32 * 2;
1312 s->mb_height = (s->height + 15) / 16;
1314 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1315 av_log(s->avctx, AV_LOG_ERROR,
1316 "decoding to AV_PIX_FMT_NONE is not supported.\n");
1320 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1323 max_slices = FFMIN(MAX_THREADS, s->mb_height);
1325 max_slices = MAX_THREADS;
1326 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1327 " reducing to %d\n", nb_slices, max_slices);
1328 nb_slices = max_slices;
1331 if ((s->width || s->height) &&
1332 av_image_check_size(s->width, s->height, 0, s->avctx))
1337 /* set chroma shifts */
1338 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1340 &s->chroma_y_shift);
1343 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1344 MAX_PICTURE_COUNT * sizeof(Picture), fail);
1345 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1346 s->picture[i].f = av_frame_alloc();
1347 if (!s->picture[i].f)
1350 memset(&s->next_picture, 0, sizeof(s->next_picture));
1351 memset(&s->last_picture, 0, sizeof(s->last_picture));
1352 memset(&s->current_picture, 0, sizeof(s->current_picture));
1353 memset(&s->new_picture, 0, sizeof(s->new_picture));
1354 s->next_picture.f = av_frame_alloc();
1355 if (!s->next_picture.f)
1357 s->last_picture.f = av_frame_alloc();
1358 if (!s->last_picture.f)
1360 s->current_picture.f = av_frame_alloc();
1361 if (!s->current_picture.f)
1363 s->new_picture.f = av_frame_alloc();
1364 if (!s->new_picture.f)
1367 if (init_context_frame(s))
1370 s->parse_context.state = -1;
1372 s->context_initialized = 1;
1373 s->thread_context[0] = s;
1375 // if (s->width && s->height) {
1376 if (nb_slices > 1) {
1377 for (i = 1; i < nb_slices; i++) {
1378 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1379 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1382 for (i = 0; i < nb_slices; i++) {
1383 if (init_duplicate_context(s->thread_context[i]) < 0)
1385 s->thread_context[i]->start_mb_y =
1386 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1387 s->thread_context[i]->end_mb_y =
1388 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1391 if (init_duplicate_context(s) < 0)
1394 s->end_mb_y = s->mb_height;
1396 s->slice_context_count = nb_slices;
1401 ff_mpv_common_end(s);
1406 * Frees and resets MpegEncContext fields depending on the resolution.
1407 * Is used during resolution changes to avoid a full reinitialization of the
1410 static void free_context_frame(MpegEncContext *s)
1414 av_freep(&s->mb_type);
1415 av_freep(&s->p_mv_table_base);
1416 av_freep(&s->b_forw_mv_table_base);
1417 av_freep(&s->b_back_mv_table_base);
1418 av_freep(&s->b_bidir_forw_mv_table_base);
1419 av_freep(&s->b_bidir_back_mv_table_base);
1420 av_freep(&s->b_direct_mv_table_base);
1421 s->p_mv_table = NULL;
1422 s->b_forw_mv_table = NULL;
1423 s->b_back_mv_table = NULL;
1424 s->b_bidir_forw_mv_table = NULL;
1425 s->b_bidir_back_mv_table = NULL;
1426 s->b_direct_mv_table = NULL;
1427 for (i = 0; i < 2; i++) {
1428 for (j = 0; j < 2; j++) {
1429 for (k = 0; k < 2; k++) {
1430 av_freep(&s->b_field_mv_table_base[i][j][k]);
1431 s->b_field_mv_table[i][j][k] = NULL;
1433 av_freep(&s->b_field_select_table[i][j]);
1434 av_freep(&s->p_field_mv_table_base[i][j]);
1435 s->p_field_mv_table[i][j] = NULL;
1437 av_freep(&s->p_field_select_table[i]);
1440 av_freep(&s->dc_val_base);
1441 av_freep(&s->coded_block_base);
1442 av_freep(&s->mbintra_table);
1443 av_freep(&s->cbp_table);
1444 av_freep(&s->pred_dir_table);
1446 av_freep(&s->mbskip_table);
1448 av_freep(&s->er.error_status_table);
1449 av_freep(&s->er.er_temp_buffer);
1450 av_freep(&s->mb_index2xy);
1451 av_freep(&s->lambda_table);
1453 av_freep(&s->cplx_tab);
1454 av_freep(&s->bits_tab);
1456 s->linesize = s->uvlinesize = 0;
1459 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1463 if (!s->context_initialized)
1464 return AVERROR(EINVAL);
1466 if (s->slice_context_count > 1) {
1467 for (i = 0; i < s->slice_context_count; i++) {
1468 free_duplicate_context(s->thread_context[i]);
1470 for (i = 1; i < s->slice_context_count; i++) {
1471 av_freep(&s->thread_context[i]);
1474 free_duplicate_context(s);
1476 free_context_frame(s);
1479 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1480 s->picture[i].needs_realloc = 1;
1483 s->last_picture_ptr =
1484 s->next_picture_ptr =
1485 s->current_picture_ptr = NULL;
1488 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1489 s->mb_height = (s->height + 31) / 32 * 2;
1491 s->mb_height = (s->height + 15) / 16;
1493 if ((s->width || s->height) &&
1494 (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1497 if ((err = init_context_frame(s)))
1500 s->thread_context[0] = s;
1502 if (s->width && s->height) {
1503 int nb_slices = s->slice_context_count;
1504 if (nb_slices > 1) {
1505 for (i = 1; i < nb_slices; i++) {
1506 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1507 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1510 for (i = 0; i < nb_slices; i++) {
1511 if ((err = init_duplicate_context(s->thread_context[i])) < 0)
1513 s->thread_context[i]->start_mb_y =
1514 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1515 s->thread_context[i]->end_mb_y =
1516 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1519 err = init_duplicate_context(s);
1523 s->end_mb_y = s->mb_height;
1525 s->slice_context_count = nb_slices;
1530 ff_mpv_common_end(s);
1534 /* init common structure for both encoder and decoder */
1535 void ff_mpv_common_end(MpegEncContext *s)
1539 if (s->slice_context_count > 1) {
1540 for (i = 0; i < s->slice_context_count; i++) {
1541 free_duplicate_context(s->thread_context[i]);
1543 for (i = 1; i < s->slice_context_count; i++) {
1544 av_freep(&s->thread_context[i]);
1546 s->slice_context_count = 1;
1547 } else free_duplicate_context(s);
1549 av_freep(&s->parse_context.buffer);
1550 s->parse_context.buffer_size = 0;
1552 av_freep(&s->bitstream_buffer);
1553 s->allocated_bitstream_buffer_size = 0;
1556 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1557 ff_free_picture_tables(&s->picture[i]);
1558 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1559 av_frame_free(&s->picture[i].f);
1562 av_freep(&s->picture);
1563 ff_free_picture_tables(&s->last_picture);
1564 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1565 av_frame_free(&s->last_picture.f);
1566 ff_free_picture_tables(&s->current_picture);
1567 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1568 av_frame_free(&s->current_picture.f);
1569 ff_free_picture_tables(&s->next_picture);
1570 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1571 av_frame_free(&s->next_picture.f);
1572 ff_free_picture_tables(&s->new_picture);
1573 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1574 av_frame_free(&s->new_picture.f);
1576 free_context_frame(s);
1578 s->context_initialized = 0;
1579 s->last_picture_ptr =
1580 s->next_picture_ptr =
1581 s->current_picture_ptr = NULL;
1582 s->linesize = s->uvlinesize = 0;
1585 static void release_unused_pictures(AVCodecContext *avctx, Picture *picture)
1589 /* release non reference frames */
1590 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1591 if (!picture[i].reference)
1592 ff_mpeg_unref_picture(avctx, &picture[i]);
1596 static inline int pic_is_unused(Picture *pic)
1598 if (!pic->f->buf[0])
1600 if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1605 static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
1610 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1611 if (!picture[i].f->buf[0])
1615 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1616 if (pic_is_unused(&picture[i]))
1621 av_log(avctx, AV_LOG_FATAL,
1622 "Internal error, picture buffer overflow\n");
1623 /* We could return -1, but the codec would crash trying to draw into a
1624 * non-existing frame anyway. This is safer than waiting for a random crash.
1625 * Also the return of this is never useful, an encoder must only allocate
1626 * as much as allowed in the specification. This has no relationship to how
1627 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1628 * enough for such valid streams).
1629 * Plus, a decoder has to check stream validity and remove frames if too
1630 * many reference frames are around. Waiting for "OOM" is not correct at
1631 * all. Similarly, missing reference frames have to be replaced by
1632 * interpolated/MC frames, anything else is a bug in the codec ...
1638 int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
1640 int ret = find_unused_picture(avctx, picture, shared);
1642 if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1643 if (picture[ret].needs_realloc) {
1644 picture[ret].needs_realloc = 0;
1645 ff_free_picture_tables(&picture[ret]);
1646 ff_mpeg_unref_picture(avctx, &picture[ret]);
1652 static void gray_frame(AVFrame *frame)
1654 int i, h_chroma_shift, v_chroma_shift;
1656 av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1658 for(i=0; i<frame->height; i++)
1659 memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1660 for(i=0; i<FF_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1661 memset(frame->data[1] + frame->linesize[1]*i,
1662 0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1663 memset(frame->data[2] + frame->linesize[2]*i,
1664 0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1669 * generic function called after decoding
1670 * the header and before a frame is decoded.
1672 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1678 if (!ff_thread_can_start_frame(avctx)) {
1679 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1683 /* mark & release old frames */
1684 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1685 s->last_picture_ptr != s->next_picture_ptr &&
1686 s->last_picture_ptr->f->buf[0]) {
1687 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1690 /* release forgotten pictures */
1691 /* if (mpeg124/h263) */
1692 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1693 if (&s->picture[i] != s->last_picture_ptr &&
1694 &s->picture[i] != s->next_picture_ptr &&
1695 s->picture[i].reference && !s->picture[i].needs_realloc) {
1696 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1697 av_log(avctx, AV_LOG_ERROR,
1698 "releasing zombie picture\n");
1699 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1703 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1705 release_unused_pictures(s->avctx, s->picture);
1707 if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1708 // we already have a unused image
1709 // (maybe it was set before reading the header)
1710 pic = s->current_picture_ptr;
1712 i = ff_find_unused_picture(s->avctx, s->picture, 0);
1714 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1717 pic = &s->picture[i];
1721 if (!s->droppable) {
1722 if (s->pict_type != AV_PICTURE_TYPE_B)
1726 pic->f->coded_picture_number = s->coded_picture_number++;
1728 if (ff_alloc_picture(s, pic, 0) < 0)
1731 s->current_picture_ptr = pic;
1732 // FIXME use only the vars from current_pic
1733 s->current_picture_ptr->f->top_field_first = s->top_field_first;
1734 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1735 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1736 if (s->picture_structure != PICT_FRAME)
1737 s->current_picture_ptr->f->top_field_first =
1738 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1740 s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1741 !s->progressive_sequence;
1742 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1744 s->current_picture_ptr->f->pict_type = s->pict_type;
1745 // if (s->avctx->flags && CODEC_FLAG_QSCALE)
1746 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1747 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1749 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1750 s->current_picture_ptr)) < 0)
1753 if (s->pict_type != AV_PICTURE_TYPE_B) {
1754 s->last_picture_ptr = s->next_picture_ptr;
1756 s->next_picture_ptr = s->current_picture_ptr;
1758 ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1759 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1760 s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1761 s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1762 s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1763 s->pict_type, s->droppable);
1765 if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1766 (s->pict_type != AV_PICTURE_TYPE_I ||
1767 s->picture_structure != PICT_FRAME)) {
1768 int h_chroma_shift, v_chroma_shift;
1769 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1770 &h_chroma_shift, &v_chroma_shift);
1771 if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1772 av_log(avctx, AV_LOG_DEBUG,
1773 "allocating dummy last picture for B frame\n");
1774 else if (s->pict_type != AV_PICTURE_TYPE_I)
1775 av_log(avctx, AV_LOG_ERROR,
1776 "warning: first frame is no keyframe\n");
1777 else if (s->picture_structure != PICT_FRAME)
1778 av_log(avctx, AV_LOG_DEBUG,
1779 "allocate dummy last picture for field based first keyframe\n");
1781 /* Allocate a dummy frame */
1782 i = ff_find_unused_picture(s->avctx, s->picture, 0);
1784 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1787 s->last_picture_ptr = &s->picture[i];
1789 s->last_picture_ptr->reference = 3;
1790 s->last_picture_ptr->f->key_frame = 0;
1791 s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1793 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1794 s->last_picture_ptr = NULL;
1798 if (!avctx->hwaccel && !(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)) {
1799 for(i=0; i<avctx->height; i++)
1800 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1801 0x80, avctx->width);
1802 if (s->last_picture_ptr->f->data[2]) {
1803 for(i=0; i<FF_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1804 memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1805 0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1806 memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1807 0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1811 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1812 for(i=0; i<avctx->height; i++)
1813 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1817 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1818 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1820 if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1821 s->pict_type == AV_PICTURE_TYPE_B) {
1822 /* Allocate a dummy frame */
1823 i = ff_find_unused_picture(s->avctx, s->picture, 0);
1825 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1828 s->next_picture_ptr = &s->picture[i];
1830 s->next_picture_ptr->reference = 3;
1831 s->next_picture_ptr->f->key_frame = 0;
1832 s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1834 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1835 s->next_picture_ptr = NULL;
1838 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1839 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1842 #if 0 // BUFREF-FIXME
1843 memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1844 memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1846 if (s->last_picture_ptr) {
1847 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1848 if (s->last_picture_ptr->f->buf[0] &&
1849 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1850 s->last_picture_ptr)) < 0)
1853 if (s->next_picture_ptr) {
1854 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1855 if (s->next_picture_ptr->f->buf[0] &&
1856 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1857 s->next_picture_ptr)) < 0)
1861 av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1862 s->last_picture_ptr->f->buf[0]));
1864 if (s->picture_structure!= PICT_FRAME) {
1866 for (i = 0; i < 4; i++) {
1867 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1868 s->current_picture.f->data[i] +=
1869 s->current_picture.f->linesize[i];
1871 s->current_picture.f->linesize[i] *= 2;
1872 s->last_picture.f->linesize[i] *= 2;
1873 s->next_picture.f->linesize[i] *= 2;
1877 /* set dequantizer, we can't do it during init as
1878 * it might change for mpeg4 and we can't do it in the header
1879 * decode as init is not called for mpeg4 there yet */
1880 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1881 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1882 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1883 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1884 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1885 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1887 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1888 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1891 if (s->avctx->debug & FF_DEBUG_NOMC) {
1892 gray_frame(s->current_picture_ptr->f);
1898 /* called after a frame has been decoded. */
1899 void ff_mpv_frame_end(MpegEncContext *s)
1903 if (s->current_picture.reference)
1904 ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1909 static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx)
1912 return clip_line(ex, ey, sx, sy, maxx);
1917 *sy = *ey + (*sy - *ey) * (int64_t)*ex / (*ex - *sx);
1924 *ey = *sy + (*ey - *sy) * (int64_t)(maxx - *sx) / (*ex - *sx);
1932 * Draw a line from (ex, ey) -> (sx, sy).
1933 * @param w width of the image
1934 * @param h height of the image
1935 * @param stride stride/linesize of the image
1936 * @param color color of the arrow
1938 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1939 int w, int h, int stride, int color)
1943 if (clip_line(&sx, &sy, &ex, &ey, w - 1))
1945 if (clip_line(&sy, &sx, &ey, &ex, h - 1))
1948 sx = av_clip(sx, 0, w - 1);
1949 sy = av_clip(sy, 0, h - 1);
1950 ex = av_clip(ex, 0, w - 1);
1951 ey = av_clip(ey, 0, h - 1);
1953 buf[sy * stride + sx] += color;
1955 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1957 FFSWAP(int, sx, ex);
1958 FFSWAP(int, sy, ey);
1960 buf += sx + sy * stride;
1962 f = ((ey - sy) << 16) / ex;
1963 for (x = 0; x <= ex; x++) {
1965 fr = (x * f) & 0xFFFF;
1966 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1967 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1971 FFSWAP(int, sx, ex);
1972 FFSWAP(int, sy, ey);
1974 buf += sx + sy * stride;
1977 f = ((ex - sx) << 16) / ey;
1980 for(y= 0; y <= ey; y++){
1982 fr = (y*f) & 0xFFFF;
1983 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1984 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1990 * Draw an arrow from (ex, ey) -> (sx, sy).
1991 * @param w width of the image
1992 * @param h height of the image
1993 * @param stride stride/linesize of the image
1994 * @param color color of the arrow
1996 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1997 int ey, int w, int h, int stride, int color, int tail, int direction)
2002 FFSWAP(int, sx, ex);
2003 FFSWAP(int, sy, ey);
2006 sx = av_clip(sx, -100, w + 100);
2007 sy = av_clip(sy, -100, h + 100);
2008 ex = av_clip(ex, -100, w + 100);
2009 ey = av_clip(ey, -100, h + 100);
2014 if (dx * dx + dy * dy > 3 * 3) {
2017 int length = ff_sqrt((rx * rx + ry * ry) << 8);
2019 // FIXME subpixel accuracy
2020 rx = ROUNDED_DIV(rx * 3 << 4, length);
2021 ry = ROUNDED_DIV(ry * 3 << 4, length);
2028 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
2029 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
2031 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
2035 static int add_mb(AVMotionVector *mb, uint32_t mb_type,
2036 int dst_x, int dst_y,
2037 int src_x, int src_y,
2040 mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
2041 mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
2046 mb->source = direction ? 1 : -1;
2047 mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
2052 * Print debugging info for the given picture.
2054 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
2055 uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
2057 int mb_width, int mb_height, int mb_stride, int quarter_sample)
2059 if ((avctx->flags2 & CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
2060 const int shift = 1 + quarter_sample;
2061 const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2062 const int mv_stride = (mb_width << mv_sample_log2) +
2063 (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2064 int mb_x, mb_y, mbcount = 0;
2066 /* size is width * height * 2 * 4 where 2 is for directions and 4 is
2067 * for the maximum number of MB (4 MB in case of IS_8x8) */
2068 AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
2072 for (mb_y = 0; mb_y < mb_height; mb_y++) {
2073 for (mb_x = 0; mb_x < mb_width; mb_x++) {
2074 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
2075 for (direction = 0; direction < 2; direction++) {
2076 if (!USES_LIST(mb_type, direction))
2078 if (IS_8X8(mb_type)) {
2079 for (i = 0; i < 4; i++) {
2080 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2081 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2082 int xy = (mb_x * 2 + (i & 1) +
2083 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2084 int mx = (motion_val[direction][xy][0] >> shift) + sx;
2085 int my = (motion_val[direction][xy][1] >> shift) + sy;
2086 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2088 } else if (IS_16X8(mb_type)) {
2089 for (i = 0; i < 2; i++) {
2090 int sx = mb_x * 16 + 8;
2091 int sy = mb_y * 16 + 4 + 8 * i;
2092 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2093 int mx = (motion_val[direction][xy][0] >> shift);
2094 int my = (motion_val[direction][xy][1] >> shift);
2096 if (IS_INTERLACED(mb_type))
2099 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2101 } else if (IS_8X16(mb_type)) {
2102 for (i = 0; i < 2; i++) {
2103 int sx = mb_x * 16 + 4 + 8 * i;
2104 int sy = mb_y * 16 + 8;
2105 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2106 int mx = motion_val[direction][xy][0] >> shift;
2107 int my = motion_val[direction][xy][1] >> shift;
2109 if (IS_INTERLACED(mb_type))
2112 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2115 int sx = mb_x * 16 + 8;
2116 int sy = mb_y * 16 + 8;
2117 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
2118 int mx = (motion_val[direction][xy][0]>>shift) + sx;
2119 int my = (motion_val[direction][xy][1]>>shift) + sy;
2120 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2127 AVFrameSideData *sd;
2129 av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
2130 sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
2135 memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
2141 /* TODO: export all the following to make them accessible for users (and filters) */
2142 if (avctx->hwaccel || !mbtype_table
2143 || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
2147 if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
2150 av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
2151 av_get_picture_type_char(pict->pict_type));
2152 for (y = 0; y < mb_height; y++) {
2153 for (x = 0; x < mb_width; x++) {
2154 if (avctx->debug & FF_DEBUG_SKIP) {
2155 int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;
2158 av_log(avctx, AV_LOG_DEBUG, "%1d", count);
2160 if (avctx->debug & FF_DEBUG_QP) {
2161 av_log(avctx, AV_LOG_DEBUG, "%2d",
2162 qscale_table[x + y * mb_stride]);
2164 if (avctx->debug & FF_DEBUG_MB_TYPE) {
2165 int mb_type = mbtype_table[x + y * mb_stride];
2166 // Type & MV direction
2167 if (IS_PCM(mb_type))
2168 av_log(avctx, AV_LOG_DEBUG, "P");
2169 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
2170 av_log(avctx, AV_LOG_DEBUG, "A");
2171 else if (IS_INTRA4x4(mb_type))
2172 av_log(avctx, AV_LOG_DEBUG, "i");
2173 else if (IS_INTRA16x16(mb_type))
2174 av_log(avctx, AV_LOG_DEBUG, "I");
2175 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
2176 av_log(avctx, AV_LOG_DEBUG, "d");
2177 else if (IS_DIRECT(mb_type))
2178 av_log(avctx, AV_LOG_DEBUG, "D");
2179 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
2180 av_log(avctx, AV_LOG_DEBUG, "g");
2181 else if (IS_GMC(mb_type))
2182 av_log(avctx, AV_LOG_DEBUG, "G");
2183 else if (IS_SKIP(mb_type))
2184 av_log(avctx, AV_LOG_DEBUG, "S");
2185 else if (!USES_LIST(mb_type, 1))
2186 av_log(avctx, AV_LOG_DEBUG, ">");
2187 else if (!USES_LIST(mb_type, 0))
2188 av_log(avctx, AV_LOG_DEBUG, "<");
2190 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2191 av_log(avctx, AV_LOG_DEBUG, "X");
2195 if (IS_8X8(mb_type))
2196 av_log(avctx, AV_LOG_DEBUG, "+");
2197 else if (IS_16X8(mb_type))
2198 av_log(avctx, AV_LOG_DEBUG, "-");
2199 else if (IS_8X16(mb_type))
2200 av_log(avctx, AV_LOG_DEBUG, "|");
2201 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
2202 av_log(avctx, AV_LOG_DEBUG, " ");
2204 av_log(avctx, AV_LOG_DEBUG, "?");
2207 if (IS_INTERLACED(mb_type))
2208 av_log(avctx, AV_LOG_DEBUG, "=");
2210 av_log(avctx, AV_LOG_DEBUG, " ");
2213 av_log(avctx, AV_LOG_DEBUG, "\n");
2217 if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
2218 (avctx->debug_mv)) {
2221 int h_chroma_shift, v_chroma_shift, block_height;
2223 const int shift = 1 + quarter_sample;
2225 const int width = avctx->width;
2226 const int height = avctx->height;
2228 const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2229 const int mv_stride = (mb_width << mv_sample_log2) +
2230 (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2232 *low_delay = 0; // needed to see the vectors without trashing the buffers
2234 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2236 av_frame_make_writable(pict);
2238 pict->opaque = NULL;
2240 ptr = pict->data[0];
2242 block_height = 16 >> v_chroma_shift;
2244 for (mb_y = 0; mb_y < mb_height; mb_y++) {
2246 for (mb_x = 0; mb_x < mb_width; mb_x++) {
2247 const int mb_index = mb_x + mb_y * mb_stride;
2249 if ((avctx->debug_mv) && motion_val[0]) {
2251 for (type = 0; type < 3; type++) {
2255 if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
2256 (pict->pict_type!= AV_PICTURE_TYPE_P))
2261 if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
2262 (pict->pict_type!= AV_PICTURE_TYPE_B))
2267 if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
2268 (pict->pict_type!= AV_PICTURE_TYPE_B))
2273 if (!USES_LIST(mbtype_table[mb_index], direction))
2276 if (IS_8X8(mbtype_table[mb_index])) {
2278 for (i = 0; i < 4; i++) {
2279 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2280 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2281 int xy = (mb_x * 2 + (i & 1) +
2282 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2283 int mx = (motion_val[direction][xy][0] >> shift) + sx;
2284 int my = (motion_val[direction][xy][1] >> shift) + sy;
2285 draw_arrow(ptr, sx, sy, mx, my, width,
2286 height, pict->linesize[0], 100, 0, direction);
2288 } else if (IS_16X8(mbtype_table[mb_index])) {
2290 for (i = 0; i < 2; i++) {
2291 int sx = mb_x * 16 + 8;
2292 int sy = mb_y * 16 + 4 + 8 * i;
2293 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2294 int mx = (motion_val[direction][xy][0] >> shift);
2295 int my = (motion_val[direction][xy][1] >> shift);
2297 if (IS_INTERLACED(mbtype_table[mb_index]))
2300 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2301 height, pict->linesize[0], 100, 0, direction);
2303 } else if (IS_8X16(mbtype_table[mb_index])) {
2305 for (i = 0; i < 2; i++) {
2306 int sx = mb_x * 16 + 4 + 8 * i;
2307 int sy = mb_y * 16 + 8;
2308 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2309 int mx = motion_val[direction][xy][0] >> shift;
2310 int my = motion_val[direction][xy][1] >> shift;
2312 if (IS_INTERLACED(mbtype_table[mb_index]))
2315 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2316 height, pict->linesize[0], 100, 0, direction);
2319 int sx= mb_x * 16 + 8;
2320 int sy= mb_y * 16 + 8;
2321 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2322 int mx= (motion_val[direction][xy][0]>>shift) + sx;
2323 int my= (motion_val[direction][xy][1]>>shift) + sy;
2324 draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100, 0, direction);
2329 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2330 uint64_t c = (qscale_table[mb_index] * 128 / 31) *
2331 0x0101010101010101ULL;
2333 for (y = 0; y < block_height; y++) {
2334 *(uint64_t *)(pict->data[1] + 8 * mb_x +
2335 (block_height * mb_y + y) *
2336 pict->linesize[1]) = c;
2337 *(uint64_t *)(pict->data[2] + 8 * mb_x +
2338 (block_height * mb_y + y) *
2339 pict->linesize[2]) = c;
2342 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2344 int mb_type = mbtype_table[mb_index];
2347 #define COLOR(theta, r) \
2348 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2349 v = (int)(128 + r * sin(theta * 3.141592 / 180));
2353 if (IS_PCM(mb_type)) {
2355 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2356 IS_INTRA16x16(mb_type)) {
2358 } else if (IS_INTRA4x4(mb_type)) {
2360 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2362 } else if (IS_DIRECT(mb_type)) {
2364 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2366 } else if (IS_GMC(mb_type)) {
2368 } else if (IS_SKIP(mb_type)) {
2370 } else if (!USES_LIST(mb_type, 1)) {
2372 } else if (!USES_LIST(mb_type, 0)) {
2375 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2379 u *= 0x0101010101010101ULL;
2380 v *= 0x0101010101010101ULL;
2381 for (y = 0; y < block_height; y++) {
2382 *(uint64_t *)(pict->data[1] + 8 * mb_x +
2383 (block_height * mb_y + y) * pict->linesize[1]) = u;
2384 *(uint64_t *)(pict->data[2] + 8 * mb_x +
2385 (block_height * mb_y + y) * pict->linesize[2]) = v;
2389 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2390 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2391 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2392 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2393 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2395 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2396 for (y = 0; y < 16; y++)
2397 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2398 pict->linesize[0]] ^= 0x80;
2400 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2401 int dm = 1 << (mv_sample_log2 - 2);
2402 for (i = 0; i < 4; i++) {
2403 int sx = mb_x * 16 + 8 * (i & 1);
2404 int sy = mb_y * 16 + 8 * (i >> 1);
2405 int xy = (mb_x * 2 + (i & 1) +
2406 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2408 int32_t *mv = (int32_t *) &motion_val[0][xy];
2409 if (mv[0] != mv[dm] ||
2410 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2411 for (y = 0; y < 8; y++)
2412 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2413 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2414 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2415 pict->linesize[0]) ^= 0x8080808080808080ULL;
2419 if (IS_INTERLACED(mb_type) &&
2420 avctx->codec->id == AV_CODEC_ID_H264) {
2425 mbskip_table[mb_index] = 0;
2431 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
2433 ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
2434 p->qscale_table, p->motion_val, &s->low_delay,
2435 s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2438 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
2440 AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
2441 int offset = 2*s->mb_stride + 1;
2443 return AVERROR(ENOMEM);
2444 av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
2445 ref->size -= offset;
2446 ref->data += offset;
2447 return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
2450 static inline int hpel_motion_lowres(MpegEncContext *s,
2451 uint8_t *dest, uint8_t *src,
2452 int field_based, int field_select,
2453 int src_x, int src_y,
2454 int width, int height, ptrdiff_t stride,
2455 int h_edge_pos, int v_edge_pos,
2456 int w, int h, h264_chroma_mc_func *pix_op,
2457 int motion_x, int motion_y)
2459 const int lowres = s->avctx->lowres;
2460 const int op_index = FFMIN(lowres, 3);
2461 const int s_mask = (2 << lowres) - 1;
2465 if (s->quarter_sample) {
2470 sx = motion_x & s_mask;
2471 sy = motion_y & s_mask;
2472 src_x += motion_x >> lowres + 1;
2473 src_y += motion_y >> lowres + 1;
2475 src += src_y * stride + src_x;
2477 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2478 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2479 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
2480 s->linesize, s->linesize,
2481 w + 1, (h + 1) << field_based,
2482 src_x, src_y << field_based,
2483 h_edge_pos, v_edge_pos);
2484 src = s->edge_emu_buffer;
2488 sx = (sx << 2) >> lowres;
2489 sy = (sy << 2) >> lowres;
2492 pix_op[op_index](dest, src, stride, h, sx, sy);
2496 /* apply one mpeg motion vector to the three components */
2497 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2504 uint8_t **ref_picture,
2505 h264_chroma_mc_func *pix_op,
2506 int motion_x, int motion_y,
2509 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2510 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
2511 ptrdiff_t uvlinesize, linesize;
2512 const int lowres = s->avctx->lowres;
2513 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
2514 const int block_s = 8>>lowres;
2515 const int s_mask = (2 << lowres) - 1;
2516 const int h_edge_pos = s->h_edge_pos >> lowres;
2517 const int v_edge_pos = s->v_edge_pos >> lowres;
2518 linesize = s->current_picture.f->linesize[0] << field_based;
2519 uvlinesize = s->current_picture.f->linesize[1] << field_based;
2521 // FIXME obviously not perfect but qpel will not work in lowres anyway
2522 if (s->quarter_sample) {
2528 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2531 sx = motion_x & s_mask;
2532 sy = motion_y & s_mask;
2533 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2534 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2536 if (s->out_format == FMT_H263) {
2537 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2538 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2539 uvsrc_x = src_x >> 1;
2540 uvsrc_y = src_y >> 1;
2541 } else if (s->out_format == FMT_H261) {
2542 // even chroma mv's are full pel in H261
2545 uvsx = (2 * mx) & s_mask;
2546 uvsy = (2 * my) & s_mask;
2547 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2548 uvsrc_y = mb_y * block_s + (my >> lowres);
2550 if(s->chroma_y_shift){
2555 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2556 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2558 if(s->chroma_x_shift){
2562 uvsy = motion_y & s_mask;
2564 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2567 uvsx = motion_x & s_mask;
2568 uvsy = motion_y & s_mask;
2575 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2576 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2577 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2579 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
2580 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2581 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2582 linesize >> field_based, linesize >> field_based,
2583 17, 17 + field_based,
2584 src_x, src_y << field_based, h_edge_pos,
2586 ptr_y = s->edge_emu_buffer;
2587 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
2588 uint8_t *ubuf = s->edge_emu_buffer + 18 * s->linesize;
2589 uint8_t *vbuf =ubuf + 9 * s->uvlinesize;
2590 s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
2591 uvlinesize >> field_based, uvlinesize >> field_based,
2593 uvsrc_x, uvsrc_y << field_based,
2594 h_edge_pos >> 1, v_edge_pos >> 1);
2595 s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
2596 uvlinesize >> field_based,uvlinesize >> field_based,
2598 uvsrc_x, uvsrc_y << field_based,
2599 h_edge_pos >> 1, v_edge_pos >> 1);
2605 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
2607 dest_y += s->linesize;
2608 dest_cb += s->uvlinesize;
2609 dest_cr += s->uvlinesize;
2613 ptr_y += s->linesize;
2614 ptr_cb += s->uvlinesize;
2615 ptr_cr += s->uvlinesize;
2618 sx = (sx << 2) >> lowres;
2619 sy = (sy << 2) >> lowres;
2620 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2622 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
2623 int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
2624 uvsx = (uvsx << 2) >> lowres;
2625 uvsy = (uvsy << 2) >> lowres;
2627 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2628 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2631 // FIXME h261 lowres loop filter
2634 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2635 uint8_t *dest_cb, uint8_t *dest_cr,
2636 uint8_t **ref_picture,
2637 h264_chroma_mc_func * pix_op,
2640 const int lowres = s->avctx->lowres;
2641 const int op_index = FFMIN(lowres, 3);
2642 const int block_s = 8 >> lowres;
2643 const int s_mask = (2 << lowres) - 1;
2644 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2645 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2646 int emu = 0, src_x, src_y, sx, sy;
2650 if (s->quarter_sample) {
2655 /* In case of 8X8, we construct a single chroma motion vector
2656 with a special rounding */
2657 mx = ff_h263_round_chroma(mx);
2658 my = ff_h263_round_chroma(my);
2662 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2663 src_y = s->mb_y * block_s + (my >> lowres + 1);
2665 offset = src_y * s->uvlinesize + src_x;
2666 ptr = ref_picture[1] + offset;
2667 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2668 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2669 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2670 s->uvlinesize, s->uvlinesize,
2672 src_x, src_y, h_edge_pos, v_edge_pos);
2673 ptr = s->edge_emu_buffer;
2676 sx = (sx << 2) >> lowres;
2677 sy = (sy << 2) >> lowres;
2678 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2680 ptr = ref_picture[2] + offset;
2682 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2683 s->uvlinesize, s->uvlinesize,
2685 src_x, src_y, h_edge_pos, v_edge_pos);
2686 ptr = s->edge_emu_buffer;
2688 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2692 * motion compensation of a single macroblock
2694 * @param dest_y luma destination pointer
2695 * @param dest_cb chroma cb/u destination pointer
2696 * @param dest_cr chroma cr/v destination pointer
2697 * @param dir direction (0->forward, 1->backward)
2698 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2699 * @param pix_op halfpel motion compensation function (average or put normally)
2700 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2702 static inline void MPV_motion_lowres(MpegEncContext *s,
2703 uint8_t *dest_y, uint8_t *dest_cb,
2705 int dir, uint8_t **ref_picture,
2706 h264_chroma_mc_func *pix_op)
2710 const int lowres = s->avctx->lowres;
2711 const int block_s = 8 >>lowres;
2716 switch (s->mv_type) {
2718 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2720 ref_picture, pix_op,
2721 s->mv[dir][0][0], s->mv[dir][0][1],
2727 for (i = 0; i < 4; i++) {
2728 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2729 s->linesize) * block_s,
2730 ref_picture[0], 0, 0,
2731 (2 * mb_x + (i & 1)) * block_s,
2732 (2 * mb_y + (i >> 1)) * block_s,
2733 s->width, s->height, s->linesize,
2734 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2735 block_s, block_s, pix_op,
2736 s->mv[dir][i][0], s->mv[dir][i][1]);
2738 mx += s->mv[dir][i][0];
2739 my += s->mv[dir][i][1];
2742 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY))
2743 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2747 if (s->picture_structure == PICT_FRAME) {
2749 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2750 1, 0, s->field_select[dir][0],
2751 ref_picture, pix_op,
2752 s->mv[dir][0][0], s->mv[dir][0][1],
2755 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2756 1, 1, s->field_select[dir][1],
2757 ref_picture, pix_op,
2758 s->mv[dir][1][0], s->mv[dir][1][1],
2761 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2762 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2763 ref_picture = s->current_picture_ptr->f->data;
2766 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2767 0, 0, s->field_select[dir][0],
2768 ref_picture, pix_op,
2770 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2774 for (i = 0; i < 2; i++) {
2775 uint8_t **ref2picture;
2777 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2778 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2779 ref2picture = ref_picture;
2781 ref2picture = s->current_picture_ptr->f->data;
2784 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2785 0, 0, s->field_select[dir][i],
2786 ref2picture, pix_op,
2787 s->mv[dir][i][0], s->mv[dir][i][1] +
2788 2 * block_s * i, block_s, mb_y >> 1);
2790 dest_y += 2 * block_s * s->linesize;
2791 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2792 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2796 if (s->picture_structure == PICT_FRAME) {
2797 for (i = 0; i < 2; i++) {
2799 for (j = 0; j < 2; j++) {
2800 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2802 ref_picture, pix_op,
2803 s->mv[dir][2 * i + j][0],
2804 s->mv[dir][2 * i + j][1],
2807 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2810 for (i = 0; i < 2; i++) {
2811 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2812 0, 0, s->picture_structure != i + 1,
2813 ref_picture, pix_op,
2814 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2815 2 * block_s, mb_y >> 1);
2817 // after put we make avg of the same block
2818 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2820 // opposite parity is always in the same
2821 // frame if this is second field
2822 if (!s->first_field) {
2823 ref_picture = s->current_picture_ptr->f->data;
2834 * find the lowest MB row referenced in the MVs
2836 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2838 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2839 int my, off, i, mvs;
2841 if (s->picture_structure != PICT_FRAME || s->mcsel)
2844 switch (s->mv_type) {
2858 for (i = 0; i < mvs; i++) {
2859 my = s->mv[dir][i][1];
2860 my_max = FFMAX(my_max, my);
2861 my_min = FFMIN(my_min, my);
2864 off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
2866 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2868 return s->mb_height-1;
2871 /* put block[] to dest[] */
2872 static inline void put_dct(MpegEncContext *s,
2873 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2875 s->dct_unquantize_intra(s, block, i, qscale);
2876 s->idsp.idct_put(dest, line_size, block);
2879 /* add block[] to dest[] */
2880 static inline void add_dct(MpegEncContext *s,
2881 int16_t *block, int i, uint8_t *dest, int line_size)
2883 if (s->block_last_index[i] >= 0) {
2884 s->idsp.idct_add(dest, line_size, block);
2888 static inline void add_dequant_dct(MpegEncContext *s,
2889 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2891 if (s->block_last_index[i] >= 0) {
2892 s->dct_unquantize_inter(s, block, i, qscale);
2894 s->idsp.idct_add(dest, line_size, block);
2899 * Clean dc, ac, coded_block for the current non-intra MB.
2901 void ff_clean_intra_table_entries(MpegEncContext *s)
2903 int wrap = s->b8_stride;
2904 int xy = s->block_index[0];
2907 s->dc_val[0][xy + 1 ] =
2908 s->dc_val[0][xy + wrap] =
2909 s->dc_val[0][xy + 1 + wrap] = 1024;
2911 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2912 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2913 if (s->msmpeg4_version>=3) {
2914 s->coded_block[xy ] =
2915 s->coded_block[xy + 1 ] =
2916 s->coded_block[xy + wrap] =
2917 s->coded_block[xy + 1 + wrap] = 0;
2920 wrap = s->mb_stride;
2921 xy = s->mb_x + s->mb_y * wrap;
2923 s->dc_val[2][xy] = 1024;
2925 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2926 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2928 s->mbintra_table[xy]= 0;
2931 /* generic function called after a macroblock has been parsed by the
2932 decoder or after it has been encoded by the encoder.
2934 Important variables used:
2935 s->mb_intra : true if intra macroblock
2936 s->mv_dir : motion vector direction
2937 s->mv_type : motion vector type
2938 s->mv : motion vector
2939 s->interlaced_dct : true if interlaced dct used (mpeg2)
2941 static av_always_inline
2942 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2943 int lowres_flag, int is_mpeg12)
2945 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2948 s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
2949 s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
2953 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2954 /* print DCT coefficients */
2956 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2958 for(j=0; j<64; j++){
2959 av_log(s->avctx, AV_LOG_DEBUG, "%5d",
2960 block[i][s->idsp.idct_permutation[j]]);
2962 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2966 s->current_picture.qscale_table[mb_xy] = s->qscale;
2968 /* update DC predictors for P macroblocks */
2970 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2971 if(s->mbintra_table[mb_xy])
2972 ff_clean_intra_table_entries(s);
2976 s->last_dc[2] = 128 << s->intra_dc_precision;
2979 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2980 s->mbintra_table[mb_xy]=1;
2982 if ((s->avctx->flags & CODEC_FLAG_PSNR) || s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor ||
2983 !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
2984 s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
2985 uint8_t *dest_y, *dest_cb, *dest_cr;
2986 int dct_linesize, dct_offset;
2987 op_pixels_func (*op_pix)[4];
2988 qpel_mc_func (*op_qpix)[16];
2989 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2990 const int uvlinesize = s->current_picture.f->linesize[1];
2991 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2992 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2994 /* avoid copy if macroblock skipped in last frame too */
2995 /* skip only during decoding as we might trash the buffers during encoding a bit */
2997 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2999 if (s->mb_skipped) {
3001 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
3003 } else if(!s->current_picture.reference) {
3006 *mbskip_ptr = 0; /* not skipped */
3010 dct_linesize = linesize << s->interlaced_dct;
3011 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
3015 dest_cb= s->dest[1];
3016 dest_cr= s->dest[2];
3018 dest_y = s->b_scratchpad;
3019 dest_cb= s->b_scratchpad+16*linesize;
3020 dest_cr= s->b_scratchpad+32*linesize;
3024 /* motion handling */
3025 /* decoding or more than one mb_type (MC was already done otherwise) */
3028 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
3029 if (s->mv_dir & MV_DIR_FORWARD) {
3030 ff_thread_await_progress(&s->last_picture_ptr->tf,
3031 ff_mpv_lowest_referenced_row(s, 0),
3034 if (s->mv_dir & MV_DIR_BACKWARD) {
3035 ff_thread_await_progress(&s->next_picture_ptr->tf,
3036 ff_mpv_lowest_referenced_row(s, 1),
3042 h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
3044 if (s->mv_dir & MV_DIR_FORWARD) {
3045 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
3046 op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
3048 if (s->mv_dir & MV_DIR_BACKWARD) {
3049 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
3052 op_qpix = s->me.qpel_put;
3053 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
3054 op_pix = s->hdsp.put_pixels_tab;
3056 op_pix = s->hdsp.put_no_rnd_pixels_tab;
3058 if (s->mv_dir & MV_DIR_FORWARD) {
3059 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
3060 op_pix = s->hdsp.avg_pixels_tab;
3061 op_qpix= s->me.qpel_avg;
3063 if (s->mv_dir & MV_DIR_BACKWARD) {
3064 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
3069 /* skip dequant / idct if we are really late ;) */
3070 if(s->avctx->skip_idct){
3071 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
3072 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
3073 || s->avctx->skip_idct >= AVDISCARD_ALL)
3077 /* add dct residue */
3078 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
3079 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
3080 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3081 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3082 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3083 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3085 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3086 if (s->chroma_y_shift){
3087 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3088 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3092 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3093 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3094 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3095 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3098 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
3099 add_dct(s, block[0], 0, dest_y , dct_linesize);
3100 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3101 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3102 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3104 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3105 if(s->chroma_y_shift){//Chroma420
3106 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3107 add_dct(s, block[5], 5, dest_cr, uvlinesize);
3110 dct_linesize = uvlinesize << s->interlaced_dct;
3111 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3113 add_dct(s, block[4], 4, dest_cb, dct_linesize);
3114 add_dct(s, block[5], 5, dest_cr, dct_linesize);
3115 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3116 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3117 if(!s->chroma_x_shift){//Chroma444
3118 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
3119 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
3120 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
3121 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
3126 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
3127 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3130 /* dct only in intra block */
3131 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
3132 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3133 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3134 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3135 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3137 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3138 if(s->chroma_y_shift){
3139 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3140 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3144 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3145 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3146 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3147 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3151 s->idsp.idct_put(dest_y, dct_linesize, block[0]);
3152 s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
3153 s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
3154 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3156 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3157 if(s->chroma_y_shift){
3158 s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
3159 s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
3162 dct_linesize = uvlinesize << s->interlaced_dct;
3163 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3165 s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
3166 s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
3167 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3168 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3169 if(!s->chroma_x_shift){//Chroma444
3170 s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
3171 s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
3172 s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
3173 s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
3181 s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
3182 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3183 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3184 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3190 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
3193 if(s->out_format == FMT_MPEG1) {
3194 if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
3195 else mpv_decode_mb_internal(s, block, 0, 1);
3198 if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
3199 else mpv_decode_mb_internal(s, block, 0, 0);
3202 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
3204 ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
3205 s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
3206 s->first_field, s->low_delay);
3209 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3210 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3211 const int uvlinesize = s->current_picture.f->linesize[1];
3212 const int mb_size= 4 - s->avctx->lowres;
3214 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
3215 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
3216 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3217 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3218 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3219 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;
3220 //block_index is not used by mpeg2, so it is not affected by chroma_format
3222 s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << mb_size);
3223 s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
3224 s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
3226 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3228 if(s->picture_structure==PICT_FRAME){
3229 s->dest[0] += s->mb_y * linesize << mb_size;
3230 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3231 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3233 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
3234 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3235 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3236 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3242 * Permute an 8x8 block.
3243 * @param block the block which will be permuted according to the given permutation vector
3244 * @param permutation the permutation vector
3245 * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3246 * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3247 * (inverse) permutated to scantable order!
3249 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3255 //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3257 for(i=0; i<=last; i++){
3258 const int j= scantable[i];
3263 for(i=0; i<=last; i++){
3264 const int j= scantable[i];
3265 const int perm_j= permutation[j];
3266 block[perm_j]= temp[j];
3270 void ff_mpeg_flush(AVCodecContext *avctx){
3272 MpegEncContext *s = avctx->priv_data;
3274 if (!s || !s->picture)
3277 for (i = 0; i < MAX_PICTURE_COUNT; i++)
3278 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
3279 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3281 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
3282 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
3283 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
3285 s->mb_x= s->mb_y= 0;
3288 s->parse_context.state= -1;
3289 s->parse_context.frame_start_found= 0;
3290 s->parse_context.overread= 0;
3291 s->parse_context.overread_index= 0;
3292 s->parse_context.index= 0;
3293 s->parse_context.last_index= 0;
3294 s->bitstream_buffer_size=0;
3299 * set qscale and update qscale dependent variables.
3301 void ff_set_qscale(MpegEncContext * s, int qscale)
3305 else if (qscale > 31)
3309 s->chroma_qscale= s->chroma_qscale_table[qscale];
3311 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3312 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3315 void ff_mpv_report_decode_progress(MpegEncContext *s)
3317 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3318 ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);