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