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