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