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 "mpeg_er.h"
43 #include "mpegutils.h"
44 #include "mpegvideo.h"
45 #include "mpegvideodata.h"
46 #include "mjpegenc.h"
47 #include "msmpeg4.h"
48 #include "qpeldsp.h"
49 #include "thread.h"
50 #include "wmv2.h"
51 #include <limits.h>
52 
54  int16_t *block, int n, int qscale)
55 {
56  int i, level, nCoeffs;
57  const uint16_t *quant_matrix;
58 
59  nCoeffs= s->block_last_index[n];
60 
61  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
62  /* XXX: only MPEG-1 */
63  quant_matrix = s->intra_matrix;
64  for(i=1;i<=nCoeffs;i++) {
65  int j= s->intra_scantable.permutated[i];
66  level = block[j];
67  if (level) {
68  if (level < 0) {
69  level = -level;
70  level = (int)(level * qscale * quant_matrix[j]) >> 3;
71  level = (level - 1) | 1;
72  level = -level;
73  } else {
74  level = (int)(level * qscale * quant_matrix[j]) >> 3;
75  level = (level - 1) | 1;
76  }
77  block[j] = level;
78  }
79  }
80 }
81 
83  int16_t *block, int n, int qscale)
84 {
85  int i, level, nCoeffs;
86  const uint16_t *quant_matrix;
87 
88  nCoeffs= s->block_last_index[n];
89 
90  quant_matrix = s->inter_matrix;
91  for(i=0; i<=nCoeffs; i++) {
92  int j= s->intra_scantable.permutated[i];
93  level = block[j];
94  if (level) {
95  if (level < 0) {
96  level = -level;
97  level = (((level << 1) + 1) * qscale *
98  ((int) (quant_matrix[j]))) >> 4;
99  level = (level - 1) | 1;
100  level = -level;
101  } else {
102  level = (((level << 1) + 1) * qscale *
103  ((int) (quant_matrix[j]))) >> 4;
104  level = (level - 1) | 1;
105  }
106  block[j] = level;
107  }
108  }
109 }
110 
112  int16_t *block, int n, int qscale)
113 {
114  int i, level, nCoeffs;
115  const uint16_t *quant_matrix;
116 
117  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
118  else qscale <<= 1;
119 
120  if(s->alternate_scan) nCoeffs= 63;
121  else nCoeffs= s->block_last_index[n];
122 
123  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
124  quant_matrix = s->intra_matrix;
125  for(i=1;i<=nCoeffs;i++) {
126  int j= s->intra_scantable.permutated[i];
127  level = block[j];
128  if (level) {
129  if (level < 0) {
130  level = -level;
131  level = (int)(level * qscale * quant_matrix[j]) >> 4;
132  level = -level;
133  } else {
134  level = (int)(level * qscale * quant_matrix[j]) >> 4;
135  }
136  block[j] = level;
137  }
138  }
139 }
140 
142  int16_t *block, int n, int qscale)
143 {
144  int i, level, nCoeffs;
145  const uint16_t *quant_matrix;
146  int sum=-1;
147 
148  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
149  else qscale <<= 1;
150 
151  if(s->alternate_scan) nCoeffs= 63;
152  else nCoeffs= s->block_last_index[n];
153 
154  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
155  sum += block[0];
156  quant_matrix = s->intra_matrix;
157  for(i=1;i<=nCoeffs;i++) {
158  int j= s->intra_scantable.permutated[i];
159  level = block[j];
160  if (level) {
161  if (level < 0) {
162  level = -level;
163  level = (int)(level * qscale * quant_matrix[j]) >> 4;
164  level = -level;
165  } else {
166  level = (int)(level * qscale * quant_matrix[j]) >> 4;
167  }
168  block[j] = level;
169  sum+=level;
170  }
171  }
172  block[63]^=sum&1;
173 }
174 
176  int16_t *block, int n, int qscale)
177 {
178  int i, level, nCoeffs;
179  const uint16_t *quant_matrix;
180  int sum=-1;
181 
182  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
183  else qscale <<= 1;
184 
185  if(s->alternate_scan) nCoeffs= 63;
186  else nCoeffs= s->block_last_index[n];
187 
188  quant_matrix = s->inter_matrix;
189  for(i=0; i<=nCoeffs; i++) {
190  int j= s->intra_scantable.permutated[i];
191  level = block[j];
192  if (level) {
193  if (level < 0) {
194  level = -level;
195  level = (((level << 1) + 1) * qscale *
196  ((int) (quant_matrix[j]))) >> 5;
197  level = -level;
198  } else {
199  level = (((level << 1) + 1) * qscale *
200  ((int) (quant_matrix[j]))) >> 5;
201  }
202  block[j] = level;
203  sum+=level;
204  }
205  }
206  block[63]^=sum&1;
207 }
208 
210  int16_t *block, int n, int qscale)
211 {
212  int i, level, qmul, qadd;
213  int nCoeffs;
214 
215  av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
216 
217  qmul = qscale << 1;
218 
219  if (!s->h263_aic) {
220  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
221  qadd = (qscale - 1) | 1;
222  }else{
223  qadd = 0;
224  }
225  if(s->ac_pred)
226  nCoeffs=63;
227  else
228  nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
229 
230  for(i=1; i<=nCoeffs; i++) {
231  level = block[i];
232  if (level) {
233  if (level < 0) {
234  level = level * qmul - qadd;
235  } else {
236  level = level * qmul + qadd;
237  }
238  block[i] = level;
239  }
240  }
241 }
242 
244  int16_t *block, int n, int qscale)
245 {
246  int i, level, qmul, qadd;
247  int nCoeffs;
248 
249  av_assert2(s->block_last_index[n]>=0);
250 
251  qadd = (qscale - 1) | 1;
252  qmul = qscale << 1;
253 
254  nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
255 
256  for(i=0; i<=nCoeffs; i++) {
257  level = block[i];
258  if (level) {
259  if (level < 0) {
260  level = level * qmul - qadd;
261  } else {
262  level = level * qmul + qadd;
263  }
264  block[i] = level;
265  }
266  }
267 }
268 
269 
270 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
271 {
272  while(h--)
273  memset(dst + h*linesize, 128, 16);
274 }
275 
276 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
277 {
278  while(h--)
279  memset(dst + h*linesize, 128, 8);
280 }
281 
282 /* init common dct for both encoder and decoder */
284 {
285  ff_blockdsp_init(&s->bdsp, s->avctx);
286  ff_h264chroma_init(&s->h264chroma, 8); //for lowres
287  ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
290 
291  if (s->avctx->debug & FF_DEBUG_NOMC) {
292  int i;
293  for (i=0; i<4; i++) {
294  s->hdsp.avg_pixels_tab[0][i] = gray16;
295  s->hdsp.put_pixels_tab[0][i] = gray16;
296  s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
297 
298  s->hdsp.avg_pixels_tab[1][i] = gray8;
299  s->hdsp.put_pixels_tab[1][i] = gray8;
300  s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
301  }
302  }
303 
312 
313  if (HAVE_INTRINSICS_NEON)
315 
316  if (ARCH_ALPHA)
318  if (ARCH_ARM)
320  if (ARCH_PPC)
322  if (ARCH_X86)
324  if (ARCH_MIPS)
326 
327  return 0;
328 }
329 
331 {
332  ff_idctdsp_init(&s->idsp, s->avctx);
333 
334  /* load & permutate scantables
335  * note: only wmv uses different ones
336  */
337  if (s->alternate_scan) {
340  } else {
343  }
346 }
347 
348 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
349 {
350  return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 0,
352  s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
353  &s->linesize, &s->uvlinesize);
354 }
355 
357 {
358  int y_size = s->b8_stride * (2 * s->mb_height + 1);
359  int c_size = s->mb_stride * (s->mb_height + 1);
360  int yc_size = y_size + 2 * c_size;
361  int i;
362 
363  if (s->mb_height & 1)
364  yc_size += 2*s->b8_stride + 2*s->mb_stride;
365 
366  s->sc.edge_emu_buffer =
367  s->me.scratchpad =
368  s->me.temp =
369  s->sc.rd_scratchpad =
370  s->sc.b_scratchpad =
371  s->sc.obmc_scratchpad = NULL;
372 
373  if (s->encoding) {
374  FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
375  ME_MAP_SIZE * sizeof(uint32_t), fail)
377  ME_MAP_SIZE * sizeof(uint32_t), fail)
378  if (s->noise_reduction) {
380  2 * 64 * sizeof(int), fail)
381  }
382  }
383  FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
384  s->block = s->blocks[0];
385 
386  for (i = 0; i < 12; i++) {
387  s->pblocks[i] = &s->block[i];
388  }
389  if (s->avctx->codec_tag == AV_RL32("VCR2")) {
390  // exchange uv
391  FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
392  }
393 
394  if (s->out_format == FMT_H263) {
395  /* ac values */
397  yc_size * sizeof(int16_t) * 16, fail);
398  s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
399  s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
400  s->ac_val[2] = s->ac_val[1] + c_size;
401  }
402 
403  return 0;
404 fail:
405  return -1; // free() through ff_mpv_common_end()
406 }
407 
409 {
410  if (!s)
411  return;
412 
414  av_freep(&s->me.scratchpad);
415  s->me.temp =
416  s->sc.rd_scratchpad =
417  s->sc.b_scratchpad =
418  s->sc.obmc_scratchpad = NULL;
419 
420  av_freep(&s->dct_error_sum);
421  av_freep(&s->me.map);
422  av_freep(&s->me.score_map);
423  av_freep(&s->blocks);
424  av_freep(&s->ac_val_base);
425  s->block = NULL;
426 }
427 
429 {
430 #define COPY(a) bak->a = src->a
431  COPY(sc.edge_emu_buffer);
432  COPY(me.scratchpad);
433  COPY(me.temp);
434  COPY(sc.rd_scratchpad);
435  COPY(sc.b_scratchpad);
436  COPY(sc.obmc_scratchpad);
437  COPY(me.map);
438  COPY(me.score_map);
439  COPY(blocks);
440  COPY(block);
441  COPY(start_mb_y);
442  COPY(end_mb_y);
443  COPY(me.map_generation);
444  COPY(pb);
445  COPY(dct_error_sum);
446  COPY(dct_count[0]);
447  COPY(dct_count[1]);
448  COPY(ac_val_base);
449  COPY(ac_val[0]);
450  COPY(ac_val[1]);
451  COPY(ac_val[2]);
452 #undef COPY
453 }
454 
456 {
457  MpegEncContext bak;
458  int i, ret;
459  // FIXME copy only needed parts
460  // START_TIMER
461  backup_duplicate_context(&bak, dst);
462  memcpy(dst, src, sizeof(MpegEncContext));
463  backup_duplicate_context(dst, &bak);
464  for (i = 0; i < 12; i++) {
465  dst->pblocks[i] = &dst->block[i];
466  }
467  if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
468  // exchange uv
469  FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
470  }
471  if (!dst->sc.edge_emu_buffer &&
472  (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
473  &dst->sc, dst->linesize)) < 0) {
474  av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
475  "scratch buffers.\n");
476  return ret;
477  }
478  // STOP_TIMER("update_duplicate_context")
479  // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
480  return 0;
481 }
482 
484  const AVCodecContext *src)
485 {
486  int i, ret;
487  MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
488 
489  if (dst == src)
490  return 0;
491 
492  av_assert0(s != s1);
493 
494  // FIXME can parameters change on I-frames?
495  // in that case dst may need a reinit
496  if (!s->context_initialized) {
497  int err;
498  memcpy(s, s1, sizeof(MpegEncContext));
499 
500  s->avctx = dst;
501  s->bitstream_buffer = NULL;
503 
504  if (s1->context_initialized){
505 // s->picture_range_start += MAX_PICTURE_COUNT;
506 // s->picture_range_end += MAX_PICTURE_COUNT;
507  ff_mpv_idct_init(s);
508  if((err = ff_mpv_common_init(s)) < 0){
509  memset(s, 0, sizeof(MpegEncContext));
510  s->avctx = dst;
511  return err;
512  }
513  }
514  }
515 
516  if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
517  s->context_reinit = 0;
518  s->height = s1->height;
519  s->width = s1->width;
520  if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
521  return ret;
522  }
523 
524  s->avctx->coded_height = s1->avctx->coded_height;
525  s->avctx->coded_width = s1->avctx->coded_width;
526  s->avctx->width = s1->avctx->width;
527  s->avctx->height = s1->avctx->height;
528 
529  s->coded_picture_number = s1->coded_picture_number;
530  s->picture_number = s1->picture_number;
531 
532  av_assert0(!s->picture || s->picture != s1->picture);
533  if(s->picture)
534  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
535  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
536  if (s1->picture && s1->picture[i].f->buf[0] &&
537  (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
538  return ret;
539  }
540 
541 #define UPDATE_PICTURE(pic)\
542 do {\
543  ff_mpeg_unref_picture(s->avctx, &s->pic);\
544  if (s1->pic.f && s1->pic.f->buf[0])\
545  ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
546  else\
547  ret = ff_update_picture_tables(&s->pic, &s1->pic);\
548  if (ret < 0)\
549  return ret;\
550 } while (0)
551 
552  UPDATE_PICTURE(current_picture);
554  UPDATE_PICTURE(next_picture);
555 
556 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
557  ((pic && pic >= old_ctx->picture && \
558  pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
559  &new_ctx->picture[pic - old_ctx->picture] : NULL)
560 
561  s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
562  s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
563  s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
564 
565  // Error/bug resilience
566  s->next_p_frame_damaged = s1->next_p_frame_damaged;
567  s->workaround_bugs = s1->workaround_bugs;
568  s->padding_bug_score = s1->padding_bug_score;
569 
570  // MPEG-4 timing info
571  memcpy(&s->last_time_base, &s1->last_time_base,
572  (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
573  (char *) &s1->last_time_base);
574 
575  // B-frame info
576  s->max_b_frames = s1->max_b_frames;
577  s->low_delay = s1->low_delay;
578  s->droppable = s1->droppable;
579 
580  // DivX handling (doesn't work)
581  s->divx_packed = s1->divx_packed;
582 
583  if (s1->bitstream_buffer) {
584  if (s1->bitstream_buffer_size +
588  s1->allocated_bitstream_buffer_size);
589  if (!s->bitstream_buffer) {
590  s->bitstream_buffer_size = 0;
591  return AVERROR(ENOMEM);
592  }
593  }
594  s->bitstream_buffer_size = s1->bitstream_buffer_size;
595  memcpy(s->bitstream_buffer, s1->bitstream_buffer,
596  s1->bitstream_buffer_size);
597  memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
599  }
600 
601  // linesize-dependent scratch buffer allocation
602  if (!s->sc.edge_emu_buffer)
603  if (s1->linesize) {
604  if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
605  &s->sc, s1->linesize) < 0) {
606  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
607  "scratch buffers.\n");
608  return AVERROR(ENOMEM);
609  }
610  } else {
611  av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
612  "be allocated due to unknown size.\n");
613  }
614 
615  // MPEG-2/interlacing info
616  memcpy(&s->progressive_sequence, &s1->progressive_sequence,
617  (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
618 
619  if (!s1->first_field) {
620  s->last_pict_type = s1->pict_type;
621  if (s1->current_picture_ptr)
622  s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
623  }
624 
625  return 0;
626 }
627 
628 /**
629  * Set the given MpegEncContext to common defaults
630  * (same for encoding and decoding).
631  * The changed fields will not depend upon the
632  * prior state of the MpegEncContext.
633  */
635 {
636  s->y_dc_scale_table =
639  s->progressive_frame = 1;
640  s->progressive_sequence = 1;
642 
643  s->coded_picture_number = 0;
644  s->picture_number = 0;
645 
646  s->f_code = 1;
647  s->b_code = 1;
648 
649  s->slice_context_count = 1;
650 }
651 
652 /**
653  * Set the given MpegEncContext to defaults for decoding.
654  * the changed fields will not depend upon
655  * the prior state of the MpegEncContext.
656  */
658 {
660 }
661 
663 {
664  s->avctx = avctx;
665  s->width = avctx->coded_width;
666  s->height = avctx->coded_height;
667  s->codec_id = avctx->codec->id;
668  s->workaround_bugs = avctx->workaround_bugs;
669 
670  /* convert fourcc to upper case */
671  s->codec_tag = avpriv_toupper4(avctx->codec_tag);
672 }
673 
674 /**
675  * Initialize and allocates MpegEncContext fields dependent on the resolution.
676  */
678 {
679  int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
680 
681  s->mb_width = (s->width + 15) / 16;
682  s->mb_stride = s->mb_width + 1;
683  s->b8_stride = s->mb_width * 2 + 1;
684  mb_array_size = s->mb_height * s->mb_stride;
685  mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
686 
687  /* set default edge pos, will be overridden
688  * in decode_header if needed */
689  s->h_edge_pos = s->mb_width * 16;
690  s->v_edge_pos = s->mb_height * 16;
691 
692  s->mb_num = s->mb_width * s->mb_height;
693 
694  s->block_wrap[0] =
695  s->block_wrap[1] =
696  s->block_wrap[2] =
697  s->block_wrap[3] = s->b8_stride;
698  s->block_wrap[4] =
699  s->block_wrap[5] = s->mb_stride;
700 
701  y_size = s->b8_stride * (2 * s->mb_height + 1);
702  c_size = s->mb_stride * (s->mb_height + 1);
703  yc_size = y_size + 2 * c_size;
704 
705  if (s->mb_height & 1)
706  yc_size += 2*s->b8_stride + 2*s->mb_stride;
707 
708  FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
709  fail); // error resilience code looks cleaner with this
710  for (y = 0; y < s->mb_height; y++)
711  for (x = 0; x < s->mb_width; x++)
712  s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
713 
714  s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
715 
716  if (s->encoding) {
717  /* Allocate MV tables */
718  FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
719  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
720  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
721  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
722  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
723  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
724  s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
730 
731  /* Allocate MB type table */
732  FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
733 
734  FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
735 
737  mb_array_size * sizeof(float), fail);
739  mb_array_size * sizeof(float), fail);
740 
741  }
742 
743  if (s->codec_id == AV_CODEC_ID_MPEG4 ||
745  /* interlaced direct mode decoding tables */
746  for (i = 0; i < 2; i++) {
747  int j, k;
748  for (j = 0; j < 2; j++) {
749  for (k = 0; k < 2; k++) {
751  s->b_field_mv_table_base[i][j][k],
752  mv_table_size * 2 * sizeof(int16_t),
753  fail);
754  s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
755  s->mb_stride + 1;
756  }
757  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
758  FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
759  s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
760  }
761  FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
762  }
763  }
764  if (s->out_format == FMT_H263) {
765  /* cbp values */
766  FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
767  s->coded_block = s->coded_block_base + s->b8_stride + 1;
768 
769  /* cbp, ac_pred, pred_dir */
770  FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
771  FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
772  }
773 
774  if (s->h263_pred || s->h263_plus || !s->encoding) {
775  /* dc values */
776  // MN: we need these for error resilience of intra-frames
777  FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
778  s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
779  s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
780  s->dc_val[2] = s->dc_val[1] + c_size;
781  for (i = 0; i < yc_size; i++)
782  s->dc_val_base[i] = 1024;
783  }
784 
785  /* which mb is an intra block */
786  FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
787  memset(s->mbintra_table, 1, mb_array_size);
788 
789  /* init macroblock skip table */
790  FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
791  // Note the + 1 is for a quicker MPEG-4 slice_end detection
792 
793  return ff_mpeg_er_init(s);
794 fail:
795  return AVERROR(ENOMEM);
796 }
797 
799 {
800  int i, j, k;
801 
802  memset(&s->next_picture, 0, sizeof(s->next_picture));
803  memset(&s->last_picture, 0, sizeof(s->last_picture));
804  memset(&s->current_picture, 0, sizeof(s->current_picture));
805  memset(&s->new_picture, 0, sizeof(s->new_picture));
806 
807  memset(s->thread_context, 0, sizeof(s->thread_context));
808 
809  s->me.map = NULL;
810  s->me.score_map = NULL;
811  s->dct_error_sum = NULL;
812  s->block = NULL;
813  s->blocks = NULL;
814  memset(s->pblocks, 0, sizeof(s->pblocks));
815  s->ac_val_base = NULL;
816  s->ac_val[0] =
817  s->ac_val[1] =
818  s->ac_val[2] =NULL;
819  s->sc.edge_emu_buffer = NULL;
820  s->me.scratchpad = NULL;
821  s->me.temp =
822  s->sc.rd_scratchpad =
823  s->sc.b_scratchpad =
824  s->sc.obmc_scratchpad = NULL;
825 
826 
827  s->bitstream_buffer = NULL;
829  s->picture = NULL;
830  s->mb_type = NULL;
831  s->p_mv_table_base = NULL;
837  s->p_mv_table = NULL;
838  s->b_forw_mv_table = NULL;
839  s->b_back_mv_table = NULL;
842  s->b_direct_mv_table = NULL;
843  for (i = 0; i < 2; i++) {
844  for (j = 0; j < 2; j++) {
845  for (k = 0; k < 2; k++) {
846  s->b_field_mv_table_base[i][j][k] = NULL;
847  s->b_field_mv_table[i][j][k] = NULL;
848  }
849  s->b_field_select_table[i][j] = NULL;
850  s->p_field_mv_table_base[i][j] = NULL;
851  s->p_field_mv_table[i][j] = NULL;
852  }
853  s->p_field_select_table[i] = NULL;
854  }
855 
856  s->dc_val_base = NULL;
857  s->coded_block_base = NULL;
858  s->mbintra_table = NULL;
859  s->cbp_table = NULL;
860  s->pred_dir_table = NULL;
861 
862  s->mbskip_table = NULL;
863 
865  s->er.er_temp_buffer = NULL;
866  s->mb_index2xy = NULL;
867  s->lambda_table = NULL;
868 
869  s->cplx_tab = NULL;
870  s->bits_tab = NULL;
871 }
872 
873 /**
874  * init common structure for both encoder and decoder.
875  * this assumes that some variables like width/height are already set
876  */
878 {
879  int i;
880  int nb_slices = (HAVE_THREADS &&
882  s->avctx->thread_count : 1;
883 
884  clear_context(s);
885 
886  if (s->encoding && s->avctx->slices)
887  nb_slices = s->avctx->slices;
888 
890  s->mb_height = (s->height + 31) / 32 * 2;
891  else
892  s->mb_height = (s->height + 15) / 16;
893 
894  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
896  "decoding to AV_PIX_FMT_NONE is not supported.\n");
897  return -1;
898  }
899 
900  if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
901  int max_slices;
902  if (s->mb_height)
903  max_slices = FFMIN(MAX_THREADS, s->mb_height);
904  else
905  max_slices = MAX_THREADS;
906  av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
907  " reducing to %d\n", nb_slices, max_slices);
908  nb_slices = max_slices;
909  }
910 
911  if ((s->width || s->height) &&
912  av_image_check_size(s->width, s->height, 0, s->avctx))
913  return -1;
914 
915  dct_init(s);
916 
917  /* set chroma shifts */
919  &s->chroma_x_shift,
920  &s->chroma_y_shift);
921 
922 
924  MAX_PICTURE_COUNT * sizeof(Picture), fail);
925  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
926  s->picture[i].f = av_frame_alloc();
927  if (!s->picture[i].f)
928  goto fail;
929  }
931  if (!s->next_picture.f)
932  goto fail;
934  if (!s->last_picture.f)
935  goto fail;
937  if (!s->current_picture.f)
938  goto fail;
940  if (!s->new_picture.f)
941  goto fail;
942 
943  if (init_context_frame(s))
944  goto fail;
945 
946  s->parse_context.state = -1;
947 
948  s->context_initialized = 1;
949  memset(s->thread_context, 0, sizeof(s->thread_context));
950  s->thread_context[0] = s;
951 
952 // if (s->width && s->height) {
953  if (nb_slices > 1) {
954  for (i = 0; i < nb_slices; i++) {
955  if (i) {
956  s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
957  if (!s->thread_context[i])
958  goto fail;
959  }
960  if (init_duplicate_context(s->thread_context[i]) < 0)
961  goto fail;
962  s->thread_context[i]->start_mb_y =
963  (s->mb_height * (i) + nb_slices / 2) / nb_slices;
964  s->thread_context[i]->end_mb_y =
965  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
966  }
967  } else {
968  if (init_duplicate_context(s) < 0)
969  goto fail;
970  s->start_mb_y = 0;
971  s->end_mb_y = s->mb_height;
972  }
973  s->slice_context_count = nb_slices;
974 // }
975 
976  return 0;
977  fail:
979  return -1;
980 }
981 
982 /**
983  * Frees and resets MpegEncContext fields depending on the resolution.
984  * Is used during resolution changes to avoid a full reinitialization of the
985  * codec.
986  */
988 {
989  int i, j, k;
990 
991  av_freep(&s->mb_type);
998  s->p_mv_table = NULL;
999  s->b_forw_mv_table = NULL;
1000  s->b_back_mv_table = NULL;
1003  s->b_direct_mv_table = NULL;
1004  for (i = 0; i < 2; i++) {
1005  for (j = 0; j < 2; j++) {
1006  for (k = 0; k < 2; k++) {
1007  av_freep(&s->b_field_mv_table_base[i][j][k]);
1008  s->b_field_mv_table[i][j][k] = NULL;
1009  }
1010  av_freep(&s->b_field_select_table[i][j]);
1011  av_freep(&s->p_field_mv_table_base[i][j]);
1012  s->p_field_mv_table[i][j] = NULL;
1013  }
1015  }
1016 
1017  av_freep(&s->dc_val_base);
1019  av_freep(&s->mbintra_table);
1020  av_freep(&s->cbp_table);
1021  av_freep(&s->pred_dir_table);
1022 
1023  av_freep(&s->mbskip_table);
1024 
1026  av_freep(&s->er.er_temp_buffer);
1027  av_freep(&s->mb_index2xy);
1028  av_freep(&s->lambda_table);
1029 
1030  av_freep(&s->cplx_tab);
1031  av_freep(&s->bits_tab);
1032 
1033  s->linesize = s->uvlinesize = 0;
1034 }
1035 
1037 {
1038  int i, err = 0;
1039 
1040  if (!s->context_initialized)
1041  return AVERROR(EINVAL);
1042 
1043  if (s->slice_context_count > 1) {
1044  for (i = 0; i < s->slice_context_count; i++) {
1046  }
1047  for (i = 1; i < s->slice_context_count; i++) {
1048  av_freep(&s->thread_context[i]);
1049  }
1050  } else
1052 
1053  free_context_frame(s);
1054 
1055  if (s->picture)
1056  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1057  s->picture[i].needs_realloc = 1;
1058  }
1059 
1060  s->last_picture_ptr =
1061  s->next_picture_ptr =
1063 
1064  // init
1066  s->mb_height = (s->height + 31) / 32 * 2;
1067  else
1068  s->mb_height = (s->height + 15) / 16;
1069 
1070  if ((s->width || s->height) &&
1071  (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1072  goto fail;
1073 
1074  if ((err = init_context_frame(s)))
1075  goto fail;
1076 
1077  memset(s->thread_context, 0, sizeof(s->thread_context));
1078  s->thread_context[0] = s;
1079 
1080  if (s->width && s->height) {
1081  int nb_slices = s->slice_context_count;
1082  if (nb_slices > 1) {
1083  for (i = 0; i < nb_slices; i++) {
1084  if (i) {
1085  s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
1086  if (!s->thread_context[i]) {
1087  err = AVERROR(ENOMEM);
1088  goto fail;
1089  }
1090  }
1091  if ((err = init_duplicate_context(s->thread_context[i])) < 0)
1092  goto fail;
1093  s->thread_context[i]->start_mb_y =
1094  (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1095  s->thread_context[i]->end_mb_y =
1096  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1097  }
1098  } else {
1099  err = init_duplicate_context(s);
1100  if (err < 0)
1101  goto fail;
1102  s->start_mb_y = 0;
1103  s->end_mb_y = s->mb_height;
1104  }
1105  s->slice_context_count = nb_slices;
1106  }
1107 
1108  return 0;
1109  fail:
1110  ff_mpv_common_end(s);
1111  return err;
1112 }
1113 
1114 /* init common structure for both encoder and decoder */
1116 {
1117  int i;
1118 
1119  if (!s)
1120  return ;
1121 
1122  if (s->slice_context_count > 1) {
1123  for (i = 0; i < s->slice_context_count; i++) {
1125  }
1126  for (i = 1; i < s->slice_context_count; i++) {
1127  av_freep(&s->thread_context[i]);
1128  }
1129  s->slice_context_count = 1;
1130  } else free_duplicate_context(s);
1131 
1133  s->parse_context.buffer_size = 0;
1134 
1137 
1138  if (s->picture) {
1139  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1141  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1142  av_frame_free(&s->picture[i].f);
1143  }
1144  }
1145  av_freep(&s->picture);
1158 
1159  free_context_frame(s);
1160 
1161  s->context_initialized = 0;
1162  s->last_picture_ptr =
1163  s->next_picture_ptr =
1165  s->linesize = s->uvlinesize = 0;
1166 }
1167 
1168 
1169 static void gray_frame(AVFrame *frame)
1170 {
1171  int i, h_chroma_shift, v_chroma_shift;
1172 
1173  av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1174 
1175  for(i=0; i<frame->height; i++)
1176  memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1177  for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1178  memset(frame->data[1] + frame->linesize[1]*i,
1179  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1180  memset(frame->data[2] + frame->linesize[2]*i,
1181  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1182  }
1183 }
1184 
1185 /**
1186  * generic function called after decoding
1187  * the header and before a frame is decoded.
1188  */
1190 {
1191  int i, ret;
1192  Picture *pic;
1193  s->mb_skipped = 0;
1194 
1195  if (!ff_thread_can_start_frame(avctx)) {
1196  av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1197  return -1;
1198  }
1199 
1200  /* mark & release old frames */
1201  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1203  s->last_picture_ptr->f->buf[0]) {
1205  }
1206 
1207  /* release forgotten pictures */
1208  /* if (MPEG-124 / H.263) */
1209  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1210  if (&s->picture[i] != s->last_picture_ptr &&
1211  &s->picture[i] != s->next_picture_ptr &&
1212  s->picture[i].reference && !s->picture[i].needs_realloc) {
1213  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1214  }
1215  }
1216 
1220 
1221  /* release non reference frames */
1222  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1223  if (!s->picture[i].reference)
1224  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1225  }
1226 
1227  if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1228  // we already have an unused image
1229  // (maybe it was set before reading the header)
1230  pic = s->current_picture_ptr;
1231  } else {
1232  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1233  if (i < 0) {
1234  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1235  return i;
1236  }
1237  pic = &s->picture[i];
1238  }
1239 
1240  pic->reference = 0;
1241  if (!s->droppable) {
1242  if (s->pict_type != AV_PICTURE_TYPE_B)
1243  pic->reference = 3;
1244  }
1245 
1247 
1248  if (alloc_picture(s, pic, 0) < 0)
1249  return -1;
1250 
1251  s->current_picture_ptr = pic;
1252  // FIXME use only the vars from current_pic
1254  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1256  if (s->picture_structure != PICT_FRAME)
1259  }
1263 
1265  // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
1266  // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1268 
1269  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1270  s->current_picture_ptr)) < 0)
1271  return ret;
1272 
1273  if (s->pict_type != AV_PICTURE_TYPE_B) {
1275  if (!s->droppable)
1277  }
1278  ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1280  s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1281  s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1283  s->pict_type, s->droppable);
1284 
1285  if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1286  (s->pict_type != AV_PICTURE_TYPE_I ||
1287  s->picture_structure != PICT_FRAME)) {
1288  int h_chroma_shift, v_chroma_shift;
1290  &h_chroma_shift, &v_chroma_shift);
1292  av_log(avctx, AV_LOG_DEBUG,
1293  "allocating dummy last picture for B frame\n");
1294  else if (s->pict_type != AV_PICTURE_TYPE_I)
1295  av_log(avctx, AV_LOG_ERROR,
1296  "warning: first frame is no keyframe\n");
1297  else if (s->picture_structure != PICT_FRAME)
1298  av_log(avctx, AV_LOG_DEBUG,
1299  "allocate dummy last picture for field based first keyframe\n");
1300 
1301  /* Allocate a dummy frame */
1302  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1303  if (i < 0) {
1304  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1305  return i;
1306  }
1307  s->last_picture_ptr = &s->picture[i];
1308 
1309  s->last_picture_ptr->reference = 3;
1310  s->last_picture_ptr->f->key_frame = 0;
1312 
1313  if (alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1314  s->last_picture_ptr = NULL;
1315  return -1;
1316  }
1317 
1318  if (!avctx->hwaccel
1319 #if FF_API_CAP_VDPAU
1321 #endif
1322  ) {
1323  for(i=0; i<avctx->height; i++)
1324  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1325  0x80, avctx->width);
1326  if (s->last_picture_ptr->f->data[2]) {
1327  for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1328  memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1329  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1330  memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1331  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1332  }
1333  }
1334 
1336  for(i=0; i<avctx->height; i++)
1337  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1338  }
1339  }
1340 
1341  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1342  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1343  }
1344  if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1345  s->pict_type == AV_PICTURE_TYPE_B) {
1346  /* Allocate a dummy frame */
1347  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1348  if (i < 0) {
1349  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1350  return i;
1351  }
1352  s->next_picture_ptr = &s->picture[i];
1353 
1354  s->next_picture_ptr->reference = 3;
1355  s->next_picture_ptr->f->key_frame = 0;
1357 
1358  if (alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1359  s->next_picture_ptr = NULL;
1360  return -1;
1361  }
1362  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1363  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1364  }
1365 
1366 #if 0 // BUFREF-FIXME
1367  memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1368  memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1369 #endif
1370  if (s->last_picture_ptr) {
1371  if (s->last_picture_ptr->f->buf[0] &&
1372  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1373  s->last_picture_ptr)) < 0)
1374  return ret;
1375  }
1376  if (s->next_picture_ptr) {
1377  if (s->next_picture_ptr->f->buf[0] &&
1378  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1379  s->next_picture_ptr)) < 0)
1380  return ret;
1381  }
1382 
1384  s->last_picture_ptr->f->buf[0]));
1385 
1386  if (s->picture_structure!= PICT_FRAME) {
1387  int i;
1388  for (i = 0; i < 4; i++) {
1390  s->current_picture.f->data[i] +=
1391  s->current_picture.f->linesize[i];
1392  }
1393  s->current_picture.f->linesize[i] *= 2;
1394  s->last_picture.f->linesize[i] *= 2;
1395  s->next_picture.f->linesize[i] *= 2;
1396  }
1397  }
1398 
1399  /* set dequantizer, we can't do it during init as
1400  * it might change for MPEG-4 and we can't do it in the header
1401  * decode as init is not called for MPEG-4 there yet */
1402  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1405  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1408  } else {
1411  }
1412 
1413  if (s->avctx->debug & FF_DEBUG_NOMC) {
1415  }
1416 
1417  return 0;
1418 }
1419 
1420 /* called after a frame has been decoded. */
1422 {
1423  emms_c();
1424 
1425  if (s->current_picture.reference)
1427 }
1428 
1429 
1430 #if FF_API_VISMV
1431 static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx)
1432 {
1433  if(*sx > *ex)
1434  return clip_line(ex, ey, sx, sy, maxx);
1435 
1436  if (*sx < 0) {
1437  if (*ex < 0)
1438  return 1;
1439  *sy = *ey + (*sy - *ey) * (int64_t)*ex / (*ex - *sx);
1440  *sx = 0;
1441  }
1442 
1443  if (*ex > maxx) {
1444  if (*sx > maxx)
1445  return 1;
1446  *ey = *sy + (*ey - *sy) * (int64_t)(maxx - *sx) / (*ex - *sx);
1447  *ex = maxx;
1448  }
1449  return 0;
1450 }
1451 
1452 
1453 /**
1454  * Draw a line from (ex, ey) -> (sx, sy).
1455  * @param w width of the image
1456  * @param h height of the image
1457  * @param stride stride/linesize of the image
1458  * @param color color of the arrow
1459  */
1460 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1461  int w, int h, int stride, int color)
1462 {
1463  int x, y, fr, f;
1464 
1465  if (clip_line(&sx, &sy, &ex, &ey, w - 1))
1466  return;
1467  if (clip_line(&sy, &sx, &ey, &ex, h - 1))
1468  return;
1469 
1470  sx = av_clip(sx, 0, w - 1);
1471  sy = av_clip(sy, 0, h - 1);
1472  ex = av_clip(ex, 0, w - 1);
1473  ey = av_clip(ey, 0, h - 1);
1474 
1475  buf[sy * stride + sx] += color;
1476 
1477  if (FFABS(ex - sx) > FFABS(ey - sy)) {
1478  if (sx > ex) {
1479  FFSWAP(int, sx, ex);
1480  FFSWAP(int, sy, ey);
1481  }
1482  buf += sx + sy * stride;
1483  ex -= sx;
1484  f = ((ey - sy) << 16) / ex;
1485  for (x = 0; x <= ex; x++) {
1486  y = (x * f) >> 16;
1487  fr = (x * f) & 0xFFFF;
1488  buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1489  if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1490  }
1491  } else {
1492  if (sy > ey) {
1493  FFSWAP(int, sx, ex);
1494  FFSWAP(int, sy, ey);
1495  }
1496  buf += sx + sy * stride;
1497  ey -= sy;
1498  if (ey)
1499  f = ((ex - sx) << 16) / ey;
1500  else
1501  f = 0;
1502  for(y= 0; y <= ey; y++){
1503  x = (y*f) >> 16;
1504  fr = (y*f) & 0xFFFF;
1505  buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1506  if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1507  }
1508  }
1509 }
1510 
1511 /**
1512  * Draw an arrow from (ex, ey) -> (sx, sy).
1513  * @param w width of the image
1514  * @param h height of the image
1515  * @param stride stride/linesize of the image
1516  * @param color color of the arrow
1517  */
1518 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1519  int ey, int w, int h, int stride, int color, int tail, int direction)
1520 {
1521  int dx,dy;
1522 
1523  if (direction) {
1524  FFSWAP(int, sx, ex);
1525  FFSWAP(int, sy, ey);
1526  }
1527 
1528  sx = av_clip(sx, -100, w + 100);
1529  sy = av_clip(sy, -100, h + 100);
1530  ex = av_clip(ex, -100, w + 100);
1531  ey = av_clip(ey, -100, h + 100);
1532 
1533  dx = ex - sx;
1534  dy = ey - sy;
1535 
1536  if (dx * dx + dy * dy > 3 * 3) {
1537  int rx = dx + dy;
1538  int ry = -dx + dy;
1539  int length = ff_sqrt((rx * rx + ry * ry) << 8);
1540 
1541  // FIXME subpixel accuracy
1542  rx = ROUNDED_DIV(rx * 3 << 4, length);
1543  ry = ROUNDED_DIV(ry * 3 << 4, length);
1544 
1545  if (tail) {
1546  rx = -rx;
1547  ry = -ry;
1548  }
1549 
1550  draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1551  draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1552  }
1553  draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1554 }
1555 #endif
1556 
1557 static int add_mb(AVMotionVector *mb, uint32_t mb_type,
1558  int dst_x, int dst_y,
1559  int motion_x, int motion_y, int motion_scale,
1560  int direction)
1561 {
1562  mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
1563  mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
1564  mb->motion_x = motion_x;
1565  mb->motion_y = motion_y;
1566  mb->motion_scale = motion_scale;
1567  mb->dst_x = dst_x;
1568  mb->dst_y = dst_y;
1569  mb->src_x = dst_x + motion_x / motion_scale;
1570  mb->src_y = dst_y + motion_y / motion_scale;
1571  mb->source = direction ? 1 : -1;
1572  mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
1573  return 1;
1574 }
1575 
1576 /**
1577  * Print debugging info for the given picture.
1578  */
1579 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
1580  uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
1581  int *low_delay,
1582  int mb_width, int mb_height, int mb_stride, int quarter_sample)
1583 {
1584  if ((avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
1585  const int shift = 1 + quarter_sample;
1586  const int scale = 1 << shift;
1587  const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
1588  const int mv_stride = (mb_width << mv_sample_log2) +
1589  (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
1590  int mb_x, mb_y, mbcount = 0;
1591 
1592  /* size is width * height * 2 * 4 where 2 is for directions and 4 is
1593  * for the maximum number of MB (4 MB in case of IS_8x8) */
1594  AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
1595  if (!mvs)
1596  return;
1597 
1598  for (mb_y = 0; mb_y < mb_height; mb_y++) {
1599  for (mb_x = 0; mb_x < mb_width; mb_x++) {
1600  int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
1601  for (direction = 0; direction < 2; direction++) {
1602  if (!USES_LIST(mb_type, direction))
1603  continue;
1604  if (IS_8X8(mb_type)) {
1605  for (i = 0; i < 4; i++) {
1606  int sx = mb_x * 16 + 4 + 8 * (i & 1);
1607  int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1608  int xy = (mb_x * 2 + (i & 1) +
1609  (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1610  int mx = motion_val[direction][xy][0];
1611  int my = motion_val[direction][xy][1];
1612  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
1613  }
1614  } else if (IS_16X8(mb_type)) {
1615  for (i = 0; i < 2; i++) {
1616  int sx = mb_x * 16 + 8;
1617  int sy = mb_y * 16 + 4 + 8 * i;
1618  int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1619  int mx = motion_val[direction][xy][0];
1620  int my = motion_val[direction][xy][1];
1621 
1622  if (IS_INTERLACED(mb_type))
1623  my *= 2;
1624 
1625  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
1626  }
1627  } else if (IS_8X16(mb_type)) {
1628  for (i = 0; i < 2; i++) {
1629  int sx = mb_x * 16 + 4 + 8 * i;
1630  int sy = mb_y * 16 + 8;
1631  int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1632  int mx = motion_val[direction][xy][0];
1633  int my = motion_val[direction][xy][1];
1634 
1635  if (IS_INTERLACED(mb_type))
1636  my *= 2;
1637 
1638  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
1639  }
1640  } else {
1641  int sx = mb_x * 16 + 8;
1642  int sy = mb_y * 16 + 8;
1643  int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1644  int mx = motion_val[direction][xy][0];
1645  int my = motion_val[direction][xy][1];
1646  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
1647  }
1648  }
1649  }
1650  }
1651 
1652  if (mbcount) {
1653  AVFrameSideData *sd;
1654 
1655  av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
1657  if (!sd) {
1658  av_freep(&mvs);
1659  return;
1660  }
1661  memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
1662  }
1663 
1664  av_freep(&mvs);
1665  }
1666 
1667  /* TODO: export all the following to make them accessible for users (and filters) */
1668  if (avctx->hwaccel || !mbtype_table
1669 #if FF_API_CAP_VDPAU
1671 #endif
1672  )
1673  return;
1674 
1675 
1676  if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1677  int x,y;
1678 
1679  av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1681  for (y = 0; y < mb_height; y++) {
1682  for (x = 0; x < mb_width; x++) {
1683  if (avctx->debug & FF_DEBUG_SKIP) {
1684  int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;
1685  if (count > 9)
1686  count = 9;
1687  av_log(avctx, AV_LOG_DEBUG, "%1d", count);
1688  }
1689  if (avctx->debug & FF_DEBUG_QP) {
1690  av_log(avctx, AV_LOG_DEBUG, "%2d",
1691  qscale_table[x + y * mb_stride]);
1692  }
1693  if (avctx->debug & FF_DEBUG_MB_TYPE) {
1694  int mb_type = mbtype_table[x + y * mb_stride];
1695  // Type & MV direction
1696  if (IS_PCM(mb_type))
1697  av_log(avctx, AV_LOG_DEBUG, "P");
1698  else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1699  av_log(avctx, AV_LOG_DEBUG, "A");
1700  else if (IS_INTRA4x4(mb_type))
1701  av_log(avctx, AV_LOG_DEBUG, "i");
1702  else if (IS_INTRA16x16(mb_type))
1703  av_log(avctx, AV_LOG_DEBUG, "I");
1704  else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1705  av_log(avctx, AV_LOG_DEBUG, "d");
1706  else if (IS_DIRECT(mb_type))
1707  av_log(avctx, AV_LOG_DEBUG, "D");
1708  else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1709  av_log(avctx, AV_LOG_DEBUG, "g");
1710  else if (IS_GMC(mb_type))
1711  av_log(avctx, AV_LOG_DEBUG, "G");
1712  else if (IS_SKIP(mb_type))
1713  av_log(avctx, AV_LOG_DEBUG, "S");
1714  else if (!USES_LIST(mb_type, 1))
1715  av_log(avctx, AV_LOG_DEBUG, ">");
1716  else if (!USES_LIST(mb_type, 0))
1717  av_log(avctx, AV_LOG_DEBUG, "<");
1718  else {
1719  av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1720  av_log(avctx, AV_LOG_DEBUG, "X");
1721  }
1722 
1723  // segmentation
1724  if (IS_8X8(mb_type))
1725  av_log(avctx, AV_LOG_DEBUG, "+");
1726  else if (IS_16X8(mb_type))
1727  av_log(avctx, AV_LOG_DEBUG, "-");
1728  else if (IS_8X16(mb_type))
1729  av_log(avctx, AV_LOG_DEBUG, "|");
1730  else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1731  av_log(avctx, AV_LOG_DEBUG, " ");
1732  else
1733  av_log(avctx, AV_LOG_DEBUG, "?");
1734 
1735 
1736  if (IS_INTERLACED(mb_type))
1737  av_log(avctx, AV_LOG_DEBUG, "=");
1738  else
1739  av_log(avctx, AV_LOG_DEBUG, " ");
1740  }
1741  }
1742  av_log(avctx, AV_LOG_DEBUG, "\n");
1743  }
1744  }
1745 
1746  if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1747  (avctx->debug_mv)) {
1748  int mb_y;
1749  int i;
1750  int h_chroma_shift, v_chroma_shift, block_height;
1751 #if FF_API_VISMV
1752  const int shift = 1 + quarter_sample;
1753  uint8_t *ptr;
1754  const int width = avctx->width;
1755  const int height = avctx->height;
1756 #endif
1757  const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
1758  const int mv_stride = (mb_width << mv_sample_log2) +
1759  (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
1760 
1761  if (low_delay)
1762  *low_delay = 0; // needed to see the vectors without trashing the buffers
1763 
1764  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1765 
1766  av_frame_make_writable(pict);
1767 
1768  pict->opaque = NULL;
1769 #if FF_API_VISMV
1770  ptr = pict->data[0];
1771 #endif
1772  block_height = 16 >> v_chroma_shift;
1773 
1774  for (mb_y = 0; mb_y < mb_height; mb_y++) {
1775  int mb_x;
1776  for (mb_x = 0; mb_x < mb_width; mb_x++) {
1777  const int mb_index = mb_x + mb_y * mb_stride;
1778 #if FF_API_VISMV
1779  if ((avctx->debug_mv) && motion_val[0]) {
1780  int type;
1781  for (type = 0; type < 3; type++) {
1782  int direction = 0;
1783  switch (type) {
1784  case 0:
1785  if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1786  (pict->pict_type!= AV_PICTURE_TYPE_P))
1787  continue;
1788  direction = 0;
1789  break;
1790  case 1:
1791  if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1792  (pict->pict_type!= AV_PICTURE_TYPE_B))
1793  continue;
1794  direction = 0;
1795  break;
1796  case 2:
1797  if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1798  (pict->pict_type!= AV_PICTURE_TYPE_B))
1799  continue;
1800  direction = 1;
1801  break;
1802  }
1803  if (!USES_LIST(mbtype_table[mb_index], direction))
1804  continue;
1805 
1806  if (IS_8X8(mbtype_table[mb_index])) {
1807  int i;
1808  for (i = 0; i < 4; i++) {
1809  int sx = mb_x * 16 + 4 + 8 * (i & 1);
1810  int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1811  int xy = (mb_x * 2 + (i & 1) +
1812  (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1813  int mx = (motion_val[direction][xy][0] >> shift) + sx;
1814  int my = (motion_val[direction][xy][1] >> shift) + sy;
1815  draw_arrow(ptr, sx, sy, mx, my, width,
1816  height, pict->linesize[0], 100, 0, direction);
1817  }
1818  } else if (IS_16X8(mbtype_table[mb_index])) {
1819  int i;
1820  for (i = 0; i < 2; i++) {
1821  int sx = mb_x * 16 + 8;
1822  int sy = mb_y * 16 + 4 + 8 * i;
1823  int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1824  int mx = (motion_val[direction][xy][0] >> shift);
1825  int my = (motion_val[direction][xy][1] >> shift);
1826 
1827  if (IS_INTERLACED(mbtype_table[mb_index]))
1828  my *= 2;
1829 
1830  draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1831  height, pict->linesize[0], 100, 0, direction);
1832  }
1833  } else if (IS_8X16(mbtype_table[mb_index])) {
1834  int i;
1835  for (i = 0; i < 2; i++) {
1836  int sx = mb_x * 16 + 4 + 8 * i;
1837  int sy = mb_y * 16 + 8;
1838  int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1839  int mx = motion_val[direction][xy][0] >> shift;
1840  int my = motion_val[direction][xy][1] >> shift;
1841 
1842  if (IS_INTERLACED(mbtype_table[mb_index]))
1843  my *= 2;
1844 
1845  draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1846  height, pict->linesize[0], 100, 0, direction);
1847  }
1848  } else {
1849  int sx= mb_x * 16 + 8;
1850  int sy= mb_y * 16 + 8;
1851  int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1852  int mx= (motion_val[direction][xy][0]>>shift) + sx;
1853  int my= (motion_val[direction][xy][1]>>shift) + sy;
1854  draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100, 0, direction);
1855  }
1856  }
1857  }
1858 #endif
1859  if ((avctx->debug & FF_DEBUG_VIS_QP)) {
1860  uint64_t c = (qscale_table[mb_index] * 128 / 31) *
1861  0x0101010101010101ULL;
1862  int y;
1863  for (y = 0; y < block_height; y++) {
1864  *(uint64_t *)(pict->data[1] + 8 * mb_x +
1865  (block_height * mb_y + y) *
1866  pict->linesize[1]) = c;
1867  *(uint64_t *)(pict->data[2] + 8 * mb_x +
1868  (block_height * mb_y + y) *
1869  pict->linesize[2]) = c;
1870  }
1871  }
1872  if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1873  motion_val[0]) {
1874  int mb_type = mbtype_table[mb_index];
1875  uint64_t u,v;
1876  int y;
1877 #define COLOR(theta, r) \
1878  u = (int)(128 + r * cos(theta * M_PI / 180)); \
1879  v = (int)(128 + r * sin(theta * M_PI / 180));
1880 
1881 
1882  u = v = 128;
1883  if (IS_PCM(mb_type)) {
1884  COLOR(120, 48)
1885  } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1886  IS_INTRA16x16(mb_type)) {
1887  COLOR(30, 48)
1888  } else if (IS_INTRA4x4(mb_type)) {
1889  COLOR(90, 48)
1890  } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1891  // COLOR(120, 48)
1892  } else if (IS_DIRECT(mb_type)) {
1893  COLOR(150, 48)
1894  } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1895  COLOR(170, 48)
1896  } else if (IS_GMC(mb_type)) {
1897  COLOR(190, 48)
1898  } else if (IS_SKIP(mb_type)) {
1899  // COLOR(180, 48)
1900  } else if (!USES_LIST(mb_type, 1)) {
1901  COLOR(240, 48)
1902  } else if (!USES_LIST(mb_type, 0)) {
1903  COLOR(0, 48)
1904  } else {
1905  av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1906  COLOR(300,48)
1907  }
1908 
1909  u *= 0x0101010101010101ULL;
1910  v *= 0x0101010101010101ULL;
1911  for (y = 0; y < block_height; y++) {
1912  *(uint64_t *)(pict->data[1] + 8 * mb_x +
1913  (block_height * mb_y + y) * pict->linesize[1]) = u;
1914  *(uint64_t *)(pict->data[2] + 8 * mb_x +
1915  (block_height * mb_y + y) * pict->linesize[2]) = v;
1916  }
1917 
1918  // segmentation
1919  if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1920  *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1921  (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1922  *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1923  (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1924  }
1925  if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1926  for (y = 0; y < 16; y++)
1927  pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1928  pict->linesize[0]] ^= 0x80;
1929  }
1930  if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1931  int dm = 1 << (mv_sample_log2 - 2);
1932  for (i = 0; i < 4; i++) {
1933  int sx = mb_x * 16 + 8 * (i & 1);
1934  int sy = mb_y * 16 + 8 * (i >> 1);
1935  int xy = (mb_x * 2 + (i & 1) +
1936  (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1937  // FIXME bidir
1938  int32_t *mv = (int32_t *) &motion_val[0][xy];
1939  if (mv[0] != mv[dm] ||
1940  mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1941  for (y = 0; y < 8; y++)
1942  pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1943  if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1944  *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1945  pict->linesize[0]) ^= 0x8080808080808080ULL;
1946  }
1947  }
1948 
1949  if (IS_INTERLACED(mb_type) &&
1950  avctx->codec->id == AV_CODEC_ID_H264) {
1951  // hmm
1952  }
1953  }
1954  if (mbskip_table)
1955  mbskip_table[mb_index] = 0;
1956  }
1957  }
1958  }
1959 }
1960 
1962 {
1964  p->qscale_table, p->motion_val, &s->low_delay,
1965  s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
1966 }
1967 
1969 {
1971  int offset = 2*s->mb_stride + 1;
1972  if(!ref)
1973  return AVERROR(ENOMEM);
1974  av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
1975  ref->size -= offset;
1976  ref->data += offset;
1977  return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
1978 }
1979 
1981  uint8_t *dest, uint8_t *src,
1982  int field_based, int field_select,
1983  int src_x, int src_y,
1984  int width, int height, ptrdiff_t stride,
1985  int h_edge_pos, int v_edge_pos,
1986  int w, int h, h264_chroma_mc_func *pix_op,
1987  int motion_x, int motion_y)
1988 {
1989  const int lowres = s->avctx->lowres;
1990  const int op_index = FFMIN(lowres, 3);
1991  const int s_mask = (2 << lowres) - 1;
1992  int emu = 0;
1993  int sx, sy;
1994 
1995  if (s->quarter_sample) {
1996  motion_x /= 2;
1997  motion_y /= 2;
1998  }
1999 
2000  sx = motion_x & s_mask;
2001  sy = motion_y & s_mask;
2002  src_x += motion_x >> lowres + 1;
2003  src_y += motion_y >> lowres + 1;
2004 
2005  src += src_y * stride + src_x;
2006 
2007  if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2008  (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2010  s->linesize, s->linesize,
2011  w + 1, (h + 1) << field_based,
2012  src_x, src_y << field_based,
2013  h_edge_pos, v_edge_pos);
2014  src = s->sc.edge_emu_buffer;
2015  emu = 1;
2016  }
2017 
2018  sx = (sx << 2) >> lowres;
2019  sy = (sy << 2) >> lowres;
2020  if (field_select)
2021  src += s->linesize;
2022  pix_op[op_index](dest, src, stride, h, sx, sy);
2023  return emu;
2024 }
2025 
2026 /* apply one mpeg motion vector to the three components */
2028  uint8_t *dest_y,
2029  uint8_t *dest_cb,
2030  uint8_t *dest_cr,
2031  int field_based,
2032  int bottom_field,
2033  int field_select,
2034  uint8_t **ref_picture,
2035  h264_chroma_mc_func *pix_op,
2036  int motion_x, int motion_y,
2037  int h, int mb_y)
2038 {
2039  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2040  int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
2041  ptrdiff_t uvlinesize, linesize;
2042  const int lowres = s->avctx->lowres;
2043  const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
2044  const int block_s = 8>>lowres;
2045  const int s_mask = (2 << lowres) - 1;
2046  const int h_edge_pos = s->h_edge_pos >> lowres;
2047  const int v_edge_pos = s->v_edge_pos >> lowres;
2048  linesize = s->current_picture.f->linesize[0] << field_based;
2049  uvlinesize = s->current_picture.f->linesize[1] << field_based;
2050 
2051  // FIXME obviously not perfect but qpel will not work in lowres anyway
2052  if (s->quarter_sample) {
2053  motion_x /= 2;
2054  motion_y /= 2;
2055  }
2056 
2057  if(field_based){
2058  motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2059  }
2060 
2061  sx = motion_x & s_mask;
2062  sy = motion_y & s_mask;
2063  src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2064  src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2065 
2066  if (s->out_format == FMT_H263) {
2067  uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2068  uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2069  uvsrc_x = src_x >> 1;
2070  uvsrc_y = src_y >> 1;
2071  } else if (s->out_format == FMT_H261) {
2072  // even chroma mv's are full pel in H261
2073  mx = motion_x / 4;
2074  my = motion_y / 4;
2075  uvsx = (2 * mx) & s_mask;
2076  uvsy = (2 * my) & s_mask;
2077  uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2078  uvsrc_y = mb_y * block_s + (my >> lowres);
2079  } else {
2080  if(s->chroma_y_shift){
2081  mx = motion_x / 2;
2082  my = motion_y / 2;
2083  uvsx = mx & s_mask;
2084  uvsy = my & s_mask;
2085  uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2086  uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2087  } else {
2088  if(s->chroma_x_shift){
2089  //Chroma422
2090  mx = motion_x / 2;
2091  uvsx = mx & s_mask;
2092  uvsy = motion_y & s_mask;
2093  uvsrc_y = src_y;
2094  uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2095  } else {
2096  //Chroma444
2097  uvsx = motion_x & s_mask;
2098  uvsy = motion_y & s_mask;
2099  uvsrc_x = src_x;
2100  uvsrc_y = src_y;
2101  }
2102  }
2103  }
2104 
2105  ptr_y = ref_picture[0] + src_y * linesize + src_x;
2106  ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2107  ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2108 
2109  if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
2110  (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2111  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
2112  linesize >> field_based, linesize >> field_based,
2113  17, 17 + field_based,
2114  src_x, src_y << field_based, h_edge_pos,
2115  v_edge_pos);
2116  ptr_y = s->sc.edge_emu_buffer;
2117  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2118  uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
2119  uint8_t *vbuf =ubuf + 9 * s->uvlinesize;
2120  s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
2121  uvlinesize >> field_based, uvlinesize >> field_based,
2122  9, 9 + field_based,
2123  uvsrc_x, uvsrc_y << field_based,
2124  h_edge_pos >> 1, v_edge_pos >> 1);
2125  s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
2126  uvlinesize >> field_based,uvlinesize >> field_based,
2127  9, 9 + field_based,
2128  uvsrc_x, uvsrc_y << field_based,
2129  h_edge_pos >> 1, v_edge_pos >> 1);
2130  ptr_cb = ubuf;
2131  ptr_cr = vbuf;
2132  }
2133  }
2134 
2135  // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
2136  if (bottom_field) {
2137  dest_y += s->linesize;
2138  dest_cb += s->uvlinesize;
2139  dest_cr += s->uvlinesize;
2140  }
2141 
2142  if (field_select) {
2143  ptr_y += s->linesize;
2144  ptr_cb += s->uvlinesize;
2145  ptr_cr += s->uvlinesize;
2146  }
2147 
2148  sx = (sx << 2) >> lowres;
2149  sy = (sy << 2) >> lowres;
2150  pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2151 
2152  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2153  int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
2154  uvsx = (uvsx << 2) >> lowres;
2155  uvsy = (uvsy << 2) >> lowres;
2156  if (hc) {
2157  pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2158  pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2159  }
2160  }
2161  // FIXME h261 lowres loop filter
2162 }
2163 
2165  uint8_t *dest_cb, uint8_t *dest_cr,
2166  uint8_t **ref_picture,
2167  h264_chroma_mc_func * pix_op,
2168  int mx, int my)
2169 {
2170  const int lowres = s->avctx->lowres;
2171  const int op_index = FFMIN(lowres, 3);
2172  const int block_s = 8 >> lowres;
2173  const int s_mask = (2 << lowres) - 1;
2174  const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2175  const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2176  int emu = 0, src_x, src_y, sx, sy;
2177  ptrdiff_t offset;
2178  uint8_t *ptr;
2179 
2180  if (s->quarter_sample) {
2181  mx /= 2;
2182  my /= 2;
2183  }
2184 
2185  /* In case of 8X8, we construct a single chroma motion vector
2186  with a special rounding */
2187  mx = ff_h263_round_chroma(mx);
2188  my = ff_h263_round_chroma(my);
2189 
2190  sx = mx & s_mask;
2191  sy = my & s_mask;
2192  src_x = s->mb_x * block_s + (mx >> lowres + 1);
2193  src_y = s->mb_y * block_s + (my >> lowres + 1);
2194 
2195  offset = src_y * s->uvlinesize + src_x;
2196  ptr = ref_picture[1] + offset;
2197  if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2198  (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2200  s->uvlinesize, s->uvlinesize,
2201  9, 9,
2202  src_x, src_y, h_edge_pos, v_edge_pos);
2203  ptr = s->sc.edge_emu_buffer;
2204  emu = 1;
2205  }
2206  sx = (sx << 2) >> lowres;
2207  sy = (sy << 2) >> lowres;
2208  pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2209 
2210  ptr = ref_picture[2] + offset;
2211  if (emu) {
2213  s->uvlinesize, s->uvlinesize,
2214  9, 9,
2215  src_x, src_y, h_edge_pos, v_edge_pos);
2216  ptr = s->sc.edge_emu_buffer;
2217  }
2218  pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2219 }
2220 
2221 /**
2222  * motion compensation of a single macroblock
2223  * @param s context
2224  * @param dest_y luma destination pointer
2225  * @param dest_cb chroma cb/u destination pointer
2226  * @param dest_cr chroma cr/v destination pointer
2227  * @param dir direction (0->forward, 1->backward)
2228  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2229  * @param pix_op halfpel motion compensation function (average or put normally)
2230  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2231  */
2232 static inline void MPV_motion_lowres(MpegEncContext *s,
2233  uint8_t *dest_y, uint8_t *dest_cb,
2234  uint8_t *dest_cr,
2235  int dir, uint8_t **ref_picture,
2236  h264_chroma_mc_func *pix_op)
2237 {
2238  int mx, my;
2239  int mb_x, mb_y, i;
2240  const int lowres = s->avctx->lowres;
2241  const int block_s = 8 >>lowres;
2242 
2243  mb_x = s->mb_x;
2244  mb_y = s->mb_y;
2245 
2246  switch (s->mv_type) {
2247  case MV_TYPE_16X16:
2248  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2249  0, 0, 0,
2250  ref_picture, pix_op,
2251  s->mv[dir][0][0], s->mv[dir][0][1],
2252  2 * block_s, mb_y);
2253  break;
2254  case MV_TYPE_8X8:
2255  mx = 0;
2256  my = 0;
2257  for (i = 0; i < 4; i++) {
2258  hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2259  s->linesize) * block_s,
2260  ref_picture[0], 0, 0,
2261  (2 * mb_x + (i & 1)) * block_s,
2262  (2 * mb_y + (i >> 1)) * block_s,
2263  s->width, s->height, s->linesize,
2264  s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2265  block_s, block_s, pix_op,
2266  s->mv[dir][i][0], s->mv[dir][i][1]);
2267 
2268  mx += s->mv[dir][i][0];
2269  my += s->mv[dir][i][1];
2270  }
2271 
2272  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
2273  chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2274  pix_op, mx, my);
2275  break;
2276  case MV_TYPE_FIELD:
2277  if (s->picture_structure == PICT_FRAME) {
2278  /* top field */
2279  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2280  1, 0, s->field_select[dir][0],
2281  ref_picture, pix_op,
2282  s->mv[dir][0][0], s->mv[dir][0][1],
2283  block_s, mb_y);
2284  /* bottom field */
2285  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2286  1, 1, s->field_select[dir][1],
2287  ref_picture, pix_op,
2288  s->mv[dir][1][0], s->mv[dir][1][1],
2289  block_s, mb_y);
2290  } else {
2291  if (s->picture_structure != s->field_select[dir][0] + 1 &&
2292  s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2293  ref_picture = s->current_picture_ptr->f->data;
2294 
2295  }
2296  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2297  0, 0, s->field_select[dir][0],
2298  ref_picture, pix_op,
2299  s->mv[dir][0][0],
2300  s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2301  }
2302  break;
2303  case MV_TYPE_16X8:
2304  for (i = 0; i < 2; i++) {
2305  uint8_t **ref2picture;
2306 
2307  if (s->picture_structure == s->field_select[dir][i] + 1 ||
2308  s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2309  ref2picture = ref_picture;
2310  } else {
2311  ref2picture = s->current_picture_ptr->f->data;
2312  }
2313 
2314  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2315  0, 0, s->field_select[dir][i],
2316  ref2picture, pix_op,
2317  s->mv[dir][i][0], s->mv[dir][i][1] +
2318  2 * block_s * i, block_s, mb_y >> 1);
2319 
2320  dest_y += 2 * block_s * s->linesize;
2321  dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2322  dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2323  }
2324  break;
2325  case MV_TYPE_DMV:
2326  if (s->picture_structure == PICT_FRAME) {
2327  for (i = 0; i < 2; i++) {
2328  int j;
2329  for (j = 0; j < 2; j++) {
2330  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2331  1, j, j ^ i,
2332  ref_picture, pix_op,
2333  s->mv[dir][2 * i + j][0],
2334  s->mv[dir][2 * i + j][1],
2335  block_s, mb_y);
2336  }
2338  }
2339  } else {
2340  for (i = 0; i < 2; i++) {
2341  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2342  0, 0, s->picture_structure != i + 1,
2343  ref_picture, pix_op,
2344  s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2345  2 * block_s, mb_y >> 1);
2346 
2347  // after put we make avg of the same block
2349 
2350  // opposite parity is always in the same
2351  // frame if this is second field
2352  if (!s->first_field) {
2353  ref_picture = s->current_picture_ptr->f->data;
2354  }
2355  }
2356  }
2357  break;
2358  default:
2359  av_assert2(0);
2360  }
2361 }
2362 
2363 /**
2364  * find the lowest MB row referenced in the MVs
2365  */
2367 {
2368  int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2369  int my, off, i, mvs;
2370 
2371  if (s->picture_structure != PICT_FRAME || s->mcsel)
2372  goto unhandled;
2373 
2374  switch (s->mv_type) {
2375  case MV_TYPE_16X16:
2376  mvs = 1;
2377  break;
2378  case MV_TYPE_16X8:
2379  mvs = 2;
2380  break;
2381  case MV_TYPE_8X8:
2382  mvs = 4;
2383  break;
2384  default:
2385  goto unhandled;
2386  }
2387 
2388  for (i = 0; i < mvs; i++) {
2389  my = s->mv[dir][i][1];
2390  my_max = FFMAX(my_max, my);
2391  my_min = FFMIN(my_min, my);
2392  }
2393 
2394  off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
2395 
2396  return av_clip(s->mb_y + off, 0, s->mb_height - 1);
2397 unhandled:
2398  return s->mb_height-1;
2399 }
2400 
2401 /* put block[] to dest[] */
2402 static inline void put_dct(MpegEncContext *s,
2403  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2404 {
2405  s->dct_unquantize_intra(s, block, i, qscale);
2406  s->idsp.idct_put(dest, line_size, block);
2407 }
2408 
2409 /* add block[] to dest[] */
2410 static inline void add_dct(MpegEncContext *s,
2411  int16_t *block, int i, uint8_t *dest, int line_size)
2412 {
2413  if (s->block_last_index[i] >= 0) {
2414  s->idsp.idct_add(dest, line_size, block);
2415  }
2416 }
2417 
2418 static inline void add_dequant_dct(MpegEncContext *s,
2419  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2420 {
2421  if (s->block_last_index[i] >= 0) {
2422  s->dct_unquantize_inter(s, block, i, qscale);
2423 
2424  s->idsp.idct_add(dest, line_size, block);
2425  }
2426 }
2427 
2428 /**
2429  * Clean dc, ac, coded_block for the current non-intra MB.
2430  */
2432 {
2433  int wrap = s->b8_stride;
2434  int xy = s->block_index[0];
2435 
2436  s->dc_val[0][xy ] =
2437  s->dc_val[0][xy + 1 ] =
2438  s->dc_val[0][xy + wrap] =
2439  s->dc_val[0][xy + 1 + wrap] = 1024;
2440  /* ac pred */
2441  memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2442  memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2443  if (s->msmpeg4_version>=3) {
2444  s->coded_block[xy ] =
2445  s->coded_block[xy + 1 ] =
2446  s->coded_block[xy + wrap] =
2447  s->coded_block[xy + 1 + wrap] = 0;
2448  }
2449  /* chroma */
2450  wrap = s->mb_stride;
2451  xy = s->mb_x + s->mb_y * wrap;
2452  s->dc_val[1][xy] =
2453  s->dc_val[2][xy] = 1024;
2454  /* ac pred */
2455  memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2456  memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2457 
2458  s->mbintra_table[xy]= 0;
2459 }
2460 
2461 /* generic function called after a macroblock has been parsed by the
2462  decoder or after it has been encoded by the encoder.
2463 
2464  Important variables used:
2465  s->mb_intra : true if intra macroblock
2466  s->mv_dir : motion vector direction
2467  s->mv_type : motion vector type
2468  s->mv : motion vector
2469  s->interlaced_dct : true if interlaced dct used (mpeg2)
2470  */
2471 static av_always_inline
2473  int lowres_flag, int is_mpeg12)
2474 {
2475  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2476 
2477  if (CONFIG_XVMC &&
2478  s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
2479  s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
2480  return;
2481  }
2482 
2483  if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2484  /* print DCT coefficients */
2485  int i,j;
2486  av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2487  for(i=0; i<6; i++){
2488  for(j=0; j<64; j++){
2489  av_log(s->avctx, AV_LOG_DEBUG, "%5d",
2490  block[i][s->idsp.idct_permutation[j]]);
2491  }
2492  av_log(s->avctx, AV_LOG_DEBUG, "\n");
2493  }
2494  }
2495 
2496  s->current_picture.qscale_table[mb_xy] = s->qscale;
2497 
2498  /* update DC predictors for P macroblocks */
2499  if (!s->mb_intra) {
2500  if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2501  if(s->mbintra_table[mb_xy])
2503  } else {
2504  s->last_dc[0] =
2505  s->last_dc[1] =
2506  s->last_dc[2] = 128 << s->intra_dc_precision;
2507  }
2508  }
2509  else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2510  s->mbintra_table[mb_xy]=1;
2511 
2513  !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
2514  s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
2515  uint8_t *dest_y, *dest_cb, *dest_cr;
2516  int dct_linesize, dct_offset;
2517  op_pixels_func (*op_pix)[4];
2518  qpel_mc_func (*op_qpix)[16];
2519  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2520  const int uvlinesize = s->current_picture.f->linesize[1];
2521  const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2522  const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2523 
2524  /* avoid copy if macroblock skipped in last frame too */
2525  /* skip only during decoding as we might trash the buffers during encoding a bit */
2526  if(!s->encoding){
2527  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2528 
2529  if (s->mb_skipped) {
2530  s->mb_skipped= 0;
2532  *mbskip_ptr = 1;
2533  } else if(!s->current_picture.reference) {
2534  *mbskip_ptr = 1;
2535  } else{
2536  *mbskip_ptr = 0; /* not skipped */
2537  }
2538  }
2539 
2540  dct_linesize = linesize << s->interlaced_dct;
2541  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2542 
2543  if(readable){
2544  dest_y= s->dest[0];
2545  dest_cb= s->dest[1];
2546  dest_cr= s->dest[2];
2547  }else{
2548  dest_y = s->sc.b_scratchpad;
2549  dest_cb= s->sc.b_scratchpad+16*linesize;
2550  dest_cr= s->sc.b_scratchpad+32*linesize;
2551  }
2552 
2553  if (!s->mb_intra) {
2554  /* motion handling */
2555  /* decoding or more than one mb_type (MC was already done otherwise) */
2556  if(!s->encoding){
2557 
2558  if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2559  if (s->mv_dir & MV_DIR_FORWARD) {
2561  lowest_referenced_row(s, 0),
2562  0);
2563  }
2564  if (s->mv_dir & MV_DIR_BACKWARD) {
2566  lowest_referenced_row(s, 1),
2567  0);
2568  }
2569  }
2570 
2571  if(lowres_flag){
2573 
2574  if (s->mv_dir & MV_DIR_FORWARD) {
2575  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
2577  }
2578  if (s->mv_dir & MV_DIR_BACKWARD) {
2579  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
2580  }
2581  }else{
2582  op_qpix = s->me.qpel_put;
2583  if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2584  op_pix = s->hdsp.put_pixels_tab;
2585  }else{
2586  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2587  }
2588  if (s->mv_dir & MV_DIR_FORWARD) {
2589  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2590  op_pix = s->hdsp.avg_pixels_tab;
2591  op_qpix= s->me.qpel_avg;
2592  }
2593  if (s->mv_dir & MV_DIR_BACKWARD) {
2594  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2595  }
2596  }
2597  }
2598 
2599  /* skip dequant / idct if we are really late ;) */
2600  if(s->avctx->skip_idct){
2603  || s->avctx->skip_idct >= AVDISCARD_ALL)
2604  goto skip_idct;
2605  }
2606 
2607  /* add dct residue */
2609  || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2610  add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2611  add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2612  add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2613  add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2614 
2615  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2616  if (s->chroma_y_shift){
2617  add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2618  add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2619  }else{
2620  dct_linesize >>= 1;
2621  dct_offset >>=1;
2622  add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2623  add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2624  add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2625  add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2626  }
2627  }
2628  } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2629  add_dct(s, block[0], 0, dest_y , dct_linesize);
2630  add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2631  add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2632  add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2633 
2634  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2635  if(s->chroma_y_shift){//Chroma420
2636  add_dct(s, block[4], 4, dest_cb, uvlinesize);
2637  add_dct(s, block[5], 5, dest_cr, uvlinesize);
2638  }else{
2639  //chroma422
2640  dct_linesize = uvlinesize << s->interlaced_dct;
2641  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2642 
2643  add_dct(s, block[4], 4, dest_cb, dct_linesize);
2644  add_dct(s, block[5], 5, dest_cr, dct_linesize);
2645  add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2646  add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2647  if(!s->chroma_x_shift){//Chroma444
2648  add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2649  add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2650  add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2651  add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2652  }
2653  }
2654  }//fi gray
2655  }
2656  else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2657  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2658  }
2659  } else {
2660  /* dct only in intra block */
2662  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2663  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2664  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2665  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2666 
2667  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2668  if(s->chroma_y_shift){
2669  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2670  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2671  }else{
2672  dct_offset >>=1;
2673  dct_linesize >>=1;
2674  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2675  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2676  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2677  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2678  }
2679  }
2680  }else{
2681  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
2682  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2683  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
2684  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2685 
2686  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2687  if(s->chroma_y_shift){
2688  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2689  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2690  }else{
2691 
2692  dct_linesize = uvlinesize << s->interlaced_dct;
2693  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2694 
2695  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
2696  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
2697  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2698  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2699  if(!s->chroma_x_shift){//Chroma444
2700  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2701  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2702  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2703  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2704  }
2705  }
2706  }//gray
2707  }
2708  }
2709 skip_idct:
2710  if(!readable){
2711  s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2712  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2713  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2714  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2715  }
2716  }
2717  }
2718 }
2719 
2720 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
2721 {
2722 #if !CONFIG_SMALL
2723  if(s->out_format == FMT_MPEG1) {
2724  if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
2725  else mpv_decode_mb_internal(s, block, 0, 1);
2726  } else
2727 #endif
2728  if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
2729  else mpv_decode_mb_internal(s, block, 0, 0);
2730 }
2731 
2733 {
2736  s->first_field, s->low_delay);
2737 }
2738 
2739 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2740  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2741  const int uvlinesize = s->current_picture.f->linesize[1];
2742  const int mb_size= 4 - s->avctx->lowres;
2743 
2744  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2745  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2746  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2747  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2748  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2749  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;
2750  //block_index is not used by mpeg2, so it is not affected by chroma_format
2751 
2752  s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << mb_size);
2753  s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
2754  s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
2755 
2757  {
2758  if(s->picture_structure==PICT_FRAME){
2759  s->dest[0] += s->mb_y * linesize << mb_size;
2760  s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2761  s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2762  }else{
2763  s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2764  s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2765  s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2767  }
2768  }
2769 }
2770 
2772  int i;
2773  MpegEncContext *s = avctx->priv_data;
2774 
2775  if (!s || !s->picture)
2776  return;
2777 
2778  for (i = 0; i < MAX_PICTURE_COUNT; i++)
2779  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2781 
2785 
2786  s->mb_x= s->mb_y= 0;
2787  s->closed_gop= 0;
2788 
2789  s->parse_context.state= -1;
2791  s->parse_context.overread= 0;
2793  s->parse_context.index= 0;
2794  s->parse_context.last_index= 0;
2795  s->bitstream_buffer_size=0;
2796  s->pp_time=0;
2797 }
2798 
2799 /**
2800  * set qscale and update qscale dependent variables.
2801  */
2802 void ff_set_qscale(MpegEncContext * s, int qscale)
2803 {
2804  if (qscale < 1)
2805  qscale = 1;
2806  else if (qscale > 31)
2807  qscale = 31;
2808 
2809  s->qscale = qscale;
2810  s->chroma_qscale= s->chroma_qscale_table[qscale];
2811 
2812  s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2814 }
2815 
2817 {
2820 }
int last_time_base
Definition: mpegvideo.h:386
int bitstream_buffer_size
Definition: mpegvideo.h:414
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free.
Definition: motion_est.h:52
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:894
#define FF_DEBUG_VIS_MB_TYPE
only access through AVOptions from outside libavcodec
Definition: avcodec.h:2922
IDCTDSPContext idsp
Definition: mpegvideo.h:227
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
#define NULL
Definition: coverity.c:32
static int init_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:356
int ff_thread_can_start_frame(AVCodecContext *avctx)
const struct AVCodec * codec
Definition: avcodec.h:1668
int16_t(* b_bidir_back_mv_table_base)[2]
Definition: mpegvideo.h:241
av_cold void ff_mpv_common_init_arm(MpegEncContext *s)
Definition: mpegvideo_arm.c:43
discard all frames except keyframes
Definition: avcodec.h:785
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2739
int picture_number
Definition: mpegvideo.h:124
const char * s
Definition: avisynth_c.h:768
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
Definition: wmv2.c:83
av_cold void ff_mpv_common_init_neon(MpegEncContext *s)
Definition: mpegvideo.c:126
ScanTable intra_v_scantable
Definition: mpegvideo.h:90
av_cold void ff_mpegvideodsp_init(MpegVideoDSPContext *c)
Definition: mpegvideodsp.c:110
static int shift(int a, int b)
Definition: sonic.c:82
void(* dct_unquantize_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:519
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
int16_t(* p_mv_table)[2]
MV table (1MV per MB) P-frame encoding.
Definition: mpegvideo.h:245
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:150
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:185
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1861
static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx)
Definition: mpegvideo.c:1431
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:68
#define IS_GMC(a)
Definition: mpegutils.h:87
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int16_t src_x
Absolute source position.
Definition: motion_vector.h:38
static void chroma_4mv_motion_lowres(MpegEncContext *s, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int mx, int my)
Definition: mpegvideo.c:2164
uint8_t * coded_block_base
Definition: mpegvideo.h:188
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:363
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:151
int16_t(*[3] ac_val)[16]
used for MPEG-4 AC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:191
MJPEG encoder.
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:129
h264_chroma_mc_func put_h264_chroma_pixels_tab[4]
Definition: h264chroma.h:27
void * opaque
for some private data of the user
Definition: frame.h:299
#define me
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:276
static void gray_frame(AVFrame *frame)
Definition: mpegvideo.c:1169
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:435
int needs_realloc
Picture needs to be reallocated (eg due to a frame size change)
Definition: mpegpicture.h:85
uint8_t * bitstream_buffer
Definition: mpegvideo.h:413
enum AVCodecID codec_id
Definition: mpegvideo.h:109
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:79
int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)
Definition: frame.c:49
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1887
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced P-frame encoding.
Definition: mpegvideo.h:251
int16_t(* p_mv_table_base)[2]
Definition: mpegvideo.h:237
uint8_t raster_end[64]
Definition: idctdsp.h:32
static int lowest_referenced_row(MpegEncContext *s, int dir)
find the lowest MB row referenced in the MVs
Definition: mpegvideo.c:2366
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
uint32_t * score_map
map to store the scores
Definition: motion_est.h:59
mpegvideo header.
discard all
Definition: avcodec.h:786
uint8_t permutated[64]
Definition: idctdsp.h:31
static void free_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:408
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:3060
int padding_bug_score
used to detect the VERY common padding bug in MPEG-4
Definition: mpegvideo.h:409
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:358
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
#define FF_DEBUG_VIS_MV_B_FOR
Definition: avcodec.h:2938
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:130
void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:30
int frame_start_found
Definition: parser.h:34
int qscale
QP.
Definition: mpegvideo.h:201
int h263_aic
Advanced INTRA Coding (AIC)
Definition: mpegvideo.h:84
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode B-frame encoding.
Definition: mpegvideo.h:247
attribute_deprecated int8_t * qscale_table
QP table Not to be accessed directly from outside libavutil.
Definition: frame.h:506
enum AVPictureType last_picture
Definition: movenc.c:68
int chroma_x_shift
Definition: mpegvideo.h:475
int encoding
true if we are encoding (vs decoding)
Definition: mpegvideo.h:111
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:513
int field_select[2][2]
Definition: mpegvideo.h:277
void(* dct_unquantize_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:517
int block_wrap[6]
Definition: mpegvideo.h:294
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:82
Macro definitions for various function/variable attributes.
int16_t(* b_back_mv_table_base)[2]
Definition: mpegvideo.h:239
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
Definition: mpegvideo.c:428
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:2431
void(* dct_unquantize_h263_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:515
#define COLOR(theta, r)
const uint8_t ff_mpeg2_non_linear_qscale[32]
Definition: mpegvideodata.c:27
static int16_t block[64]
Definition: dct.c:113
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2979
#define USES_LIST(a, list)
Definition: mpegutils.h:101
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2732
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
int context_reinit
Definition: mpegvideo.h:548
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:34
int16_t * dc_val_base
Definition: mpegvideo.h:183
ScratchpadContext sc
Definition: mpegvideo.h:199
uint8_t
#define ME_MAP_SIZE
Definition: motion_est.h:38
#define av_cold
Definition: attributes.h:82
av_cold void ff_mpv_common_init_axp(MpegEncContext *s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:140
#define mb
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
enum OutputFormat out_format
output format
Definition: mpegvideo.h:101
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1036
int noise_reduction
Definition: mpegvideo.h:566
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, op_pixels_func(*pix_op)[4], qpel_mc_func(*qpix_op)[16])
#define FF_DEBUG_VIS_MV_B_BACK
Definition: avcodec.h:2939
uint8_t * pred_dir_table
used to store pred_dir for partitioned decoding
Definition: mpegvideo.h:197
Multithreading support functions.
int frame_skip_threshold
Definition: mpegvideo.h:560
qpel_mc_func(* qpel_put)[16]
Definition: motion_est.h:91
int16_t dst_x
Absolute destination position.
Definition: motion_vector.h:42
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:455
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
Definition: mpegvideo.h:284
int interlaced_dct
Definition: mpegvideo.h:480
void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2720
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:177
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:441
int intra_dc_precision
Definition: mpegvideo.h:460
static AVFrame * frame
#define FF_API_CAP_VDPAU
Definition: version.h:73
quarterpel DSP functions
void ff_mpv_common_init_ppc(MpegEncContext *s)
Structure to hold side data for an AVFrame.
Definition: frame.h:143
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define height
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
Definition: mpegvideo.h:248
float * cplx_tab
Definition: mpegvideo.h:544
int32_t source
Where the current macroblock comes from; negative value when it comes from the past, positive value when it comes from the future.
Definition: motion_vector.h:30
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:91
#define AV_CODEC_CAP_HWACCEL_VDPAU
Codec can export data for HW decoding (VDPAU).
Definition: avcodec.h:994
#define ff_dlog(a,...)
void(* decode_mb)(struct MpegEncContext *s)
Called for every Macroblock in a slice.
Definition: avcodec.h:3801
#define FF_DEBUG_MB_TYPE
Definition: avcodec.h:2903
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:390
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
Definition: mpegvideo.c:348
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:318
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:330
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:126
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:3070
static av_always_inline void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
Definition: mpegvideo.c:2472
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
Definition: mpegvideo.h:117
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:860
high precision timer, useful to profile code
int16_t(*[2][2] p_field_mv_table_base)[2]
Definition: mpegvideo.h:243
#define av_log(a,...)
#define ff_sqrt
Definition: mathops.h:215
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2802
#define ROUNDED_DIV(a, b)
Definition: common.h:56
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:270
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:99
ThreadFrame tf
Definition: mpegpicture.h:47
#define U(x)
Definition: vp56_arith.h:37
int16_t * dc_val[3]
used for MPEG-4 DC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:184
enum AVCodecID id
Definition: avcodec.h:3587
int h263_plus
H.263+ headers.
Definition: mpegvideo.h:106
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:153
unsigned int buffer_size
Definition: parser.h:32
int width
width and height of the video frame
Definition: frame.h:236
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:182
static void add_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size)
Definition: mpegvideo.c:2410
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:192
int chroma_y_shift
Definition: mpegvideo.h:476
int partitioned_frame
is current frame partitioned
Definition: mpegvideo.h:403
uint8_t * rd_scratchpad
scratchpad for rate distortion mb decision
Definition: mpegpicture.h:37
#define AVERROR(e)
Definition: error.h:43
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:153
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2291
ERContext er
Definition: mpegvideo.h:550
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:3109
int last_lambda_for[5]
last lambda for a specific pict type
Definition: mpegvideo.h:216
uint8_t w
Width and height of the block.
Definition: motion_vector.h:34
int reference
Definition: mpegpicture.h:87
int capabilities
Codec capabilities.
Definition: avcodec.h:3592
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:141
void(* dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:511
void(* dct_unquantize_mpeg1_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:505
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1754
#define wrap(func)
Definition: neontest.h:65
static void put_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:2402
simple assert() macros that are a bit more flexible than ISO C assert().
int overread_index
the index into ParseContext.buffer of the overread bytes
Definition: parser.h:36
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
GLsizei GLsizei * length
Definition: opengl_enc.c:115
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:53
#define IS_SKIP(a)
Definition: mpegutils.h:83
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:399
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
Definition: mpegvideo.h:291
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color)
Draw a line from (ex, ey) -> (sx, sy).
Definition: mpegvideo.c:1460
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:404
uint8_t *[2][2] b_field_select_table
Definition: mpegvideo.h:254
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:299
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1115
#define FFMAX(a, b)
Definition: common.h:94
av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
Definition: mpegvideo.c:454
#define fail()
Definition: checkasm.h:82
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2771
return
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
int coded_picture_number
used to set pic->coded_picture_number, should not be used for/by anything else
Definition: mpegvideo.h:123
int * lambda_table
Definition: mpegvideo.h:205
uint8_t * error_status_table
const uint8_t ff_alternate_horizontal_scan[64]
Definition: mpegvideodata.c:89
int ff_mpeg_er_init(MpegEncContext *s)
Definition: mpeg_er.c:97
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:499
common internal API header
#define MAX_THREADS
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color, int tail, int direction)
Draw an arrow from (ex, ey) -> (sx, sy).
Definition: mpegvideo.c:1518
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:251
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band...
Definition: avcodec.h:1920
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1968
int progressive_frame
Definition: mpegvideo.h:478
#define IS_16X8(a)
Definition: mpegutils.h:89
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:258
#define UPDATE_PICTURE(pic)
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:885
int top_field_first
Definition: mpegvideo.h:462
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:3101
uint8_t * er_temp_buffer
int overread
the number of bytes which where irreversibly read from the next frame
Definition: parser.h:35
#define FFMIN(a, b)
Definition: common.h:96
int last_index
Definition: parser.h:31
#define IS_DIRECT(a)
Definition: mpegutils.h:86
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed B-frames
Definition: mpegvideo.h:360
int32_t motion_x
Motion vector src_x = dst_x + motion_x / motion_scale src_y = dst_y + motion_y / motion_scale.
Definition: motion_vector.h:53
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:175
Picture new_picture
copy of the source picture structure for encoding.
Definition: mpegvideo.h:171
#define width
int width
picture width / height.
Definition: avcodec.h:1846
uint8_t * mbskip_table
used to avoid copy if macroblock skipped (for black regions for example) and used for B-frame encodin...
Definition: mpegvideo.h:193
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:181
Picture.
Definition: mpegpicture.h:45
int alternate_scan
Definition: mpegvideo.h:467
unsigned int allocated_bitstream_buffer_size
Definition: mpegvideo.h:415
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
int16_t(* ac_val_base)[16]
Definition: mpegvideo.h:190
int32_t
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:864
Motion vectors exported by some codecs (on demand through the export_mvs flag set in the libavcodec A...
Definition: frame.h:95
#define FF_DEBUG_SKIP
Definition: avcodec.h:2912
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:3102
int16_t(*[2][2][2] b_field_mv_table_base)[2]
Definition: mpegvideo.h:244
int16_t(* b_forw_mv_table_base)[2]
Definition: mpegvideo.h:238
int16_t(*[12] pblocks)[64]
Definition: mpegvideo.h:495
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:83
MotionEstContext me
Definition: mpegvideo.h:282
int frame_skip_factor
Definition: mpegvideo.h:561
int n
Definition: avisynth_c.h:684
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
av_cold void ff_mpv_common_init_mips(MpegEncContext *s)
int mb_decision
macroblock decision mode
Definition: avcodec.h:2222
void(* idct_add)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:77
uint8_t * mbintra_table
used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
Definition: mpegvideo.h:195
#define src
Definition: vp9dsp.c:530
void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: imgconvert.c:38
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:483
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:196
void ff_mpv_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:657
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:3090
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:293
#define IS_INTRA16x16(a)
Definition: mpegutils.h:78
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
Definition: mpegvideo.h:297
int first_field
is 1 for the first field of a field picture 0 otherwise
Definition: mpegvideo.h:481
static const int8_t mv[256][2]
Definition: 4xm.c:77
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:248
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:70
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
static void clear_context(MpegEncContext *s)
Definition: mpegvideo.c:798
AVBufferRef * qscale_table_buf
Definition: mpegpicture.h:49
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:263
int16_t(* b_bidir_forw_mv_table_base)[2]
Definition: mpegvideo.h:240
int coded_picture_number
picture number in bitstream order
Definition: frame.h:285
uint16_t inter_matrix[64]
Definition: mpegvideo.h:302
#define IS_INTERLACED(a)
Definition: mpegutils.h:85
uint8_t * buffer
Definition: parser.h:29
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:152
Libavcodec external API header.
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:131
enum AVCodecID codec_id
Definition: avcodec.h:1676
BlockDSPContext bdsp
Definition: mpegvideo.h:223
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:58
enum AVDiscard skip_idct
Skip IDCT/dequantization for selected frames.
Definition: avcodec.h:3277
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
int debug
debug
Definition: avcodec.h:2899
main external API structure.
Definition: avcodec.h:1659
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int shared, int encoding, int chroma_x_shift, int chroma_y_shift, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride, ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
Allocate a Picture.
Definition: mpegpicture.c:228
ScanTable intra_scantable
Definition: mpegvideo.h:88
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t * coded_block
used for coded block pattern prediction (msmpeg4v3, wmv1)
Definition: mpegvideo.h:189
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:97
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1691
uint8_t * data
Definition: frame.h:145
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:111
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:268
static int add_mb(AVMotionVector *mb, uint32_t mb_type, int dst_x, int dst_y, int motion_x, int motion_y, int motion_scale, int direction)
Definition: mpegvideo.c:1557
void * buf
Definition: avisynth_c.h:690
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1961
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t(*motion_val[2])[2], int *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegvideo.c:1579
GLint GLenum type
Definition: opengl_enc.c:105
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
Picture * picture
main picture buffer
Definition: mpegvideo.h:133
int progressive_sequence
Definition: mpegvideo.h:453
int coded_height
Definition: avcodec.h:1861
#define IS_16X16(a)
Definition: mpegutils.h:88
ScanTable intra_h_scantable
Definition: mpegvideo.h:89
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
Definition: hpeldsp.h:80
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced B-frame encoding.
Definition: mpegvideo.h:252
uint8_t * cbp_table
used to store cbp, ac_pred for partitioned decoding
Definition: mpegvideo.h:196
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:616
int closed_gop
MPEG1/2 GOP is closed.
Definition: mpegvideo.h:208
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:56
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:3839
#define FF_DEBUG_DCT_COEFF
Definition: avcodec.h:2911
struct AVFrame * f
Definition: mpegpicture.h:46
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:2225
#define IS_8X16(a)
Definition: mpegutils.h:90
int context_initialized
Definition: mpegvideo.h:121
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:132
int32_t motion_y
Definition: motion_vector.h:53
#define s1
Definition: regdef.h:38
static int ff_h263_round_chroma(int x)
Definition: motion_est.h:101
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1189
#define u(width,...)
int f_code
forward MV resolution
Definition: mpegvideo.h:235
#define COPY(a)
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
int max_b_frames
max number of B-frames for encoding
Definition: mpegvideo.h:112
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:209
int size
Size of data in bytes.
Definition: buffer.h:93
int h263_pred
use MPEG-4/H.263 ac/dc predictions
Definition: mpegvideo.h:102
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
Definition: mpegvideo.h:249
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:537
static int init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
Definition: mpegvideo.c:677
#define IS_PCM(a)
Definition: mpegutils.h:79
uint8_t *[2] p_field_select_table
Definition: mpegvideo.h:253
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode B-frame encoding.
Definition: mpegvideo.h:250
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:186
uint8_t level
Definition: svq3.c:206
qpel_mc_func(* qpel_avg)[16]
Definition: motion_est.h:92
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode B-frame encoding.
Definition: mpegvideo.h:246
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:128
uint16_t motion_scale
Definition: motion_vector.h:54
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, int srcStride, int h, int x, int y)
Definition: h264chroma.h:24
static void dct_unquantize_h263_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:209
MpegEncContext.
Definition: mpegvideo.h:78
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:180
int8_t * qscale_table
Definition: mpegpicture.h:50
struct AVCodecContext * avctx
Definition: mpegvideo.h:95
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:291
A reference to a data buffer.
Definition: buffer.h:81
discard all non reference
Definition: avcodec.h:782
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
MpegVideoDSPContext mdsp
Definition: mpegvideo.h:229
int(* dct_error_sum)[64]
Definition: mpegvideo.h:332
uint64_t flags
Extra flag information.
Definition: motion_vector.h:47
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:127
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Definition: mpegvideo.c:662
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
const uint8_t ff_default_chroma_qscale_table[32]
Definition: mpegvideodata.c:21
uint8_t * dest[3]
Definition: mpegvideo.h:295
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
Definition: internal.h:130
static av_cold int dct_init(MpegEncContext *s)
Definition: mpegvideo.c:283
static double c[64]
int last_pict_type
Definition: mpegvideo.h:211
static void dct_unquantize_h263_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:243
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:159
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
#define FF_DEBUG_QP
Definition: avcodec.h:2904
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:179
Bi-dir predicted.
Definition: avutil.h:270
int index
Definition: parser.h:30
#define FF_DEBUG_VIS_MV_P_FOR
Definition: avcodec.h:2937
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:2843
uint8_t * b_scratchpad
scratchpad used for writing into write only buffers
Definition: mpegpicture.h:39
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (H.263)
Definition: mpegvideo.h:187
const uint8_t ff_alternate_vertical_scan[64]
uint32_t * map
map to avoid duplicate evaluations
Definition: motion_est.h:58
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:455
void(* dct_unquantize_mpeg1_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:507
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:733
static int lowres
Definition: ffplay.c:334
H264ChromaContext h264chroma
Definition: mpegvideo.h:225
int16_t(* blocks)[12][64]
Definition: mpegvideo.h:498
#define IS_INTRA(x, y)
h264_chroma_mc_func avg_h264_chroma_pixels_tab[4]
Definition: h264chroma.h:28
int slices
Number of slices.
Definition: avcodec.h:2412
void * priv_data
Definition: avcodec.h:1701
#define PICT_FRAME
Definition: mpegutils.h:39
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:877
#define IS_INTRA4x4(a)
Definition: mpegutils.h:77
int picture_structure
Definition: mpegvideo.h:457
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
VideoDSPContext vdsp
Definition: mpegvideo.h:233
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:241
#define IS_8X8(a)
Definition: mpegutils.h:91
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:323
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1421
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:270
uint8_t * obmc_scratchpad
Definition: mpegpicture.h:38
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:497
ParseContext parse_context
Definition: mpegvideo.h:362
static void add_dequant_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:2418
Picture next_picture
copy of the next picture structure.
Definition: mpegvideo.h:165
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:253
#define FF_DEBUG_NOMC
Definition: avcodec.h:2927
#define IS_ACPRED(a)
Definition: mpegutils.h:96
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int field_based, int bottom_field, int field_select, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int motion_x, int motion_y, int h, int mb_y)
Definition: mpegvideo.c:2027
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1761
int chroma_qscale
chroma QP
Definition: mpegvideo.h:202
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:932
void(* dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:509
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2452
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding). ...
Definition: mpegvideo.c:634
static void free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution.
Definition: mpegvideo.c:987
static int hpel_motion_lowres(MpegEncContext *s, uint8_t *dest, uint8_t *src, int field_based, int field_select, int src_x, int src_y, int width, int height, ptrdiff_t stride, int h_edge_pos, int v_edge_pos, int w, int h, h264_chroma_mc_func *pix_op, int motion_x, int motion_y)
Definition: mpegvideo.c:1980
int height
Definition: frame.h:236
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:300
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
#define av_freep(p)
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
Definition: mpegvideo.h:116
ScanTable inter_scantable
if inter == intra then intra should be used to reduce the cache usage
Definition: mpegvideo.h:87
#define av_always_inline
Definition: attributes.h:39
uint8_t * temp
Definition: motion_est.h:56
#define FF_DEBUG_VIS_QP
only access through AVOptions from outside libavcodec
Definition: avcodec.h:2921
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
Definition: common.h:99
#define stride
int debug_mv
debug Code outside libavcodec should access this field using AVOptions
Definition: avcodec.h:2936
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:267
int16_t(* b_direct_mv_table_base)[2]
Definition: mpegvideo.h:242
int b_code
backward MV resolution for B-frames (MPEG-4)
Definition: mpegvideo.h:236
float * bits_tab
Definition: mpegvideo.h:544
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2816
static void MPV_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, h264_chroma_mc_func *pix_op)
motion compensation of a single macroblock
Definition: mpegvideo.c:2232
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:139
Predicted.
Definition: avutil.h:269
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
HpelDSPContext hdsp
Definition: mpegvideo.h:226