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);
61 /* enable all paranoid tests for rounding, overflows, etc... */
67 static const uint8_t ff_default_chroma_qscale_table[32] = {
68 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
69 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
70 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
73 const uint8_t ff_mpeg1_dc_scale_table[128] = {
74 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
80 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
81 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
85 static const uint8_t mpeg2_dc_scale_table1[128] = {
86 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
92 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
97 static const uint8_t mpeg2_dc_scale_table2[128] = {
98 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
104 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
109 static const uint8_t mpeg2_dc_scale_table3[128] = {
110 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
116 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
117 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
121 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
122 ff_mpeg1_dc_scale_table,
123 mpeg2_dc_scale_table1,
124 mpeg2_dc_scale_table2,
125 mpeg2_dc_scale_table3,
128 const enum AVPixelFormat ff_pixfmt_list_420[] = {
133 const enum AVPixelFormat ff_hwaccel_pixfmt_list_420[] = {
134 AV_PIX_FMT_DXVA2_VLD,
135 AV_PIX_FMT_VAAPI_VLD,
141 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
143 uint32_t *av_restrict state)
151 for (i = 0; i < 3; i++) {
152 uint32_t tmp = *state << 8;
153 *state = tmp + *(p++);
154 if (tmp == 0x100 || p == end)
159 if (p[-1] > 1 ) p += 3;
160 else if (p[-2] ) p += 2;
161 else if (p[-3]|(p[-1]-1)) p++;
168 p = FFMIN(p, end) - 4;
174 /* init common dct for both encoder and decoder */
175 av_cold int ff_dct_common_init(MpegEncContext *s)
177 ff_dsputil_init(&s->dsp, s->avctx);
179 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
180 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
181 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
182 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
183 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
184 if (s->flags & CODEC_FLAG_BITEXACT)
185 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
186 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
189 ff_MPV_common_init_x86(s);
191 ff_MPV_common_init_axp(s);
193 ff_MPV_common_init_arm(s);
195 ff_MPV_common_init_altivec(s);
197 ff_MPV_common_init_bfin(s);
200 /* load & permutate scantables
201 * note: only wmv uses different ones
203 if (s->alternate_scan) {
204 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
205 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
207 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
208 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
210 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
211 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
216 void ff_copy_picture(Picture *dst, Picture *src)
219 dst->f.type = FF_BUFFER_TYPE_COPY;
223 * Release a frame buffer
225 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
227 /* WM Image / Screen codecs allocate internal buffers with different
228 * dimensions / colorspaces; ignore user-defined callbacks for these. */
229 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
230 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
231 s->codec_id != AV_CODEC_ID_MSS2)
232 ff_thread_release_buffer(s->avctx, &pic->f);
234 avcodec_default_release_buffer(s->avctx, &pic->f);
235 av_freep(&pic->f.hwaccel_picture_private);
239 * Allocate a frame buffer
241 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
245 if (s->avctx->hwaccel) {
246 assert(!pic->f.hwaccel_picture_private);
247 if (s->avctx->hwaccel->priv_data_size) {
248 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
249 if (!pic->f.hwaccel_picture_private) {
250 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
256 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
257 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
258 s->codec_id != AV_CODEC_ID_MSS2)
259 r = ff_thread_get_buffer(s->avctx, &pic->f);
261 r = avcodec_default_get_buffer(s->avctx, &pic->f);
263 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
264 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
265 r, pic->f.type, pic->f.data[0]);
266 av_freep(&pic->f.hwaccel_picture_private);
270 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
271 s->uvlinesize != pic->f.linesize[1])) {
272 av_log(s->avctx, AV_LOG_ERROR,
273 "get_buffer() failed (stride changed)\n");
274 free_frame_buffer(s, pic);
278 if (pic->f.linesize[1] != pic->f.linesize[2]) {
279 av_log(s->avctx, AV_LOG_ERROR,
280 "get_buffer() failed (uv stride mismatch)\n");
281 free_frame_buffer(s, pic);
289 * Allocate a Picture.
290 * The pixels are allocated/set by calling get_buffer() if shared = 0
292 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
294 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
296 // the + 1 is needed so memset(,,stride*height) does not sig11
298 const int mb_array_size = s->mb_stride * s->mb_height;
299 const int b8_array_size = s->b8_stride * s->mb_height * 2;
300 const int b4_array_size = s->b4_stride * s->mb_height * 4;
305 assert(pic->f.data[0]);
306 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
307 pic->f.type = FF_BUFFER_TYPE_SHARED;
309 assert(!pic->f.data[0]);
311 if (alloc_frame_buffer(s, pic) < 0)
314 s->linesize = pic->f.linesize[0];
315 s->uvlinesize = pic->f.linesize[1];
318 if (pic->f.qscale_table == NULL) {
320 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
321 mb_array_size * sizeof(int16_t), fail)
322 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
323 mb_array_size * sizeof(int16_t), fail)
324 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
325 mb_array_size * sizeof(int8_t ), fail)
328 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
329 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
330 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
331 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
333 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
334 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
336 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
337 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
338 if (s->out_format == FMT_H264) {
339 for (i = 0; i < 2; i++) {
340 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
341 2 * (b4_array_size + 4) * sizeof(int16_t),
343 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
344 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
345 4 * mb_array_size * sizeof(uint8_t), fail)
347 pic->f.motion_subsample_log2 = 2;
348 } else if (s->out_format == FMT_H263 || s->encoding ||
349 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
350 for (i = 0; i < 2; i++) {
351 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
352 2 * (b8_array_size + 4) * sizeof(int16_t),
354 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
355 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
356 4 * mb_array_size * sizeof(uint8_t), fail)
358 pic->f.motion_subsample_log2 = 3;
360 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
361 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
362 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
364 pic->f.qstride = s->mb_stride;
365 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
366 1 * sizeof(AVPanScan), fail)
372 fail: // for the FF_ALLOCZ_OR_GOTO macro
374 free_frame_buffer(s, pic);
379 * Deallocate a picture.
381 static void free_picture(MpegEncContext *s, Picture *pic)
385 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
386 free_frame_buffer(s, pic);
389 av_freep(&pic->mb_var);
390 av_freep(&pic->mc_mb_var);
391 av_freep(&pic->mb_mean);
392 av_freep(&pic->f.mbskip_table);
393 av_freep(&pic->qscale_table_base);
394 pic->f.qscale_table = NULL;
395 av_freep(&pic->mb_type_base);
396 pic->f.mb_type = NULL;
397 av_freep(&pic->f.dct_coeff);
398 av_freep(&pic->f.pan_scan);
399 pic->f.mb_type = NULL;
400 for (i = 0; i < 2; i++) {
401 av_freep(&pic->motion_val_base[i]);
402 av_freep(&pic->f.ref_index[i]);
403 pic->f.motion_val[i] = NULL;
406 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
407 for (i = 0; i < 4; i++) {
409 pic->f.data[i] = NULL;
415 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
417 int y_size = s->b8_stride * (2 * s->mb_height + 1);
418 int c_size = s->mb_stride * (s->mb_height + 1);
419 int yc_size = y_size + 2 * c_size;
422 // edge emu needs blocksize + filter length - 1
423 // (= 17x17 for halfpel / 21x21 for h264)
424 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
425 (s->width + 95) * 2 * 21 * 4, fail); // (width + edge + align)*interlaced*MBsize*tolerance
427 // FIXME should be linesize instead of s->width * 2
428 // but that is not known before get_buffer()
429 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
430 (s->width + 95) * 4 * 16 * 2 * sizeof(uint8_t), fail)
431 s->me.temp = s->me.scratchpad;
432 s->rd_scratchpad = s->me.scratchpad;
433 s->b_scratchpad = s->me.scratchpad;
434 s->obmc_scratchpad = s->me.scratchpad + 16;
436 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
437 ME_MAP_SIZE * sizeof(uint32_t), fail)
438 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
439 ME_MAP_SIZE * sizeof(uint32_t), fail)
440 if (s->avctx->noise_reduction) {
441 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
442 2 * 64 * sizeof(int), fail)
445 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
446 s->block = s->blocks[0];
448 for (i = 0; i < 12; i++) {
449 s->pblocks[i] = &s->block[i];
452 if (s->out_format == FMT_H263) {
454 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
455 yc_size * sizeof(int16_t) * 16, fail);
456 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
457 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
458 s->ac_val[2] = s->ac_val[1] + c_size;
463 return -1; // free() through ff_MPV_common_end()
466 static void free_duplicate_context(MpegEncContext *s)
471 av_freep(&s->edge_emu_buffer);
472 av_freep(&s->me.scratchpad);
476 s->obmc_scratchpad = NULL;
478 av_freep(&s->dct_error_sum);
479 av_freep(&s->me.map);
480 av_freep(&s->me.score_map);
481 av_freep(&s->blocks);
482 av_freep(&s->ac_val_base);
486 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
488 #define COPY(a) bak->a = src->a
489 COPY(edge_emu_buffer);
494 COPY(obmc_scratchpad);
501 COPY(me.map_generation);
513 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
517 // FIXME copy only needed parts
519 backup_duplicate_context(&bak, dst);
520 memcpy(dst, src, sizeof(MpegEncContext));
521 backup_duplicate_context(dst, &bak);
522 for (i = 0; i < 12; i++) {
523 dst->pblocks[i] = &dst->block[i];
525 // STOP_TIMER("update_duplicate_context")
526 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
529 int ff_mpeg_update_thread_context(AVCodecContext *dst,
530 const AVCodecContext *src)
534 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
541 // FIXME can parameters change on I-frames?
542 // in that case dst may need a reinit
543 if (!s->context_initialized) {
544 memcpy(s, s1, sizeof(MpegEncContext));
547 s->bitstream_buffer = NULL;
548 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
550 if (s1->context_initialized){
551 s->picture_range_start += MAX_PICTURE_COUNT;
552 s->picture_range_end += MAX_PICTURE_COUNT;
553 if((err = ff_MPV_common_init(s)) < 0)
558 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
559 s->context_reinit = 0;
560 s->height = s1->height;
561 s->width = s1->width;
562 if ((err = ff_MPV_common_frame_size_change(s)) < 0)
566 s->avctx->coded_height = s1->avctx->coded_height;
567 s->avctx->coded_width = s1->avctx->coded_width;
568 s->avctx->width = s1->avctx->width;
569 s->avctx->height = s1->avctx->height;
571 s->coded_picture_number = s1->coded_picture_number;
572 s->picture_number = s1->picture_number;
573 s->input_picture_number = s1->input_picture_number;
575 av_assert0(!s->picture || s->picture != s1->picture);
576 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
577 memcpy(&s->last_picture, &s1->last_picture,
578 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
580 // reset s->picture[].f.extended_data to s->picture[].f.data
581 for (i = 0; i < s->picture_count; i++)
582 s->picture[i].f.extended_data = s->picture[i].f.data;
584 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
585 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
586 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
588 // Error/bug resilience
589 s->next_p_frame_damaged = s1->next_p_frame_damaged;
590 s->workaround_bugs = s1->workaround_bugs;
591 s->padding_bug_score = s1->padding_bug_score;
594 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
595 (char *) &s1->shape - (char *) &s1->time_increment_bits);
598 s->max_b_frames = s1->max_b_frames;
599 s->low_delay = s1->low_delay;
600 s->dropable = s1->dropable;
602 // DivX handling (doesn't work)
603 s->divx_packed = s1->divx_packed;
605 if (s1->bitstream_buffer) {
606 if (s1->bitstream_buffer_size +
607 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
608 av_fast_malloc(&s->bitstream_buffer,
609 &s->allocated_bitstream_buffer_size,
610 s1->allocated_bitstream_buffer_size);
611 s->bitstream_buffer_size = s1->bitstream_buffer_size;
612 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
613 s1->bitstream_buffer_size);
614 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
615 FF_INPUT_BUFFER_PADDING_SIZE);
618 // MPEG2/interlacing info
619 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
620 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
622 if (!s1->first_field) {
623 s->last_pict_type = s1->pict_type;
624 if (s1->current_picture_ptr)
625 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
627 if (s1->pict_type != AV_PICTURE_TYPE_B) {
628 s->last_non_b_pict_type = s1->pict_type;
636 * Set the given MpegEncContext to common defaults
637 * (same for encoding and decoding).
638 * The changed fields will not depend upon the
639 * prior state of the MpegEncContext.
641 void ff_MPV_common_defaults(MpegEncContext *s)
643 s->y_dc_scale_table =
644 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
645 s->chroma_qscale_table = ff_default_chroma_qscale_table;
646 s->progressive_frame = 1;
647 s->progressive_sequence = 1;
648 s->picture_structure = PICT_FRAME;
650 s->coded_picture_number = 0;
651 s->picture_number = 0;
652 s->input_picture_number = 0;
654 s->picture_in_gop_number = 0;
659 s->picture_range_start = 0;
660 s->picture_range_end = MAX_PICTURE_COUNT;
662 s->slice_context_count = 1;
666 * Set the given MpegEncContext to defaults for decoding.
667 * the changed fields will not depend upon
668 * the prior state of the MpegEncContext.
670 void ff_MPV_decode_defaults(MpegEncContext *s)
672 ff_MPV_common_defaults(s);
676 * Initialize and allocates MpegEncContext fields dependent on the resolution.
678 static int init_context_frame(MpegEncContext *s)
680 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
682 s->mb_width = (s->width + 15) / 16;
683 s->mb_stride = s->mb_width + 1;
684 s->b8_stride = s->mb_width * 2 + 1;
685 s->b4_stride = s->mb_width * 4 + 1;
686 mb_array_size = s->mb_height * s->mb_stride;
687 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
689 /* set default edge pos, will be overriden
690 * in decode_header if needed */
691 s->h_edge_pos = s->mb_width * 16;
692 s->v_edge_pos = s->mb_height * 16;
694 s->mb_num = s->mb_width * s->mb_height;
699 s->block_wrap[3] = s->b8_stride;
701 s->block_wrap[5] = s->mb_stride;
703 y_size = s->b8_stride * (2 * s->mb_height + 1);
704 c_size = s->mb_stride * (s->mb_height + 1);
705 yc_size = y_size + 2 * c_size;
707 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
708 for (y = 0; y < s->mb_height; y++)
709 for (x = 0; x < s->mb_width; x++)
710 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
712 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
715 /* Allocate MV tables */
716 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
717 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
718 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
719 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
720 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
721 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
722 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
723 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
724 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
725 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
726 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
727 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
729 /* Allocate MB type table */
730 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
732 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
734 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
735 mb_array_size * sizeof(float), fail);
736 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
737 mb_array_size * sizeof(float), fail);
741 FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
742 mb_array_size * sizeof(uint8_t), fail);
743 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
744 mb_array_size * sizeof(uint8_t), fail);
746 if (s->codec_id == AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)) {
747 /* interlaced direct mode decoding tables */
748 for (i = 0; i < 2; i++) {
750 for (j = 0; j < 2; j++) {
751 for (k = 0; k < 2; k++) {
752 FF_ALLOCZ_OR_GOTO(s->avctx,
753 s->b_field_mv_table_base[i][j][k],
754 mv_table_size * 2 * sizeof(int16_t),
756 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
759 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
760 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
761 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
763 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
766 if (s->out_format == FMT_H263) {
768 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
769 s->coded_block = s->coded_block_base + s->b8_stride + 1;
771 /* cbp, ac_pred, pred_dir */
772 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
773 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
776 if (s->h263_pred || s->h263_plus || !s->encoding) {
778 // MN: we need these for error resilience of intra-frames
779 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
780 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
781 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
782 s->dc_val[2] = s->dc_val[1] + c_size;
783 for (i = 0; i < yc_size; i++)
784 s->dc_val_base[i] = 1024;
787 /* which mb is a intra block */
788 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
789 memset(s->mbintra_table, 1, mb_array_size);
791 /* init macroblock skip table */
792 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
793 // Note the + 1 is for a quicker mpeg4 slice_end detection
797 return AVERROR(ENOMEM);
801 * init common structure for both encoder and decoder.
802 * this assumes that some variables like width/height are already set
804 av_cold int ff_MPV_common_init(MpegEncContext *s)
807 int nb_slices = (HAVE_THREADS &&
808 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
809 s->avctx->thread_count : 1;
811 if (s->encoding && s->avctx->slices)
812 nb_slices = s->avctx->slices;
814 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
815 s->mb_height = (s->height + 31) / 32 * 2;
816 else if (s->codec_id != AV_CODEC_ID_H264)
817 s->mb_height = (s->height + 15) / 16;
819 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
820 av_log(s->avctx, AV_LOG_ERROR,
821 "decoding to AV_PIX_FMT_NONE is not supported.\n");
825 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
828 max_slices = FFMIN(MAX_THREADS, s->mb_height);
830 max_slices = MAX_THREADS;
831 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
832 " reducing to %d\n", nb_slices, max_slices);
833 nb_slices = max_slices;
836 if ((s->width || s->height) &&
837 av_image_check_size(s->width, s->height, 0, s->avctx))
840 ff_dct_common_init(s);
842 s->flags = s->avctx->flags;
843 s->flags2 = s->avctx->flags2;
845 /* set chroma shifts */
846 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
848 /* convert fourcc to upper case */
849 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
850 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
852 s->avctx->coded_frame = &s->current_picture.f;
855 if (s->msmpeg4_version) {
856 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
857 2 * 2 * (MAX_LEVEL + 1) *
858 (MAX_RUN + 1) * 2 * sizeof(int), fail);
860 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
862 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail)
863 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail)
864 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail)
865 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
866 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
867 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
868 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
869 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
871 if (s->avctx->noise_reduction) {
872 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
876 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
877 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
878 s->picture_count * sizeof(Picture), fail);
879 for (i = 0; i < s->picture_count; i++) {
880 avcodec_get_frame_defaults(&s->picture[i].f);
883 if (init_context_frame(s))
886 s->parse_context.state = -1;
888 s->context_initialized = 1;
889 s->thread_context[0] = s;
891 // if (s->width && s->height) {
893 for (i = 1; i < nb_slices; i++) {
894 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
895 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
898 for (i = 0; i < nb_slices; i++) {
899 if (init_duplicate_context(s->thread_context[i], s) < 0)
901 s->thread_context[i]->start_mb_y =
902 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
903 s->thread_context[i]->end_mb_y =
904 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
907 if (init_duplicate_context(s, s) < 0)
910 s->end_mb_y = s->mb_height;
912 s->slice_context_count = nb_slices;
917 ff_MPV_common_end(s);
922 * Frees and resets MpegEncContext fields depending on the resolution.
923 * Is used during resolution changes to avoid a full reinitialization of the
926 static int free_context_frame(MpegEncContext *s)
930 av_freep(&s->mb_type);
931 av_freep(&s->p_mv_table_base);
932 av_freep(&s->b_forw_mv_table_base);
933 av_freep(&s->b_back_mv_table_base);
934 av_freep(&s->b_bidir_forw_mv_table_base);
935 av_freep(&s->b_bidir_back_mv_table_base);
936 av_freep(&s->b_direct_mv_table_base);
937 s->p_mv_table = NULL;
938 s->b_forw_mv_table = NULL;
939 s->b_back_mv_table = NULL;
940 s->b_bidir_forw_mv_table = NULL;
941 s->b_bidir_back_mv_table = NULL;
942 s->b_direct_mv_table = NULL;
943 for (i = 0; i < 2; i++) {
944 for (j = 0; j < 2; j++) {
945 for (k = 0; k < 2; k++) {
946 av_freep(&s->b_field_mv_table_base[i][j][k]);
947 s->b_field_mv_table[i][j][k] = NULL;
949 av_freep(&s->b_field_select_table[i][j]);
950 av_freep(&s->p_field_mv_table_base[i][j]);
951 s->p_field_mv_table[i][j] = NULL;
953 av_freep(&s->p_field_select_table[i]);
956 av_freep(&s->dc_val_base);
957 av_freep(&s->coded_block_base);
958 av_freep(&s->mbintra_table);
959 av_freep(&s->cbp_table);
960 av_freep(&s->pred_dir_table);
962 av_freep(&s->mbskip_table);
964 av_freep(&s->error_status_table);
965 av_freep(&s->er_temp_buffer);
966 av_freep(&s->mb_index2xy);
967 av_freep(&s->lambda_table);
969 av_freep(&s->cplx_tab);
970 av_freep(&s->bits_tab);
972 s->linesize = s->uvlinesize = 0;
974 for (i = 0; i < 3; i++)
975 av_freep(&s->visualization_buffer[i]);
977 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
978 avcodec_default_free_buffers(s->avctx);
983 int ff_MPV_common_frame_size_change(MpegEncContext *s)
987 if (s->slice_context_count > 1) {
988 for (i = 0; i < s->slice_context_count; i++) {
989 free_duplicate_context(s->thread_context[i]);
991 for (i = 1; i < s->slice_context_count; i++) {
992 av_freep(&s->thread_context[i]);
995 free_duplicate_context(s);
997 free_context_frame(s);
1000 for (i = 0; i < s->picture_count; i++) {
1001 s->picture[i].needs_realloc = 1;
1004 s->last_picture_ptr =
1005 s->next_picture_ptr =
1006 s->current_picture_ptr = NULL;
1009 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1010 s->mb_height = (s->height + 31) / 32 * 2;
1011 else if (s->codec_id != AV_CODEC_ID_H264)
1012 s->mb_height = (s->height + 15) / 16;
1014 if ((s->width || s->height) &&
1015 av_image_check_size(s->width, s->height, 0, s->avctx))
1016 return AVERROR_INVALIDDATA;
1018 if ((err = init_context_frame(s)))
1021 s->thread_context[0] = s;
1023 if (s->width && s->height) {
1024 int nb_slices = s->slice_context_count;
1025 if (nb_slices > 1) {
1026 for (i = 1; i < nb_slices; i++) {
1027 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1028 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1031 for (i = 0; i < nb_slices; i++) {
1032 if (init_duplicate_context(s->thread_context[i], s) < 0)
1034 s->thread_context[i]->start_mb_y =
1035 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1036 s->thread_context[i]->end_mb_y =
1037 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1040 if (init_duplicate_context(s, s) < 0)
1043 s->end_mb_y = s->mb_height;
1045 s->slice_context_count = nb_slices;
1050 ff_MPV_common_end(s);
1054 /* init common structure for both encoder and decoder */
1055 void ff_MPV_common_end(MpegEncContext *s)
1059 if (s->slice_context_count > 1) {
1060 for (i = 0; i < s->slice_context_count; i++) {
1061 free_duplicate_context(s->thread_context[i]);
1063 for (i = 1; i < s->slice_context_count; i++) {
1064 av_freep(&s->thread_context[i]);
1066 s->slice_context_count = 1;
1067 } else free_duplicate_context(s);
1069 av_freep(&s->parse_context.buffer);
1070 s->parse_context.buffer_size = 0;
1072 av_freep(&s->bitstream_buffer);
1073 s->allocated_bitstream_buffer_size = 0;
1075 av_freep(&s->avctx->stats_out);
1076 av_freep(&s->ac_stats);
1078 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1079 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1080 s->q_chroma_intra_matrix= NULL;
1081 s->q_chroma_intra_matrix16= NULL;
1082 av_freep(&s->q_intra_matrix);
1083 av_freep(&s->q_inter_matrix);
1084 av_freep(&s->q_intra_matrix16);
1085 av_freep(&s->q_inter_matrix16);
1086 av_freep(&s->input_picture);
1087 av_freep(&s->reordered_input_picture);
1088 av_freep(&s->dct_offset);
1090 if (s->picture && !s->avctx->internal->is_copy) {
1091 for (i = 0; i < s->picture_count; i++) {
1092 free_picture(s, &s->picture[i]);
1095 av_freep(&s->picture);
1097 free_context_frame(s);
1099 s->context_initialized = 0;
1100 s->last_picture_ptr =
1101 s->next_picture_ptr =
1102 s->current_picture_ptr = NULL;
1103 s->linesize = s->uvlinesize = 0;
1106 void ff_init_rl(RLTable *rl,
1107 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1109 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1110 uint8_t index_run[MAX_RUN + 1];
1111 int last, run, level, start, end, i;
1113 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1114 if (static_store && rl->max_level[0])
1117 /* compute max_level[], max_run[] and index_run[] */
1118 for (last = 0; last < 2; last++) {
1127 memset(max_level, 0, MAX_RUN + 1);
1128 memset(max_run, 0, MAX_LEVEL + 1);
1129 memset(index_run, rl->n, MAX_RUN + 1);
1130 for (i = start; i < end; i++) {
1131 run = rl->table_run[i];
1132 level = rl->table_level[i];
1133 if (index_run[run] == rl->n)
1135 if (level > max_level[run])
1136 max_level[run] = level;
1137 if (run > max_run[level])
1138 max_run[level] = run;
1141 rl->max_level[last] = static_store[last];
1143 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1144 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1146 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1148 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1149 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1151 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1153 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1154 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1158 void ff_init_vlc_rl(RLTable *rl)
1162 for (q = 0; q < 32; q++) {
1164 int qadd = (q - 1) | 1;
1170 for (i = 0; i < rl->vlc.table_size; i++) {
1171 int code = rl->vlc.table[i][0];
1172 int len = rl->vlc.table[i][1];
1175 if (len == 0) { // illegal code
1178 } else if (len < 0) { // more bits needed
1182 if (code == rl->n) { // esc
1186 run = rl->table_run[code] + 1;
1187 level = rl->table_level[code] * qmul + qadd;
1188 if (code >= rl->last) run += 192;
1191 rl->rl_vlc[q][i].len = len;
1192 rl->rl_vlc[q][i].level = level;
1193 rl->rl_vlc[q][i].run = run;
1198 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1202 /* release non reference frames */
1203 for (i = 0; i < s->picture_count; i++) {
1204 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1205 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1206 (remove_current || &s->picture[i] != s->current_picture_ptr)
1207 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1208 free_frame_buffer(s, &s->picture[i]);
1213 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1215 if (pic->f.data[0] == NULL)
1217 if (pic->needs_realloc)
1218 if (!pic->owner2 || pic->owner2 == s)
1223 static int find_unused_picture(MpegEncContext *s, int shared)
1228 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1229 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1233 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1234 if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1237 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1238 if (pic_is_unused(s, &s->picture[i]))
1243 av_log(s->avctx, AV_LOG_FATAL,
1244 "Internal error, picture buffer overflow\n");
1245 /* We could return -1, but the codec would crash trying to draw into a
1246 * non-existing frame anyway. This is safer than waiting for a random crash.
1247 * Also the return of this is never useful, an encoder must only allocate
1248 * as much as allowed in the specification. This has no relationship to how
1249 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1250 * enough for such valid streams).
1251 * Plus, a decoder has to check stream validity and remove frames if too
1252 * many reference frames are around. Waiting for "OOM" is not correct at
1253 * all. Similarly, missing reference frames have to be replaced by
1254 * interpolated/MC frames, anything else is a bug in the codec ...
1260 int ff_find_unused_picture(MpegEncContext *s, int shared)
1262 int ret = find_unused_picture(s, shared);
1264 if (ret >= 0 && ret < s->picture_range_end) {
1265 if (s->picture[ret].needs_realloc) {
1266 s->picture[ret].needs_realloc = 0;
1267 free_picture(s, &s->picture[ret]);
1268 avcodec_get_frame_defaults(&s->picture[ret].f);
1274 static void update_noise_reduction(MpegEncContext *s)
1278 for (intra = 0; intra < 2; intra++) {
1279 if (s->dct_count[intra] > (1 << 16)) {
1280 for (i = 0; i < 64; i++) {
1281 s->dct_error_sum[intra][i] >>= 1;
1283 s->dct_count[intra] >>= 1;
1286 for (i = 0; i < 64; i++) {
1287 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1288 s->dct_count[intra] +
1289 s->dct_error_sum[intra][i] / 2) /
1290 (s->dct_error_sum[intra][i] + 1);
1296 * generic function for encode/decode called after coding/decoding
1297 * the header and before a frame is coded/decoded.
1299 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1305 if (!ff_thread_can_start_frame(avctx)) {
1306 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1310 /* mark & release old frames */
1311 if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1312 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1313 s->last_picture_ptr != s->next_picture_ptr &&
1314 s->last_picture_ptr->f.data[0]) {
1315 if (s->last_picture_ptr->owner2 == s)
1316 free_frame_buffer(s, s->last_picture_ptr);
1319 /* release forgotten pictures */
1320 /* if (mpeg124/h263) */
1322 for (i = 0; i < s->picture_count; i++) {
1323 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1324 &s->picture[i] != s->last_picture_ptr &&
1325 &s->picture[i] != s->next_picture_ptr &&
1326 s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1327 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1328 av_log(avctx, AV_LOG_ERROR,
1329 "releasing zombie picture\n");
1330 free_frame_buffer(s, &s->picture[i]);
1337 ff_release_unused_pictures(s, 1);
1339 if (s->current_picture_ptr &&
1340 s->current_picture_ptr->f.data[0] == NULL) {
1341 // we already have a unused image
1342 // (maybe it was set before reading the header)
1343 pic = s->current_picture_ptr;
1345 i = ff_find_unused_picture(s, 0);
1347 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1350 pic = &s->picture[i];
1353 pic->f.reference = 0;
1355 if (s->codec_id == AV_CODEC_ID_H264)
1356 pic->f.reference = s->picture_structure;
1357 else if (s->pict_type != AV_PICTURE_TYPE_B)
1358 pic->f.reference = 3;
1361 pic->f.coded_picture_number = s->coded_picture_number++;
1363 if (ff_alloc_picture(s, pic, 0) < 0)
1366 s->current_picture_ptr = pic;
1367 // FIXME use only the vars from current_pic
1368 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1369 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1370 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1371 if (s->picture_structure != PICT_FRAME)
1372 s->current_picture_ptr->f.top_field_first =
1373 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1375 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1376 !s->progressive_sequence;
1377 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1380 s->current_picture_ptr->f.pict_type = s->pict_type;
1381 // if (s->flags && CODEC_FLAG_QSCALE)
1382 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1383 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1385 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1387 if (s->pict_type != AV_PICTURE_TYPE_B) {
1388 s->last_picture_ptr = s->next_picture_ptr;
1390 s->next_picture_ptr = s->current_picture_ptr;
1392 av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1393 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1394 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1395 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1396 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1397 s->pict_type, s->dropable);
1399 if (s->codec_id != AV_CODEC_ID_H264) {
1400 if ((s->last_picture_ptr == NULL ||
1401 s->last_picture_ptr->f.data[0] == NULL) &&
1402 (s->pict_type != AV_PICTURE_TYPE_I ||
1403 s->picture_structure != PICT_FRAME)) {
1404 if (s->pict_type != AV_PICTURE_TYPE_I)
1405 av_log(avctx, AV_LOG_ERROR,
1406 "warning: first frame is no keyframe\n");
1407 else if (s->picture_structure != PICT_FRAME)
1408 av_log(avctx, AV_LOG_INFO,
1409 "allocate dummy last picture for field based first keyframe\n");
1411 /* Allocate a dummy frame */
1412 i = ff_find_unused_picture(s, 0);
1414 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1417 s->last_picture_ptr = &s->picture[i];
1418 s->last_picture_ptr->f.key_frame = 0;
1419 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1420 s->last_picture_ptr = NULL;
1424 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1425 for(i=0; i<avctx->height; i++)
1426 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1429 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1430 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1431 s->last_picture_ptr->f.reference = 3;
1433 if ((s->next_picture_ptr == NULL ||
1434 s->next_picture_ptr->f.data[0] == NULL) &&
1435 s->pict_type == AV_PICTURE_TYPE_B) {
1436 /* Allocate a dummy frame */
1437 i = ff_find_unused_picture(s, 0);
1439 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1442 s->next_picture_ptr = &s->picture[i];
1443 s->next_picture_ptr->f.key_frame = 0;
1444 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1445 s->next_picture_ptr = NULL;
1448 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1449 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1450 s->next_picture_ptr->f.reference = 3;
1454 if (s->last_picture_ptr)
1455 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1456 if (s->next_picture_ptr)
1457 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1459 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) {
1460 if (s->next_picture_ptr)
1461 s->next_picture_ptr->owner2 = s;
1462 if (s->last_picture_ptr)
1463 s->last_picture_ptr->owner2 = s;
1466 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1467 s->last_picture_ptr->f.data[0]));
1469 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1471 for (i = 0; i < 4; i++) {
1472 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1473 s->current_picture.f.data[i] +=
1474 s->current_picture.f.linesize[i];
1476 s->current_picture.f.linesize[i] *= 2;
1477 s->last_picture.f.linesize[i] *= 2;
1478 s->next_picture.f.linesize[i] *= 2;
1482 s->err_recognition = avctx->err_recognition;
1484 /* set dequantizer, we can't do it during init as
1485 * it might change for mpeg4 and we can't do it in the header
1486 * decode as init is not called for mpeg4 there yet */
1487 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1488 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1489 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1490 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1491 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1492 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1494 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1495 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1498 if (s->dct_error_sum) {
1499 assert(s->avctx->noise_reduction && s->encoding);
1500 update_noise_reduction(s);
1503 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1504 return ff_xvmc_field_start(s, avctx);
1509 /* generic function for encode/decode called after a
1510 * frame has been coded/decoded. */
1511 void ff_MPV_frame_end(MpegEncContext *s)
1514 /* redraw edges for the frame if decoding didn't complete */
1515 // just to make sure that all data is rendered.
1516 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1517 ff_xvmc_field_end(s);
1518 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1519 !s->avctx->hwaccel &&
1520 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1521 s->unrestricted_mv &&
1522 s->current_picture.f.reference &&
1524 !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1527 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1528 int hshift = desc->log2_chroma_w;
1529 int vshift = desc->log2_chroma_h;
1530 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1531 s->h_edge_pos, s->v_edge_pos,
1532 EDGE_WIDTH, EDGE_WIDTH,
1533 EDGE_TOP | EDGE_BOTTOM);
1534 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1535 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1536 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1537 EDGE_TOP | EDGE_BOTTOM);
1538 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1539 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1540 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1541 EDGE_TOP | EDGE_BOTTOM);
1546 s->last_pict_type = s->pict_type;
1547 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1548 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1549 s->last_non_b_pict_type = s->pict_type;
1552 /* copy back current_picture variables */
1553 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1554 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1555 s->picture[i] = s->current_picture;
1559 assert(i < MAX_PICTURE_COUNT);
1563 /* release non-reference frames */
1564 for (i = 0; i < s->picture_count; i++) {
1565 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1566 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1567 free_frame_buffer(s, &s->picture[i]);
1571 // clear copies, to avoid confusion
1573 memset(&s->last_picture, 0, sizeof(Picture));
1574 memset(&s->next_picture, 0, sizeof(Picture));
1575 memset(&s->current_picture, 0, sizeof(Picture));
1577 s->avctx->coded_frame = &s->current_picture_ptr->f;
1579 if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1580 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1585 * Draw a line from (ex, ey) -> (sx, sy).
1586 * @param w width of the image
1587 * @param h height of the image
1588 * @param stride stride/linesize of the image
1589 * @param color color of the arrow
1591 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1592 int w, int h, int stride, int color)
1596 sx = av_clip(sx, 0, w - 1);
1597 sy = av_clip(sy, 0, h - 1);
1598 ex = av_clip(ex, 0, w - 1);
1599 ey = av_clip(ey, 0, h - 1);
1601 buf[sy * stride + sx] += color;
1603 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1605 FFSWAP(int, sx, ex);
1606 FFSWAP(int, sy, ey);
1608 buf += sx + sy * stride;
1610 f = ((ey - sy) << 16) / ex;
1611 for(x= 0; x <= ex; x++){
1613 fr = (x * f) & 0xFFFF;
1614 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1615 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1619 FFSWAP(int, sx, ex);
1620 FFSWAP(int, sy, ey);
1622 buf += sx + sy * stride;
1625 f = ((ex - sx) << 16) / ey;
1628 for(y= 0; y <= ey; y++){
1630 fr = (y*f) & 0xFFFF;
1631 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1632 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1638 * Draw an arrow from (ex, ey) -> (sx, sy).
1639 * @param w width of the image
1640 * @param h height of the image
1641 * @param stride stride/linesize of the image
1642 * @param color color of the arrow
1644 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1645 int ey, int w, int h, int stride, int color)
1649 sx = av_clip(sx, -100, w + 100);
1650 sy = av_clip(sy, -100, h + 100);
1651 ex = av_clip(ex, -100, w + 100);
1652 ey = av_clip(ey, -100, h + 100);
1657 if (dx * dx + dy * dy > 3 * 3) {
1660 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1662 // FIXME subpixel accuracy
1663 rx = ROUNDED_DIV(rx * 3 << 4, length);
1664 ry = ROUNDED_DIV(ry * 3 << 4, length);
1666 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1667 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1669 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1673 * Print debugging info for the given picture.
1675 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1677 if ( s->avctx->hwaccel || !pict || !pict->mb_type
1678 || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1682 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1685 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1686 av_get_picture_type_char(pict->pict_type));
1687 for (y = 0; y < s->mb_height; y++) {
1688 for (x = 0; x < s->mb_width; x++) {
1689 if (s->avctx->debug & FF_DEBUG_SKIP) {
1690 int count = s->mbskip_table[x + y * s->mb_stride];
1693 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1695 if (s->avctx->debug & FF_DEBUG_QP) {
1696 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1697 pict->qscale_table[x + y * s->mb_stride]);
1699 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1700 int mb_type = pict->mb_type[x + y * s->mb_stride];
1701 // Type & MV direction
1702 if (IS_PCM(mb_type))
1703 av_log(s->avctx, AV_LOG_DEBUG, "P");
1704 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1705 av_log(s->avctx, AV_LOG_DEBUG, "A");
1706 else if (IS_INTRA4x4(mb_type))
1707 av_log(s->avctx, AV_LOG_DEBUG, "i");
1708 else if (IS_INTRA16x16(mb_type))
1709 av_log(s->avctx, AV_LOG_DEBUG, "I");
1710 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1711 av_log(s->avctx, AV_LOG_DEBUG, "d");
1712 else if (IS_DIRECT(mb_type))
1713 av_log(s->avctx, AV_LOG_DEBUG, "D");
1714 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1715 av_log(s->avctx, AV_LOG_DEBUG, "g");
1716 else if (IS_GMC(mb_type))
1717 av_log(s->avctx, AV_LOG_DEBUG, "G");
1718 else if (IS_SKIP(mb_type))
1719 av_log(s->avctx, AV_LOG_DEBUG, "S");
1720 else if (!USES_LIST(mb_type, 1))
1721 av_log(s->avctx, AV_LOG_DEBUG, ">");
1722 else if (!USES_LIST(mb_type, 0))
1723 av_log(s->avctx, AV_LOG_DEBUG, "<");
1725 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1726 av_log(s->avctx, AV_LOG_DEBUG, "X");
1730 if (IS_8X8(mb_type))
1731 av_log(s->avctx, AV_LOG_DEBUG, "+");
1732 else if (IS_16X8(mb_type))
1733 av_log(s->avctx, AV_LOG_DEBUG, "-");
1734 else if (IS_8X16(mb_type))
1735 av_log(s->avctx, AV_LOG_DEBUG, "|");
1736 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1737 av_log(s->avctx, AV_LOG_DEBUG, " ");
1739 av_log(s->avctx, AV_LOG_DEBUG, "?");
1742 if (IS_INTERLACED(mb_type))
1743 av_log(s->avctx, AV_LOG_DEBUG, "=");
1745 av_log(s->avctx, AV_LOG_DEBUG, " ");
1748 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1752 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1753 (s->avctx->debug_mv)) {
1754 const int shift = 1 + s->quarter_sample;
1758 int h_chroma_shift, v_chroma_shift, block_height;
1759 const int width = s->avctx->width;
1760 const int height = s->avctx->height;
1761 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1762 const int mv_stride = (s->mb_width << mv_sample_log2) +
1763 (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1764 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1766 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1768 for (i = 0; i < 3; i++) {
1769 size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1770 pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1771 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1772 memcpy(s->visualization_buffer[i], pict->data[i], size);
1773 pict->data[i] = s->visualization_buffer[i];
1775 pict->type = FF_BUFFER_TYPE_COPY;
1777 ptr = pict->data[0];
1778 block_height = 16 >> v_chroma_shift;
1780 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1782 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1783 const int mb_index = mb_x + mb_y * s->mb_stride;
1784 if ((s->avctx->debug_mv) && pict->motion_val[0]) {
1786 for (type = 0; type < 3; type++) {
1790 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1791 (pict->pict_type!= AV_PICTURE_TYPE_P))
1796 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1797 (pict->pict_type!= AV_PICTURE_TYPE_B))
1802 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1803 (pict->pict_type!= AV_PICTURE_TYPE_B))
1808 if (!USES_LIST(pict->mb_type[mb_index], direction))
1811 if (IS_8X8(pict->mb_type[mb_index])) {
1813 for (i = 0; i < 4; i++) {
1814 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1815 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1816 int xy = (mb_x * 2 + (i & 1) +
1817 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1818 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1819 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1820 draw_arrow(ptr, sx, sy, mx, my, width,
1821 height, s->linesize, 100);
1823 } else if (IS_16X8(pict->mb_type[mb_index])) {
1825 for (i = 0; i < 2; i++) {
1826 int sx = mb_x * 16 + 8;
1827 int sy = mb_y * 16 + 4 + 8 * i;
1828 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1829 int mx = (pict->motion_val[direction][xy][0] >> shift);
1830 int my = (pict->motion_val[direction][xy][1] >> shift);
1832 if (IS_INTERLACED(pict->mb_type[mb_index]))
1835 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1836 height, s->linesize, 100);
1838 } else if (IS_8X16(pict->mb_type[mb_index])) {
1840 for (i = 0; i < 2; i++) {
1841 int sx = mb_x * 16 + 4 + 8 * i;
1842 int sy = mb_y * 16 + 8;
1843 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1844 int mx = pict->motion_val[direction][xy][0] >> shift;
1845 int my = pict->motion_val[direction][xy][1] >> shift;
1847 if (IS_INTERLACED(pict->mb_type[mb_index]))
1850 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1851 height, s->linesize, 100);
1854 int sx= mb_x * 16 + 8;
1855 int sy= mb_y * 16 + 8;
1856 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1857 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1858 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1859 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1863 if ((s->avctx->debug & FF_DEBUG_VIS_QP)) {
1864 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1865 0x0101010101010101ULL;
1867 for (y = 0; y < block_height; y++) {
1868 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1869 (block_height * mb_y + y) *
1870 pict->linesize[1]) = c;
1871 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1872 (block_height * mb_y + y) *
1873 pict->linesize[2]) = c;
1876 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1877 pict->motion_val[0]) {
1878 int mb_type = pict->mb_type[mb_index];
1881 #define COLOR(theta, r) \
1882 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1883 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1887 if (IS_PCM(mb_type)) {
1889 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1890 IS_INTRA16x16(mb_type)) {
1892 } else if (IS_INTRA4x4(mb_type)) {
1894 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1896 } else if (IS_DIRECT(mb_type)) {
1898 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1900 } else if (IS_GMC(mb_type)) {
1902 } else if (IS_SKIP(mb_type)) {
1904 } else if (!USES_LIST(mb_type, 1)) {
1906 } else if (!USES_LIST(mb_type, 0)) {
1909 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1913 u *= 0x0101010101010101ULL;
1914 v *= 0x0101010101010101ULL;
1915 for (y = 0; y < block_height; y++) {
1916 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1917 (block_height * mb_y + y) * pict->linesize[1]) = u;
1918 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1919 (block_height * mb_y + y) * pict->linesize[2]) = v;
1923 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1924 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1925 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1926 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1927 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1929 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1930 for (y = 0; y < 16; y++)
1931 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1932 pict->linesize[0]] ^= 0x80;
1934 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1935 int dm = 1 << (mv_sample_log2 - 2);
1936 for (i = 0; i < 4; i++) {
1937 int sx = mb_x * 16 + 8 * (i & 1);
1938 int sy = mb_y * 16 + 8 * (i >> 1);
1939 int xy = (mb_x * 2 + (i & 1) +
1940 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1942 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1943 if (mv[0] != mv[dm] ||
1944 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1945 for (y = 0; y < 8; y++)
1946 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1947 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1948 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1949 pict->linesize[0]) ^= 0x8080808080808080ULL;
1953 if (IS_INTERLACED(mb_type) &&
1954 s->codec_id == AV_CODEC_ID_H264) {
1958 s->mbskip_table[mb_index] = 0;
1964 static inline int hpel_motion_lowres(MpegEncContext *s,
1965 uint8_t *dest, uint8_t *src,
1966 int field_based, int field_select,
1967 int src_x, int src_y,
1968 int width, int height, int stride,
1969 int h_edge_pos, int v_edge_pos,
1970 int w, int h, h264_chroma_mc_func *pix_op,
1971 int motion_x, int motion_y)
1973 const int lowres = s->avctx->lowres;
1974 const int op_index = FFMIN(lowres, 2);
1975 const int s_mask = (2 << lowres) - 1;
1979 if (s->quarter_sample) {
1984 sx = motion_x & s_mask;
1985 sy = motion_y & s_mask;
1986 src_x += motion_x >> lowres + 1;
1987 src_y += motion_y >> lowres + 1;
1989 src += src_y * stride + src_x;
1991 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1992 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1993 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1994 (h + 1) << field_based, src_x,
1995 src_y << field_based,
1998 src = s->edge_emu_buffer;
2002 sx = (sx << 2) >> lowres;
2003 sy = (sy << 2) >> lowres;
2006 pix_op[op_index](dest, src, stride, h, sx, sy);
2010 /* apply one mpeg motion vector to the three components */
2011 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2018 uint8_t **ref_picture,
2019 h264_chroma_mc_func *pix_op,
2020 int motion_x, int motion_y,
2023 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2024 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2026 const int lowres = s->avctx->lowres;
2027 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
2028 const int block_s = 8>>lowres;
2029 const int s_mask = (2 << lowres) - 1;
2030 const int h_edge_pos = s->h_edge_pos >> lowres;
2031 const int v_edge_pos = s->v_edge_pos >> lowres;
2032 linesize = s->current_picture.f.linesize[0] << field_based;
2033 uvlinesize = s->current_picture.f.linesize[1] << field_based;
2035 // FIXME obviously not perfect but qpel will not work in lowres anyway
2036 if (s->quarter_sample) {
2042 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2045 sx = motion_x & s_mask;
2046 sy = motion_y & s_mask;
2047 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2048 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2050 if (s->out_format == FMT_H263) {
2051 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2052 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2053 uvsrc_x = src_x >> 1;
2054 uvsrc_y = src_y >> 1;
2055 } else if (s->out_format == FMT_H261) {
2056 // even chroma mv's are full pel in H261
2059 uvsx = (2 * mx) & s_mask;
2060 uvsy = (2 * my) & s_mask;
2061 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2062 uvsrc_y = mb_y * block_s + (my >> lowres);
2064 if(s->chroma_y_shift){
2069 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2070 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2072 if(s->chroma_x_shift){
2076 uvsy = motion_y & s_mask;
2078 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2081 uvsx = motion_x & s_mask;
2082 uvsy = motion_y & s_mask;
2089 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2090 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2091 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2093 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
2094 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2095 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2096 linesize >> field_based, 17, 17 + field_based,
2097 src_x, src_y << field_based, h_edge_pos,
2099 ptr_y = s->edge_emu_buffer;
2100 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2101 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2102 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2104 uvsrc_x, uvsrc_y << field_based,
2105 h_edge_pos >> 1, v_edge_pos >> 1);
2106 s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2108 uvsrc_x, uvsrc_y << field_based,
2109 h_edge_pos >> 1, v_edge_pos >> 1);
2111 ptr_cr = uvbuf + 16;
2115 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2117 dest_y += s->linesize;
2118 dest_cb += s->uvlinesize;
2119 dest_cr += s->uvlinesize;
2123 ptr_y += s->linesize;
2124 ptr_cb += s->uvlinesize;
2125 ptr_cr += s->uvlinesize;
2128 sx = (sx << 2) >> lowres;
2129 sy = (sy << 2) >> lowres;
2130 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2132 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2133 uvsx = (uvsx << 2) >> lowres;
2134 uvsy = (uvsy << 2) >> lowres;
2135 if (h >> s->chroma_y_shift) {
2136 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2137 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2140 // FIXME h261 lowres loop filter
2143 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2144 uint8_t *dest_cb, uint8_t *dest_cr,
2145 uint8_t **ref_picture,
2146 h264_chroma_mc_func * pix_op,
2149 const int lowres = s->avctx->lowres;
2150 const int op_index = FFMIN(lowres, 2);
2151 const int block_s = 8 >> lowres;
2152 const int s_mask = (2 << lowres) - 1;
2153 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2154 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2155 int emu = 0, src_x, src_y, offset, sx, sy;
2158 if (s->quarter_sample) {
2163 /* In case of 8X8, we construct a single chroma motion vector
2164 with a special rounding */
2165 mx = ff_h263_round_chroma(mx);
2166 my = ff_h263_round_chroma(my);
2170 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2171 src_y = s->mb_y * block_s + (my >> lowres + 1);
2173 offset = src_y * s->uvlinesize + src_x;
2174 ptr = ref_picture[1] + offset;
2175 if (s->flags & CODEC_FLAG_EMU_EDGE) {
2176 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2177 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2178 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2179 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2180 ptr = s->edge_emu_buffer;
2184 sx = (sx << 2) >> lowres;
2185 sy = (sy << 2) >> lowres;
2186 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2188 ptr = ref_picture[2] + offset;
2190 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2191 src_x, src_y, h_edge_pos, v_edge_pos);
2192 ptr = s->edge_emu_buffer;
2194 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2198 * motion compensation of a single macroblock
2200 * @param dest_y luma destination pointer
2201 * @param dest_cb chroma cb/u destination pointer
2202 * @param dest_cr chroma cr/v destination pointer
2203 * @param dir direction (0->forward, 1->backward)
2204 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2205 * @param pix_op halfpel motion compensation function (average or put normally)
2206 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2208 static inline void MPV_motion_lowres(MpegEncContext *s,
2209 uint8_t *dest_y, uint8_t *dest_cb,
2211 int dir, uint8_t **ref_picture,
2212 h264_chroma_mc_func *pix_op)
2216 const int lowres = s->avctx->lowres;
2217 const int block_s = 8 >>lowres;
2222 switch (s->mv_type) {
2224 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2226 ref_picture, pix_op,
2227 s->mv[dir][0][0], s->mv[dir][0][1],
2233 for (i = 0; i < 4; i++) {
2234 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2235 s->linesize) * block_s,
2236 ref_picture[0], 0, 0,
2237 (2 * mb_x + (i & 1)) * block_s,
2238 (2 * mb_y + (i >> 1)) * block_s,
2239 s->width, s->height, s->linesize,
2240 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2241 block_s, block_s, pix_op,
2242 s->mv[dir][i][0], s->mv[dir][i][1]);
2244 mx += s->mv[dir][i][0];
2245 my += s->mv[dir][i][1];
2248 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2249 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2253 if (s->picture_structure == PICT_FRAME) {
2255 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2256 1, 0, s->field_select[dir][0],
2257 ref_picture, pix_op,
2258 s->mv[dir][0][0], s->mv[dir][0][1],
2261 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2262 1, 1, s->field_select[dir][1],
2263 ref_picture, pix_op,
2264 s->mv[dir][1][0], s->mv[dir][1][1],
2267 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2268 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2269 ref_picture = s->current_picture_ptr->f.data;
2272 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2273 0, 0, s->field_select[dir][0],
2274 ref_picture, pix_op,
2276 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2280 for (i = 0; i < 2; i++) {
2281 uint8_t **ref2picture;
2283 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2284 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2285 ref2picture = ref_picture;
2287 ref2picture = s->current_picture_ptr->f.data;
2290 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2291 0, 0, s->field_select[dir][i],
2292 ref2picture, pix_op,
2293 s->mv[dir][i][0], s->mv[dir][i][1] +
2294 2 * block_s * i, block_s, mb_y >> 1);
2296 dest_y += 2 * block_s * s->linesize;
2297 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2298 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2302 if (s->picture_structure == PICT_FRAME) {
2303 for (i = 0; i < 2; i++) {
2305 for (j = 0; j < 2; j++) {
2306 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2308 ref_picture, pix_op,
2309 s->mv[dir][2 * i + j][0],
2310 s->mv[dir][2 * i + j][1],
2313 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2316 for (i = 0; i < 2; i++) {
2317 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2318 0, 0, s->picture_structure != i + 1,
2319 ref_picture, pix_op,
2320 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2321 2 * block_s, mb_y >> 1);
2323 // after put we make avg of the same block
2324 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2326 // opposite parity is always in the same
2327 // frame if this is second field
2328 if (!s->first_field) {
2329 ref_picture = s->current_picture_ptr->f.data;
2340 * find the lowest MB row referenced in the MVs
2342 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2344 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2345 int my, off, i, mvs;
2347 if (s->picture_structure != PICT_FRAME || s->mcsel)
2350 switch (s->mv_type) {
2364 for (i = 0; i < mvs; i++) {
2365 my = s->mv[dir][i][1]<<qpel_shift;
2366 my_max = FFMAX(my_max, my);
2367 my_min = FFMIN(my_min, my);
2370 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2372 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2374 return s->mb_height-1;
2377 /* put block[] to dest[] */
2378 static inline void put_dct(MpegEncContext *s,
2379 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2381 s->dct_unquantize_intra(s, block, i, qscale);
2382 s->dsp.idct_put (dest, line_size, block);
2385 /* add block[] to dest[] */
2386 static inline void add_dct(MpegEncContext *s,
2387 DCTELEM *block, int i, uint8_t *dest, int line_size)
2389 if (s->block_last_index[i] >= 0) {
2390 s->dsp.idct_add (dest, line_size, block);
2394 static inline void add_dequant_dct(MpegEncContext *s,
2395 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2397 if (s->block_last_index[i] >= 0) {
2398 s->dct_unquantize_inter(s, block, i, qscale);
2400 s->dsp.idct_add (dest, line_size, block);
2405 * Clean dc, ac, coded_block for the current non-intra MB.
2407 void ff_clean_intra_table_entries(MpegEncContext *s)
2409 int wrap = s->b8_stride;
2410 int xy = s->block_index[0];
2413 s->dc_val[0][xy + 1 ] =
2414 s->dc_val[0][xy + wrap] =
2415 s->dc_val[0][xy + 1 + wrap] = 1024;
2417 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2418 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2419 if (s->msmpeg4_version>=3) {
2420 s->coded_block[xy ] =
2421 s->coded_block[xy + 1 ] =
2422 s->coded_block[xy + wrap] =
2423 s->coded_block[xy + 1 + wrap] = 0;
2426 wrap = s->mb_stride;
2427 xy = s->mb_x + s->mb_y * wrap;
2429 s->dc_val[2][xy] = 1024;
2431 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2432 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2434 s->mbintra_table[xy]= 0;
2437 /* generic function called after a macroblock has been parsed by the
2438 decoder or after it has been encoded by the encoder.
2440 Important variables used:
2441 s->mb_intra : true if intra macroblock
2442 s->mv_dir : motion vector direction
2443 s->mv_type : motion vector type
2444 s->mv : motion vector
2445 s->interlaced_dct : true if interlaced dct used (mpeg2)
2447 static av_always_inline
2448 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2449 int lowres_flag, int is_mpeg12)
2451 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2452 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2453 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2457 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2458 /* save DCT coefficients */
2460 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2461 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2463 for(j=0; j<64; j++){
2464 *dct++ = block[i][s->dsp.idct_permutation[j]];
2465 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2467 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2471 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2473 /* update DC predictors for P macroblocks */
2475 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2476 if(s->mbintra_table[mb_xy])
2477 ff_clean_intra_table_entries(s);
2481 s->last_dc[2] = 128 << s->intra_dc_precision;
2484 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2485 s->mbintra_table[mb_xy]=1;
2487 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
2488 uint8_t *dest_y, *dest_cb, *dest_cr;
2489 int dct_linesize, dct_offset;
2490 op_pixels_func (*op_pix)[4];
2491 qpel_mc_func (*op_qpix)[16];
2492 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2493 const int uvlinesize = s->current_picture.f.linesize[1];
2494 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2495 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2497 /* avoid copy if macroblock skipped in last frame too */
2498 /* skip only during decoding as we might trash the buffers during encoding a bit */
2500 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2502 if (s->mb_skipped) {
2504 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2506 } else if(!s->current_picture.f.reference) {
2509 *mbskip_ptr = 0; /* not skipped */
2513 dct_linesize = linesize << s->interlaced_dct;
2514 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2518 dest_cb= s->dest[1];
2519 dest_cr= s->dest[2];
2521 dest_y = s->b_scratchpad;
2522 dest_cb= s->b_scratchpad+16*linesize;
2523 dest_cr= s->b_scratchpad+32*linesize;
2527 /* motion handling */
2528 /* decoding or more than one mb_type (MC was already done otherwise) */
2531 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2532 if (s->mv_dir & MV_DIR_FORWARD) {
2533 ff_thread_await_progress(&s->last_picture_ptr->f,
2534 ff_MPV_lowest_referenced_row(s, 0),
2537 if (s->mv_dir & MV_DIR_BACKWARD) {
2538 ff_thread_await_progress(&s->next_picture_ptr->f,
2539 ff_MPV_lowest_referenced_row(s, 1),
2545 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2547 if (s->mv_dir & MV_DIR_FORWARD) {
2548 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2549 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2551 if (s->mv_dir & MV_DIR_BACKWARD) {
2552 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2555 op_qpix= s->me.qpel_put;
2556 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2557 op_pix = s->dsp.put_pixels_tab;
2559 op_pix = s->dsp.put_no_rnd_pixels_tab;
2561 if (s->mv_dir & MV_DIR_FORWARD) {
2562 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2563 op_pix = s->dsp.avg_pixels_tab;
2564 op_qpix= s->me.qpel_avg;
2566 if (s->mv_dir & MV_DIR_BACKWARD) {
2567 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2572 /* skip dequant / idct if we are really late ;) */
2573 if(s->avctx->skip_idct){
2574 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2575 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2576 || s->avctx->skip_idct >= AVDISCARD_ALL)
2580 /* add dct residue */
2581 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2582 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2583 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2584 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2585 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2586 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2588 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2589 if (s->chroma_y_shift){
2590 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2591 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2595 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2596 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2597 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2598 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2601 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2602 add_dct(s, block[0], 0, dest_y , dct_linesize);
2603 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2604 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2605 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2607 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2608 if(s->chroma_y_shift){//Chroma420
2609 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2610 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2613 dct_linesize = uvlinesize << s->interlaced_dct;
2614 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2616 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2617 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2618 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2619 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2620 if(!s->chroma_x_shift){//Chroma444
2621 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2622 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2623 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2624 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2629 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2630 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2633 /* dct only in intra block */
2634 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2635 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2636 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2637 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2638 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2640 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2641 if(s->chroma_y_shift){
2642 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2643 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2647 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2648 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2649 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2650 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2654 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2655 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2656 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2657 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2659 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2660 if(s->chroma_y_shift){
2661 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2662 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2665 dct_linesize = uvlinesize << s->interlaced_dct;
2666 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2668 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2669 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2670 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2671 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2672 if(!s->chroma_x_shift){//Chroma444
2673 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2674 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2675 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2676 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2684 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2685 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2686 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2691 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2693 if(s->out_format == FMT_MPEG1) {
2694 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2695 else MPV_decode_mb_internal(s, block, 0, 1);
2698 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2699 else MPV_decode_mb_internal(s, block, 0, 0);
2703 * @param h is the normal height, this will be reduced automatically if needed for the last row
2705 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2706 const int field_pic= s->picture_structure != PICT_FRAME;
2712 if (!s->avctx->hwaccel
2713 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2714 && s->unrestricted_mv
2715 && s->current_picture.f.reference
2717 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2718 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
2719 int sides = 0, edge_h;
2720 int hshift = desc->log2_chroma_w;
2721 int vshift = desc->log2_chroma_h;
2722 if (y==0) sides |= EDGE_TOP;
2723 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2725 edge_h= FFMIN(h, s->v_edge_pos - y);
2727 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2728 s->linesize, s->h_edge_pos, edge_h,
2729 EDGE_WIDTH, EDGE_WIDTH, sides);
2730 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2731 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2732 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2733 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2734 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2735 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2738 h= FFMIN(h, s->avctx->height - y);
2740 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2742 if (s->avctx->draw_horiz_band) {
2744 int offset[AV_NUM_DATA_POINTERS];
2747 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2748 src = &s->current_picture_ptr->f;
2749 else if(s->last_picture_ptr)
2750 src = &s->last_picture_ptr->f;
2754 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2755 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2758 offset[0]= y * s->linesize;
2760 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2761 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2767 s->avctx->draw_horiz_band(s->avctx, src, offset,
2768 y, s->picture_structure, h);
2772 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2773 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2774 const int uvlinesize = s->current_picture.f.linesize[1];
2775 const int mb_size= 4 - s->avctx->lowres;
2777 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2778 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2779 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2780 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2781 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2782 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;
2783 //block_index is not used by mpeg2, so it is not affected by chroma_format
2785 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2786 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2787 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2789 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2791 if(s->picture_structure==PICT_FRAME){
2792 s->dest[0] += s->mb_y * linesize << mb_size;
2793 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2794 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2796 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2797 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2798 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2799 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2804 void ff_mpeg_flush(AVCodecContext *avctx){
2806 MpegEncContext *s = avctx->priv_data;
2808 if(s==NULL || s->picture==NULL)
2811 for(i=0; i<s->picture_count; i++){
2812 if (s->picture[i].f.data[0] &&
2813 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2814 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2815 free_frame_buffer(s, &s->picture[i]);
2817 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2819 s->mb_x= s->mb_y= 0;
2822 s->parse_context.state= -1;
2823 s->parse_context.frame_start_found= 0;
2824 s->parse_context.overread= 0;
2825 s->parse_context.overread_index= 0;
2826 s->parse_context.index= 0;
2827 s->parse_context.last_index= 0;
2828 s->bitstream_buffer_size=0;
2832 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2833 DCTELEM *block, int n, int qscale)
2835 int i, level, nCoeffs;
2836 const uint16_t *quant_matrix;
2838 nCoeffs= s->block_last_index[n];
2840 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2841 /* XXX: only mpeg1 */
2842 quant_matrix = s->intra_matrix;
2843 for(i=1;i<=nCoeffs;i++) {
2844 int j= s->intra_scantable.permutated[i];
2849 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2850 level = (level - 1) | 1;
2853 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2854 level = (level - 1) | 1;
2861 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2862 DCTELEM *block, int n, int qscale)
2864 int i, level, nCoeffs;
2865 const uint16_t *quant_matrix;
2867 nCoeffs= s->block_last_index[n];
2869 quant_matrix = s->inter_matrix;
2870 for(i=0; i<=nCoeffs; i++) {
2871 int j= s->intra_scantable.permutated[i];
2876 level = (((level << 1) + 1) * qscale *
2877 ((int) (quant_matrix[j]))) >> 4;
2878 level = (level - 1) | 1;
2881 level = (((level << 1) + 1) * qscale *
2882 ((int) (quant_matrix[j]))) >> 4;
2883 level = (level - 1) | 1;
2890 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2891 DCTELEM *block, int n, int qscale)
2893 int i, level, nCoeffs;
2894 const uint16_t *quant_matrix;
2896 if(s->alternate_scan) nCoeffs= 63;
2897 else nCoeffs= s->block_last_index[n];
2899 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2900 quant_matrix = s->intra_matrix;
2901 for(i=1;i<=nCoeffs;i++) {
2902 int j= s->intra_scantable.permutated[i];
2907 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2910 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2917 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2918 DCTELEM *block, int n, int qscale)
2920 int i, level, nCoeffs;
2921 const uint16_t *quant_matrix;
2924 if(s->alternate_scan) nCoeffs= 63;
2925 else nCoeffs= s->block_last_index[n];
2927 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2929 quant_matrix = s->intra_matrix;
2930 for(i=1;i<=nCoeffs;i++) {
2931 int j= s->intra_scantable.permutated[i];
2936 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2939 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2948 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2949 DCTELEM *block, int n, int qscale)
2951 int i, level, nCoeffs;
2952 const uint16_t *quant_matrix;
2955 if(s->alternate_scan) nCoeffs= 63;
2956 else nCoeffs= s->block_last_index[n];
2958 quant_matrix = s->inter_matrix;
2959 for(i=0; i<=nCoeffs; i++) {
2960 int j= s->intra_scantable.permutated[i];
2965 level = (((level << 1) + 1) * qscale *
2966 ((int) (quant_matrix[j]))) >> 4;
2969 level = (((level << 1) + 1) * qscale *
2970 ((int) (quant_matrix[j]))) >> 4;
2979 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2980 DCTELEM *block, int n, int qscale)
2982 int i, level, qmul, qadd;
2985 assert(s->block_last_index[n]>=0);
2990 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2991 qadd = (qscale - 1) | 1;
2998 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3000 for(i=1; i<=nCoeffs; i++) {
3004 level = level * qmul - qadd;
3006 level = level * qmul + qadd;
3013 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3014 DCTELEM *block, int n, int qscale)
3016 int i, level, qmul, qadd;
3019 assert(s->block_last_index[n]>=0);
3021 qadd = (qscale - 1) | 1;
3024 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3026 for(i=0; i<=nCoeffs; i++) {
3030 level = level * qmul - qadd;
3032 level = level * qmul + qadd;
3040 * set qscale and update qscale dependent variables.
3042 void ff_set_qscale(MpegEncContext * s, int qscale)
3046 else if (qscale > 31)
3050 s->chroma_qscale= s->chroma_qscale_table[qscale];
3052 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3053 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3056 void ff_MPV_report_decode_progress(MpegEncContext *s)
3058 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
3059 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);