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