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