6b3a6ee31a12b28bfd67be653580bf95d49cabac
[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 /**
1405  * generic function called after decoding
1406  * the header and before a frame is decoded.
1407  */
1408 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1409 {
1410     int i, ret;
1411     Picture *pic;
1412     s->mb_skipped = 0;
1413
1414     /* mark & release old frames */
1415     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1416         s->last_picture_ptr != s->next_picture_ptr &&
1417         s->last_picture_ptr->f.buf[0]) {
1418         ff_mpeg_unref_picture(s, s->last_picture_ptr);
1419     }
1420
1421     /* release forgotten pictures */
1422     /* if (mpeg124/h263) */
1423     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1424         if (&s->picture[i] != s->last_picture_ptr &&
1425             &s->picture[i] != s->next_picture_ptr &&
1426             s->picture[i].reference && !s->picture[i].needs_realloc) {
1427             if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1428                 av_log(avctx, AV_LOG_ERROR,
1429                        "releasing zombie picture\n");
1430             ff_mpeg_unref_picture(s, &s->picture[i]);
1431         }
1432     }
1433
1434     ff_mpeg_unref_picture(s, &s->current_picture);
1435
1436     release_unused_pictures(s);
1437
1438     if (s->current_picture_ptr &&
1439         s->current_picture_ptr->f.buf[0] == NULL) {
1440         // we already have a unused image
1441         // (maybe it was set before reading the header)
1442         pic = s->current_picture_ptr;
1443     } else {
1444         i   = ff_find_unused_picture(s, 0);
1445         if (i < 0) {
1446             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1447             return i;
1448         }
1449         pic = &s->picture[i];
1450     }
1451
1452     pic->reference = 0;
1453     if (!s->droppable) {
1454         if (s->pict_type != AV_PICTURE_TYPE_B)
1455             pic->reference = 3;
1456     }
1457
1458     pic->f.coded_picture_number = s->coded_picture_number++;
1459
1460     if (ff_alloc_picture(s, pic, 0) < 0)
1461         return -1;
1462
1463     s->current_picture_ptr = pic;
1464     // FIXME use only the vars from current_pic
1465     s->current_picture_ptr->f.top_field_first = s->top_field_first;
1466     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1467         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1468         if (s->picture_structure != PICT_FRAME)
1469             s->current_picture_ptr->f.top_field_first =
1470                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1471     }
1472     s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1473                                                  !s->progressive_sequence;
1474     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1475
1476     s->current_picture_ptr->f.pict_type = s->pict_type;
1477     // if (s->flags && CODEC_FLAG_QSCALE)
1478     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1479     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1480
1481     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1482                                    s->current_picture_ptr)) < 0)
1483         return ret;
1484
1485     if (s->pict_type != AV_PICTURE_TYPE_B) {
1486         s->last_picture_ptr = s->next_picture_ptr;
1487         if (!s->droppable)
1488             s->next_picture_ptr = s->current_picture_ptr;
1489     }
1490     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1491             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1492             s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1493             s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1494             s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1495             s->pict_type, s->droppable);
1496
1497     if ((s->last_picture_ptr == NULL ||
1498          s->last_picture_ptr->f.buf[0] == NULL) &&
1499         (s->pict_type != AV_PICTURE_TYPE_I ||
1500          s->picture_structure != PICT_FRAME)) {
1501         int h_chroma_shift, v_chroma_shift;
1502         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1503                                          &h_chroma_shift, &v_chroma_shift);
1504         if (s->pict_type != AV_PICTURE_TYPE_I)
1505             av_log(avctx, AV_LOG_ERROR,
1506                    "warning: first frame is no keyframe\n");
1507         else if (s->picture_structure != PICT_FRAME)
1508             av_log(avctx, AV_LOG_INFO,
1509                    "allocate dummy last picture for field based first keyframe\n");
1510
1511         /* Allocate a dummy frame */
1512         i = ff_find_unused_picture(s, 0);
1513         if (i < 0) {
1514             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1515             return i;
1516         }
1517         s->last_picture_ptr = &s->picture[i];
1518
1519         s->last_picture_ptr->reference   = 3;
1520         s->last_picture_ptr->f.pict_type = AV_PICTURE_TYPE_I;
1521
1522         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1523             s->last_picture_ptr = NULL;
1524             return -1;
1525         }
1526
1527         memset(s->last_picture_ptr->f.data[0], 0,
1528                avctx->height * s->last_picture_ptr->f.linesize[0]);
1529         memset(s->last_picture_ptr->f.data[1], 0x80,
1530                (avctx->height >> v_chroma_shift) *
1531                s->last_picture_ptr->f.linesize[1]);
1532         memset(s->last_picture_ptr->f.data[2], 0x80,
1533                (avctx->height >> v_chroma_shift) *
1534                s->last_picture_ptr->f.linesize[2]);
1535
1536         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1537         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1538     }
1539     if ((s->next_picture_ptr == NULL ||
1540          s->next_picture_ptr->f.buf[0] == NULL) &&
1541         s->pict_type == AV_PICTURE_TYPE_B) {
1542         /* Allocate a dummy frame */
1543         i = ff_find_unused_picture(s, 0);
1544         if (i < 0) {
1545             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1546             return i;
1547         }
1548         s->next_picture_ptr = &s->picture[i];
1549
1550         s->next_picture_ptr->reference   = 3;
1551         s->next_picture_ptr->f.pict_type = AV_PICTURE_TYPE_I;
1552
1553         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1554             s->next_picture_ptr = NULL;
1555             return -1;
1556         }
1557         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1558         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1559     }
1560
1561     if (s->last_picture_ptr) {
1562         ff_mpeg_unref_picture(s, &s->last_picture);
1563         if (s->last_picture_ptr->f.buf[0] &&
1564             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1565                                        s->last_picture_ptr)) < 0)
1566             return ret;
1567     }
1568     if (s->next_picture_ptr) {
1569         ff_mpeg_unref_picture(s, &s->next_picture);
1570         if (s->next_picture_ptr->f.buf[0] &&
1571             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1572                                        s->next_picture_ptr)) < 0)
1573             return ret;
1574     }
1575
1576     if (s->pict_type != AV_PICTURE_TYPE_I &&
1577         !(s->last_picture_ptr && s->last_picture_ptr->f.buf[0])) {
1578         av_log(s, AV_LOG_ERROR,
1579                "Non-reference picture received and no reference available\n");
1580         return AVERROR_INVALIDDATA;
1581     }
1582
1583     if (s->picture_structure!= PICT_FRAME) {
1584         int i;
1585         for (i = 0; i < 4; i++) {
1586             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1587                 s->current_picture.f.data[i] +=
1588                     s->current_picture.f.linesize[i];
1589             }
1590             s->current_picture.f.linesize[i] *= 2;
1591             s->last_picture.f.linesize[i]    *= 2;
1592             s->next_picture.f.linesize[i]    *= 2;
1593         }
1594     }
1595
1596     s->err_recognition = avctx->err_recognition;
1597
1598     /* set dequantizer, we can't do it during init as
1599      * it might change for mpeg4 and we can't do it in the header
1600      * decode as init is not called for mpeg4 there yet */
1601     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1602         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1603         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1604     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1605         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1606         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1607     } else {
1608         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1609         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1610     }
1611
1612 #if FF_API_XVMC
1613 FF_DISABLE_DEPRECATION_WARNINGS
1614     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1615         return ff_xvmc_field_start(s, avctx);
1616 FF_ENABLE_DEPRECATION_WARNINGS
1617 #endif /* FF_API_XVMC */
1618
1619     return 0;
1620 }
1621
1622 /* called after a frame has been decoded. */
1623 void ff_MPV_frame_end(MpegEncContext *s)
1624 {
1625 #if FF_API_XVMC
1626 FF_DISABLE_DEPRECATION_WARNINGS
1627     /* redraw edges for the frame if decoding didn't complete */
1628     // just to make sure that all data is rendered.
1629     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1630         ff_xvmc_field_end(s);
1631     } else
1632 FF_ENABLE_DEPRECATION_WARNINGS
1633 #endif /* FF_API_XVMC */
1634     if (s->er.error_count  &&
1635         !s->avctx->hwaccel &&
1636         s->unrestricted_mv &&
1637         s->current_picture.reference &&
1638         !s->intra_only &&
1639         !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1640         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1641         int hshift = desc->log2_chroma_w;
1642         int vshift = desc->log2_chroma_h;
1643         s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1644                           s->h_edge_pos, s->v_edge_pos,
1645                           EDGE_WIDTH, EDGE_WIDTH,
1646                           EDGE_TOP | EDGE_BOTTOM);
1647         s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1648                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1649                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1650                           EDGE_TOP | EDGE_BOTTOM);
1651         s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1652                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1653                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1654                           EDGE_TOP | EDGE_BOTTOM);
1655     }
1656
1657     emms_c();
1658
1659     if (s->current_picture.reference)
1660         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1661 }
1662
1663 /**
1664  * Print debugging info for the given picture.
1665  */
1666 void ff_print_debug_info(MpegEncContext *s, Picture *p)
1667 {
1668     AVFrame *pict;
1669     if (s->avctx->hwaccel || !p || !p->mb_type)
1670         return;
1671     pict = &p->f;
1672
1673     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1674         int x,y;
1675
1676         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1677         switch (pict->pict_type) {
1678         case AV_PICTURE_TYPE_I:
1679             av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1680             break;
1681         case AV_PICTURE_TYPE_P:
1682             av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1683             break;
1684         case AV_PICTURE_TYPE_B:
1685             av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1686             break;
1687         case AV_PICTURE_TYPE_S:
1688             av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1689             break;
1690         case AV_PICTURE_TYPE_SI:
1691             av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1692             break;
1693         case AV_PICTURE_TYPE_SP:
1694             av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1695             break;
1696         }
1697         for (y = 0; y < s->mb_height; y++) {
1698             for (x = 0; x < s->mb_width; x++) {
1699                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1700                     int count = s->mbskip_table[x + y * s->mb_stride];
1701                     if (count > 9)
1702                         count = 9;
1703                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1704                 }
1705                 if (s->avctx->debug & FF_DEBUG_QP) {
1706                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1707                            p->qscale_table[x + y * s->mb_stride]);
1708                 }
1709                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1710                     int mb_type = p->mb_type[x + y * s->mb_stride];
1711                     // Type & MV direction
1712                     if (IS_PCM(mb_type))
1713                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1714                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1715                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1716                     else if (IS_INTRA4x4(mb_type))
1717                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1718                     else if (IS_INTRA16x16(mb_type))
1719                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1720                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1721                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1722                     else if (IS_DIRECT(mb_type))
1723                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1724                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1725                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1726                     else if (IS_GMC(mb_type))
1727                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1728                     else if (IS_SKIP(mb_type))
1729                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1730                     else if (!USES_LIST(mb_type, 1))
1731                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1732                     else if (!USES_LIST(mb_type, 0))
1733                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1734                     else {
1735                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1736                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1737                     }
1738
1739                     // segmentation
1740                     if (IS_8X8(mb_type))
1741                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1742                     else if (IS_16X8(mb_type))
1743                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1744                     else if (IS_8X16(mb_type))
1745                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1746                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1747                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1748                     else
1749                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1750
1751
1752                     if (IS_INTERLACED(mb_type))
1753                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1754                     else
1755                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1756                 }
1757             }
1758             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1759         }
1760     }
1761 }
1762
1763 /**
1764  * find the lowest MB row referenced in the MVs
1765  */
1766 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1767 {
1768     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1769     int my, off, i, mvs;
1770
1771     if (s->picture_structure != PICT_FRAME || s->mcsel)
1772         goto unhandled;
1773
1774     switch (s->mv_type) {
1775         case MV_TYPE_16X16:
1776             mvs = 1;
1777             break;
1778         case MV_TYPE_16X8:
1779             mvs = 2;
1780             break;
1781         case MV_TYPE_8X8:
1782             mvs = 4;
1783             break;
1784         default:
1785             goto unhandled;
1786     }
1787
1788     for (i = 0; i < mvs; i++) {
1789         my = s->mv[dir][i][1]<<qpel_shift;
1790         my_max = FFMAX(my_max, my);
1791         my_min = FFMIN(my_min, my);
1792     }
1793
1794     off = (FFMAX(-my_min, my_max) + 63) >> 6;
1795
1796     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1797 unhandled:
1798     return s->mb_height-1;
1799 }
1800
1801 /* put block[] to dest[] */
1802 static inline void put_dct(MpegEncContext *s,
1803                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1804 {
1805     s->dct_unquantize_intra(s, block, i, qscale);
1806     s->dsp.idct_put (dest, line_size, block);
1807 }
1808
1809 /* add block[] to dest[] */
1810 static inline void add_dct(MpegEncContext *s,
1811                            int16_t *block, int i, uint8_t *dest, int line_size)
1812 {
1813     if (s->block_last_index[i] >= 0) {
1814         s->dsp.idct_add (dest, line_size, block);
1815     }
1816 }
1817
1818 static inline void add_dequant_dct(MpegEncContext *s,
1819                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1820 {
1821     if (s->block_last_index[i] >= 0) {
1822         s->dct_unquantize_inter(s, block, i, qscale);
1823
1824         s->dsp.idct_add (dest, line_size, block);
1825     }
1826 }
1827
1828 /**
1829  * Clean dc, ac, coded_block for the current non-intra MB.
1830  */
1831 void ff_clean_intra_table_entries(MpegEncContext *s)
1832 {
1833     int wrap = s->b8_stride;
1834     int xy = s->block_index[0];
1835
1836     s->dc_val[0][xy           ] =
1837     s->dc_val[0][xy + 1       ] =
1838     s->dc_val[0][xy     + wrap] =
1839     s->dc_val[0][xy + 1 + wrap] = 1024;
1840     /* ac pred */
1841     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1842     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1843     if (s->msmpeg4_version>=3) {
1844         s->coded_block[xy           ] =
1845         s->coded_block[xy + 1       ] =
1846         s->coded_block[xy     + wrap] =
1847         s->coded_block[xy + 1 + wrap] = 0;
1848     }
1849     /* chroma */
1850     wrap = s->mb_stride;
1851     xy = s->mb_x + s->mb_y * wrap;
1852     s->dc_val[1][xy] =
1853     s->dc_val[2][xy] = 1024;
1854     /* ac pred */
1855     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1856     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1857
1858     s->mbintra_table[xy]= 0;
1859 }
1860
1861 /* generic function called after a macroblock has been parsed by the
1862    decoder or after it has been encoded by the encoder.
1863
1864    Important variables used:
1865    s->mb_intra : true if intra macroblock
1866    s->mv_dir   : motion vector direction
1867    s->mv_type  : motion vector type
1868    s->mv       : motion vector
1869    s->interlaced_dct : true if interlaced dct used (mpeg2)
1870  */
1871 static av_always_inline
1872 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
1873                             int is_mpeg12)
1874 {
1875     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1876
1877 #if FF_API_XVMC
1878 FF_DISABLE_DEPRECATION_WARNINGS
1879     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1880         ff_xvmc_decode_mb(s);//xvmc uses pblocks
1881         return;
1882     }
1883 FF_ENABLE_DEPRECATION_WARNINGS
1884 #endif /* FF_API_XVMC */
1885
1886     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1887        /* print DCT coefficients */
1888        int i,j;
1889        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1890        for(i=0; i<6; i++){
1891            for(j=0; j<64; j++){
1892                av_log(s->avctx, AV_LOG_DEBUG, "%5d", block[i][s->dsp.idct_permutation[j]]);
1893            }
1894            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1895        }
1896     }
1897
1898     s->current_picture.qscale_table[mb_xy] = s->qscale;
1899
1900     /* update DC predictors for P macroblocks */
1901     if (!s->mb_intra) {
1902         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1903             if(s->mbintra_table[mb_xy])
1904                 ff_clean_intra_table_entries(s);
1905         } else {
1906             s->last_dc[0] =
1907             s->last_dc[1] =
1908             s->last_dc[2] = 128 << s->intra_dc_precision;
1909         }
1910     }
1911     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1912         s->mbintra_table[mb_xy]=1;
1913
1914     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
1915         uint8_t *dest_y, *dest_cb, *dest_cr;
1916         int dct_linesize, dct_offset;
1917         op_pixels_func (*op_pix)[4];
1918         qpel_mc_func (*op_qpix)[16];
1919         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
1920         const int uvlinesize = s->current_picture.f.linesize[1];
1921         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
1922         const int block_size = 8;
1923
1924         /* avoid copy if macroblock skipped in last frame too */
1925         /* skip only during decoding as we might trash the buffers during encoding a bit */
1926         if(!s->encoding){
1927             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1928
1929             if (s->mb_skipped) {
1930                 s->mb_skipped= 0;
1931                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
1932                 *mbskip_ptr = 1;
1933             } else if(!s->current_picture.reference) {
1934                 *mbskip_ptr = 1;
1935             } else{
1936                 *mbskip_ptr = 0; /* not skipped */
1937             }
1938         }
1939
1940         dct_linesize = linesize << s->interlaced_dct;
1941         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
1942
1943         if(readable){
1944             dest_y=  s->dest[0];
1945             dest_cb= s->dest[1];
1946             dest_cr= s->dest[2];
1947         }else{
1948             dest_y = s->b_scratchpad;
1949             dest_cb= s->b_scratchpad+16*linesize;
1950             dest_cr= s->b_scratchpad+32*linesize;
1951         }
1952
1953         if (!s->mb_intra) {
1954             /* motion handling */
1955             /* decoding or more than one mb_type (MC was already done otherwise) */
1956             if(!s->encoding){
1957
1958                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
1959                     if (s->mv_dir & MV_DIR_FORWARD) {
1960                         ff_thread_await_progress(&s->last_picture_ptr->tf,
1961                                                  ff_MPV_lowest_referenced_row(s, 0),
1962                                                  0);
1963                     }
1964                     if (s->mv_dir & MV_DIR_BACKWARD) {
1965                         ff_thread_await_progress(&s->next_picture_ptr->tf,
1966                                                  ff_MPV_lowest_referenced_row(s, 1),
1967                                                  0);
1968                     }
1969                 }
1970
1971                 op_qpix= s->me.qpel_put;
1972                 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
1973                     op_pix = s->hdsp.put_pixels_tab;
1974                 }else{
1975                     op_pix = s->hdsp.put_no_rnd_pixels_tab;
1976                 }
1977                 if (s->mv_dir & MV_DIR_FORWARD) {
1978                     ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
1979                     op_pix = s->hdsp.avg_pixels_tab;
1980                     op_qpix= s->me.qpel_avg;
1981                 }
1982                 if (s->mv_dir & MV_DIR_BACKWARD) {
1983                     ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
1984                 }
1985             }
1986
1987             /* skip dequant / idct if we are really late ;) */
1988             if(s->avctx->skip_idct){
1989                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
1990                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
1991                    || s->avctx->skip_idct >= AVDISCARD_ALL)
1992                     goto skip_idct;
1993             }
1994
1995             /* add dct residue */
1996             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
1997                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
1998                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1999                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2000                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2001                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2002
2003                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2004                     if (s->chroma_y_shift){
2005                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2006                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2007                     }else{
2008                         dct_linesize >>= 1;
2009                         dct_offset >>=1;
2010                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2011                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2012                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2013                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2014                     }
2015                 }
2016             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2017                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2018                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2019                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2020                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2021
2022                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2023                     if(s->chroma_y_shift){//Chroma420
2024                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2025                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2026                     }else{
2027                         //chroma422
2028                         dct_linesize = uvlinesize << s->interlaced_dct;
2029                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2030
2031                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2032                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2033                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2034                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2035                         if(!s->chroma_x_shift){//Chroma444
2036                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2037                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2038                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2039                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2040                         }
2041                     }
2042                 }//fi gray
2043             }
2044             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2045                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2046             }
2047         } else {
2048             /* dct only in intra block */
2049             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2050                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2051                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2052                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2053                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2054
2055                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2056                     if(s->chroma_y_shift){
2057                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2058                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2059                     }else{
2060                         dct_offset >>=1;
2061                         dct_linesize >>=1;
2062                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2063                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2064                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2065                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2066                     }
2067                 }
2068             }else{
2069                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2070                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2071                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2072                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2073
2074                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2075                     if(s->chroma_y_shift){
2076                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2077                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2078                     }else{
2079
2080                         dct_linesize = uvlinesize << s->interlaced_dct;
2081                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2082
2083                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2084                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2085                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2086                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2087                         if(!s->chroma_x_shift){//Chroma444
2088                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2089                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2090                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2091                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2092                         }
2093                     }
2094                 }//gray
2095             }
2096         }
2097 skip_idct:
2098         if(!readable){
2099             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2100             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2101             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2102         }
2103     }
2104 }
2105
2106 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2107 #if !CONFIG_SMALL
2108     if(s->out_format == FMT_MPEG1) {
2109         MPV_decode_mb_internal(s, block, 1);
2110     } else
2111 #endif
2112         MPV_decode_mb_internal(s, block, 0);
2113 }
2114
2115 /**
2116  * @param h is the normal height, this will be reduced automatically if needed for the last row
2117  */
2118 void ff_draw_horiz_band(AVCodecContext *avctx, DSPContext *dsp, Picture *cur,
2119                         Picture *last, int y, int h, int picture_structure,
2120                         int first_field, int draw_edges, int low_delay,
2121                         int v_edge_pos, int h_edge_pos)
2122 {
2123     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2124     int hshift = desc->log2_chroma_w;
2125     int vshift = desc->log2_chroma_h;
2126     const int field_pic = picture_structure != PICT_FRAME;
2127     if(field_pic){
2128         h <<= 1;
2129         y <<= 1;
2130     }
2131
2132     if (!avctx->hwaccel &&
2133         draw_edges &&
2134         cur->reference &&
2135         !(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
2136         int *linesize = cur->f.linesize;
2137         int sides = 0, edge_h;
2138         if (y==0) sides |= EDGE_TOP;
2139         if (y + h >= v_edge_pos)
2140             sides |= EDGE_BOTTOM;
2141
2142         edge_h= FFMIN(h, v_edge_pos - y);
2143
2144         dsp->draw_edges(cur->f.data[0] + y * linesize[0],
2145                         linesize[0], h_edge_pos, edge_h,
2146                         EDGE_WIDTH, EDGE_WIDTH, sides);
2147         dsp->draw_edges(cur->f.data[1] + (y >> vshift) * linesize[1],
2148                         linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2149                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2150         dsp->draw_edges(cur->f.data[2] + (y >> vshift) * linesize[2],
2151                         linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2152                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2153     }
2154
2155     h = FFMIN(h, avctx->height - y);
2156
2157     if(field_pic && first_field && !(avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2158
2159     if (avctx->draw_horiz_band) {
2160         AVFrame *src;
2161         int offset[AV_NUM_DATA_POINTERS];
2162         int i;
2163
2164         if(cur->f.pict_type == AV_PICTURE_TYPE_B || low_delay ||
2165            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2166             src = &cur->f;
2167         else if (last)
2168             src = &last->f;
2169         else
2170             return;
2171
2172         if (cur->f.pict_type == AV_PICTURE_TYPE_B &&
2173             picture_structure == PICT_FRAME &&
2174             avctx->codec_id != AV_CODEC_ID_SVQ3) {
2175             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2176                 offset[i] = 0;
2177         }else{
2178             offset[0]= y * src->linesize[0];
2179             offset[1]=
2180             offset[2]= (y >> vshift) * src->linesize[1];
2181             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2182                 offset[i] = 0;
2183         }
2184
2185         emms_c();
2186
2187         avctx->draw_horiz_band(avctx, src, offset,
2188                                y, picture_structure, h);
2189     }
2190 }
2191
2192 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2193 {
2194     int draw_edges = s->unrestricted_mv && !s->intra_only;
2195     ff_draw_horiz_band(s->avctx, &s->dsp, &s->current_picture,
2196                        &s->last_picture, y, h, s->picture_structure,
2197                        s->first_field, draw_edges, s->low_delay,
2198                        s->v_edge_pos, s->h_edge_pos);
2199 }
2200
2201 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2202     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2203     const int uvlinesize = s->current_picture.f.linesize[1];
2204     const int mb_size= 4;
2205
2206     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2207     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2208     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2209     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2210     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2211     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;
2212     //block_index is not used by mpeg2, so it is not affected by chroma_format
2213
2214     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
2215     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2216     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2217
2218     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2219     {
2220         if(s->picture_structure==PICT_FRAME){
2221         s->dest[0] += s->mb_y *   linesize << mb_size;
2222         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2223         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2224         }else{
2225             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2226             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2227             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2228             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2229         }
2230     }
2231 }
2232
2233 /**
2234  * Permute an 8x8 block.
2235  * @param block the block which will be permuted according to the given permutation vector
2236  * @param permutation the permutation vector
2237  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
2238  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
2239  *                  (inverse) permutated to scantable order!
2240  */
2241 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
2242 {
2243     int i;
2244     int16_t temp[64];
2245
2246     if(last<=0) return;
2247     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
2248
2249     for(i=0; i<=last; i++){
2250         const int j= scantable[i];
2251         temp[j]= block[j];
2252         block[j]=0;
2253     }
2254
2255     for(i=0; i<=last; i++){
2256         const int j= scantable[i];
2257         const int perm_j= permutation[j];
2258         block[perm_j]= temp[j];
2259     }
2260 }
2261
2262 void ff_mpeg_flush(AVCodecContext *avctx){
2263     int i;
2264     MpegEncContext *s = avctx->priv_data;
2265
2266     if(s==NULL || s->picture==NULL)
2267         return;
2268
2269     for (i = 0; i < MAX_PICTURE_COUNT; i++)
2270         ff_mpeg_unref_picture(s, &s->picture[i]);
2271     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2272
2273     ff_mpeg_unref_picture(s, &s->current_picture);
2274     ff_mpeg_unref_picture(s, &s->last_picture);
2275     ff_mpeg_unref_picture(s, &s->next_picture);
2276
2277     s->mb_x= s->mb_y= 0;
2278
2279     s->parse_context.state= -1;
2280     s->parse_context.frame_start_found= 0;
2281     s->parse_context.overread= 0;
2282     s->parse_context.overread_index= 0;
2283     s->parse_context.index= 0;
2284     s->parse_context.last_index= 0;
2285     s->bitstream_buffer_size=0;
2286     s->pp_time=0;
2287 }
2288
2289 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2290                                    int16_t *block, int n, int qscale)
2291 {
2292     int i, level, nCoeffs;
2293     const uint16_t *quant_matrix;
2294
2295     nCoeffs= s->block_last_index[n];
2296
2297     if (n < 4)
2298         block[0] = block[0] * s->y_dc_scale;
2299     else
2300         block[0] = block[0] * s->c_dc_scale;
2301     /* XXX: only mpeg1 */
2302     quant_matrix = s->intra_matrix;
2303     for(i=1;i<=nCoeffs;i++) {
2304         int j= s->intra_scantable.permutated[i];
2305         level = block[j];
2306         if (level) {
2307             if (level < 0) {
2308                 level = -level;
2309                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2310                 level = (level - 1) | 1;
2311                 level = -level;
2312             } else {
2313                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2314                 level = (level - 1) | 1;
2315             }
2316             block[j] = level;
2317         }
2318     }
2319 }
2320
2321 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2322                                    int16_t *block, int n, int qscale)
2323 {
2324     int i, level, nCoeffs;
2325     const uint16_t *quant_matrix;
2326
2327     nCoeffs= s->block_last_index[n];
2328
2329     quant_matrix = s->inter_matrix;
2330     for(i=0; i<=nCoeffs; i++) {
2331         int j= s->intra_scantable.permutated[i];
2332         level = block[j];
2333         if (level) {
2334             if (level < 0) {
2335                 level = -level;
2336                 level = (((level << 1) + 1) * qscale *
2337                          ((int) (quant_matrix[j]))) >> 4;
2338                 level = (level - 1) | 1;
2339                 level = -level;
2340             } else {
2341                 level = (((level << 1) + 1) * qscale *
2342                          ((int) (quant_matrix[j]))) >> 4;
2343                 level = (level - 1) | 1;
2344             }
2345             block[j] = level;
2346         }
2347     }
2348 }
2349
2350 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2351                                    int16_t *block, int n, int qscale)
2352 {
2353     int i, level, nCoeffs;
2354     const uint16_t *quant_matrix;
2355
2356     if(s->alternate_scan) nCoeffs= 63;
2357     else nCoeffs= s->block_last_index[n];
2358
2359     if (n < 4)
2360         block[0] = block[0] * s->y_dc_scale;
2361     else
2362         block[0] = block[0] * s->c_dc_scale;
2363     quant_matrix = s->intra_matrix;
2364     for(i=1;i<=nCoeffs;i++) {
2365         int j= s->intra_scantable.permutated[i];
2366         level = block[j];
2367         if (level) {
2368             if (level < 0) {
2369                 level = -level;
2370                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2371                 level = -level;
2372             } else {
2373                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2374             }
2375             block[j] = level;
2376         }
2377     }
2378 }
2379
2380 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2381                                    int16_t *block, int n, int qscale)
2382 {
2383     int i, level, nCoeffs;
2384     const uint16_t *quant_matrix;
2385     int sum=-1;
2386
2387     if(s->alternate_scan) nCoeffs= 63;
2388     else nCoeffs= s->block_last_index[n];
2389
2390     if (n < 4)
2391         block[0] = block[0] * s->y_dc_scale;
2392     else
2393         block[0] = block[0] * s->c_dc_scale;
2394     quant_matrix = s->intra_matrix;
2395     for(i=1;i<=nCoeffs;i++) {
2396         int j= s->intra_scantable.permutated[i];
2397         level = block[j];
2398         if (level) {
2399             if (level < 0) {
2400                 level = -level;
2401                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2402                 level = -level;
2403             } else {
2404                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2405             }
2406             block[j] = level;
2407             sum+=level;
2408         }
2409     }
2410     block[63]^=sum&1;
2411 }
2412
2413 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2414                                    int16_t *block, int n, int qscale)
2415 {
2416     int i, level, nCoeffs;
2417     const uint16_t *quant_matrix;
2418     int sum=-1;
2419
2420     if(s->alternate_scan) nCoeffs= 63;
2421     else nCoeffs= s->block_last_index[n];
2422
2423     quant_matrix = s->inter_matrix;
2424     for(i=0; i<=nCoeffs; i++) {
2425         int j= s->intra_scantable.permutated[i];
2426         level = block[j];
2427         if (level) {
2428             if (level < 0) {
2429                 level = -level;
2430                 level = (((level << 1) + 1) * qscale *
2431                          ((int) (quant_matrix[j]))) >> 4;
2432                 level = -level;
2433             } else {
2434                 level = (((level << 1) + 1) * qscale *
2435                          ((int) (quant_matrix[j]))) >> 4;
2436             }
2437             block[j] = level;
2438             sum+=level;
2439         }
2440     }
2441     block[63]^=sum&1;
2442 }
2443
2444 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2445                                   int16_t *block, int n, int qscale)
2446 {
2447     int i, level, qmul, qadd;
2448     int nCoeffs;
2449
2450     assert(s->block_last_index[n]>=0);
2451
2452     qmul = qscale << 1;
2453
2454     if (!s->h263_aic) {
2455         if (n < 4)
2456             block[0] = block[0] * s->y_dc_scale;
2457         else
2458             block[0] = block[0] * s->c_dc_scale;
2459         qadd = (qscale - 1) | 1;
2460     }else{
2461         qadd = 0;
2462     }
2463     if(s->ac_pred)
2464         nCoeffs=63;
2465     else
2466         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2467
2468     for(i=1; i<=nCoeffs; i++) {
2469         level = block[i];
2470         if (level) {
2471             if (level < 0) {
2472                 level = level * qmul - qadd;
2473             } else {
2474                 level = level * qmul + qadd;
2475             }
2476             block[i] = level;
2477         }
2478     }
2479 }
2480
2481 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2482                                   int16_t *block, int n, int qscale)
2483 {
2484     int i, level, qmul, qadd;
2485     int nCoeffs;
2486
2487     assert(s->block_last_index[n]>=0);
2488
2489     qadd = (qscale - 1) | 1;
2490     qmul = qscale << 1;
2491
2492     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2493
2494     for(i=0; i<=nCoeffs; i++) {
2495         level = block[i];
2496         if (level) {
2497             if (level < 0) {
2498                 level = level * qmul - qadd;
2499             } else {
2500                 level = level * qmul + qadd;
2501             }
2502             block[i] = level;
2503         }
2504     }
2505 }
2506
2507 /**
2508  * set qscale and update qscale dependent variables.
2509  */
2510 void ff_set_qscale(MpegEncContext * s, int qscale)
2511 {
2512     if (qscale < 1)
2513         qscale = 1;
2514     else if (qscale > 31)
2515         qscale = 31;
2516
2517     s->qscale = qscale;
2518     s->chroma_qscale= s->chroma_qscale_table[qscale];
2519
2520     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2521     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2522 }
2523
2524 void ff_MPV_report_decode_progress(MpegEncContext *s)
2525 {
2526     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2527         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2528 }
2529
2530 #if CONFIG_ERROR_RESILIENCE
2531 void ff_mpeg_er_frame_start(MpegEncContext *s)
2532 {
2533     ERContext *er = &s->er;
2534
2535     er->cur_pic  = s->current_picture_ptr;
2536     er->last_pic = s->last_picture_ptr;
2537     er->next_pic = s->next_picture_ptr;
2538
2539     er->pp_time           = s->pp_time;
2540     er->pb_time           = s->pb_time;
2541     er->quarter_sample    = s->quarter_sample;
2542     er->partitioned_frame = s->partitioned_frame;
2543
2544     ff_er_frame_start(er);
2545 }
2546 #endif /* CONFIG_ERROR_RESILIENCE */