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