2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/imgutils.h"
35 #include "mpegvideo.h"
38 #include "xvmc_internal.h"
45 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
46 DCTELEM *block, int n, int qscale);
47 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
58 DCTELEM *block, int n, int qscale);
64 static const uint8_t ff_default_chroma_qscale_table[32] = {
65 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
66 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
67 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
70 const uint8_t ff_mpeg1_dc_scale_table[128] = {
71 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
72 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
73 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
74 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 static const uint8_t mpeg2_dc_scale_table1[128] = {
83 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
84 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94 static const uint8_t mpeg2_dc_scale_table2[128] = {
95 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
96 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
97 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 static const uint8_t mpeg2_dc_scale_table3[128] = {
107 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
109 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
110 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
113 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
119 ff_mpeg1_dc_scale_table,
120 mpeg2_dc_scale_table1,
121 mpeg2_dc_scale_table2,
122 mpeg2_dc_scale_table3,
125 const enum AVPixelFormat ff_pixfmt_list_420[] = {
130 const enum AVPixelFormat ff_hwaccel_pixfmt_list_420[] = {
131 AV_PIX_FMT_DXVA2_VLD,
132 AV_PIX_FMT_VAAPI_VLD,
138 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
140 uint32_t *av_restrict state)
148 for (i = 0; i < 3; i++) {
149 uint32_t tmp = *state << 8;
150 *state = tmp + *(p++);
151 if (tmp == 0x100 || p == end)
156 if (p[-1] > 1 ) p += 3;
157 else if (p[-2] ) p += 2;
158 else if (p[-3]|(p[-1]-1)) p++;
165 p = FFMIN(p, end) - 4;
171 /* init common dct for both encoder and decoder */
172 av_cold int ff_dct_common_init(MpegEncContext *s)
174 ff_dsputil_init(&s->dsp, s->avctx);
176 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
177 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
178 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
179 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
180 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
181 if (s->flags & CODEC_FLAG_BITEXACT)
182 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
183 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
186 ff_MPV_common_init_x86(s);
188 ff_MPV_common_init_axp(s);
190 ff_MPV_common_init_arm(s);
192 ff_MPV_common_init_altivec(s);
194 ff_MPV_common_init_bfin(s);
197 /* load & permutate scantables
198 * note: only wmv uses different ones
200 if (s->alternate_scan) {
201 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
202 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
204 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
205 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
207 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
208 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
213 void ff_copy_picture(Picture *dst, Picture *src)
216 dst->f.type = FF_BUFFER_TYPE_COPY;
220 * Release a frame buffer
222 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
224 /* WM Image / Screen codecs allocate internal buffers with different
225 * dimensions / colorspaces; ignore user-defined callbacks for these. */
226 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
227 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
228 s->codec_id != AV_CODEC_ID_MSS2)
229 ff_thread_release_buffer(s->avctx, &pic->f);
231 avcodec_default_release_buffer(s->avctx, &pic->f);
232 av_freep(&pic->f.hwaccel_picture_private);
236 * Allocate a frame buffer
238 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
242 if (s->avctx->hwaccel) {
243 assert(!pic->f.hwaccel_picture_private);
244 if (s->avctx->hwaccel->priv_data_size) {
245 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
246 if (!pic->f.hwaccel_picture_private) {
247 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
253 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
254 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
255 s->codec_id != AV_CODEC_ID_MSS2)
256 r = ff_thread_get_buffer(s->avctx, &pic->f);
258 r = avcodec_default_get_buffer(s->avctx, &pic->f);
260 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
261 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
262 r, pic->f.type, pic->f.data[0]);
263 av_freep(&pic->f.hwaccel_picture_private);
267 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
268 s->uvlinesize != pic->f.linesize[1])) {
269 av_log(s->avctx, AV_LOG_ERROR,
270 "get_buffer() failed (stride changed)\n");
271 free_frame_buffer(s, pic);
275 if (pic->f.linesize[1] != pic->f.linesize[2]) {
276 av_log(s->avctx, AV_LOG_ERROR,
277 "get_buffer() failed (uv stride mismatch)\n");
278 free_frame_buffer(s, pic);
286 * Allocate a Picture.
287 * The pixels are allocated/set by calling get_buffer() if shared = 0
289 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
291 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
293 // the + 1 is needed so memset(,,stride*height) does not sig11
295 const int mb_array_size = s->mb_stride * s->mb_height;
296 const int b8_array_size = s->b8_stride * s->mb_height * 2;
297 const int b4_array_size = s->b4_stride * s->mb_height * 4;
302 assert(pic->f.data[0]);
303 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
304 pic->f.type = FF_BUFFER_TYPE_SHARED;
306 assert(!pic->f.data[0]);
308 if (alloc_frame_buffer(s, pic) < 0)
311 s->linesize = pic->f.linesize[0];
312 s->uvlinesize = pic->f.linesize[1];
315 if (pic->f.qscale_table == NULL) {
317 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
318 mb_array_size * sizeof(int16_t), fail)
319 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
320 mb_array_size * sizeof(int16_t), fail)
321 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
322 mb_array_size * sizeof(int8_t ), fail)
325 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
326 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
327 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
328 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
330 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
331 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
333 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
334 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
335 if (s->out_format == FMT_H264) {
336 for (i = 0; i < 2; i++) {
337 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
338 2 * (b4_array_size + 4) * sizeof(int16_t),
340 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
341 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
342 4 * mb_array_size * sizeof(uint8_t), fail)
344 pic->f.motion_subsample_log2 = 2;
345 } else if (s->out_format == FMT_H263 || s->encoding ||
346 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
347 for (i = 0; i < 2; i++) {
348 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
349 2 * (b8_array_size + 4) * sizeof(int16_t),
351 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
352 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
353 4 * mb_array_size * sizeof(uint8_t), fail)
355 pic->f.motion_subsample_log2 = 3;
357 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
358 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
359 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
361 pic->f.qstride = s->mb_stride;
362 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
363 1 * sizeof(AVPanScan), fail)
369 fail: // for the FF_ALLOCZ_OR_GOTO macro
371 free_frame_buffer(s, pic);
376 * Deallocate a picture.
378 static void free_picture(MpegEncContext *s, Picture *pic)
382 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
383 free_frame_buffer(s, pic);
386 av_freep(&pic->mb_var);
387 av_freep(&pic->mc_mb_var);
388 av_freep(&pic->mb_mean);
389 av_freep(&pic->f.mbskip_table);
390 av_freep(&pic->qscale_table_base);
391 pic->f.qscale_table = NULL;
392 av_freep(&pic->mb_type_base);
393 pic->f.mb_type = NULL;
394 av_freep(&pic->f.dct_coeff);
395 av_freep(&pic->f.pan_scan);
396 pic->f.mb_type = NULL;
397 for (i = 0; i < 2; i++) {
398 av_freep(&pic->motion_val_base[i]);
399 av_freep(&pic->f.ref_index[i]);
400 pic->f.motion_val[i] = NULL;
403 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
404 for (i = 0; i < 4; i++) {
406 pic->f.data[i] = NULL;
412 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
414 int y_size = s->b8_stride * (2 * s->mb_height + 1);
415 int c_size = s->mb_stride * (s->mb_height + 1);
416 int yc_size = y_size + 2 * c_size;
419 // edge emu needs blocksize + filter length - 1
420 // (= 17x17 for halfpel / 21x21 for h264)
421 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
422 (s->width + 95) * 2 * 21 * 4, fail); // (width + edge + align)*interlaced*MBsize*tolerance
424 // FIXME should be linesize instead of s->width * 2
425 // but that is not known before get_buffer()
426 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
427 (s->width + 95) * 4 * 16 * 2 * sizeof(uint8_t), fail)
428 s->me.temp = s->me.scratchpad;
429 s->rd_scratchpad = s->me.scratchpad;
430 s->b_scratchpad = s->me.scratchpad;
431 s->obmc_scratchpad = s->me.scratchpad + 16;
433 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
434 ME_MAP_SIZE * sizeof(uint32_t), fail)
435 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
436 ME_MAP_SIZE * sizeof(uint32_t), fail)
437 if (s->avctx->noise_reduction) {
438 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
439 2 * 64 * sizeof(int), fail)
442 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
443 s->block = s->blocks[0];
445 for (i = 0; i < 12; i++) {
446 s->pblocks[i] = &s->block[i];
449 if (s->out_format == FMT_H263) {
451 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
452 yc_size * sizeof(int16_t) * 16, fail);
453 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
454 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
455 s->ac_val[2] = s->ac_val[1] + c_size;
460 return -1; // free() through ff_MPV_common_end()
463 static void free_duplicate_context(MpegEncContext *s)
468 av_freep(&s->edge_emu_buffer);
469 av_freep(&s->me.scratchpad);
473 s->obmc_scratchpad = NULL;
475 av_freep(&s->dct_error_sum);
476 av_freep(&s->me.map);
477 av_freep(&s->me.score_map);
478 av_freep(&s->blocks);
479 av_freep(&s->ac_val_base);
483 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
485 #define COPY(a) bak->a = src->a
486 COPY(edge_emu_buffer);
491 COPY(obmc_scratchpad);
498 COPY(me.map_generation);
510 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
514 // FIXME copy only needed parts
516 backup_duplicate_context(&bak, dst);
517 memcpy(dst, src, sizeof(MpegEncContext));
518 backup_duplicate_context(dst, &bak);
519 for (i = 0; i < 12; i++) {
520 dst->pblocks[i] = &dst->block[i];
522 // STOP_TIMER("update_duplicate_context")
523 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
526 int ff_mpeg_update_thread_context(AVCodecContext *dst,
527 const AVCodecContext *src)
531 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
538 // FIXME can parameters change on I-frames?
539 // in that case dst may need a reinit
540 if (!s->context_initialized) {
541 memcpy(s, s1, sizeof(MpegEncContext));
544 s->bitstream_buffer = NULL;
545 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
547 if (s1->context_initialized){
548 s->picture_range_start += MAX_PICTURE_COUNT;
549 s->picture_range_end += MAX_PICTURE_COUNT;
550 if((err = ff_MPV_common_init(s)) < 0)
555 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
556 s->context_reinit = 0;
557 s->height = s1->height;
558 s->width = s1->width;
559 if ((err = ff_MPV_common_frame_size_change(s)) < 0)
563 s->avctx->coded_height = s1->avctx->coded_height;
564 s->avctx->coded_width = s1->avctx->coded_width;
565 s->avctx->width = s1->avctx->width;
566 s->avctx->height = s1->avctx->height;
568 s->coded_picture_number = s1->coded_picture_number;
569 s->picture_number = s1->picture_number;
570 s->input_picture_number = s1->input_picture_number;
572 av_assert0(!s->picture || s->picture != s1->picture);
573 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
574 memcpy(&s->last_picture, &s1->last_picture,
575 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
577 // reset s->picture[].f.extended_data to s->picture[].f.data
578 for (i = 0; i < s->picture_count; i++)
579 s->picture[i].f.extended_data = s->picture[i].f.data;
581 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
582 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
583 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
585 // Error/bug resilience
586 s->next_p_frame_damaged = s1->next_p_frame_damaged;
587 s->workaround_bugs = s1->workaround_bugs;
588 s->padding_bug_score = s1->padding_bug_score;
591 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
592 (char *) &s1->shape - (char *) &s1->time_increment_bits);
595 s->max_b_frames = s1->max_b_frames;
596 s->low_delay = s1->low_delay;
597 s->droppable = s1->droppable;
599 // DivX handling (doesn't work)
600 s->divx_packed = s1->divx_packed;
602 if (s1->bitstream_buffer) {
603 if (s1->bitstream_buffer_size +
604 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
605 av_fast_malloc(&s->bitstream_buffer,
606 &s->allocated_bitstream_buffer_size,
607 s1->allocated_bitstream_buffer_size);
608 s->bitstream_buffer_size = s1->bitstream_buffer_size;
609 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
610 s1->bitstream_buffer_size);
611 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
612 FF_INPUT_BUFFER_PADDING_SIZE);
615 // MPEG2/interlacing info
616 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
617 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
619 if (!s1->first_field) {
620 s->last_pict_type = s1->pict_type;
621 if (s1->current_picture_ptr)
622 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
624 if (s1->pict_type != AV_PICTURE_TYPE_B) {
625 s->last_non_b_pict_type = s1->pict_type;
633 * Set the given MpegEncContext to common defaults
634 * (same for encoding and decoding).
635 * The changed fields will not depend upon the
636 * prior state of the MpegEncContext.
638 void ff_MPV_common_defaults(MpegEncContext *s)
640 s->y_dc_scale_table =
641 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
642 s->chroma_qscale_table = ff_default_chroma_qscale_table;
643 s->progressive_frame = 1;
644 s->progressive_sequence = 1;
645 s->picture_structure = PICT_FRAME;
647 s->coded_picture_number = 0;
648 s->picture_number = 0;
649 s->input_picture_number = 0;
651 s->picture_in_gop_number = 0;
656 s->picture_range_start = 0;
657 s->picture_range_end = MAX_PICTURE_COUNT;
659 s->slice_context_count = 1;
663 * Set the given MpegEncContext to defaults for decoding.
664 * the changed fields will not depend upon
665 * the prior state of the MpegEncContext.
667 void ff_MPV_decode_defaults(MpegEncContext *s)
669 ff_MPV_common_defaults(s);
673 * Initialize and allocates MpegEncContext fields dependent on the resolution.
675 static int init_context_frame(MpegEncContext *s)
677 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
679 s->mb_width = (s->width + 15) / 16;
680 s->mb_stride = s->mb_width + 1;
681 s->b8_stride = s->mb_width * 2 + 1;
682 s->b4_stride = s->mb_width * 4 + 1;
683 mb_array_size = s->mb_height * s->mb_stride;
684 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
686 /* set default edge pos, will be overriden
687 * in decode_header if needed */
688 s->h_edge_pos = s->mb_width * 16;
689 s->v_edge_pos = s->mb_height * 16;
691 s->mb_num = s->mb_width * s->mb_height;
696 s->block_wrap[3] = s->b8_stride;
698 s->block_wrap[5] = s->mb_stride;
700 y_size = s->b8_stride * (2 * s->mb_height + 1);
701 c_size = s->mb_stride * (s->mb_height + 1);
702 yc_size = y_size + 2 * c_size;
704 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
705 for (y = 0; y < s->mb_height; y++)
706 for (x = 0; x < s->mb_width; x++)
707 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
709 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
712 /* Allocate MV tables */
713 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
714 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
715 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
716 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
717 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
718 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
719 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
720 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
721 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
722 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
723 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
724 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
726 /* Allocate MB type table */
727 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
729 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
731 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
732 mb_array_size * sizeof(float), fail);
733 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
734 mb_array_size * sizeof(float), fail);
738 FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
739 mb_array_size * sizeof(uint8_t), fail);
740 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
741 mb_array_size * sizeof(uint8_t), fail);
743 if (s->codec_id == AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)) {
744 /* interlaced direct mode decoding tables */
745 for (i = 0; i < 2; i++) {
747 for (j = 0; j < 2; j++) {
748 for (k = 0; k < 2; k++) {
749 FF_ALLOCZ_OR_GOTO(s->avctx,
750 s->b_field_mv_table_base[i][j][k],
751 mv_table_size * 2 * sizeof(int16_t),
753 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
756 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
757 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
758 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
760 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
763 if (s->out_format == FMT_H263) {
765 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
766 s->coded_block = s->coded_block_base + s->b8_stride + 1;
768 /* cbp, ac_pred, pred_dir */
769 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
770 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
773 if (s->h263_pred || s->h263_plus || !s->encoding) {
775 // MN: we need these for error resilience of intra-frames
776 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
777 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
778 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
779 s->dc_val[2] = s->dc_val[1] + c_size;
780 for (i = 0; i < yc_size; i++)
781 s->dc_val_base[i] = 1024;
784 /* which mb is a intra block */
785 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
786 memset(s->mbintra_table, 1, mb_array_size);
788 /* init macroblock skip table */
789 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
790 // Note the + 1 is for a quicker mpeg4 slice_end detection
794 return AVERROR(ENOMEM);
798 * init common structure for both encoder and decoder.
799 * this assumes that some variables like width/height are already set
801 av_cold int ff_MPV_common_init(MpegEncContext *s)
804 int nb_slices = (HAVE_THREADS &&
805 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
806 s->avctx->thread_count : 1;
808 if (s->encoding && s->avctx->slices)
809 nb_slices = s->avctx->slices;
811 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
812 s->mb_height = (s->height + 31) / 32 * 2;
813 else if (s->codec_id != AV_CODEC_ID_H264)
814 s->mb_height = (s->height + 15) / 16;
816 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
817 av_log(s->avctx, AV_LOG_ERROR,
818 "decoding to AV_PIX_FMT_NONE is not supported.\n");
822 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
825 max_slices = FFMIN(MAX_THREADS, s->mb_height);
827 max_slices = MAX_THREADS;
828 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
829 " reducing to %d\n", nb_slices, max_slices);
830 nb_slices = max_slices;
833 if ((s->width || s->height) &&
834 av_image_check_size(s->width, s->height, 0, s->avctx))
837 ff_dct_common_init(s);
839 s->flags = s->avctx->flags;
840 s->flags2 = s->avctx->flags2;
842 /* set chroma shifts */
843 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
845 /* convert fourcc to upper case */
846 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
847 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
849 s->avctx->coded_frame = &s->current_picture.f;
852 if (s->msmpeg4_version) {
853 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
854 2 * 2 * (MAX_LEVEL + 1) *
855 (MAX_RUN + 1) * 2 * sizeof(int), fail);
857 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
859 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail)
860 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail)
861 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail)
862 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
863 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
864 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
865 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
866 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
868 if (s->avctx->noise_reduction) {
869 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
873 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
874 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
875 s->picture_count * sizeof(Picture), fail);
876 for (i = 0; i < s->picture_count; i++) {
877 avcodec_get_frame_defaults(&s->picture[i].f);
880 if (init_context_frame(s))
883 s->parse_context.state = -1;
885 s->context_initialized = 1;
886 s->thread_context[0] = s;
888 // if (s->width && s->height) {
890 for (i = 1; i < nb_slices; i++) {
891 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
892 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
895 for (i = 0; i < nb_slices; i++) {
896 if (init_duplicate_context(s->thread_context[i], s) < 0)
898 s->thread_context[i]->start_mb_y =
899 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
900 s->thread_context[i]->end_mb_y =
901 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
904 if (init_duplicate_context(s, s) < 0)
907 s->end_mb_y = s->mb_height;
909 s->slice_context_count = nb_slices;
914 ff_MPV_common_end(s);
919 * Frees and resets MpegEncContext fields depending on the resolution.
920 * Is used during resolution changes to avoid a full reinitialization of the
923 static int free_context_frame(MpegEncContext *s)
927 av_freep(&s->mb_type);
928 av_freep(&s->p_mv_table_base);
929 av_freep(&s->b_forw_mv_table_base);
930 av_freep(&s->b_back_mv_table_base);
931 av_freep(&s->b_bidir_forw_mv_table_base);
932 av_freep(&s->b_bidir_back_mv_table_base);
933 av_freep(&s->b_direct_mv_table_base);
934 s->p_mv_table = NULL;
935 s->b_forw_mv_table = NULL;
936 s->b_back_mv_table = NULL;
937 s->b_bidir_forw_mv_table = NULL;
938 s->b_bidir_back_mv_table = NULL;
939 s->b_direct_mv_table = NULL;
940 for (i = 0; i < 2; i++) {
941 for (j = 0; j < 2; j++) {
942 for (k = 0; k < 2; k++) {
943 av_freep(&s->b_field_mv_table_base[i][j][k]);
944 s->b_field_mv_table[i][j][k] = NULL;
946 av_freep(&s->b_field_select_table[i][j]);
947 av_freep(&s->p_field_mv_table_base[i][j]);
948 s->p_field_mv_table[i][j] = NULL;
950 av_freep(&s->p_field_select_table[i]);
953 av_freep(&s->dc_val_base);
954 av_freep(&s->coded_block_base);
955 av_freep(&s->mbintra_table);
956 av_freep(&s->cbp_table);
957 av_freep(&s->pred_dir_table);
959 av_freep(&s->mbskip_table);
961 av_freep(&s->error_status_table);
962 av_freep(&s->er_temp_buffer);
963 av_freep(&s->mb_index2xy);
964 av_freep(&s->lambda_table);
966 av_freep(&s->cplx_tab);
967 av_freep(&s->bits_tab);
969 s->linesize = s->uvlinesize = 0;
971 for (i = 0; i < 3; i++)
972 av_freep(&s->visualization_buffer[i]);
974 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
975 avcodec_default_free_buffers(s->avctx);
980 int ff_MPV_common_frame_size_change(MpegEncContext *s)
984 if (s->slice_context_count > 1) {
985 for (i = 0; i < s->slice_context_count; i++) {
986 free_duplicate_context(s->thread_context[i]);
988 for (i = 1; i < s->slice_context_count; i++) {
989 av_freep(&s->thread_context[i]);
992 free_duplicate_context(s);
994 free_context_frame(s);
997 for (i = 0; i < s->picture_count; i++) {
998 s->picture[i].needs_realloc = 1;
1001 s->last_picture_ptr =
1002 s->next_picture_ptr =
1003 s->current_picture_ptr = NULL;
1006 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1007 s->mb_height = (s->height + 31) / 32 * 2;
1008 else if (s->codec_id != AV_CODEC_ID_H264)
1009 s->mb_height = (s->height + 15) / 16;
1011 if ((s->width || s->height) &&
1012 av_image_check_size(s->width, s->height, 0, s->avctx))
1013 return AVERROR_INVALIDDATA;
1015 if ((err = init_context_frame(s)))
1018 s->thread_context[0] = s;
1020 if (s->width && s->height) {
1021 int nb_slices = s->slice_context_count;
1022 if (nb_slices > 1) {
1023 for (i = 1; i < nb_slices; i++) {
1024 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1025 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1028 for (i = 0; i < nb_slices; i++) {
1029 if (init_duplicate_context(s->thread_context[i], s) < 0)
1031 s->thread_context[i]->start_mb_y =
1032 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1033 s->thread_context[i]->end_mb_y =
1034 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1037 if (init_duplicate_context(s, s) < 0)
1040 s->end_mb_y = s->mb_height;
1042 s->slice_context_count = nb_slices;
1047 ff_MPV_common_end(s);
1051 /* init common structure for both encoder and decoder */
1052 void ff_MPV_common_end(MpegEncContext *s)
1056 if (s->slice_context_count > 1) {
1057 for (i = 0; i < s->slice_context_count; i++) {
1058 free_duplicate_context(s->thread_context[i]);
1060 for (i = 1; i < s->slice_context_count; i++) {
1061 av_freep(&s->thread_context[i]);
1063 s->slice_context_count = 1;
1064 } else free_duplicate_context(s);
1066 av_freep(&s->parse_context.buffer);
1067 s->parse_context.buffer_size = 0;
1069 av_freep(&s->bitstream_buffer);
1070 s->allocated_bitstream_buffer_size = 0;
1072 av_freep(&s->avctx->stats_out);
1073 av_freep(&s->ac_stats);
1075 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1076 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1077 s->q_chroma_intra_matrix= NULL;
1078 s->q_chroma_intra_matrix16= NULL;
1079 av_freep(&s->q_intra_matrix);
1080 av_freep(&s->q_inter_matrix);
1081 av_freep(&s->q_intra_matrix16);
1082 av_freep(&s->q_inter_matrix16);
1083 av_freep(&s->input_picture);
1084 av_freep(&s->reordered_input_picture);
1085 av_freep(&s->dct_offset);
1087 if (s->picture && !s->avctx->internal->is_copy) {
1088 for (i = 0; i < s->picture_count; i++) {
1089 free_picture(s, &s->picture[i]);
1092 av_freep(&s->picture);
1094 free_context_frame(s);
1096 s->context_initialized = 0;
1097 s->last_picture_ptr =
1098 s->next_picture_ptr =
1099 s->current_picture_ptr = NULL;
1100 s->linesize = s->uvlinesize = 0;
1103 void ff_init_rl(RLTable *rl,
1104 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1106 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1107 uint8_t index_run[MAX_RUN + 1];
1108 int last, run, level, start, end, i;
1110 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1111 if (static_store && rl->max_level[0])
1114 /* compute max_level[], max_run[] and index_run[] */
1115 for (last = 0; last < 2; last++) {
1124 memset(max_level, 0, MAX_RUN + 1);
1125 memset(max_run, 0, MAX_LEVEL + 1);
1126 memset(index_run, rl->n, MAX_RUN + 1);
1127 for (i = start; i < end; i++) {
1128 run = rl->table_run[i];
1129 level = rl->table_level[i];
1130 if (index_run[run] == rl->n)
1132 if (level > max_level[run])
1133 max_level[run] = level;
1134 if (run > max_run[level])
1135 max_run[level] = run;
1138 rl->max_level[last] = static_store[last];
1140 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1141 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1143 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1145 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1146 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1148 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1150 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1151 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1155 void ff_init_vlc_rl(RLTable *rl)
1159 for (q = 0; q < 32; q++) {
1161 int qadd = (q - 1) | 1;
1167 for (i = 0; i < rl->vlc.table_size; i++) {
1168 int code = rl->vlc.table[i][0];
1169 int len = rl->vlc.table[i][1];
1172 if (len == 0) { // illegal code
1175 } else if (len < 0) { // more bits needed
1179 if (code == rl->n) { // esc
1183 run = rl->table_run[code] + 1;
1184 level = rl->table_level[code] * qmul + qadd;
1185 if (code >= rl->last) run += 192;
1188 rl->rl_vlc[q][i].len = len;
1189 rl->rl_vlc[q][i].level = level;
1190 rl->rl_vlc[q][i].run = run;
1195 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1199 /* release non reference frames */
1200 for (i = 0; i < s->picture_count; i++) {
1201 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1202 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1203 (remove_current || &s->picture[i] != s->current_picture_ptr)
1204 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1205 free_frame_buffer(s, &s->picture[i]);
1210 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1212 if (pic->f.data[0] == NULL)
1214 if (pic->needs_realloc)
1215 if (!pic->owner2 || pic->owner2 == s)
1220 static int find_unused_picture(MpegEncContext *s, int shared)
1225 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1226 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1230 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1231 if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1234 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1235 if (pic_is_unused(s, &s->picture[i]))
1240 av_log(s->avctx, AV_LOG_FATAL,
1241 "Internal error, picture buffer overflow\n");
1242 /* We could return -1, but the codec would crash trying to draw into a
1243 * non-existing frame anyway. This is safer than waiting for a random crash.
1244 * Also the return of this is never useful, an encoder must only allocate
1245 * as much as allowed in the specification. This has no relationship to how
1246 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1247 * enough for such valid streams).
1248 * Plus, a decoder has to check stream validity and remove frames if too
1249 * many reference frames are around. Waiting for "OOM" is not correct at
1250 * all. Similarly, missing reference frames have to be replaced by
1251 * interpolated/MC frames, anything else is a bug in the codec ...
1257 int ff_find_unused_picture(MpegEncContext *s, int shared)
1259 int ret = find_unused_picture(s, shared);
1261 if (ret >= 0 && ret < s->picture_range_end) {
1262 if (s->picture[ret].needs_realloc) {
1263 s->picture[ret].needs_realloc = 0;
1264 free_picture(s, &s->picture[ret]);
1265 avcodec_get_frame_defaults(&s->picture[ret].f);
1271 static void update_noise_reduction(MpegEncContext *s)
1275 for (intra = 0; intra < 2; intra++) {
1276 if (s->dct_count[intra] > (1 << 16)) {
1277 for (i = 0; i < 64; i++) {
1278 s->dct_error_sum[intra][i] >>= 1;
1280 s->dct_count[intra] >>= 1;
1283 for (i = 0; i < 64; i++) {
1284 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1285 s->dct_count[intra] +
1286 s->dct_error_sum[intra][i] / 2) /
1287 (s->dct_error_sum[intra][i] + 1);
1293 * generic function for encode/decode called after coding/decoding
1294 * the header and before a frame is coded/decoded.
1296 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1302 if (!ff_thread_can_start_frame(avctx)) {
1303 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1307 /* mark & release old frames */
1308 if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1309 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1310 s->last_picture_ptr != s->next_picture_ptr &&
1311 s->last_picture_ptr->f.data[0]) {
1312 if (s->last_picture_ptr->owner2 == s)
1313 free_frame_buffer(s, s->last_picture_ptr);
1316 /* release forgotten pictures */
1317 /* if (mpeg124/h263) */
1319 for (i = 0; i < s->picture_count; i++) {
1320 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1321 &s->picture[i] != s->last_picture_ptr &&
1322 &s->picture[i] != s->next_picture_ptr &&
1323 s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1324 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1325 av_log(avctx, AV_LOG_ERROR,
1326 "releasing zombie picture\n");
1327 free_frame_buffer(s, &s->picture[i]);
1334 ff_release_unused_pictures(s, 1);
1336 if (s->current_picture_ptr &&
1337 s->current_picture_ptr->f.data[0] == NULL) {
1338 // we already have a unused image
1339 // (maybe it was set before reading the header)
1340 pic = s->current_picture_ptr;
1342 i = ff_find_unused_picture(s, 0);
1344 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1347 pic = &s->picture[i];
1350 pic->f.reference = 0;
1351 if (!s->droppable) {
1352 if (s->codec_id == AV_CODEC_ID_H264)
1353 pic->f.reference = s->picture_structure;
1354 else if (s->pict_type != AV_PICTURE_TYPE_B)
1355 pic->f.reference = 3;
1358 pic->f.coded_picture_number = s->coded_picture_number++;
1360 if (ff_alloc_picture(s, pic, 0) < 0)
1363 s->current_picture_ptr = pic;
1364 // FIXME use only the vars from current_pic
1365 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1366 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1367 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1368 if (s->picture_structure != PICT_FRAME)
1369 s->current_picture_ptr->f.top_field_first =
1370 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1372 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1373 !s->progressive_sequence;
1374 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1377 s->current_picture_ptr->f.pict_type = s->pict_type;
1378 // if (s->flags && CODEC_FLAG_QSCALE)
1379 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1380 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1382 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1384 if (s->pict_type != AV_PICTURE_TYPE_B) {
1385 s->last_picture_ptr = s->next_picture_ptr;
1387 s->next_picture_ptr = s->current_picture_ptr;
1389 av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1390 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1391 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1392 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1393 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1394 s->pict_type, s->droppable);
1396 if (s->codec_id != AV_CODEC_ID_H264) {
1397 if ((s->last_picture_ptr == NULL ||
1398 s->last_picture_ptr->f.data[0] == NULL) &&
1399 (s->pict_type != AV_PICTURE_TYPE_I ||
1400 s->picture_structure != PICT_FRAME)) {
1401 if (s->pict_type != AV_PICTURE_TYPE_I)
1402 av_log(avctx, AV_LOG_ERROR,
1403 "warning: first frame is no keyframe\n");
1404 else if (s->picture_structure != PICT_FRAME)
1405 av_log(avctx, AV_LOG_INFO,
1406 "allocate dummy last picture for field based first keyframe\n");
1408 /* Allocate a dummy frame */
1409 i = ff_find_unused_picture(s, 0);
1411 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1414 s->last_picture_ptr = &s->picture[i];
1415 s->last_picture_ptr->f.key_frame = 0;
1416 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1417 s->last_picture_ptr = NULL;
1421 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1422 for(i=0; i<avctx->height; i++)
1423 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1426 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1427 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1428 s->last_picture_ptr->f.reference = 3;
1430 if ((s->next_picture_ptr == NULL ||
1431 s->next_picture_ptr->f.data[0] == NULL) &&
1432 s->pict_type == AV_PICTURE_TYPE_B) {
1433 /* Allocate a dummy frame */
1434 i = ff_find_unused_picture(s, 0);
1436 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1439 s->next_picture_ptr = &s->picture[i];
1440 s->next_picture_ptr->f.key_frame = 0;
1441 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1442 s->next_picture_ptr = NULL;
1445 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1446 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1447 s->next_picture_ptr->f.reference = 3;
1451 if (s->last_picture_ptr)
1452 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1453 if (s->next_picture_ptr)
1454 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1456 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) {
1457 if (s->next_picture_ptr)
1458 s->next_picture_ptr->owner2 = s;
1459 if (s->last_picture_ptr)
1460 s->last_picture_ptr->owner2 = s;
1463 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1464 s->last_picture_ptr->f.data[0]));
1466 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1468 for (i = 0; i < 4; i++) {
1469 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1470 s->current_picture.f.data[i] +=
1471 s->current_picture.f.linesize[i];
1473 s->current_picture.f.linesize[i] *= 2;
1474 s->last_picture.f.linesize[i] *= 2;
1475 s->next_picture.f.linesize[i] *= 2;
1479 s->err_recognition = avctx->err_recognition;
1481 /* set dequantizer, we can't do it during init as
1482 * it might change for mpeg4 and we can't do it in the header
1483 * decode as init is not called for mpeg4 there yet */
1484 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1485 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1486 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1487 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1488 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1489 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1491 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1492 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1495 if (s->dct_error_sum) {
1496 assert(s->avctx->noise_reduction && s->encoding);
1497 update_noise_reduction(s);
1500 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1501 return ff_xvmc_field_start(s, avctx);
1506 /* generic function for encode/decode called after a
1507 * frame has been coded/decoded. */
1508 void ff_MPV_frame_end(MpegEncContext *s)
1511 /* redraw edges for the frame if decoding didn't complete */
1512 // just to make sure that all data is rendered.
1513 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1514 ff_xvmc_field_end(s);
1515 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1516 !s->avctx->hwaccel &&
1517 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1518 s->unrestricted_mv &&
1519 s->current_picture.f.reference &&
1521 !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1524 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1525 int hshift = desc->log2_chroma_w;
1526 int vshift = desc->log2_chroma_h;
1527 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1528 s->h_edge_pos, s->v_edge_pos,
1529 EDGE_WIDTH, EDGE_WIDTH,
1530 EDGE_TOP | EDGE_BOTTOM);
1531 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1532 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1533 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1534 EDGE_TOP | EDGE_BOTTOM);
1535 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1536 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1537 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1538 EDGE_TOP | EDGE_BOTTOM);
1543 s->last_pict_type = s->pict_type;
1544 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1545 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1546 s->last_non_b_pict_type = s->pict_type;
1549 /* copy back current_picture variables */
1550 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1551 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1552 s->picture[i] = s->current_picture;
1556 assert(i < MAX_PICTURE_COUNT);
1560 /* release non-reference frames */
1561 for (i = 0; i < s->picture_count; i++) {
1562 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1563 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1564 free_frame_buffer(s, &s->picture[i]);
1568 // clear copies, to avoid confusion
1570 memset(&s->last_picture, 0, sizeof(Picture));
1571 memset(&s->next_picture, 0, sizeof(Picture));
1572 memset(&s->current_picture, 0, sizeof(Picture));
1574 s->avctx->coded_frame = &s->current_picture_ptr->f;
1576 if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1577 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1582 * Draw a line from (ex, ey) -> (sx, sy).
1583 * @param w width of the image
1584 * @param h height of the image
1585 * @param stride stride/linesize of the image
1586 * @param color color of the arrow
1588 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1589 int w, int h, int stride, int color)
1593 sx = av_clip(sx, 0, w - 1);
1594 sy = av_clip(sy, 0, h - 1);
1595 ex = av_clip(ex, 0, w - 1);
1596 ey = av_clip(ey, 0, h - 1);
1598 buf[sy * stride + sx] += color;
1600 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1602 FFSWAP(int, sx, ex);
1603 FFSWAP(int, sy, ey);
1605 buf += sx + sy * stride;
1607 f = ((ey - sy) << 16) / ex;
1608 for(x= 0; x <= ex; x++){
1610 fr = (x * f) & 0xFFFF;
1611 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1612 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1616 FFSWAP(int, sx, ex);
1617 FFSWAP(int, sy, ey);
1619 buf += sx + sy * stride;
1622 f = ((ex - sx) << 16) / ey;
1625 for(y= 0; y <= ey; y++){
1627 fr = (y*f) & 0xFFFF;
1628 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1629 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1635 * Draw an arrow from (ex, ey) -> (sx, sy).
1636 * @param w width of the image
1637 * @param h height of the image
1638 * @param stride stride/linesize of the image
1639 * @param color color of the arrow
1641 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1642 int ey, int w, int h, int stride, int color)
1646 sx = av_clip(sx, -100, w + 100);
1647 sy = av_clip(sy, -100, h + 100);
1648 ex = av_clip(ex, -100, w + 100);
1649 ey = av_clip(ey, -100, h + 100);
1654 if (dx * dx + dy * dy > 3 * 3) {
1657 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1659 // FIXME subpixel accuracy
1660 rx = ROUNDED_DIV(rx * 3 << 4, length);
1661 ry = ROUNDED_DIV(ry * 3 << 4, length);
1663 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1664 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1666 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1670 * Print debugging info for the given picture.
1672 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1674 if ( s->avctx->hwaccel || !pict || !pict->mb_type
1675 || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1679 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1682 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1683 av_get_picture_type_char(pict->pict_type));
1684 for (y = 0; y < s->mb_height; y++) {
1685 for (x = 0; x < s->mb_width; x++) {
1686 if (s->avctx->debug & FF_DEBUG_SKIP) {
1687 int count = s->mbskip_table[x + y * s->mb_stride];
1690 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1692 if (s->avctx->debug & FF_DEBUG_QP) {
1693 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1694 pict->qscale_table[x + y * s->mb_stride]);
1696 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1697 int mb_type = pict->mb_type[x + y * s->mb_stride];
1698 // Type & MV direction
1699 if (IS_PCM(mb_type))
1700 av_log(s->avctx, AV_LOG_DEBUG, "P");
1701 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1702 av_log(s->avctx, AV_LOG_DEBUG, "A");
1703 else if (IS_INTRA4x4(mb_type))
1704 av_log(s->avctx, AV_LOG_DEBUG, "i");
1705 else if (IS_INTRA16x16(mb_type))
1706 av_log(s->avctx, AV_LOG_DEBUG, "I");
1707 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1708 av_log(s->avctx, AV_LOG_DEBUG, "d");
1709 else if (IS_DIRECT(mb_type))
1710 av_log(s->avctx, AV_LOG_DEBUG, "D");
1711 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1712 av_log(s->avctx, AV_LOG_DEBUG, "g");
1713 else if (IS_GMC(mb_type))
1714 av_log(s->avctx, AV_LOG_DEBUG, "G");
1715 else if (IS_SKIP(mb_type))
1716 av_log(s->avctx, AV_LOG_DEBUG, "S");
1717 else if (!USES_LIST(mb_type, 1))
1718 av_log(s->avctx, AV_LOG_DEBUG, ">");
1719 else if (!USES_LIST(mb_type, 0))
1720 av_log(s->avctx, AV_LOG_DEBUG, "<");
1722 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1723 av_log(s->avctx, AV_LOG_DEBUG, "X");
1727 if (IS_8X8(mb_type))
1728 av_log(s->avctx, AV_LOG_DEBUG, "+");
1729 else if (IS_16X8(mb_type))
1730 av_log(s->avctx, AV_LOG_DEBUG, "-");
1731 else if (IS_8X16(mb_type))
1732 av_log(s->avctx, AV_LOG_DEBUG, "|");
1733 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1734 av_log(s->avctx, AV_LOG_DEBUG, " ");
1736 av_log(s->avctx, AV_LOG_DEBUG, "?");
1739 if (IS_INTERLACED(mb_type))
1740 av_log(s->avctx, AV_LOG_DEBUG, "=");
1742 av_log(s->avctx, AV_LOG_DEBUG, " ");
1745 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1749 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1750 (s->avctx->debug_mv)) {
1751 const int shift = 1 + s->quarter_sample;
1755 int h_chroma_shift, v_chroma_shift, block_height;
1756 const int width = s->avctx->width;
1757 const int height = s->avctx->height;
1758 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1759 const int mv_stride = (s->mb_width << mv_sample_log2) +
1760 (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1761 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1763 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1765 for (i = 0; i < 3; i++) {
1766 size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1767 pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1768 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1769 memcpy(s->visualization_buffer[i], pict->data[i], size);
1770 pict->data[i] = s->visualization_buffer[i];
1772 pict->type = FF_BUFFER_TYPE_COPY;
1774 ptr = pict->data[0];
1775 block_height = 16 >> v_chroma_shift;
1777 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1779 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1780 const int mb_index = mb_x + mb_y * s->mb_stride;
1781 if ((s->avctx->debug_mv) && pict->motion_val[0]) {
1783 for (type = 0; type < 3; type++) {
1787 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1788 (pict->pict_type!= AV_PICTURE_TYPE_P))
1793 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1794 (pict->pict_type!= AV_PICTURE_TYPE_B))
1799 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1800 (pict->pict_type!= AV_PICTURE_TYPE_B))
1805 if (!USES_LIST(pict->mb_type[mb_index], direction))
1808 if (IS_8X8(pict->mb_type[mb_index])) {
1810 for (i = 0; i < 4; i++) {
1811 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1812 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1813 int xy = (mb_x * 2 + (i & 1) +
1814 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1815 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1816 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1817 draw_arrow(ptr, sx, sy, mx, my, width,
1818 height, s->linesize, 100);
1820 } else if (IS_16X8(pict->mb_type[mb_index])) {
1822 for (i = 0; i < 2; i++) {
1823 int sx = mb_x * 16 + 8;
1824 int sy = mb_y * 16 + 4 + 8 * i;
1825 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1826 int mx = (pict->motion_val[direction][xy][0] >> shift);
1827 int my = (pict->motion_val[direction][xy][1] >> shift);
1829 if (IS_INTERLACED(pict->mb_type[mb_index]))
1832 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1833 height, s->linesize, 100);
1835 } else if (IS_8X16(pict->mb_type[mb_index])) {
1837 for (i = 0; i < 2; i++) {
1838 int sx = mb_x * 16 + 4 + 8 * i;
1839 int sy = mb_y * 16 + 8;
1840 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1841 int mx = pict->motion_val[direction][xy][0] >> shift;
1842 int my = pict->motion_val[direction][xy][1] >> shift;
1844 if (IS_INTERLACED(pict->mb_type[mb_index]))
1847 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1848 height, s->linesize, 100);
1851 int sx= mb_x * 16 + 8;
1852 int sy= mb_y * 16 + 8;
1853 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1854 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1855 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1856 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1860 if ((s->avctx->debug & FF_DEBUG_VIS_QP)) {
1861 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1862 0x0101010101010101ULL;
1864 for (y = 0; y < block_height; y++) {
1865 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1866 (block_height * mb_y + y) *
1867 pict->linesize[1]) = c;
1868 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1869 (block_height * mb_y + y) *
1870 pict->linesize[2]) = c;
1873 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1874 pict->motion_val[0]) {
1875 int mb_type = pict->mb_type[mb_index];
1878 #define COLOR(theta, r) \
1879 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1880 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1884 if (IS_PCM(mb_type)) {
1886 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1887 IS_INTRA16x16(mb_type)) {
1889 } else if (IS_INTRA4x4(mb_type)) {
1891 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1893 } else if (IS_DIRECT(mb_type)) {
1895 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1897 } else if (IS_GMC(mb_type)) {
1899 } else if (IS_SKIP(mb_type)) {
1901 } else if (!USES_LIST(mb_type, 1)) {
1903 } else if (!USES_LIST(mb_type, 0)) {
1906 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1910 u *= 0x0101010101010101ULL;
1911 v *= 0x0101010101010101ULL;
1912 for (y = 0; y < block_height; y++) {
1913 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1914 (block_height * mb_y + y) * pict->linesize[1]) = u;
1915 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1916 (block_height * mb_y + y) * pict->linesize[2]) = v;
1920 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1921 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1922 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1923 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1924 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1926 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1927 for (y = 0; y < 16; y++)
1928 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1929 pict->linesize[0]] ^= 0x80;
1931 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1932 int dm = 1 << (mv_sample_log2 - 2);
1933 for (i = 0; i < 4; i++) {
1934 int sx = mb_x * 16 + 8 * (i & 1);
1935 int sy = mb_y * 16 + 8 * (i >> 1);
1936 int xy = (mb_x * 2 + (i & 1) +
1937 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1939 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1940 if (mv[0] != mv[dm] ||
1941 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1942 for (y = 0; y < 8; y++)
1943 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1944 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1945 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1946 pict->linesize[0]) ^= 0x8080808080808080ULL;
1950 if (IS_INTERLACED(mb_type) &&
1951 s->codec_id == AV_CODEC_ID_H264) {
1955 s->mbskip_table[mb_index] = 0;
1961 static inline int hpel_motion_lowres(MpegEncContext *s,
1962 uint8_t *dest, uint8_t *src,
1963 int field_based, int field_select,
1964 int src_x, int src_y,
1965 int width, int height, int stride,
1966 int h_edge_pos, int v_edge_pos,
1967 int w, int h, h264_chroma_mc_func *pix_op,
1968 int motion_x, int motion_y)
1970 const int lowres = s->avctx->lowres;
1971 const int op_index = FFMIN(lowres, 2);
1972 const int s_mask = (2 << lowres) - 1;
1976 if (s->quarter_sample) {
1981 sx = motion_x & s_mask;
1982 sy = motion_y & s_mask;
1983 src_x += motion_x >> lowres + 1;
1984 src_y += motion_y >> lowres + 1;
1986 src += src_y * stride + src_x;
1988 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1989 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1990 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1991 (h + 1) << field_based, src_x,
1992 src_y << field_based,
1995 src = s->edge_emu_buffer;
1999 sx = (sx << 2) >> lowres;
2000 sy = (sy << 2) >> lowres;
2003 pix_op[op_index](dest, src, stride, h, sx, sy);
2007 /* apply one mpeg motion vector to the three components */
2008 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2015 uint8_t **ref_picture,
2016 h264_chroma_mc_func *pix_op,
2017 int motion_x, int motion_y,
2020 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2021 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2023 const int lowres = s->avctx->lowres;
2024 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
2025 const int block_s = 8>>lowres;
2026 const int s_mask = (2 << lowres) - 1;
2027 const int h_edge_pos = s->h_edge_pos >> lowres;
2028 const int v_edge_pos = s->v_edge_pos >> lowres;
2029 linesize = s->current_picture.f.linesize[0] << field_based;
2030 uvlinesize = s->current_picture.f.linesize[1] << field_based;
2032 // FIXME obviously not perfect but qpel will not work in lowres anyway
2033 if (s->quarter_sample) {
2039 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2042 sx = motion_x & s_mask;
2043 sy = motion_y & s_mask;
2044 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2045 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2047 if (s->out_format == FMT_H263) {
2048 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2049 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2050 uvsrc_x = src_x >> 1;
2051 uvsrc_y = src_y >> 1;
2052 } else if (s->out_format == FMT_H261) {
2053 // even chroma mv's are full pel in H261
2056 uvsx = (2 * mx) & s_mask;
2057 uvsy = (2 * my) & s_mask;
2058 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2059 uvsrc_y = mb_y * block_s + (my >> lowres);
2061 if(s->chroma_y_shift){
2066 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2067 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2069 if(s->chroma_x_shift){
2073 uvsy = motion_y & s_mask;
2075 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2078 uvsx = motion_x & s_mask;
2079 uvsy = motion_y & s_mask;
2086 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2087 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2088 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2090 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
2091 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2092 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2093 linesize >> field_based, 17, 17 + field_based,
2094 src_x, src_y << field_based, h_edge_pos,
2096 ptr_y = s->edge_emu_buffer;
2097 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2098 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2099 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2101 uvsrc_x, uvsrc_y << field_based,
2102 h_edge_pos >> 1, v_edge_pos >> 1);
2103 s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2105 uvsrc_x, uvsrc_y << field_based,
2106 h_edge_pos >> 1, v_edge_pos >> 1);
2108 ptr_cr = uvbuf + 16;
2112 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2114 dest_y += s->linesize;
2115 dest_cb += s->uvlinesize;
2116 dest_cr += s->uvlinesize;
2120 ptr_y += s->linesize;
2121 ptr_cb += s->uvlinesize;
2122 ptr_cr += s->uvlinesize;
2125 sx = (sx << 2) >> lowres;
2126 sy = (sy << 2) >> lowres;
2127 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2129 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2130 uvsx = (uvsx << 2) >> lowres;
2131 uvsy = (uvsy << 2) >> lowres;
2132 if (h >> s->chroma_y_shift) {
2133 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2134 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2137 // FIXME h261 lowres loop filter
2140 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2141 uint8_t *dest_cb, uint8_t *dest_cr,
2142 uint8_t **ref_picture,
2143 h264_chroma_mc_func * pix_op,
2146 const int lowres = s->avctx->lowres;
2147 const int op_index = FFMIN(lowres, 2);
2148 const int block_s = 8 >> lowres;
2149 const int s_mask = (2 << lowres) - 1;
2150 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2151 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2152 int emu = 0, src_x, src_y, offset, sx, sy;
2155 if (s->quarter_sample) {
2160 /* In case of 8X8, we construct a single chroma motion vector
2161 with a special rounding */
2162 mx = ff_h263_round_chroma(mx);
2163 my = ff_h263_round_chroma(my);
2167 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2168 src_y = s->mb_y * block_s + (my >> lowres + 1);
2170 offset = src_y * s->uvlinesize + src_x;
2171 ptr = ref_picture[1] + offset;
2172 if (s->flags & CODEC_FLAG_EMU_EDGE) {
2173 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2174 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2175 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2176 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2177 ptr = s->edge_emu_buffer;
2181 sx = (sx << 2) >> lowres;
2182 sy = (sy << 2) >> lowres;
2183 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2185 ptr = ref_picture[2] + offset;
2187 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2188 src_x, src_y, h_edge_pos, v_edge_pos);
2189 ptr = s->edge_emu_buffer;
2191 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2195 * motion compensation of a single macroblock
2197 * @param dest_y luma destination pointer
2198 * @param dest_cb chroma cb/u destination pointer
2199 * @param dest_cr chroma cr/v destination pointer
2200 * @param dir direction (0->forward, 1->backward)
2201 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2202 * @param pix_op halfpel motion compensation function (average or put normally)
2203 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2205 static inline void MPV_motion_lowres(MpegEncContext *s,
2206 uint8_t *dest_y, uint8_t *dest_cb,
2208 int dir, uint8_t **ref_picture,
2209 h264_chroma_mc_func *pix_op)
2213 const int lowres = s->avctx->lowres;
2214 const int block_s = 8 >>lowres;
2219 switch (s->mv_type) {
2221 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2223 ref_picture, pix_op,
2224 s->mv[dir][0][0], s->mv[dir][0][1],
2230 for (i = 0; i < 4; i++) {
2231 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2232 s->linesize) * block_s,
2233 ref_picture[0], 0, 0,
2234 (2 * mb_x + (i & 1)) * block_s,
2235 (2 * mb_y + (i >> 1)) * block_s,
2236 s->width, s->height, s->linesize,
2237 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2238 block_s, block_s, pix_op,
2239 s->mv[dir][i][0], s->mv[dir][i][1]);
2241 mx += s->mv[dir][i][0];
2242 my += s->mv[dir][i][1];
2245 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2246 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2250 if (s->picture_structure == PICT_FRAME) {
2252 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2253 1, 0, s->field_select[dir][0],
2254 ref_picture, pix_op,
2255 s->mv[dir][0][0], s->mv[dir][0][1],
2258 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2259 1, 1, s->field_select[dir][1],
2260 ref_picture, pix_op,
2261 s->mv[dir][1][0], s->mv[dir][1][1],
2264 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2265 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2266 ref_picture = s->current_picture_ptr->f.data;
2269 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2270 0, 0, s->field_select[dir][0],
2271 ref_picture, pix_op,
2273 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2277 for (i = 0; i < 2; i++) {
2278 uint8_t **ref2picture;
2280 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2281 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2282 ref2picture = ref_picture;
2284 ref2picture = s->current_picture_ptr->f.data;
2287 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2288 0, 0, s->field_select[dir][i],
2289 ref2picture, pix_op,
2290 s->mv[dir][i][0], s->mv[dir][i][1] +
2291 2 * block_s * i, block_s, mb_y >> 1);
2293 dest_y += 2 * block_s * s->linesize;
2294 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2295 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2299 if (s->picture_structure == PICT_FRAME) {
2300 for (i = 0; i < 2; i++) {
2302 for (j = 0; j < 2; j++) {
2303 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2305 ref_picture, pix_op,
2306 s->mv[dir][2 * i + j][0],
2307 s->mv[dir][2 * i + j][1],
2310 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2313 for (i = 0; i < 2; i++) {
2314 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2315 0, 0, s->picture_structure != i + 1,
2316 ref_picture, pix_op,
2317 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2318 2 * block_s, mb_y >> 1);
2320 // after put we make avg of the same block
2321 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2323 // opposite parity is always in the same
2324 // frame if this is second field
2325 if (!s->first_field) {
2326 ref_picture = s->current_picture_ptr->f.data;
2337 * find the lowest MB row referenced in the MVs
2339 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2341 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2342 int my, off, i, mvs;
2344 if (s->picture_structure != PICT_FRAME || s->mcsel)
2347 switch (s->mv_type) {
2361 for (i = 0; i < mvs; i++) {
2362 my = s->mv[dir][i][1]<<qpel_shift;
2363 my_max = FFMAX(my_max, my);
2364 my_min = FFMIN(my_min, my);
2367 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2369 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2371 return s->mb_height-1;
2374 /* put block[] to dest[] */
2375 static inline void put_dct(MpegEncContext *s,
2376 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2378 s->dct_unquantize_intra(s, block, i, qscale);
2379 s->dsp.idct_put (dest, line_size, block);
2382 /* add block[] to dest[] */
2383 static inline void add_dct(MpegEncContext *s,
2384 DCTELEM *block, int i, uint8_t *dest, int line_size)
2386 if (s->block_last_index[i] >= 0) {
2387 s->dsp.idct_add (dest, line_size, block);
2391 static inline void add_dequant_dct(MpegEncContext *s,
2392 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2394 if (s->block_last_index[i] >= 0) {
2395 s->dct_unquantize_inter(s, block, i, qscale);
2397 s->dsp.idct_add (dest, line_size, block);
2402 * Clean dc, ac, coded_block for the current non-intra MB.
2404 void ff_clean_intra_table_entries(MpegEncContext *s)
2406 int wrap = s->b8_stride;
2407 int xy = s->block_index[0];
2410 s->dc_val[0][xy + 1 ] =
2411 s->dc_val[0][xy + wrap] =
2412 s->dc_val[0][xy + 1 + wrap] = 1024;
2414 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2415 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2416 if (s->msmpeg4_version>=3) {
2417 s->coded_block[xy ] =
2418 s->coded_block[xy + 1 ] =
2419 s->coded_block[xy + wrap] =
2420 s->coded_block[xy + 1 + wrap] = 0;
2423 wrap = s->mb_stride;
2424 xy = s->mb_x + s->mb_y * wrap;
2426 s->dc_val[2][xy] = 1024;
2428 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2429 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2431 s->mbintra_table[xy]= 0;
2434 /* generic function called after a macroblock has been parsed by the
2435 decoder or after it has been encoded by the encoder.
2437 Important variables used:
2438 s->mb_intra : true if intra macroblock
2439 s->mv_dir : motion vector direction
2440 s->mv_type : motion vector type
2441 s->mv : motion vector
2442 s->interlaced_dct : true if interlaced dct used (mpeg2)
2444 static av_always_inline
2445 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2446 int lowres_flag, int is_mpeg12)
2448 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2449 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2450 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2454 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2455 /* save DCT coefficients */
2457 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2458 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2460 for(j=0; j<64; j++){
2461 *dct++ = block[i][s->dsp.idct_permutation[j]];
2462 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2464 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2468 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2470 /* update DC predictors for P macroblocks */
2472 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2473 if(s->mbintra_table[mb_xy])
2474 ff_clean_intra_table_entries(s);
2478 s->last_dc[2] = 128 << s->intra_dc_precision;
2481 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2482 s->mbintra_table[mb_xy]=1;
2484 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2485 uint8_t *dest_y, *dest_cb, *dest_cr;
2486 int dct_linesize, dct_offset;
2487 op_pixels_func (*op_pix)[4];
2488 qpel_mc_func (*op_qpix)[16];
2489 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2490 const int uvlinesize = s->current_picture.f.linesize[1];
2491 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2492 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2494 /* avoid copy if macroblock skipped in last frame too */
2495 /* skip only during decoding as we might trash the buffers during encoding a bit */
2497 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2499 if (s->mb_skipped) {
2501 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2503 } else if(!s->current_picture.f.reference) {
2506 *mbskip_ptr = 0; /* not skipped */
2510 dct_linesize = linesize << s->interlaced_dct;
2511 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2515 dest_cb= s->dest[1];
2516 dest_cr= s->dest[2];
2518 dest_y = s->b_scratchpad;
2519 dest_cb= s->b_scratchpad+16*linesize;
2520 dest_cr= s->b_scratchpad+32*linesize;
2524 /* motion handling */
2525 /* decoding or more than one mb_type (MC was already done otherwise) */
2528 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2529 if (s->mv_dir & MV_DIR_FORWARD) {
2530 ff_thread_await_progress(&s->last_picture_ptr->f,
2531 ff_MPV_lowest_referenced_row(s, 0),
2534 if (s->mv_dir & MV_DIR_BACKWARD) {
2535 ff_thread_await_progress(&s->next_picture_ptr->f,
2536 ff_MPV_lowest_referenced_row(s, 1),
2542 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2544 if (s->mv_dir & MV_DIR_FORWARD) {
2545 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2546 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2548 if (s->mv_dir & MV_DIR_BACKWARD) {
2549 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2552 op_qpix= s->me.qpel_put;
2553 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2554 op_pix = s->dsp.put_pixels_tab;
2556 op_pix = s->dsp.put_no_rnd_pixels_tab;
2558 if (s->mv_dir & MV_DIR_FORWARD) {
2559 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2560 op_pix = s->dsp.avg_pixels_tab;
2561 op_qpix= s->me.qpel_avg;
2563 if (s->mv_dir & MV_DIR_BACKWARD) {
2564 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2569 /* skip dequant / idct if we are really late ;) */
2570 if(s->avctx->skip_idct){
2571 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2572 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2573 || s->avctx->skip_idct >= AVDISCARD_ALL)
2577 /* add dct residue */
2578 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2579 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2580 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2581 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2582 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2583 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2585 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2586 if (s->chroma_y_shift){
2587 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2588 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2592 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2593 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2594 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2595 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2598 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2599 add_dct(s, block[0], 0, dest_y , dct_linesize);
2600 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2601 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2602 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2604 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2605 if(s->chroma_y_shift){//Chroma420
2606 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2607 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2610 dct_linesize = uvlinesize << s->interlaced_dct;
2611 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2613 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2614 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2615 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2616 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2617 if(!s->chroma_x_shift){//Chroma444
2618 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2619 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2620 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2621 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2626 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2627 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2630 /* dct only in intra block */
2631 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2632 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2633 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2634 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2635 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2637 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2638 if(s->chroma_y_shift){
2639 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2640 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2644 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2645 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2646 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2647 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2651 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2652 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2653 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2654 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2656 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2657 if(s->chroma_y_shift){
2658 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2659 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2662 dct_linesize = uvlinesize << s->interlaced_dct;
2663 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2665 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2666 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2667 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2668 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2669 if(!s->chroma_x_shift){//Chroma444
2670 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2671 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2672 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2673 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2681 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2682 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2683 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2688 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2690 if(s->out_format == FMT_MPEG1) {
2691 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2692 else MPV_decode_mb_internal(s, block, 0, 1);
2695 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2696 else MPV_decode_mb_internal(s, block, 0, 0);
2700 * @param h is the normal height, this will be reduced automatically if needed for the last row
2702 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2703 const int field_pic= s->picture_structure != PICT_FRAME;
2709 if (!s->avctx->hwaccel
2710 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2711 && s->unrestricted_mv
2712 && s->current_picture.f.reference
2714 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2715 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
2716 int sides = 0, edge_h;
2717 int hshift = desc->log2_chroma_w;
2718 int vshift = desc->log2_chroma_h;
2719 if (y==0) sides |= EDGE_TOP;
2720 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2722 edge_h= FFMIN(h, s->v_edge_pos - y);
2724 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2725 s->linesize, s->h_edge_pos, edge_h,
2726 EDGE_WIDTH, EDGE_WIDTH, sides);
2727 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2728 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2729 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2730 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2731 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2732 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2735 h= FFMIN(h, s->avctx->height - y);
2737 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2739 if (s->avctx->draw_horiz_band) {
2741 int offset[AV_NUM_DATA_POINTERS];
2744 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2745 src = &s->current_picture_ptr->f;
2746 else if(s->last_picture_ptr)
2747 src = &s->last_picture_ptr->f;
2751 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2752 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2755 offset[0]= y * s->linesize;
2757 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2758 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2764 s->avctx->draw_horiz_band(s->avctx, src, offset,
2765 y, s->picture_structure, h);
2769 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2770 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2771 const int uvlinesize = s->current_picture.f.linesize[1];
2772 const int mb_size= 4 - s->avctx->lowres;
2774 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2775 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2776 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2777 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2778 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2779 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;
2780 //block_index is not used by mpeg2, so it is not affected by chroma_format
2782 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2783 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2784 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2786 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2788 if(s->picture_structure==PICT_FRAME){
2789 s->dest[0] += s->mb_y * linesize << mb_size;
2790 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2791 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2793 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2794 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2795 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2796 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2801 void ff_mpeg_flush(AVCodecContext *avctx){
2803 MpegEncContext *s = avctx->priv_data;
2805 if(s==NULL || s->picture==NULL)
2808 for(i=0; i<s->picture_count; i++){
2809 if (s->picture[i].f.data[0] &&
2810 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2811 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2812 free_frame_buffer(s, &s->picture[i]);
2814 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2816 s->mb_x= s->mb_y= 0;
2819 s->parse_context.state= -1;
2820 s->parse_context.frame_start_found= 0;
2821 s->parse_context.overread= 0;
2822 s->parse_context.overread_index= 0;
2823 s->parse_context.index= 0;
2824 s->parse_context.last_index= 0;
2825 s->bitstream_buffer_size=0;
2829 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2830 DCTELEM *block, int n, int qscale)
2832 int i, level, nCoeffs;
2833 const uint16_t *quant_matrix;
2835 nCoeffs= s->block_last_index[n];
2837 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2838 /* XXX: only mpeg1 */
2839 quant_matrix = s->intra_matrix;
2840 for(i=1;i<=nCoeffs;i++) {
2841 int j= s->intra_scantable.permutated[i];
2846 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2847 level = (level - 1) | 1;
2850 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2851 level = (level - 1) | 1;
2858 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2859 DCTELEM *block, int n, int qscale)
2861 int i, level, nCoeffs;
2862 const uint16_t *quant_matrix;
2864 nCoeffs= s->block_last_index[n];
2866 quant_matrix = s->inter_matrix;
2867 for(i=0; i<=nCoeffs; i++) {
2868 int j= s->intra_scantable.permutated[i];
2873 level = (((level << 1) + 1) * qscale *
2874 ((int) (quant_matrix[j]))) >> 4;
2875 level = (level - 1) | 1;
2878 level = (((level << 1) + 1) * qscale *
2879 ((int) (quant_matrix[j]))) >> 4;
2880 level = (level - 1) | 1;
2887 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2888 DCTELEM *block, int n, int qscale)
2890 int i, level, nCoeffs;
2891 const uint16_t *quant_matrix;
2893 if(s->alternate_scan) nCoeffs= 63;
2894 else nCoeffs= s->block_last_index[n];
2896 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2897 quant_matrix = s->intra_matrix;
2898 for(i=1;i<=nCoeffs;i++) {
2899 int j= s->intra_scantable.permutated[i];
2904 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2907 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2914 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2915 DCTELEM *block, int n, int qscale)
2917 int i, level, nCoeffs;
2918 const uint16_t *quant_matrix;
2921 if(s->alternate_scan) nCoeffs= 63;
2922 else nCoeffs= s->block_last_index[n];
2924 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2926 quant_matrix = s->intra_matrix;
2927 for(i=1;i<=nCoeffs;i++) {
2928 int j= s->intra_scantable.permutated[i];
2933 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2936 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2945 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2946 DCTELEM *block, int n, int qscale)
2948 int i, level, nCoeffs;
2949 const uint16_t *quant_matrix;
2952 if(s->alternate_scan) nCoeffs= 63;
2953 else nCoeffs= s->block_last_index[n];
2955 quant_matrix = s->inter_matrix;
2956 for(i=0; i<=nCoeffs; i++) {
2957 int j= s->intra_scantable.permutated[i];
2962 level = (((level << 1) + 1) * qscale *
2963 ((int) (quant_matrix[j]))) >> 4;
2966 level = (((level << 1) + 1) * qscale *
2967 ((int) (quant_matrix[j]))) >> 4;
2976 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2977 DCTELEM *block, int n, int qscale)
2979 int i, level, qmul, qadd;
2982 assert(s->block_last_index[n]>=0);
2987 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2988 qadd = (qscale - 1) | 1;
2995 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2997 for(i=1; i<=nCoeffs; i++) {
3001 level = level * qmul - qadd;
3003 level = level * qmul + qadd;
3010 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3011 DCTELEM *block, int n, int qscale)
3013 int i, level, qmul, qadd;
3016 assert(s->block_last_index[n]>=0);
3018 qadd = (qscale - 1) | 1;
3021 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3023 for(i=0; i<=nCoeffs; i++) {
3027 level = level * qmul - qadd;
3029 level = level * qmul + qadd;
3037 * set qscale and update qscale dependent variables.
3039 void ff_set_qscale(MpegEncContext * s, int qscale)
3043 else if (qscale > 31)
3047 s->chroma_qscale= s->chroma_qscale_table[qscale];
3049 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3050 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3053 void ff_MPV_report_decode_progress(MpegEncContext *s)
3055 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
3056 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);