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