Remove lowres video decoding
[libav.git] / libavcodec / mpegvideo.c
1 /*
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>
5 *
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7 *
8 * This file is part of Libav.
9 *
10 * Libav 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.
14 *
15 * Libav 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.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /**
26 * @file
27 * The simplest mpeg encoder (well, it was the simplest!).
28 */
29
30 #include "libavutil/intmath.h"
31 #include "libavutil/imgutils.h"
32 #include "avcodec.h"
33 #include "dsputil.h"
34 #include "internal.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
37 #include "mjpegenc.h"
38 #include "msmpeg4.h"
39 #include "faandct.h"
40 #include "xvmc_internal.h"
41 #include "thread.h"
42 #include <limits.h>
43
44 //#undef NDEBUG
45 //#include <assert.h>
46
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58 DCTELEM *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60 DCTELEM *block, int n, int qscale);
61
62
63 /* enable all paranoid tests for rounding, overflows, etc... */
64 //#define PARANOID
65
66 //#define DEBUG
67
68
69 static const uint8_t ff_default_chroma_qscale_table[32] = {
70 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
71 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
72 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
73 };
74
75 const uint8_t ff_mpeg1_dc_scale_table[128] = {
76 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
83 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
84 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
85 };
86
87 static const uint8_t mpeg2_dc_scale_table1[128] = {
88 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
95 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
96 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
97 };
98
99 static const uint8_t mpeg2_dc_scale_table2[128] = {
100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
109 };
110
111 static const uint8_t mpeg2_dc_scale_table3[128] = {
112 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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,
119 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
120 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
121 };
122
123 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
124 ff_mpeg1_dc_scale_table,
125 mpeg2_dc_scale_table1,
126 mpeg2_dc_scale_table2,
127 mpeg2_dc_scale_table3,
128 };
129
130 const enum PixelFormat ff_pixfmt_list_420[] = {
131 PIX_FMT_YUV420P,
132 PIX_FMT_NONE
133 };
134
135 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
136 PIX_FMT_DXVA2_VLD,
137 PIX_FMT_VAAPI_VLD,
138 PIX_FMT_VDA_VLD,
139 PIX_FMT_YUV420P,
140 PIX_FMT_NONE
141 };
142
143 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *restrict p,
144 const uint8_t *end,
145 uint32_t * restrict state)
146 {
147 int i;
148
149 assert(p <= end);
150 if (p >= end)
151 return end;
152
153 for (i = 0; i < 3; i++) {
154 uint32_t tmp = *state << 8;
155 *state = tmp + *(p++);
156 if (tmp == 0x100 || p == end)
157 return p;
158 }
159
160 while (p < end) {
161 if (p[-1] > 1 ) p += 3;
162 else if (p[-2] ) p += 2;
163 else if (p[-3]|(p[-1]-1)) p++;
164 else {
165 p++;
166 break;
167 }
168 }
169
170 p = FFMIN(p, end) - 4;
171 *state = AV_RB32(p);
172
173 return p + 4;
174 }
175
176 /* init common dct for both encoder and decoder */
177 av_cold int ff_dct_common_init(MpegEncContext *s)
178 {
179 ff_dsputil_init(&s->dsp, s->avctx);
180
181 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
182 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
183 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
184 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
185 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
186 if (s->flags & CODEC_FLAG_BITEXACT)
187 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
188 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
189
190 #if HAVE_MMX
191 ff_MPV_common_init_mmx(s);
192 #elif ARCH_ALPHA
193 ff_MPV_common_init_axp(s);
194 #elif HAVE_MMI
195 ff_MPV_common_init_mmi(s);
196 #elif ARCH_ARM
197 ff_MPV_common_init_arm(s);
198 #elif HAVE_ALTIVEC
199 ff_MPV_common_init_altivec(s);
200 #elif ARCH_BFIN
201 ff_MPV_common_init_bfin(s);
202 #endif
203
204 /* load & permutate scantables
205 * note: only wmv uses different ones
206 */
207 if (s->alternate_scan) {
208 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
209 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
210 } else {
211 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
212 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
213 }
214 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
215 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
216
217 return 0;
218 }
219
220 void ff_copy_picture(Picture *dst, Picture *src)
221 {
222 *dst = *src;
223 dst->f.type = FF_BUFFER_TYPE_COPY;
224 }
225
226 /**
227 * Release a frame buffer
228 */
229 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
230 {
231 /* Windows Media Image codecs allocate internal buffers with different
232 * dimensions; ignore user defined callbacks for these
233 */
234 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
235 ff_thread_release_buffer(s->avctx, &pic->f);
236 else
237 avcodec_default_release_buffer(s->avctx, &pic->f);
238 av_freep(&pic->f.hwaccel_picture_private);
239 }
240
241 /**
242 * Allocate a frame buffer
243 */
244 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
245 {
246 int r;
247
248 if (s->avctx->hwaccel) {
249 assert(!pic->f.hwaccel_picture_private);
250 if (s->avctx->hwaccel->priv_data_size) {
251 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
252 if (!pic->f.hwaccel_picture_private) {
253 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
254 return -1;
255 }
256 }
257 }
258
259 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
260 r = ff_thread_get_buffer(s->avctx, &pic->f);
261 else
262 r = avcodec_default_get_buffer(s->avctx, &pic->f);
263
264 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
265 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
266 r, pic->f.type, pic->f.data[0]);
267 av_freep(&pic->f.hwaccel_picture_private);
268 return -1;
269 }
270
271 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
272 s->uvlinesize != pic->f.linesize[1])) {
273 av_log(s->avctx, AV_LOG_ERROR,
274 "get_buffer() failed (stride changed)\n");
275 free_frame_buffer(s, pic);
276 return -1;
277 }
278
279 if (pic->f.linesize[1] != pic->f.linesize[2]) {
280 av_log(s->avctx, AV_LOG_ERROR,
281 "get_buffer() failed (uv stride mismatch)\n");
282 free_frame_buffer(s, pic);
283 return -1;
284 }
285
286 return 0;
287 }
288
289 /**
290 * Allocate a Picture.
291 * The pixels are allocated/set by calling get_buffer() if shared = 0
292 */
293 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
294 {
295 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
296
297 // the + 1 is needed so memset(,,stride*height) does not sig11
298
299 const int mb_array_size = s->mb_stride * s->mb_height;
300 const int b8_array_size = s->b8_stride * s->mb_height * 2;
301 const int b4_array_size = s->b4_stride * s->mb_height * 4;
302 int i;
303 int r = -1;
304
305 if (shared) {
306 assert(pic->f.data[0]);
307 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
308 pic->f.type = FF_BUFFER_TYPE_SHARED;
309 } else {
310 assert(!pic->f.data[0]);
311
312 if (alloc_frame_buffer(s, pic) < 0)
313 return -1;
314
315 s->linesize = pic->f.linesize[0];
316 s->uvlinesize = pic->f.linesize[1];
317 }
318
319 if (pic->f.qscale_table == NULL) {
320 if (s->encoding) {
321 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
322 mb_array_size * sizeof(int16_t), fail)
323 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
324 mb_array_size * sizeof(int16_t), fail)
325 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
326 mb_array_size * sizeof(int8_t ), fail)
327 }
328
329 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
330 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
331 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
332 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
333 fail)
334 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
335 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
336 fail)
337 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
338 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
339 if (s->out_format == FMT_H264) {
340 for (i = 0; i < 2; i++) {
341 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
342 2 * (b4_array_size + 4) * sizeof(int16_t),
343 fail)
344 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
345 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
346 4 * mb_array_size * sizeof(uint8_t), fail)
347 }
348 pic->f.motion_subsample_log2 = 2;
349 } else if (s->out_format == FMT_H263 || s->encoding ||
350 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
351 for (i = 0; i < 2; i++) {
352 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
353 2 * (b8_array_size + 4) * sizeof(int16_t),
354 fail)
355 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
356 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
357 4 * mb_array_size * sizeof(uint8_t), fail)
358 }
359 pic->f.motion_subsample_log2 = 3;
360 }
361 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
362 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
363 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
364 }
365 pic->f.qstride = s->mb_stride;
366 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
367 1 * sizeof(AVPanScan), fail)
368 }
369
370 pic->owner2 = s;
371
372 return 0;
373 fail: // for the FF_ALLOCZ_OR_GOTO macro
374 if (r >= 0)
375 free_frame_buffer(s, pic);
376 return -1;
377 }
378
379 /**
380 * Deallocate a picture.
381 */
382 static void free_picture(MpegEncContext *s, Picture *pic)
383 {
384 int i;
385
386 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
387 free_frame_buffer(s, pic);
388 }
389
390 av_freep(&pic->mb_var);
391 av_freep(&pic->mc_mb_var);
392 av_freep(&pic->mb_mean);
393 av_freep(&pic->f.mbskip_table);
394 av_freep(&pic->qscale_table_base);
395 av_freep(&pic->mb_type_base);
396 av_freep(&pic->f.dct_coeff);
397 av_freep(&pic->f.pan_scan);
398 pic->f.mb_type = NULL;
399 for (i = 0; i < 2; i++) {
400 av_freep(&pic->motion_val_base[i]);
401 av_freep(&pic->f.ref_index[i]);
402 }
403
404 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
405 for (i = 0; i < 4; i++) {
406 pic->f.base[i] =
407 pic->f.data[i] = NULL;
408 }
409 pic->f.type = 0;
410 }
411 }
412
413 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
414 {
415 int y_size = s->b8_stride * (2 * s->mb_height + 1);
416 int c_size = s->mb_stride * (s->mb_height + 1);
417 int yc_size = y_size + 2 * c_size;
418 int i;
419
420 // edge emu needs blocksize + filter length - 1
421 // (= 17x17 for halfpel / 21x21 for h264)
422 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
423 (s->width + 64) * 2 * 21 * 2, fail); // (width + edge + align)*interlaced*MBsize*tolerance
424
425 // FIXME should be linesize instead of s->width * 2
426 // but that is not known before get_buffer()
427 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
428 (s->width + 64) * 4 * 16 * 2 * sizeof(uint8_t), fail)
429 s->me.temp = s->me.scratchpad;
430 s->rd_scratchpad = s->me.scratchpad;
431 s->b_scratchpad = s->me.scratchpad;
432 s->obmc_scratchpad = s->me.scratchpad + 16;
433 if (s->encoding) {
434 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
435 ME_MAP_SIZE * sizeof(uint32_t), fail)
436 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
437 ME_MAP_SIZE * sizeof(uint32_t), fail)
438 if (s->avctx->noise_reduction) {
439 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
440 2 * 64 * sizeof(int), fail)
441 }
442 }
443 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
444 s->block = s->blocks[0];
445
446 for (i = 0; i < 12; i++) {
447 s->pblocks[i] = &s->block[i];
448 }
449
450 if (s->out_format == FMT_H263) {
451 /* ac values */
452 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
453 yc_size * sizeof(int16_t) * 16, fail);
454 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
455 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
456 s->ac_val[2] = s->ac_val[1] + c_size;
457 }
458
459 return 0;
460 fail:
461 return -1; // free() through ff_MPV_common_end()
462 }
463
464 static void free_duplicate_context(MpegEncContext *s)
465 {
466 if (s == NULL)
467 return;
468
469 av_freep(&s->edge_emu_buffer);
470 av_freep(&s->me.scratchpad);
471 s->me.temp =
472 s->rd_scratchpad =
473 s->b_scratchpad =
474 s->obmc_scratchpad = NULL;
475
476 av_freep(&s->dct_error_sum);
477 av_freep(&s->me.map);
478 av_freep(&s->me.score_map);
479 av_freep(&s->blocks);
480 av_freep(&s->ac_val_base);
481 s->block = NULL;
482 }
483
484 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
485 {
486 #define COPY(a) bak->a = src->a
487 COPY(edge_emu_buffer);
488 COPY(me.scratchpad);
489 COPY(me.temp);
490 COPY(rd_scratchpad);
491 COPY(b_scratchpad);
492 COPY(obmc_scratchpad);
493 COPY(me.map);
494 COPY(me.score_map);
495 COPY(blocks);
496 COPY(block);
497 COPY(start_mb_y);
498 COPY(end_mb_y);
499 COPY(me.map_generation);
500 COPY(pb);
501 COPY(dct_error_sum);
502 COPY(dct_count[0]);
503 COPY(dct_count[1]);
504 COPY(ac_val_base);
505 COPY(ac_val[0]);
506 COPY(ac_val[1]);
507 COPY(ac_val[2]);
508 #undef COPY
509 }
510
511 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
512 {
513 MpegEncContext bak;
514 int i;
515 // FIXME copy only needed parts
516 // START_TIMER
517 backup_duplicate_context(&bak, dst);
518 memcpy(dst, src, sizeof(MpegEncContext));
519 backup_duplicate_context(dst, &bak);
520 for (i = 0; i < 12; i++) {
521 dst->pblocks[i] = &dst->block[i];
522 }
523 // STOP_TIMER("update_duplicate_context")
524 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
525 }
526
527 int ff_mpeg_update_thread_context(AVCodecContext *dst,
528 const AVCodecContext *src)
529 {
530 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
531
532 if (dst == src || !s1->context_initialized)
533 return 0;
534
535 // FIXME can parameters change on I-frames?
536 // in that case dst may need a reinit
537 if (!s->context_initialized) {
538 memcpy(s, s1, sizeof(MpegEncContext));
539
540 s->avctx = dst;
541 s->picture_range_start += MAX_PICTURE_COUNT;
542 s->picture_range_end += MAX_PICTURE_COUNT;
543 s->bitstream_buffer = NULL;
544 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
545
546 ff_MPV_common_init(s);
547 }
548
549 s->avctx->coded_height = s1->avctx->coded_height;
550 s->avctx->coded_width = s1->avctx->coded_width;
551 s->avctx->width = s1->avctx->width;
552 s->avctx->height = s1->avctx->height;
553
554 s->coded_picture_number = s1->coded_picture_number;
555 s->picture_number = s1->picture_number;
556 s->input_picture_number = s1->input_picture_number;
557
558 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
559 memcpy(&s->last_picture, &s1->last_picture,
560 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
561
562 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
563 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
564 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
565
566 // Error/bug resilience
567 s->next_p_frame_damaged = s1->next_p_frame_damaged;
568 s->workaround_bugs = s1->workaround_bugs;
569
570 // MPEG4 timing info
571 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
572 (char *) &s1->shape - (char *) &s1->time_increment_bits);
573
574 // B-frame info
575 s->max_b_frames = s1->max_b_frames;
576 s->low_delay = s1->low_delay;
577 s->dropable = s1->dropable;
578
579 // DivX handling (doesn't work)
580 s->divx_packed = s1->divx_packed;
581
582 if (s1->bitstream_buffer) {
583 if (s1->bitstream_buffer_size +
584 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
585 av_fast_malloc(&s->bitstream_buffer,
586 &s->allocated_bitstream_buffer_size,
587 s1->allocated_bitstream_buffer_size);
588 s->bitstream_buffer_size = s1->bitstream_buffer_size;
589 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
590 s1->bitstream_buffer_size);
591 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
592 FF_INPUT_BUFFER_PADDING_SIZE);
593 }
594
595 // MPEG2/interlacing info
596 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
597 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
598
599 if (!s1->first_field) {
600 s->last_pict_type = s1->pict_type;
601 if (s1->current_picture_ptr)
602 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
603
604 if (s1->pict_type != AV_PICTURE_TYPE_B) {
605 s->last_non_b_pict_type = s1->pict_type;
606 }
607 }
608
609 return 0;
610 }
611
612 /**
613 * Set the given MpegEncContext to common defaults
614 * (same for encoding and decoding).
615 * The changed fields will not depend upon the
616 * prior state of the MpegEncContext.
617 */
618 void ff_MPV_common_defaults(MpegEncContext *s)
619 {
620 s->y_dc_scale_table =
621 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
622 s->chroma_qscale_table = ff_default_chroma_qscale_table;
623 s->progressive_frame = 1;
624 s->progressive_sequence = 1;
625 s->picture_structure = PICT_FRAME;
626
627 s->coded_picture_number = 0;
628 s->picture_number = 0;
629 s->input_picture_number = 0;
630
631 s->picture_in_gop_number = 0;
632
633 s->f_code = 1;
634 s->b_code = 1;
635
636 s->picture_range_start = 0;
637 s->picture_range_end = MAX_PICTURE_COUNT;
638
639 s->slice_context_count = 1;
640 }
641
642 /**
643 * Set the given MpegEncContext to defaults for decoding.
644 * the changed fields will not depend upon
645 * the prior state of the MpegEncContext.
646 */
647 void ff_MPV_decode_defaults(MpegEncContext *s)
648 {
649 ff_MPV_common_defaults(s);
650 }
651
652 /**
653 * init common structure for both encoder and decoder.
654 * this assumes that some variables like width/height are already set
655 */
656 av_cold int ff_MPV_common_init(MpegEncContext *s)
657 {
658 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
659 int nb_slices = (HAVE_THREADS &&
660 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
661 s->avctx->thread_count : 1;
662
663 if (s->encoding && s->avctx->slices)
664 nb_slices = s->avctx->slices;
665
666 if (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
667 s->mb_height = (s->height + 31) / 32 * 2;
668 else if (s->codec_id != CODEC_ID_H264)
669 s->mb_height = (s->height + 15) / 16;
670
671 if (s->avctx->pix_fmt == PIX_FMT_NONE) {
672 av_log(s->avctx, AV_LOG_ERROR,
673 "decoding to PIX_FMT_NONE is not supported.\n");
674 return -1;
675 }
676
677 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
678 int max_slices;
679 if (s->mb_height)
680 max_slices = FFMIN(MAX_THREADS, s->mb_height);
681 else
682 max_slices = MAX_THREADS;
683 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
684 " reducing to %d\n", nb_slices, max_slices);
685 nb_slices = max_slices;
686 }
687
688 if ((s->width || s->height) &&
689 av_image_check_size(s->width, s->height, 0, s->avctx))
690 return -1;
691
692 ff_dct_common_init(s);
693
694 s->flags = s->avctx->flags;
695 s->flags2 = s->avctx->flags2;
696
697 if (s->width && s->height) {
698 s->mb_width = (s->width + 15) / 16;
699 s->mb_stride = s->mb_width + 1;
700 s->b8_stride = s->mb_width * 2 + 1;
701 s->b4_stride = s->mb_width * 4 + 1;
702 mb_array_size = s->mb_height * s->mb_stride;
703 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
704
705 /* set chroma shifts */
706 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
707 &s->chroma_y_shift);
708
709 /* set default edge pos, will be overriden
710 * in decode_header if needed */
711 s->h_edge_pos = s->mb_width * 16;
712 s->v_edge_pos = s->mb_height * 16;
713
714 s->mb_num = s->mb_width * s->mb_height;
715
716 s->block_wrap[0] =
717 s->block_wrap[1] =
718 s->block_wrap[2] =
719 s->block_wrap[3] = s->b8_stride;
720 s->block_wrap[4] =
721 s->block_wrap[5] = s->mb_stride;
722
723 y_size = s->b8_stride * (2 * s->mb_height + 1);
724 c_size = s->mb_stride * (s->mb_height + 1);
725 yc_size = y_size + 2 * c_size;
726
727 /* convert fourcc to upper case */
728 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
729
730 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
731
732 s->avctx->coded_frame = &s->current_picture.f;
733
734 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
735 fail); // error ressilience code looks cleaner with this
736 for (y = 0; y < s->mb_height; y++)
737 for (x = 0; x < s->mb_width; x++)
738 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
739
740 s->mb_index2xy[s->mb_height * s->mb_width] =
741 (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
742
743 if (s->encoding) {
744 /* Allocate MV tables */
745 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
746 mv_table_size * 2 * sizeof(int16_t), fail);
747 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
748 mv_table_size * 2 * sizeof(int16_t), fail);
749 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
750 mv_table_size * 2 * sizeof(int16_t), fail);
751 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
752 mv_table_size * 2 * sizeof(int16_t), fail);
753 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
754 mv_table_size * 2 * sizeof(int16_t), fail);
755 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
756 mv_table_size * 2 * sizeof(int16_t), fail);
757 s->p_mv_table = s->p_mv_table_base +
758 s->mb_stride + 1;
759 s->b_forw_mv_table = s->b_forw_mv_table_base +
760 s->mb_stride + 1;
761 s->b_back_mv_table = s->b_back_mv_table_base +
762 s->mb_stride + 1;
763 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
764 s->mb_stride + 1;
765 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
766 s->mb_stride + 1;
767 s->b_direct_mv_table = s->b_direct_mv_table_base +
768 s->mb_stride + 1;
769
770 if (s->msmpeg4_version) {
771 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
772 2 * 2 * (MAX_LEVEL + 1) *
773 (MAX_RUN + 1) * 2 * sizeof(int), fail);
774 }
775 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
776
777 /* Allocate MB type table */
778 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
779 sizeof(uint16_t), fail); // needed for encoding
780
781 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
782 sizeof(int), fail);
783
784 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,
785 64 * 32 * sizeof(int), fail);
786 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,
787 64 * 32 * sizeof(int), fail);
788 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,
789 64 * 32 * 2 * sizeof(uint16_t), fail);
790 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,
791 64 * 32 * 2 * sizeof(uint16_t), fail);
792 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
793 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
794 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
795 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
796
797 if (s->avctx->noise_reduction) {
798 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
799 2 * 64 * sizeof(uint16_t), fail);
800 }
801 }
802 }
803
804 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
805 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
806 s->picture_count * sizeof(Picture), fail);
807 for (i = 0; i < s->picture_count; i++) {
808 avcodec_get_frame_defaults(&s->picture[i].f);
809 }
810
811 if (s->width && s->height) {
812 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
813 mb_array_size * sizeof(uint8_t), fail);
814
815 if (s->codec_id == CODEC_ID_MPEG4 ||
816 (s->flags & CODEC_FLAG_INTERLACED_ME)) {
817 /* interlaced direct mode decoding tables */
818 for (i = 0; i < 2; i++) {
819 int j, k;
820 for (j = 0; j < 2; j++) {
821 for (k = 0; k < 2; k++) {
822 FF_ALLOCZ_OR_GOTO(s->avctx,
823 s->b_field_mv_table_base[i][j][k],
824 mv_table_size * 2 * sizeof(int16_t),
825 fail);
826 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
827 s->mb_stride + 1;
828 }
829 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
830 mb_array_size * 2 * sizeof(uint8_t),
831 fail);
832 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
833 mv_table_size * 2 * sizeof(int16_t),
834 fail);
835 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
836 + s->mb_stride + 1;
837 }
838 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
839 mb_array_size * 2 * sizeof(uint8_t),
840 fail);
841 }
842 }
843 if (s->out_format == FMT_H263) {
844 /* cbp values */
845 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
846 s->coded_block = s->coded_block_base + s->b8_stride + 1;
847
848 /* cbp, ac_pred, pred_dir */
849 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
850 mb_array_size * sizeof(uint8_t), fail);
851 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
852 mb_array_size * sizeof(uint8_t), fail);
853 }
854
855 if (s->h263_pred || s->h263_plus || !s->encoding) {
856 /* dc values */
857 // MN: we need these for error resilience of intra-frames
858 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
859 yc_size * sizeof(int16_t), fail);
860 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
861 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
862 s->dc_val[2] = s->dc_val[1] + c_size;
863 for (i = 0; i < yc_size; i++)
864 s->dc_val_base[i] = 1024;
865 }
866
867 /* which mb is a intra block */
868 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
869 memset(s->mbintra_table, 1, mb_array_size);
870
871 /* init macroblock skip table */
872 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
873 // Note the + 1 is for a quicker mpeg4 slice_end detection
874
875 s->parse_context.state = -1;
876 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
877 s->avctx->debug_mv) {
878 s->visualization_buffer[0] = av_malloc((s->mb_width * 16 +
879 2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
880 s->visualization_buffer[1] = av_malloc((s->mb_width * 16 +
881 2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
882 s->visualization_buffer[2] = av_malloc((s->mb_width * 16 +
883 2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
884 }
885 }
886
887 s->context_initialized = 1;
888 s->thread_context[0] = s;
889
890 if (s->width && s->height) {
891 if (nb_slices > 1) {
892 for (i = 1; i < nb_slices; i++) {
893 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
894 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
895 }
896
897 for (i = 0; i < nb_slices; i++) {
898 if (init_duplicate_context(s->thread_context[i], s) < 0)
899 goto fail;
900 s->thread_context[i]->start_mb_y =
901 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
902 s->thread_context[i]->end_mb_y =
903 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
904 }
905 } else {
906 if (init_duplicate_context(s, s) < 0)
907 goto fail;
908 s->start_mb_y = 0;
909 s->end_mb_y = s->mb_height;
910 }
911 s->slice_context_count = nb_slices;
912 }
913
914 return 0;
915 fail:
916 ff_MPV_common_end(s);
917 return -1;
918 }
919
920 /* init common structure for both encoder and decoder */
921 void ff_MPV_common_end(MpegEncContext *s)
922 {
923 int i, j, k;
924
925 if (s->slice_context_count > 1) {
926 for (i = 0; i < s->slice_context_count; i++) {
927 free_duplicate_context(s->thread_context[i]);
928 }
929 for (i = 1; i < s->slice_context_count; i++) {
930 av_freep(&s->thread_context[i]);
931 }
932 s->slice_context_count = 1;
933 } else free_duplicate_context(s);
934
935 av_freep(&s->parse_context.buffer);
936 s->parse_context.buffer_size = 0;
937
938 av_freep(&s->mb_type);
939 av_freep(&s->p_mv_table_base);
940 av_freep(&s->b_forw_mv_table_base);
941 av_freep(&s->b_back_mv_table_base);
942 av_freep(&s->b_bidir_forw_mv_table_base);
943 av_freep(&s->b_bidir_back_mv_table_base);
944 av_freep(&s->b_direct_mv_table_base);
945 s->p_mv_table = NULL;
946 s->b_forw_mv_table = NULL;
947 s->b_back_mv_table = NULL;
948 s->b_bidir_forw_mv_table = NULL;
949 s->b_bidir_back_mv_table = NULL;
950 s->b_direct_mv_table = NULL;
951 for (i = 0; i < 2; i++) {
952 for (j = 0; j < 2; j++) {
953 for (k = 0; k < 2; k++) {
954 av_freep(&s->b_field_mv_table_base[i][j][k]);
955 s->b_field_mv_table[i][j][k] = NULL;
956 }
957 av_freep(&s->b_field_select_table[i][j]);
958 av_freep(&s->p_field_mv_table_base[i][j]);
959 s->p_field_mv_table[i][j] = NULL;
960 }
961 av_freep(&s->p_field_select_table[i]);
962 }
963
964 av_freep(&s->dc_val_base);
965 av_freep(&s->coded_block_base);
966 av_freep(&s->mbintra_table);
967 av_freep(&s->cbp_table);
968 av_freep(&s->pred_dir_table);
969
970 av_freep(&s->mbskip_table);
971 av_freep(&s->bitstream_buffer);
972 s->allocated_bitstream_buffer_size = 0;
973
974 av_freep(&s->avctx->stats_out);
975 av_freep(&s->ac_stats);
976 av_freep(&s->error_status_table);
977 av_freep(&s->mb_index2xy);
978 av_freep(&s->lambda_table);
979 av_freep(&s->q_intra_matrix);
980 av_freep(&s->q_inter_matrix);
981 av_freep(&s->q_intra_matrix16);
982 av_freep(&s->q_inter_matrix16);
983 av_freep(&s->input_picture);
984 av_freep(&s->reordered_input_picture);
985 av_freep(&s->dct_offset);
986
987 if (s->picture && !s->avctx->internal->is_copy) {
988 for (i = 0; i < s->picture_count; i++) {
989 free_picture(s, &s->picture[i]);
990 }
991 }
992 av_freep(&s->picture);
993 s->context_initialized = 0;
994 s->last_picture_ptr =
995 s->next_picture_ptr =
996 s->current_picture_ptr = NULL;
997 s->linesize = s->uvlinesize = 0;
998
999 for (i = 0; i < 3; i++)
1000 av_freep(&s->visualization_buffer[i]);
1001
1002 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
1003 avcodec_default_free_buffers(s->avctx);
1004 }
1005
1006 void ff_init_rl(RLTable *rl,
1007 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1008 {
1009 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1010 uint8_t index_run[MAX_RUN + 1];
1011 int last, run, level, start, end, i;
1012
1013 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1014 if (static_store && rl->max_level[0])
1015 return;
1016
1017 /* compute max_level[], max_run[] and index_run[] */
1018 for (last = 0; last < 2; last++) {
1019 if (last == 0) {
1020 start = 0;
1021 end = rl->last;
1022 } else {
1023 start = rl->last;
1024 end = rl->n;
1025 }
1026
1027 memset(max_level, 0, MAX_RUN + 1);
1028 memset(max_run, 0, MAX_LEVEL + 1);
1029 memset(index_run, rl->n, MAX_RUN + 1);
1030 for (i = start; i < end; i++) {
1031 run = rl->table_run[i];
1032 level = rl->table_level[i];
1033 if (index_run[run] == rl->n)
1034 index_run[run] = i;
1035 if (level > max_level[run])
1036 max_level[run] = level;
1037 if (run > max_run[level])
1038 max_run[level] = run;
1039 }
1040 if (static_store)
1041 rl->max_level[last] = static_store[last];
1042 else
1043 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1044 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1045 if (static_store)
1046 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1047 else
1048 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1049 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1050 if (static_store)
1051 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1052 else
1053 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1054 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1055 }
1056 }
1057
1058 void ff_init_vlc_rl(RLTable *rl)
1059 {
1060 int i, q;
1061
1062 for (q = 0; q < 32; q++) {
1063 int qmul = q * 2;
1064 int qadd = (q - 1) | 1;
1065
1066 if (q == 0) {
1067 qmul = 1;
1068 qadd = 0;
1069 }
1070 for (i = 0; i < rl->vlc.table_size; i++) {
1071 int code = rl->vlc.table[i][0];
1072 int len = rl->vlc.table[i][1];
1073 int level, run;
1074
1075 if (len == 0) { // illegal code
1076 run = 66;
1077 level = MAX_LEVEL;
1078 } else if (len < 0) { // more bits needed
1079 run = 0;
1080 level = code;
1081 } else {
1082 if (code == rl->n) { // esc
1083 run = 66;
1084 level = 0;
1085 } else {
1086 run = rl->table_run[code] + 1;
1087 level = rl->table_level[code] * qmul + qadd;
1088 if (code >= rl->last) run += 192;
1089 }
1090 }
1091 rl->rl_vlc[q][i].len = len;
1092 rl->rl_vlc[q][i].level = level;
1093 rl->rl_vlc[q][i].run = run;
1094 }
1095 }
1096 }
1097
1098 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1099 {
1100 int i;
1101
1102 /* release non reference frames */
1103 for (i = 0; i < s->picture_count; i++) {
1104 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1105 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1106 (remove_current || &s->picture[i] != s->current_picture_ptr)
1107 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1108 free_frame_buffer(s, &s->picture[i]);
1109 }
1110 }
1111 }
1112
1113 int ff_find_unused_picture(MpegEncContext *s, int shared)
1114 {
1115 int i;
1116
1117 if (shared) {
1118 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1119 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1120 return i;
1121 }
1122 } else {
1123 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1124 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
1125 return i; // FIXME
1126 }
1127 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1128 if (s->picture[i].f.data[0] == NULL)
1129 return i;
1130 }
1131 }
1132
1133 return AVERROR_INVALIDDATA;
1134 }
1135
1136 static void update_noise_reduction(MpegEncContext *s)
1137 {
1138 int intra, i;
1139
1140 for (intra = 0; intra < 2; intra++) {
1141 if (s->dct_count[intra] > (1 << 16)) {
1142 for (i = 0; i < 64; i++) {
1143 s->dct_error_sum[intra][i] >>= 1;
1144 }
1145 s->dct_count[intra] >>= 1;
1146 }
1147
1148 for (i = 0; i < 64; i++) {
1149 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1150 s->dct_count[intra] +
1151 s->dct_error_sum[intra][i] / 2) /
1152 (s->dct_error_sum[intra][i] + 1);
1153 }
1154 }
1155 }
1156
1157 /**
1158 * generic function for encode/decode called after coding/decoding
1159 * the header and before a frame is coded/decoded.
1160 */
1161 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1162 {
1163 int i;
1164 Picture *pic;
1165 s->mb_skipped = 0;
1166
1167 assert(s->last_picture_ptr == NULL || s->out_format != FMT_H264 ||
1168 s->codec_id == CODEC_ID_SVQ3);
1169
1170 /* mark & release old frames */
1171 if (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3) {
1172 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1173 s->last_picture_ptr != s->next_picture_ptr &&
1174 s->last_picture_ptr->f.data[0]) {
1175 if (s->last_picture_ptr->owner2 == s)
1176 free_frame_buffer(s, s->last_picture_ptr);
1177 }
1178
1179 /* release forgotten pictures */
1180 /* if (mpeg124/h263) */
1181 if (!s->encoding) {
1182 for (i = 0; i < s->picture_count; i++) {
1183 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1184 &s->picture[i] != s->last_picture_ptr &&
1185 &s->picture[i] != s->next_picture_ptr &&
1186 s->picture[i].f.reference) {
1187 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1188 av_log(avctx, AV_LOG_ERROR,
1189 "releasing zombie picture\n");
1190 free_frame_buffer(s, &s->picture[i]);
1191 }
1192 }
1193 }
1194 }
1195
1196 if (!s->encoding) {
1197 ff_release_unused_pictures(s, 1);
1198
1199 if (s->current_picture_ptr &&
1200 s->current_picture_ptr->f.data[0] == NULL) {
1201 // we already have a unused image
1202 // (maybe it was set before reading the header)
1203 pic = s->current_picture_ptr;
1204 } else {
1205 i = ff_find_unused_picture(s, 0);
1206 pic = &s->picture[i];
1207 }
1208
1209 pic->f.reference = 0;
1210 if (!s->dropable) {
1211 if (s->codec_id == CODEC_ID_H264)
1212 pic->f.reference = s->picture_structure;
1213 else if (s->pict_type != AV_PICTURE_TYPE_B)
1214 pic->f.reference = 3;
1215 }
1216
1217 pic->f.coded_picture_number = s->coded_picture_number++;
1218
1219 if (ff_alloc_picture(s, pic, 0) < 0)
1220 return -1;
1221
1222 s->current_picture_ptr = pic;
1223 // FIXME use only the vars from current_pic
1224 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1225 if (s->codec_id == CODEC_ID_MPEG1VIDEO ||
1226 s->codec_id == CODEC_ID_MPEG2VIDEO) {
1227 if (s->picture_structure != PICT_FRAME)
1228 s->current_picture_ptr->f.top_field_first =
1229 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1230 }
1231 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1232 !s->progressive_sequence;
1233 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1234 }
1235
1236 s->current_picture_ptr->f.pict_type = s->pict_type;
1237 // if (s->flags && CODEC_FLAG_QSCALE)
1238 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1239 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1240
1241 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1242
1243 if (s->pict_type != AV_PICTURE_TYPE_B) {
1244 s->last_picture_ptr = s->next_picture_ptr;
1245 if (!s->dropable)
1246 s->next_picture_ptr = s->current_picture_ptr;
1247 }
1248 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1249 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1250 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1251 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1252 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1253 s->pict_type, s->dropable); */
1254
1255 if (s->codec_id != CODEC_ID_H264) {
1256 if ((s->last_picture_ptr == NULL ||
1257 s->last_picture_ptr->f.data[0] == NULL) &&
1258 (s->pict_type != AV_PICTURE_TYPE_I ||
1259 s->picture_structure != PICT_FRAME)) {
1260 if (s->pict_type != AV_PICTURE_TYPE_I)
1261 av_log(avctx, AV_LOG_ERROR,
1262 "warning: first frame is no keyframe\n");
1263 else if (s->picture_structure != PICT_FRAME)
1264 av_log(avctx, AV_LOG_INFO,
1265 "allocate dummy last picture for field based first keyframe\n");
1266
1267 /* Allocate a dummy frame */
1268 i = ff_find_unused_picture(s, 0);
1269 s->last_picture_ptr = &s->picture[i];
1270 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1271 s->last_picture_ptr = NULL;
1272 return -1;
1273 }
1274 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1275 ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1276 s->last_picture_ptr->f.reference = 3;
1277 }
1278 if ((s->next_picture_ptr == NULL ||
1279 s->next_picture_ptr->f.data[0] == NULL) &&
1280 s->pict_type == AV_PICTURE_TYPE_B) {
1281 /* Allocate a dummy frame */
1282 i = ff_find_unused_picture(s, 0);
1283 s->next_picture_ptr = &s->picture[i];
1284 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1285 s->next_picture_ptr = NULL;
1286 return -1;
1287 }
1288 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1289 ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1290 s->next_picture_ptr->f.reference = 3;
1291 }
1292 }
1293
1294 if (s->last_picture_ptr)
1295 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1296 if (s->next_picture_ptr)
1297 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1298
1299 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1300 (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3)) {
1301 if (s->next_picture_ptr)
1302 s->next_picture_ptr->owner2 = s;
1303 if (s->last_picture_ptr)
1304 s->last_picture_ptr->owner2 = s;
1305 }
1306
1307 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1308 s->last_picture_ptr->f.data[0]));
1309
1310 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1311 int i;
1312 for (i = 0; i < 4; i++) {
1313 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1314 s->current_picture.f.data[i] +=
1315 s->current_picture.f.linesize[i];
1316 }
1317 s->current_picture.f.linesize[i] *= 2;
1318 s->last_picture.f.linesize[i] *= 2;
1319 s->next_picture.f.linesize[i] *= 2;
1320 }
1321 }
1322
1323 s->err_recognition = avctx->err_recognition;
1324
1325 /* set dequantizer, we can't do it during init as
1326 * it might change for mpeg4 and we can't do it in the header
1327 * decode as init is not called for mpeg4 there yet */
1328 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1329 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1330 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1331 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1332 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1333 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1334 } else {
1335 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1336 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1337 }
1338
1339 if (s->dct_error_sum) {
1340 assert(s->avctx->noise_reduction && s->encoding);
1341 update_noise_reduction(s);
1342 }
1343
1344 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1345 return ff_xvmc_field_start(s, avctx);
1346
1347 return 0;
1348 }
1349
1350 /* generic function for encode/decode called after a
1351 * frame has been coded/decoded. */
1352 void ff_MPV_frame_end(MpegEncContext *s)
1353 {
1354 int i;
1355 /* redraw edges for the frame if decoding didn't complete */
1356 // just to make sure that all data is rendered.
1357 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1358 ff_xvmc_field_end(s);
1359 } else if ((s->error_count || s->encoding) &&
1360 !s->avctx->hwaccel &&
1361 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1362 s->unrestricted_mv &&
1363 s->current_picture.f.reference &&
1364 !s->intra_only &&
1365 !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1366 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1367 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1368 s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1369 s->h_edge_pos, s->v_edge_pos,
1370 EDGE_WIDTH, EDGE_WIDTH,
1371 EDGE_TOP | EDGE_BOTTOM);
1372 s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1373 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1374 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1375 EDGE_TOP | EDGE_BOTTOM);
1376 s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1377 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1378 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1379 EDGE_TOP | EDGE_BOTTOM);
1380 }
1381
1382 emms_c();
1383
1384 s->last_pict_type = s->pict_type;
1385 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1386 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1387 s->last_non_b_pict_type = s->pict_type;
1388 }
1389 #if 0
1390 /* copy back current_picture variables */
1391 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1392 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1393 s->picture[i] = s->current_picture;
1394 break;
1395 }
1396 }
1397 assert(i < MAX_PICTURE_COUNT);
1398 #endif
1399
1400 if (s->encoding) {
1401 /* release non-reference frames */
1402 for (i = 0; i < s->picture_count; i++) {
1403 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1404 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1405 free_frame_buffer(s, &s->picture[i]);
1406 }
1407 }
1408 }
1409 // clear copies, to avoid confusion
1410 #if 0
1411 memset(&s->last_picture, 0, sizeof(Picture));
1412 memset(&s->next_picture, 0, sizeof(Picture));
1413 memset(&s->current_picture, 0, sizeof(Picture));
1414 #endif
1415 s->avctx->coded_frame = &s->current_picture_ptr->f;
1416
1417 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1418 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1419 }
1420 }
1421
1422 /**
1423 * Draw a line from (ex, ey) -> (sx, sy).
1424 * @param w width of the image
1425 * @param h height of the image
1426 * @param stride stride/linesize of the image
1427 * @param color color of the arrow
1428 */
1429 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1430 int w, int h, int stride, int color)
1431 {
1432 int x, y, fr, f;
1433
1434 sx = av_clip(sx, 0, w - 1);
1435 sy = av_clip(sy, 0, h - 1);
1436 ex = av_clip(ex, 0, w - 1);
1437 ey = av_clip(ey, 0, h - 1);
1438
1439 buf[sy * stride + sx] += color;
1440
1441 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1442 if (sx > ex) {
1443 FFSWAP(int, sx, ex);
1444 FFSWAP(int, sy, ey);
1445 }
1446 buf += sx + sy * stride;
1447 ex -= sx;
1448 f = ((ey - sy) << 16) / ex;
1449 for (x = 0; x = ex; x++) {
1450 y = (x * f) >> 16;
1451 fr = (x * f) & 0xFFFF;
1452 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1453 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1454 }
1455 } else {
1456 if (sy > ey) {
1457 FFSWAP(int, sx, ex);
1458 FFSWAP(int, sy, ey);
1459 }
1460 buf += sx + sy * stride;
1461 ey -= sy;
1462 if (ey)
1463 f = ((ex - sx) << 16) / ey;
1464 else
1465 f = 0;
1466 for (y = 0; y = ey; y++) {
1467 x = (y * f) >> 16;
1468 fr = (y * f) & 0xFFFF;
1469 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1470 buf[y * stride + x + 1] += (color * fr ) >> 16;
1471 }
1472 }
1473 }
1474
1475 /**
1476 * Draw an arrow from (ex, ey) -> (sx, sy).
1477 * @param w width of the image
1478 * @param h height of the image
1479 * @param stride stride/linesize of the image
1480 * @param color color of the arrow
1481 */
1482 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1483 int ey, int w, int h, int stride, int color)
1484 {
1485 int dx,dy;
1486
1487 sx = av_clip(sx, -100, w + 100);
1488 sy = av_clip(sy, -100, h + 100);
1489 ex = av_clip(ex, -100, w + 100);
1490 ey = av_clip(ey, -100, h + 100);
1491
1492 dx = ex - sx;
1493 dy = ey - sy;
1494
1495 if (dx * dx + dy * dy > 3 * 3) {
1496 int rx = dx + dy;
1497 int ry = -dx + dy;
1498 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1499
1500 // FIXME subpixel accuracy
1501 rx = ROUNDED_DIV(rx * 3 << 4, length);
1502 ry = ROUNDED_DIV(ry * 3 << 4, length);
1503
1504 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1505 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1506 }
1507 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1508 }
1509
1510 /**
1511 * Print debugging info for the given picture.
1512 */
1513 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1514 {
1515 if (s->avctx->hwaccel || !pict || !pict->mb_type)
1516 return;
1517
1518 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1519 int x,y;
1520
1521 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1522 switch (pict->pict_type) {
1523 case AV_PICTURE_TYPE_I:
1524 av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1525 break;
1526 case AV_PICTURE_TYPE_P:
1527 av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1528 break;
1529 case AV_PICTURE_TYPE_B:
1530 av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1531 break;
1532 case AV_PICTURE_TYPE_S:
1533 av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1534 break;
1535 case AV_PICTURE_TYPE_SI:
1536 av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1537 break;
1538 case AV_PICTURE_TYPE_SP:
1539 av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1540 break;
1541 }
1542 for (y = 0; y < s->mb_height; y++) {
1543 for (x = 0; x < s->mb_width; x++) {
1544 if (s->avctx->debug & FF_DEBUG_SKIP) {
1545 int count = s->mbskip_table[x + y * s->mb_stride];
1546 if (count > 9)
1547 count = 9;
1548 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1549 }
1550 if (s->avctx->debug & FF_DEBUG_QP) {
1551 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1552 pict->qscale_table[x + y * s->mb_stride]);
1553 }
1554 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1555 int mb_type = pict->mb_type[x + y * s->mb_stride];
1556 // Type & MV direction
1557 if (IS_PCM(mb_type))
1558 av_log(s->avctx, AV_LOG_DEBUG, "P");
1559 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1560 av_log(s->avctx, AV_LOG_DEBUG, "A");
1561 else if (IS_INTRA4x4(mb_type))
1562 av_log(s->avctx, AV_LOG_DEBUG, "i");
1563 else if (IS_INTRA16x16(mb_type))
1564 av_log(s->avctx, AV_LOG_DEBUG, "I");
1565 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1566 av_log(s->avctx, AV_LOG_DEBUG, "d");
1567 else if (IS_DIRECT(mb_type))
1568 av_log(s->avctx, AV_LOG_DEBUG, "D");
1569 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1570 av_log(s->avctx, AV_LOG_DEBUG, "g");
1571 else if (IS_GMC(mb_type))
1572 av_log(s->avctx, AV_LOG_DEBUG, "G");
1573 else if (IS_SKIP(mb_type))
1574 av_log(s->avctx, AV_LOG_DEBUG, "S");
1575 else if (!USES_LIST(mb_type, 1))
1576 av_log(s->avctx, AV_LOG_DEBUG, ">");
1577 else if (!USES_LIST(mb_type, 0))
1578 av_log(s->avctx, AV_LOG_DEBUG, "<");
1579 else {
1580 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1581 av_log(s->avctx, AV_LOG_DEBUG, "X");
1582 }
1583
1584 // segmentation
1585 if (IS_8X8(mb_type))
1586 av_log(s->avctx, AV_LOG_DEBUG, "+");
1587 else if (IS_16X8(mb_type))
1588 av_log(s->avctx, AV_LOG_DEBUG, "-");
1589 else if (IS_8X16(mb_type))
1590 av_log(s->avctx, AV_LOG_DEBUG, "|");
1591 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1592 av_log(s->avctx, AV_LOG_DEBUG, " ");
1593 else
1594 av_log(s->avctx, AV_LOG_DEBUG, "?");
1595
1596
1597 if (IS_INTERLACED(mb_type))
1598 av_log(s->avctx, AV_LOG_DEBUG, "=");
1599 else
1600 av_log(s->avctx, AV_LOG_DEBUG, " ");
1601 }
1602 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1603 }
1604 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1605 }
1606 }
1607
1608 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1609 (s->avctx->debug_mv)) {
1610 const int shift = 1 + s->quarter_sample;
1611 int mb_y;
1612 uint8_t *ptr;
1613 int i;
1614 int h_chroma_shift, v_chroma_shift, block_height;
1615 const int width = s->avctx->width;
1616 const int height = s->avctx->height;
1617 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1618 const int mv_stride = (s->mb_width << mv_sample_log2) +
1619 (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1620 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1621
1622 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1623 &h_chroma_shift, &v_chroma_shift);
1624 for (i = 0; i < 3; i++) {
1625 memcpy(s->visualization_buffer[i], pict->data[i],
1626 (i == 0) ? pict->linesize[i] * height:
1627 pict->linesize[i] * height >> v_chroma_shift);
1628 pict->data[i] = s->visualization_buffer[i];
1629 }
1630 pict->type = FF_BUFFER_TYPE_COPY;
1631 ptr = pict->data[0];
1632 block_height = 16 >> v_chroma_shift;
1633
1634 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1635 int mb_x;
1636 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1637 const int mb_index = mb_x + mb_y * s->mb_stride;
1638 if ((s->avctx->debug_mv) && pict->motion_val) {
1639 int type;
1640 for (type = 0; type < 3; type++) {
1641 int direction = 0;
1642 switch (type) {
1643 case 0:
1644 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1645 (pict->pict_type!= AV_PICTURE_TYPE_P))
1646 continue;
1647 direction = 0;
1648 break;
1649 case 1:
1650 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1651 (pict->pict_type!= AV_PICTURE_TYPE_B))
1652 continue;
1653 direction = 0;
1654 break;
1655 case 2:
1656 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1657 (pict->pict_type!= AV_PICTURE_TYPE_B))
1658 continue;
1659 direction = 1;
1660 break;
1661 }
1662 if (!USES_LIST(pict->mb_type[mb_index], direction))
1663 continue;
1664
1665 if (IS_8X8(pict->mb_type[mb_index])) {
1666 int i;
1667 for (i = 0; i < 4; i++) {
1668 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1669 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1670 int xy = (mb_x * 2 + (i & 1) +
1671 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1672 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1673 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1674 draw_arrow(ptr, sx, sy, mx, my, width,
1675 height, s->linesize, 100);
1676 }
1677 } else if (IS_16X8(pict->mb_type[mb_index])) {
1678 int i;
1679 for (i = 0; i < 2; i++) {
1680 int sx = mb_x * 16 + 8;
1681 int sy = mb_y * 16 + 4 + 8 * i;
1682 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1683 int mx = (pict->motion_val[direction][xy][0] >> shift);
1684 int my = (pict->motion_val[direction][xy][1] >> shift);
1685
1686 if (IS_INTERLACED(pict->mb_type[mb_index]))
1687 my *= 2;
1688
1689 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1690 height, s->linesize, 100);
1691 }
1692 } else if (IS_8X16(pict->mb_type[mb_index])) {
1693 int i;
1694 for (i = 0; i < 2; i++) {
1695 int sx = mb_x * 16 + 4 + 8 * i;
1696 int sy = mb_y * 16 + 8;
1697 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1698 int mx = pict->motion_val[direction][xy][0] >> shift;
1699 int my = pict->motion_val[direction][xy][1] >> shift;
1700
1701 if (IS_INTERLACED(pict->mb_type[mb_index]))
1702 my *= 2;
1703
1704 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1705 height, s->linesize, 100);
1706 }
1707 } else {
1708 int sx = mb_x * 16 + 8;
1709 int sy = mb_y * 16 + 8;
1710 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1711 int mx = pict->motion_val[direction][xy][0] >> shift + sx;
1712 int my = pict->motion_val[direction][xy][1] >> shift + sy;
1713 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1714 }
1715 }
1716 }
1717 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1718 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1719 0x0101010101010101ULL;
1720 int y;
1721 for (y = 0; y < block_height; y++) {
1722 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1723 (block_height * mb_y + y) *
1724 pict->linesize[1]) = c;
1725 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1726 (block_height * mb_y + y) *
1727 pict->linesize[2]) = c;
1728 }
1729 }
1730 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1731 pict->motion_val) {
1732 int mb_type = pict->mb_type[mb_index];
1733 uint64_t u,v;
1734 int y;
1735 #define COLOR(theta, r) \
1736 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1737 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1738
1739
1740 u = v = 128;
1741 if (IS_PCM(mb_type)) {
1742 COLOR(120, 48)
1743 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1744 IS_INTRA16x16(mb_type)) {
1745 COLOR(30, 48)
1746 } else if (IS_INTRA4x4(mb_type)) {
1747 COLOR(90, 48)
1748 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1749 // COLOR(120, 48)
1750 } else if (IS_DIRECT(mb_type)) {
1751 COLOR(150, 48)
1752 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1753 COLOR(170, 48)
1754 } else if (IS_GMC(mb_type)) {
1755 COLOR(190, 48)
1756 } else if (IS_SKIP(mb_type)) {
1757 // COLOR(180, 48)
1758 } else if (!USES_LIST(mb_type, 1)) {
1759 COLOR(240, 48)
1760 } else if (!USES_LIST(mb_type, 0)) {
1761 COLOR(0, 48)
1762 } else {
1763 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1764 COLOR(300,48)
1765 }
1766
1767 u *= 0x0101010101010101ULL;
1768 v *= 0x0101010101010101ULL;
1769 for (y = 0; y < block_height; y++) {
1770 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1771 (block_height * mb_y + y) * pict->linesize[1]) = u;
1772 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1773 (block_height * mb_y + y) * pict->linesize[2]) = v;
1774 }
1775
1776 // segmentation
1777 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1778 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1779 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1780 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1781 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1782 }
1783 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1784 for (y = 0; y < 16; y++)
1785 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1786 pict->linesize[0]] ^= 0x80;
1787 }
1788 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1789 int dm = 1 << (mv_sample_log2 - 2);
1790 for (i = 0; i < 4; i++) {
1791 int sx = mb_x * 16 + 8 * (i & 1);
1792 int sy = mb_y * 16 + 8 * (i >> 1);
1793 int xy = (mb_x * 2 + (i & 1) +
1794 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1795 // FIXME bidir
1796 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1797 if (mv[0] != mv[dm] ||
1798 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1799 for (y = 0; y < 8; y++)
1800 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1801 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1802 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1803 pict->linesize[0]) ^= 0x8080808080808080ULL;
1804 }
1805 }
1806
1807 if (IS_INTERLACED(mb_type) &&
1808 s->codec_id == CODEC_ID_H264) {
1809 // hmm
1810 }
1811 }
1812 s->mbskip_table[mb_index] = 0;
1813 }
1814 }
1815 }
1816 }
1817
1818 /**
1819 * find the lowest MB row referenced in the MVs
1820 */
1821 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1822 {
1823 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1824 int my, off, i, mvs;
1825
1826 if (s->picture_structure != PICT_FRAME) goto unhandled;
1827
1828 switch (s->mv_type) {
1829 case MV_TYPE_16X16:
1830 mvs = 1;
1831 break;
1832 case MV_TYPE_16X8:
1833 mvs = 2;
1834 break;
1835 case MV_TYPE_8X8:
1836 mvs = 4;
1837 break;
1838 default:
1839 goto unhandled;
1840 }
1841
1842 for (i = 0; i < mvs; i++) {
1843 my = s->mv[dir][i][1]<<qpel_shift;
1844 my_max = FFMAX(my_max, my);
1845 my_min = FFMIN(my_min, my);
1846 }
1847
1848 off = (FFMAX(-my_min, my_max) + 63) >> 6;
1849
1850 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1851 unhandled:
1852 return s->mb_height-1;
1853 }
1854
1855 /* put block[] to dest[] */
1856 static inline void put_dct(MpegEncContext *s,
1857 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1858 {
1859 s->dct_unquantize_intra(s, block, i, qscale);
1860 s->dsp.idct_put (dest, line_size, block);
1861 }
1862
1863 /* add block[] to dest[] */
1864 static inline void add_dct(MpegEncContext *s,
1865 DCTELEM *block, int i, uint8_t *dest, int line_size)
1866 {
1867 if (s->block_last_index[i] >= 0) {
1868 s->dsp.idct_add (dest, line_size, block);
1869 }
1870 }
1871
1872 static inline void add_dequant_dct(MpegEncContext *s,
1873 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1874 {
1875 if (s->block_last_index[i] >= 0) {
1876 s->dct_unquantize_inter(s, block, i, qscale);
1877
1878 s->dsp.idct_add (dest, line_size, block);
1879 }
1880 }
1881
1882 /**
1883 * Clean dc, ac, coded_block for the current non-intra MB.
1884 */
1885 void ff_clean_intra_table_entries(MpegEncContext *s)
1886 {
1887 int wrap = s->b8_stride;
1888 int xy = s->block_index[0];
1889
1890 s->dc_val[0][xy ] =
1891 s->dc_val[0][xy + 1 ] =
1892 s->dc_val[0][xy + wrap] =
1893 s->dc_val[0][xy + 1 + wrap] = 1024;
1894 /* ac pred */
1895 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1896 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1897 if (s->msmpeg4_version>=3) {
1898 s->coded_block[xy ] =
1899 s->coded_block[xy + 1 ] =
1900 s->coded_block[xy + wrap] =
1901 s->coded_block[xy + 1 + wrap] = 0;
1902 }
1903 /* chroma */
1904 wrap = s->mb_stride;
1905 xy = s->mb_x + s->mb_y * wrap;
1906 s->dc_val[1][xy] =
1907 s->dc_val[2][xy] = 1024;
1908 /* ac pred */
1909 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1910 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1911
1912 s->mbintra_table[xy]= 0;
1913 }
1914
1915 /* generic function called after a macroblock has been parsed by the
1916 decoder or after it has been encoded by the encoder.
1917
1918 Important variables used:
1919 s->mb_intra : true if intra macroblock
1920 s->mv_dir : motion vector direction
1921 s->mv_type : motion vector type
1922 s->mv : motion vector
1923 s->interlaced_dct : true if interlaced dct used (mpeg2)
1924 */
1925 static av_always_inline
1926 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1927 int is_mpeg12)
1928 {
1929 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1930 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1931 ff_xvmc_decode_mb(s);//xvmc uses pblocks
1932 return;
1933 }
1934
1935 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1936 /* save DCT coefficients */
1937 int i,j;
1938 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
1939 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1940 for(i=0; i<6; i++){
1941 for(j=0; j<64; j++){
1942 *dct++ = block[i][s->dsp.idct_permutation[j]];
1943 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
1944 }
1945 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1946 }
1947 }
1948
1949 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
1950
1951 /* update DC predictors for P macroblocks */
1952 if (!s->mb_intra) {
1953 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1954 if(s->mbintra_table[mb_xy])
1955 ff_clean_intra_table_entries(s);
1956 } else {
1957 s->last_dc[0] =
1958 s->last_dc[1] =
1959 s->last_dc[2] = 128 << s->intra_dc_precision;
1960 }
1961 }
1962 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1963 s->mbintra_table[mb_xy]=1;
1964
1965 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
1966 uint8_t *dest_y, *dest_cb, *dest_cr;
1967 int dct_linesize, dct_offset;
1968 op_pixels_func (*op_pix)[4];
1969 qpel_mc_func (*op_qpix)[16];
1970 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
1971 const int uvlinesize = s->current_picture.f.linesize[1];
1972 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
1973 const int block_size = 8;
1974
1975 /* avoid copy if macroblock skipped in last frame too */
1976 /* skip only during decoding as we might trash the buffers during encoding a bit */
1977 if(!s->encoding){
1978 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1979
1980 if (s->mb_skipped) {
1981 s->mb_skipped= 0;
1982 assert(s->pict_type!=AV_PICTURE_TYPE_I);
1983 *mbskip_ptr = 1;
1984 } else if(!s->current_picture.f.reference) {
1985 *mbskip_ptr = 1;
1986 } else{
1987 *mbskip_ptr = 0; /* not skipped */
1988 }
1989 }
1990
1991 dct_linesize = linesize << s->interlaced_dct;
1992 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
1993
1994 if(readable){
1995 dest_y= s->dest[0];
1996 dest_cb= s->dest[1];
1997 dest_cr= s->dest[2];
1998 }else{
1999 dest_y = s->b_scratchpad;
2000 dest_cb= s->b_scratchpad+16*linesize;
2001 dest_cr= s->b_scratchpad+32*linesize;
2002 }
2003
2004 if (!s->mb_intra) {
2005 /* motion handling */
2006 /* decoding or more than one mb_type (MC was already done otherwise) */
2007 if(!s->encoding){
2008
2009 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2010 if (s->mv_dir & MV_DIR_FORWARD) {
2011 ff_thread_await_progress(&s->last_picture_ptr->f,
2012 ff_MPV_lowest_referenced_row(s, 0),
2013 0);
2014 }
2015 if (s->mv_dir & MV_DIR_BACKWARD) {
2016 ff_thread_await_progress(&s->next_picture_ptr->f,
2017 ff_MPV_lowest_referenced_row(s, 1),
2018 0);
2019 }
2020 }
2021
2022 op_qpix= s->me.qpel_put;
2023 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2024 op_pix = s->dsp.put_pixels_tab;
2025 }else{
2026 op_pix = s->dsp.put_no_rnd_pixels_tab;
2027 }
2028 if (s->mv_dir & MV_DIR_FORWARD) {
2029 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2030 op_pix = s->dsp.avg_pixels_tab;
2031 op_qpix= s->me.qpel_avg;
2032 }
2033 if (s->mv_dir & MV_DIR_BACKWARD) {
2034 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2035 }
2036 }
2037
2038 /* skip dequant / idct if we are really late ;) */
2039 if(s->avctx->skip_idct){
2040 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2041 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2042 || s->avctx->skip_idct >= AVDISCARD_ALL)
2043 goto skip_idct;
2044 }
2045
2046 /* add dct residue */
2047 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2048 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2049 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2050 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2051 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2052 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2053
2054 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2055 if (s->chroma_y_shift){
2056 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2057 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2058 }else{
2059 dct_linesize >>= 1;
2060 dct_offset >>=1;
2061 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2062 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2063 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2064 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2065 }
2066 }
2067 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2068 add_dct(s, block[0], 0, dest_y , dct_linesize);
2069 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2070 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2071 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2072
2073 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2074 if(s->chroma_y_shift){//Chroma420
2075 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2076 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2077 }else{
2078 //chroma422
2079 dct_linesize = uvlinesize << s->interlaced_dct;
2080 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2081
2082 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2083 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2084 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2085 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2086 if(!s->chroma_x_shift){//Chroma444
2087 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2088 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2089 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2090 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2091 }
2092 }
2093 }//fi gray
2094 }
2095 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2096 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2097 }
2098 } else {
2099 /* dct only in intra block */
2100 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2101 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2102 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2103 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2104 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2105
2106 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2107 if(s->chroma_y_shift){
2108 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2109 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2110 }else{
2111 dct_offset >>=1;
2112 dct_linesize >>=1;
2113 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2114 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2115 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2116 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2117 }
2118 }
2119 }else{
2120 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2121 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2122 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2123 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2124
2125 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2126 if(s->chroma_y_shift){
2127 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2128 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2129 }else{
2130
2131 dct_linesize = uvlinesize << s->interlaced_dct;
2132 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2133
2134 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2135 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2136 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2137 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2138 if(!s->chroma_x_shift){//Chroma444
2139 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2140 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2141 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2142 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2143 }
2144 }
2145 }//gray
2146 }
2147 }
2148 skip_idct:
2149 if(!readable){
2150 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2151 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2152 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2153 }
2154 }
2155 }
2156
2157 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2158 #if !CONFIG_SMALL
2159 if(s->out_format == FMT_MPEG1) {
2160 MPV_decode_mb_internal(s, block, 1);
2161 } else
2162 #endif
2163 MPV_decode_mb_internal(s, block, 0);
2164 }
2165
2166 /**
2167 * @param h is the normal height, this will be reduced automatically if needed for the last row
2168 */
2169 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2170 const int field_pic= s->picture_structure != PICT_FRAME;
2171 if(field_pic){
2172 h <<= 1;
2173 y <<= 1;
2174 }
2175
2176 if (!s->avctx->hwaccel
2177 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2178 && s->unrestricted_mv
2179 && s->current_picture.f.reference
2180 && !s->intra_only
2181 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2182 int sides = 0, edge_h;
2183 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2184 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2185 if (y==0) sides |= EDGE_TOP;
2186 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2187
2188 edge_h= FFMIN(h, s->v_edge_pos - y);
2189
2190 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2191 s->linesize, s->h_edge_pos, edge_h,
2192 EDGE_WIDTH, EDGE_WIDTH, sides);
2193 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2194 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2195 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2196 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2197 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2198 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2199 }
2200
2201 h= FFMIN(h, s->avctx->height - y);
2202
2203 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2204
2205 if (s->avctx->draw_horiz_band) {
2206 AVFrame *src;
2207 int offset[AV_NUM_DATA_POINTERS];
2208 int i;
2209
2210 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2211 src = &s->current_picture_ptr->f;
2212 else if(s->last_picture_ptr)
2213 src = &s->last_picture_ptr->f;
2214 else
2215 return;
2216
2217 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2218 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2219 offset[i] = 0;
2220 }else{
2221 offset[0]= y * s->linesize;
2222 offset[1]=
2223 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2224 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2225 offset[i] = 0;
2226 }
2227
2228 emms_c();
2229
2230 s->avctx->draw_horiz_band(s->avctx, src, offset,
2231 y, s->picture_structure, h);
2232 }
2233 }
2234
2235 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2236 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2237 const int uvlinesize = s->current_picture.f.linesize[1];
2238 const int mb_size= 4;
2239
2240 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2241 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2242 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2243 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2244 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2245 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;
2246 //block_index is not used by mpeg2, so it is not affected by chroma_format
2247
2248 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2249 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2250 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2251
2252 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2253 {
2254 if(s->picture_structure==PICT_FRAME){
2255 s->dest[0] += s->mb_y * linesize << mb_size;
2256 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2257 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2258 }else{
2259 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2260 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2261 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2262 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2263 }
2264 }
2265 }
2266
2267 void ff_mpeg_flush(AVCodecContext *avctx){
2268 int i;
2269 MpegEncContext *s = avctx->priv_data;
2270
2271 if(s==NULL || s->picture==NULL)
2272 return;
2273
2274 for(i=0; i<s->picture_count; i++){
2275 if (s->picture[i].f.data[0] &&
2276 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2277 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2278 free_frame_buffer(s, &s->picture[i]);
2279 }
2280 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2281
2282 s->mb_x= s->mb_y= 0;
2283
2284 s->parse_context.state= -1;
2285 s->parse_context.frame_start_found= 0;
2286 s->parse_context.overread= 0;
2287 s->parse_context.overread_index= 0;
2288 s->parse_context.index= 0;
2289 s->parse_context.last_index= 0;
2290 s->bitstream_buffer_size=0;
2291 s->pp_time=0;
2292 }
2293
2294 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2295 DCTELEM *block, int n, int qscale)
2296 {
2297 int i, level, nCoeffs;
2298 const uint16_t *quant_matrix;
2299
2300 nCoeffs= s->block_last_index[n];
2301
2302 if (n < 4)
2303 block[0] = block[0] * s->y_dc_scale;
2304 else
2305 block[0] = block[0] * s->c_dc_scale;
2306 /* XXX: only mpeg1 */
2307 quant_matrix = s->intra_matrix;
2308 for(i=1;i<=nCoeffs;i++) {
2309 int j= s->intra_scantable.permutated[i];
2310 level = block[j];
2311 if (level) {
2312 if (level < 0) {
2313 level = -level;
2314 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2315 level = (level - 1) | 1;
2316 level = -level;
2317 } else {
2318 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2319 level = (level - 1) | 1;
2320 }
2321 block[j] = level;
2322 }
2323 }
2324 }
2325
2326 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2327 DCTELEM *block, int n, int qscale)
2328 {
2329 int i, level, nCoeffs;
2330 const uint16_t *quant_matrix;
2331
2332 nCoeffs= s->block_last_index[n];
2333
2334 quant_matrix = s->inter_matrix;
2335 for(i=0; i<=nCoeffs; i++) {
2336 int j= s->intra_scantable.permutated[i];
2337 level = block[j];
2338 if (level) {
2339 if (level < 0) {
2340 level = -level;
2341 level = (((level << 1) + 1) * qscale *
2342 ((int) (quant_matrix[j]))) >> 4;
2343 level = (level - 1) | 1;
2344 level = -level;
2345 } else {
2346 level = (((level << 1) + 1) * qscale *
2347 ((int) (quant_matrix[j]))) >> 4;
2348 level = (level - 1) | 1;
2349 }
2350 block[j] = level;
2351 }
2352 }
2353 }
2354
2355 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2356 DCTELEM *block, int n, int qscale)
2357 {
2358 int i, level, nCoeffs;
2359 const uint16_t *quant_matrix;
2360
2361 if(s->alternate_scan) nCoeffs= 63;
2362 else nCoeffs= s->block_last_index[n];
2363
2364 if (n < 4)
2365 block[0] = block[0] * s->y_dc_scale;
2366 else
2367 block[0] = block[0] * s->c_dc_scale;
2368 quant_matrix = s->intra_matrix;
2369 for(i=1;i<=nCoeffs;i++) {
2370 int j= s->intra_scantable.permutated[i];
2371 level = block[j];
2372 if (level) {
2373 if (level < 0) {
2374 level = -level;
2375 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2376 level = -level;
2377 } else {
2378 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2379 }
2380 block[j] = level;
2381 }
2382 }
2383 }
2384
2385 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2386 DCTELEM *block, int n, int qscale)
2387 {
2388 int i, level, nCoeffs;
2389 const uint16_t *quant_matrix;
2390 int sum=-1;
2391
2392 if(s->alternate_scan) nCoeffs= 63;
2393 else nCoeffs= s->block_last_index[n];
2394
2395 if (n < 4)
2396 block[0] = block[0] * s->y_dc_scale;
2397 else
2398 block[0] = block[0] * s->c_dc_scale;
2399 quant_matrix = s->intra_matrix;
2400 for(i=1;i<=nCoeffs;i++) {
2401 int j= s->intra_scantable.permutated[i];
2402 level = block[j];
2403 if (level) {
2404 if (level < 0) {
2405 level = -level;
2406 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2407 level = -level;
2408 } else {
2409 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2410 }
2411 block[j] = level;
2412 sum+=level;
2413 }
2414 }
2415 block[63]^=sum&1;
2416 }
2417
2418 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2419 DCTELEM *block, int n, int qscale)
2420 {
2421 int i, level, nCoeffs;
2422 const uint16_t *quant_matrix;
2423 int sum=-1;
2424
2425 if(s->alternate_scan) nCoeffs= 63;
2426 else nCoeffs= s->block_last_index[n];
2427
2428 quant_matrix = s->inter_matrix;
2429 for(i=0; i<=nCoeffs; i++) {
2430 int j= s->intra_scantable.permutated[i];
2431 level = block[j];
2432 if (level) {
2433 if (level < 0) {
2434 level = -level;
2435 level = (((level << 1) + 1) * qscale *
2436 ((int) (quant_matrix[j]))) >> 4;
2437 level = -level;
2438 } else {
2439 level = (((level << 1) + 1) * qscale *
2440 ((int) (quant_matrix[j]))) >> 4;
2441 }
2442 block[j] = level;
2443 sum+=level;
2444 }
2445 }
2446 block[63]^=sum&1;
2447 }
2448
2449 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2450 DCTELEM *block, int n, int qscale)
2451 {
2452 int i, level, qmul, qadd;
2453 int nCoeffs;
2454
2455 assert(s->block_last_index[n]>=0);
2456
2457 qmul = qscale << 1;
2458
2459 if (!s->h263_aic) {
2460 if (n < 4)
2461 block[0] = block[0] * s->y_dc_scale;
2462 else
2463 block[0] = block[0] * s->c_dc_scale;
2464 qadd = (qscale - 1) | 1;
2465 }else{
2466 qadd = 0;
2467 }
2468 if(s->ac_pred)
2469 nCoeffs=63;
2470 else
2471 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2472
2473 for(i=1; i<=nCoeffs; i++) {
2474 level = block[i];
2475 if (level) {
2476 if (level < 0) {
2477 level = level * qmul - qadd;
2478 } else {
2479 level = level * qmul + qadd;
2480 }
2481 block[i] = level;
2482 }
2483 }
2484 }
2485
2486 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2487 DCTELEM *block, int n, int qscale)
2488 {
2489 int i, level, qmul, qadd;
2490 int nCoeffs;
2491
2492 assert(s->block_last_index[n]>=0);
2493
2494 qadd = (qscale - 1) | 1;
2495 qmul = qscale << 1;
2496
2497 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2498
2499 for(i=0; i<=nCoeffs; i++) {
2500 level = block[i];
2501 if (level) {
2502 if (level < 0) {
2503 level = level * qmul - qadd;
2504 } else {
2505 level = level * qmul + qadd;
2506 }
2507 block[i] = level;
2508 }
2509 }
2510 }
2511
2512 /**
2513 * set qscale and update qscale dependent variables.
2514 */
2515 void ff_set_qscale(MpegEncContext * s, int qscale)
2516 {
2517 if (qscale < 1)
2518 qscale = 1;
2519 else if (qscale > 31)
2520 qscale = 31;
2521
2522 s->qscale = qscale;
2523 s->chroma_qscale= s->chroma_qscale_table[qscale];
2524
2525 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2526 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2527 }
2528
2529 void ff_MPV_report_decode_progress(MpegEncContext *s)
2530 {
2531 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2532 ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);
2533 }