FFmpeg
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 "avcodec.h"
36 #include "blockdsp.h"
37 #include "h264chroma.h"
38 #include "idctdsp.h"
39 #include "internal.h"
40 #include "mathops.h"
41 #include "mpeg_er.h"
42 #include "mpegutils.h"
43 #include "mpegvideo.h"
44 #include "mpegvideodata.h"
45 #include "mjpegenc.h"
46 #include "msmpeg4.h"
47 #include "qpeldsp.h"
48 #include "thread.h"
49 #include "wmv2.h"
50 #include <limits.h>
51 
53  int16_t *block, int n, int qscale)
54 {
55  int i, level, nCoeffs;
56  const uint16_t *quant_matrix;
57 
58  nCoeffs= s->block_last_index[n];
59 
60  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
61  /* XXX: only MPEG-1 */
62  quant_matrix = s->intra_matrix;
63  for(i=1;i<=nCoeffs;i++) {
64  int j= s->intra_scantable.permutated[i];
65  level = block[j];
66  if (level) {
67  if (level < 0) {
68  level = -level;
69  level = (int)(level * qscale * quant_matrix[j]) >> 3;
70  level = (level - 1) | 1;
71  level = -level;
72  } else {
73  level = (int)(level * qscale * quant_matrix[j]) >> 3;
74  level = (level - 1) | 1;
75  }
76  block[j] = level;
77  }
78  }
79 }
80 
82  int16_t *block, int n, int qscale)
83 {
84  int i, level, nCoeffs;
85  const uint16_t *quant_matrix;
86 
87  nCoeffs= s->block_last_index[n];
88 
89  quant_matrix = s->inter_matrix;
90  for(i=0; i<=nCoeffs; i++) {
91  int j= s->intra_scantable.permutated[i];
92  level = block[j];
93  if (level) {
94  if (level < 0) {
95  level = -level;
96  level = (((level << 1) + 1) * qscale *
97  ((int) (quant_matrix[j]))) >> 4;
98  level = (level - 1) | 1;
99  level = -level;
100  } else {
101  level = (((level << 1) + 1) * qscale *
102  ((int) (quant_matrix[j]))) >> 4;
103  level = (level - 1) | 1;
104  }
105  block[j] = level;
106  }
107  }
108 }
109 
111  int16_t *block, int n, int qscale)
112 {
113  int i, level, nCoeffs;
114  const uint16_t *quant_matrix;
115 
116  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
117  else qscale <<= 1;
118 
119  if(s->alternate_scan) nCoeffs= 63;
120  else nCoeffs= s->block_last_index[n];
121 
122  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
123  quant_matrix = s->intra_matrix;
124  for(i=1;i<=nCoeffs;i++) {
125  int j= s->intra_scantable.permutated[i];
126  level = block[j];
127  if (level) {
128  if (level < 0) {
129  level = -level;
130  level = (int)(level * qscale * quant_matrix[j]) >> 4;
131  level = -level;
132  } else {
133  level = (int)(level * qscale * quant_matrix[j]) >> 4;
134  }
135  block[j] = level;
136  }
137  }
138 }
139 
141  int16_t *block, int n, int qscale)
142 {
143  int i, level, nCoeffs;
144  const uint16_t *quant_matrix;
145  int sum=-1;
146 
147  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
148  else qscale <<= 1;
149 
150  if(s->alternate_scan) nCoeffs= 63;
151  else nCoeffs= s->block_last_index[n];
152 
153  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
154  sum += block[0];
155  quant_matrix = s->intra_matrix;
156  for(i=1;i<=nCoeffs;i++) {
157  int j= s->intra_scantable.permutated[i];
158  level = block[j];
159  if (level) {
160  if (level < 0) {
161  level = -level;
162  level = (int)(level * qscale * quant_matrix[j]) >> 4;
163  level = -level;
164  } else {
165  level = (int)(level * qscale * quant_matrix[j]) >> 4;
166  }
167  block[j] = level;
168  sum+=level;
169  }
170  }
171  block[63]^=sum&1;
172 }
173 
175  int16_t *block, int n, int qscale)
176 {
177  int i, level, nCoeffs;
178  const uint16_t *quant_matrix;
179  int sum=-1;
180 
181  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
182  else qscale <<= 1;
183 
184  if(s->alternate_scan) nCoeffs= 63;
185  else nCoeffs= s->block_last_index[n];
186 
187  quant_matrix = s->inter_matrix;
188  for(i=0; i<=nCoeffs; i++) {
189  int j= s->intra_scantable.permutated[i];
190  level = block[j];
191  if (level) {
192  if (level < 0) {
193  level = -level;
194  level = (((level << 1) + 1) * qscale *
195  ((int) (quant_matrix[j]))) >> 5;
196  level = -level;
197  } else {
198  level = (((level << 1) + 1) * qscale *
199  ((int) (quant_matrix[j]))) >> 5;
200  }
201  block[j] = level;
202  sum+=level;
203  }
204  }
205  block[63]^=sum&1;
206 }
207 
209  int16_t *block, int n, int qscale)
210 {
211  int i, level, qmul, qadd;
212  int nCoeffs;
213 
214  av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
215 
216  qmul = qscale << 1;
217 
218  if (!s->h263_aic) {
219  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
220  qadd = (qscale - 1) | 1;
221  }else{
222  qadd = 0;
223  }
224  if(s->ac_pred)
225  nCoeffs=63;
226  else
227  nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
228 
229  for(i=1; i<=nCoeffs; i++) {
230  level = block[i];
231  if (level) {
232  if (level < 0) {
233  level = level * qmul - qadd;
234  } else {
235  level = level * qmul + qadd;
236  }
237  block[i] = level;
238  }
239  }
240 }
241 
243  int16_t *block, int n, int qscale)
244 {
245  int i, level, qmul, qadd;
246  int nCoeffs;
247 
248  av_assert2(s->block_last_index[n]>=0);
249 
250  qadd = (qscale - 1) | 1;
251  qmul = qscale << 1;
252 
253  nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
254 
255  for(i=0; i<=nCoeffs; i++) {
256  level = block[i];
257  if (level) {
258  if (level < 0) {
259  level = level * qmul - qadd;
260  } else {
261  level = level * qmul + qadd;
262  }
263  block[i] = level;
264  }
265  }
266 }
267 
268 
269 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
270 {
271  while(h--)
272  memset(dst + h*linesize, 128, 16);
273 }
274 
275 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
276 {
277  while(h--)
278  memset(dst + h*linesize, 128, 8);
279 }
280 
281 /* init common dct for both encoder and decoder */
283 {
284  ff_blockdsp_init(&s->bdsp, s->avctx);
285  ff_h264chroma_init(&s->h264chroma, 8); //for lowres
286  ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
289 
290  if (s->avctx->debug & FF_DEBUG_NOMC) {
291  int i;
292  for (i=0; i<4; i++) {
293  s->hdsp.avg_pixels_tab[0][i] = gray16;
294  s->hdsp.put_pixels_tab[0][i] = gray16;
296 
297  s->hdsp.avg_pixels_tab[1][i] = gray8;
298  s->hdsp.put_pixels_tab[1][i] = gray8;
300  }
301  }
302 
311 
312  if (HAVE_INTRINSICS_NEON)
314 
315  if (ARCH_ALPHA)
317  if (ARCH_ARM)
319  if (ARCH_PPC)
321  if (ARCH_X86)
323  if (ARCH_MIPS)
325 
326  return 0;
327 }
328 
330 {
331  if (s->codec_id == AV_CODEC_ID_MPEG4)
333  ff_idctdsp_init(&s->idsp, s->avctx);
334 
335  /* load & permutate scantables
336  * note: only wmv uses different ones
337  */
338  if (s->alternate_scan) {
341  } else {
344  }
347 }
348 
350 {
351  return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, 0, 0,
353  s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
354  &s->linesize, &s->uvlinesize);
355 }
356 
358 {
359  int y_size = s->b8_stride * (2 * s->mb_height + 1);
360  int c_size = s->mb_stride * (s->mb_height + 1);
361  int yc_size = y_size + 2 * c_size;
362  int i;
363 
364  if (s->mb_height & 1)
365  yc_size += 2*s->b8_stride + 2*s->mb_stride;
366 
367  s->sc.edge_emu_buffer =
368  s->me.scratchpad =
369  s->me.temp =
370  s->sc.rd_scratchpad =
371  s->sc.b_scratchpad =
372  s->sc.obmc_scratchpad = NULL;
373 
374  if (s->encoding) {
375  FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
376  ME_MAP_SIZE * sizeof(uint32_t), fail)
378  ME_MAP_SIZE * sizeof(uint32_t), fail)
379  if (s->noise_reduction) {
381  2 * 64 * sizeof(int), fail)
382  }
383  }
384  FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
385  s->block = s->blocks[0];
386 
387  for (i = 0; i < 12; i++) {
388  s->pblocks[i] = &s->block[i];
389  }
390 
391  FF_ALLOCZ_OR_GOTO(s->avctx, s->block32, sizeof(*s->block32), fail)
392  s->dpcm_direction = 0;
394 
395  if (s->avctx->codec_tag == AV_RL32("VCR2")) {
396  // exchange uv
397  FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
398  }
399 
400  if (s->out_format == FMT_H263) {
401  /* ac values */
403  yc_size * sizeof(int16_t) * 16, fail);
404  s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
405  s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
406  s->ac_val[2] = s->ac_val[1] + c_size;
407  }
408 
409  return 0;
410 fail:
411  return -1; // free() through ff_mpv_common_end()
412 }
413 
415 {
416  if (!s)
417  return;
418 
420  av_freep(&s->me.scratchpad);
421  s->me.temp =
422  s->sc.rd_scratchpad =
423  s->sc.b_scratchpad =
424  s->sc.obmc_scratchpad = NULL;
425 
426  av_freep(&s->dct_error_sum);
427  av_freep(&s->me.map);
428  av_freep(&s->me.score_map);
429  av_freep(&s->blocks);
430  av_freep(&s->block32);
432  av_freep(&s->ac_val_base);
433  s->block = NULL;
434 }
435 
437 {
438 #define COPY(a) bak->a = src->a
439  COPY(sc.edge_emu_buffer);
440  COPY(me.scratchpad);
441  COPY(me.temp);
442  COPY(sc.rd_scratchpad);
443  COPY(sc.b_scratchpad);
444  COPY(sc.obmc_scratchpad);
445  COPY(me.map);
446  COPY(me.score_map);
447  COPY(blocks);
448  COPY(block);
449  COPY(block32);
450  COPY(dpcm_macroblock);
451  COPY(dpcm_direction);
452  COPY(start_mb_y);
453  COPY(end_mb_y);
454  COPY(me.map_generation);
455  COPY(pb);
456  COPY(dct_error_sum);
457  COPY(dct_count[0]);
458  COPY(dct_count[1]);
459  COPY(ac_val_base);
460  COPY(ac_val[0]);
461  COPY(ac_val[1]);
462  COPY(ac_val[2]);
463 #undef COPY
464 }
465 
467 {
468  MpegEncContext bak;
469  int i, ret;
470  // FIXME copy only needed parts
471  backup_duplicate_context(&bak, dst);
472  memcpy(dst, src, sizeof(MpegEncContext));
473  backup_duplicate_context(dst, &bak);
474  for (i = 0; i < 12; i++) {
475  dst->pblocks[i] = &dst->block[i];
476  }
477  if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
478  // exchange uv
479  FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
480  }
481  if (!dst->sc.edge_emu_buffer &&
482  (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
483  &dst->sc, dst->linesize)) < 0) {
484  av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
485  "scratch buffers.\n");
486  return ret;
487  }
488  return 0;
489 }
490 
492  const AVCodecContext *src)
493 {
494  int i, ret;
495  MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
496 
497  if (dst == src)
498  return 0;
499 
500  av_assert0(s != s1);
501 
502  // FIXME can parameters change on I-frames?
503  // in that case dst may need a reinit
504  if (!s->context_initialized) {
505  int err;
506  memcpy(s, s1, sizeof(MpegEncContext));
507 
508  s->avctx = dst;
509  s->bitstream_buffer = NULL;
511 
512  if (s1->context_initialized){
513 // s->picture_range_start += MAX_PICTURE_COUNT;
514 // s->picture_range_end += MAX_PICTURE_COUNT;
515  ff_mpv_idct_init(s);
516  if((err = ff_mpv_common_init(s)) < 0){
517  memset(s, 0, sizeof(MpegEncContext));
518  s->avctx = dst;
519  return err;
520  }
521  }
522  }
523 
524  if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
525  s->context_reinit = 0;
526  s->height = s1->height;
527  s->width = s1->width;
528  if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
529  return ret;
530  }
531 
532  s->avctx->coded_height = s1->avctx->coded_height;
533  s->avctx->coded_width = s1->avctx->coded_width;
534  s->avctx->width = s1->avctx->width;
535  s->avctx->height = s1->avctx->height;
536 
537  s->quarter_sample = s1->quarter_sample;
538 
539  s->coded_picture_number = s1->coded_picture_number;
540  s->picture_number = s1->picture_number;
541 
542  av_assert0(!s->picture || s->picture != s1->picture);
543  if(s->picture)
544  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
545  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
546  if (s1->picture && s1->picture[i].f->buf[0] &&
547  (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
548  return ret;
549  }
550 
551 #define UPDATE_PICTURE(pic)\
552 do {\
553  ff_mpeg_unref_picture(s->avctx, &s->pic);\
554  if (s1->pic.f && s1->pic.f->buf[0])\
555  ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
556  else\
557  ret = ff_update_picture_tables(&s->pic, &s1->pic);\
558  if (ret < 0)\
559  return ret;\
560 } while (0)
561 
562  UPDATE_PICTURE(current_picture);
564  UPDATE_PICTURE(next_picture);
565 
566 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
567  ((pic && pic >= old_ctx->picture && \
568  pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
569  &new_ctx->picture[pic - old_ctx->picture] : NULL)
570 
571  s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
572  s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
573  s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
574 
575  // Error/bug resilience
576  s->next_p_frame_damaged = s1->next_p_frame_damaged;
577  s->workaround_bugs = s1->workaround_bugs;
578  s->padding_bug_score = s1->padding_bug_score;
579 
580  // MPEG-4 timing info
581  memcpy(&s->last_time_base, &s1->last_time_base,
582  (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
583  (char *) &s1->last_time_base);
584 
585  // B-frame info
586  s->max_b_frames = s1->max_b_frames;
587  s->low_delay = s1->low_delay;
588  s->droppable = s1->droppable;
589 
590  // DivX handling (doesn't work)
591  s->divx_packed = s1->divx_packed;
592 
593  if (s1->bitstream_buffer) {
594  if (s1->bitstream_buffer_size +
598  s1->allocated_bitstream_buffer_size);
599  if (!s->bitstream_buffer) {
600  s->bitstream_buffer_size = 0;
601  return AVERROR(ENOMEM);
602  }
603  }
604  s->bitstream_buffer_size = s1->bitstream_buffer_size;
605  memcpy(s->bitstream_buffer, s1->bitstream_buffer,
606  s1->bitstream_buffer_size);
607  memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
609  }
610 
611  // linesize-dependent scratch buffer allocation
612  if (!s->sc.edge_emu_buffer)
613  if (s1->linesize) {
614  if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
615  &s->sc, s1->linesize) < 0) {
616  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
617  "scratch buffers.\n");
618  return AVERROR(ENOMEM);
619  }
620  } else {
621  av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
622  "be allocated due to unknown size.\n");
623  }
624 
625  // MPEG-2/interlacing info
626  memcpy(&s->progressive_sequence, &s1->progressive_sequence,
627  (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
628 
629  if (!s1->first_field) {
630  s->last_pict_type = s1->pict_type;
631  if (s1->current_picture_ptr)
632  s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
633  }
634 
635  return 0;
636 }
637 
638 /**
639  * Set the given MpegEncContext to common defaults
640  * (same for encoding and decoding).
641  * The changed fields will not depend upon the
642  * prior state of the MpegEncContext.
643  */
645 {
646  s->y_dc_scale_table =
649  s->progressive_frame = 1;
650  s->progressive_sequence = 1;
652 
653  s->coded_picture_number = 0;
654  s->picture_number = 0;
655 
656  s->f_code = 1;
657  s->b_code = 1;
658 
659  s->slice_context_count = 1;
660 }
661 
662 /**
663  * Set the given MpegEncContext to defaults for decoding.
664  * the changed fields will not depend upon
665  * the prior state of the MpegEncContext.
666  */
668 {
670 }
671 
673 {
674  s->avctx = avctx;
675  s->width = avctx->coded_width;
676  s->height = avctx->coded_height;
677  s->codec_id = avctx->codec->id;
678  s->workaround_bugs = avctx->workaround_bugs;
679 
680  /* convert fourcc to upper case */
681  s->codec_tag = avpriv_toupper4(avctx->codec_tag);
682 }
683 
684 /**
685  * Initialize and allocates MpegEncContext fields dependent on the resolution.
686  */
688 {
689  int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
690 
691  s->mb_width = (s->width + 15) / 16;
692  s->mb_stride = s->mb_width + 1;
693  s->b8_stride = s->mb_width * 2 + 1;
694  mb_array_size = s->mb_height * s->mb_stride;
695  mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
696 
697  /* set default edge pos, will be overridden
698  * in decode_header if needed */
699  s->h_edge_pos = s->mb_width * 16;
700  s->v_edge_pos = s->mb_height * 16;
701 
702  s->mb_num = s->mb_width * s->mb_height;
703 
704  s->block_wrap[0] =
705  s->block_wrap[1] =
706  s->block_wrap[2] =
707  s->block_wrap[3] = s->b8_stride;
708  s->block_wrap[4] =
709  s->block_wrap[5] = s->mb_stride;
710 
711  y_size = s->b8_stride * (2 * s->mb_height + 1);
712  c_size = s->mb_stride * (s->mb_height + 1);
713  yc_size = y_size + 2 * c_size;
714 
715  if (s->mb_height & 1)
716  yc_size += 2*s->b8_stride + 2*s->mb_stride;
717 
718  FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
719  fail); // error resilience code looks cleaner with this
720  for (y = 0; y < s->mb_height; y++)
721  for (x = 0; x < s->mb_width; x++)
722  s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
723 
724  s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
725 
726  if (s->encoding) {
727  /* Allocate MV tables */
728  FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
729  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
730  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
731  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
732  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
733  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
734  s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
740 
741  /* Allocate MB type table */
742  FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
743 
744  FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
745 
747  mb_array_size * sizeof(float), fail);
749  mb_array_size * sizeof(float), fail);
750 
751  }
752 
753  if (s->codec_id == AV_CODEC_ID_MPEG4 ||
755  /* interlaced direct mode decoding tables */
756  for (i = 0; i < 2; i++) {
757  int j, k;
758  for (j = 0; j < 2; j++) {
759  for (k = 0; k < 2; k++) {
761  s->b_field_mv_table_base[i][j][k],
762  mv_table_size * 2 * sizeof(int16_t),
763  fail);
764  s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
765  s->mb_stride + 1;
766  }
767  FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
768  FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
769  s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
770  }
771  FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
772  }
773  }
774  if (s->out_format == FMT_H263) {
775  /* cbp values */
776  FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
777  s->coded_block = s->coded_block_base + s->b8_stride + 1;
778 
779  /* cbp, ac_pred, pred_dir */
780  FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
781  FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
782  }
783 
784  if (s->h263_pred || s->h263_plus || !s->encoding) {
785  /* dc values */
786  // MN: we need these for error resilience of intra-frames
787  FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
788  s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
789  s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
790  s->dc_val[2] = s->dc_val[1] + c_size;
791  for (i = 0; i < yc_size; i++)
792  s->dc_val_base[i] = 1024;
793  }
794 
795  /* which mb is an intra block */
796  FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
797  memset(s->mbintra_table, 1, mb_array_size);
798 
799  /* init macroblock skip table */
800  FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
801  // Note the + 1 is for a quicker MPEG-4 slice_end detection
802 
803  return ff_mpeg_er_init(s);
804 fail:
805  return AVERROR(ENOMEM);
806 }
807 
809 {
810  int i, j, k;
811 
812  memset(&s->next_picture, 0, sizeof(s->next_picture));
813  memset(&s->last_picture, 0, sizeof(s->last_picture));
814  memset(&s->current_picture, 0, sizeof(s->current_picture));
815  memset(&s->new_picture, 0, sizeof(s->new_picture));
816 
817  memset(s->thread_context, 0, sizeof(s->thread_context));
818 
819  s->me.map = NULL;
820  s->me.score_map = NULL;
821  s->dct_error_sum = NULL;
822  s->block = NULL;
823  s->blocks = NULL;
824  s->block32 = NULL;
825  memset(s->pblocks, 0, sizeof(s->pblocks));
826  s->dpcm_direction = 0;
827  s->dpcm_macroblock = NULL;
828  s->ac_val_base = NULL;
829  s->ac_val[0] =
830  s->ac_val[1] =
831  s->ac_val[2] =NULL;
832  s->sc.edge_emu_buffer = NULL;
833  s->me.scratchpad = NULL;
834  s->me.temp =
835  s->sc.rd_scratchpad =
836  s->sc.b_scratchpad =
837  s->sc.obmc_scratchpad = NULL;
838 
839 
840  s->bitstream_buffer = NULL;
842  s->picture = NULL;
843  s->mb_type = NULL;
844  s->p_mv_table_base = NULL;
850  s->p_mv_table = NULL;
851  s->b_forw_mv_table = NULL;
852  s->b_back_mv_table = NULL;
855  s->b_direct_mv_table = NULL;
856  for (i = 0; i < 2; i++) {
857  for (j = 0; j < 2; j++) {
858  for (k = 0; k < 2; k++) {
859  s->b_field_mv_table_base[i][j][k] = NULL;
860  s->b_field_mv_table[i][j][k] = NULL;
861  }
862  s->b_field_select_table[i][j] = NULL;
863  s->p_field_mv_table_base[i][j] = NULL;
864  s->p_field_mv_table[i][j] = NULL;
865  }
867  }
868 
869  s->dc_val_base = NULL;
870  s->coded_block_base = NULL;
871  s->mbintra_table = NULL;
872  s->cbp_table = NULL;
873  s->pred_dir_table = NULL;
874 
875  s->mbskip_table = NULL;
876 
878  s->er.er_temp_buffer = NULL;
879  s->mb_index2xy = NULL;
880  s->lambda_table = NULL;
881 
882  s->cplx_tab = NULL;
883  s->bits_tab = NULL;
884 }
885 
886 /**
887  * init common structure for both encoder and decoder.
888  * this assumes that some variables like width/height are already set
889  */
891 {
892  int i, ret;
893  int nb_slices = (HAVE_THREADS &&
895  s->avctx->thread_count : 1;
896 
897  clear_context(s);
898 
899  if (s->encoding && s->avctx->slices)
900  nb_slices = s->avctx->slices;
901 
903  s->mb_height = (s->height + 31) / 32 * 2;
904  else
905  s->mb_height = (s->height + 15) / 16;
906 
907  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
909  "decoding to AV_PIX_FMT_NONE is not supported.\n");
910  return -1;
911  }
912 
913  if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
914  int max_slices;
915  if (s->mb_height)
916  max_slices = FFMIN(MAX_THREADS, s->mb_height);
917  else
918  max_slices = MAX_THREADS;
919  av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
920  " reducing to %d\n", nb_slices, max_slices);
921  nb_slices = max_slices;
922  }
923 
924  if ((s->width || s->height) &&
925  av_image_check_size(s->width, s->height, 0, s->avctx))
926  return -1;
927 
928  dct_init(s);
929 
930  /* set chroma shifts */
932  &s->chroma_x_shift,
933  &s->chroma_y_shift);
934  if (ret)
935  return ret;
936 
938  MAX_PICTURE_COUNT * sizeof(Picture), fail);
939  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
940  s->picture[i].f = av_frame_alloc();
941  if (!s->picture[i].f)
942  goto fail;
943  }
945  if (!s->next_picture.f)
946  goto fail;
948  if (!s->last_picture.f)
949  goto fail;
951  if (!s->current_picture.f)
952  goto fail;
954  if (!s->new_picture.f)
955  goto fail;
956 
957  if (init_context_frame(s))
958  goto fail;
959 
960  s->parse_context.state = -1;
961 
962  s->context_initialized = 1;
963  memset(s->thread_context, 0, sizeof(s->thread_context));
964  s->thread_context[0] = s;
965 
966 // if (s->width && s->height) {
967  if (nb_slices > 1) {
968  for (i = 0; i < nb_slices; i++) {
969  if (i) {
970  s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
971  if (!s->thread_context[i])
972  goto fail;
973  }
974  if (init_duplicate_context(s->thread_context[i]) < 0)
975  goto fail;
977  (s->mb_height * (i) + nb_slices / 2) / nb_slices;
978  s->thread_context[i]->end_mb_y =
979  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
980  }
981  } else {
982  if (init_duplicate_context(s) < 0)
983  goto fail;
984  s->start_mb_y = 0;
985  s->end_mb_y = s->mb_height;
986  }
987  s->slice_context_count = nb_slices;
988 // }
989 
990  return 0;
991  fail:
993  return -1;
994 }
995 
996 /**
997  * Frees and resets MpegEncContext fields depending on the resolution.
998  * Is used during resolution changes to avoid a full reinitialization of the
999  * codec.
1000  */
1002 {
1003  int i, j, k;
1004 
1005  av_freep(&s->mb_type);
1012  s->p_mv_table = NULL;
1013  s->b_forw_mv_table = NULL;
1014  s->b_back_mv_table = NULL;
1017  s->b_direct_mv_table = NULL;
1018  for (i = 0; i < 2; i++) {
1019  for (j = 0; j < 2; j++) {
1020  for (k = 0; k < 2; k++) {
1021  av_freep(&s->b_field_mv_table_base[i][j][k]);
1022  s->b_field_mv_table[i][j][k] = NULL;
1023  }
1024  av_freep(&s->b_field_select_table[i][j]);
1025  av_freep(&s->p_field_mv_table_base[i][j]);
1026  s->p_field_mv_table[i][j] = NULL;
1027  }
1029  }
1030 
1031  av_freep(&s->dc_val_base);
1033  av_freep(&s->mbintra_table);
1034  av_freep(&s->cbp_table);
1035  av_freep(&s->pred_dir_table);
1036 
1037  av_freep(&s->mbskip_table);
1038 
1040  av_freep(&s->er.er_temp_buffer);
1041  av_freep(&s->mb_index2xy);
1042  av_freep(&s->lambda_table);
1043 
1044  av_freep(&s->cplx_tab);
1045  av_freep(&s->bits_tab);
1046 
1047  s->linesize = s->uvlinesize = 0;
1048 }
1049 
1051 {
1052  int i, err = 0;
1053 
1054  if (!s->context_initialized)
1055  return AVERROR(EINVAL);
1056 
1057  if (s->slice_context_count > 1) {
1058  for (i = 0; i < s->slice_context_count; i++) {
1060  }
1061  for (i = 1; i < s->slice_context_count; i++) {
1062  av_freep(&s->thread_context[i]);
1063  }
1064  } else
1066 
1067  free_context_frame(s);
1068 
1069  if (s->picture)
1070  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1071  s->picture[i].needs_realloc = 1;
1072  }
1073 
1074  s->last_picture_ptr =
1075  s->next_picture_ptr =
1077 
1078  // init
1080  s->mb_height = (s->height + 31) / 32 * 2;
1081  else
1082  s->mb_height = (s->height + 15) / 16;
1083 
1084  if ((s->width || s->height) &&
1085  (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1086  goto fail;
1087 
1088  if ((err = init_context_frame(s)))
1089  goto fail;
1090 
1091  memset(s->thread_context, 0, sizeof(s->thread_context));
1092  s->thread_context[0] = s;
1093 
1094  if (s->width && s->height) {
1095  int nb_slices = s->slice_context_count;
1096  if (nb_slices > 1) {
1097  for (i = 0; i < nb_slices; i++) {
1098  if (i) {
1099  s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
1100  if (!s->thread_context[i]) {
1101  err = AVERROR(ENOMEM);
1102  goto fail;
1103  }
1104  }
1105  if ((err = init_duplicate_context(s->thread_context[i])) < 0)
1106  goto fail;
1107  s->thread_context[i]->start_mb_y =
1108  (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1109  s->thread_context[i]->end_mb_y =
1110  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1111  }
1112  } else {
1113  err = init_duplicate_context(s);
1114  if (err < 0)
1115  goto fail;
1116  s->start_mb_y = 0;
1117  s->end_mb_y = s->mb_height;
1118  }
1119  s->slice_context_count = nb_slices;
1120  }
1121 
1122  return 0;
1123  fail:
1124  ff_mpv_common_end(s);
1125  return err;
1126 }
1127 
1128 /* init common structure for both encoder and decoder */
1130 {
1131  int i;
1132 
1133  if (!s)
1134  return ;
1135 
1136  if (s->slice_context_count > 1) {
1137  for (i = 0; i < s->slice_context_count; i++) {
1139  }
1140  for (i = 1; i < s->slice_context_count; i++) {
1141  av_freep(&s->thread_context[i]);
1142  }
1143  s->slice_context_count = 1;
1144  } else free_duplicate_context(s);
1145 
1147  s->parse_context.buffer_size = 0;
1148 
1151 
1152  if (s->picture) {
1153  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1155  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1156  av_frame_free(&s->picture[i].f);
1157  }
1158  }
1159  av_freep(&s->picture);
1172 
1173  free_context_frame(s);
1174 
1175  s->context_initialized = 0;
1176  s->last_picture_ptr =
1177  s->next_picture_ptr =
1179  s->linesize = s->uvlinesize = 0;
1180 }
1181 
1182 
1183 static void gray_frame(AVFrame *frame)
1184 {
1185  int i, h_chroma_shift, v_chroma_shift;
1186 
1187  av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1188 
1189  for(i=0; i<frame->height; i++)
1190  memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1191  for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1192  memset(frame->data[1] + frame->linesize[1]*i,
1193  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1194  memset(frame->data[2] + frame->linesize[2]*i,
1195  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1196  }
1197 }
1198 
1199 /**
1200  * generic function called after decoding
1201  * the header and before a frame is decoded.
1202  */
1204 {
1205  int i, ret;
1206  Picture *pic;
1207  s->mb_skipped = 0;
1208 
1209  if (!ff_thread_can_start_frame(avctx)) {
1210  av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1211  return -1;
1212  }
1213 
1214  /* mark & release old frames */
1215  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1217  s->last_picture_ptr->f->buf[0]) {
1219  }
1220 
1221  /* release forgotten pictures */
1222  /* if (MPEG-124 / H.263) */
1223  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1224  if (&s->picture[i] != s->last_picture_ptr &&
1225  &s->picture[i] != s->next_picture_ptr &&
1226  s->picture[i].reference && !s->picture[i].needs_realloc) {
1227  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1228  }
1229  }
1230 
1234 
1235  /* release non reference frames */
1236  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1237  if (!s->picture[i].reference)
1238  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1239  }
1240 
1241  if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1242  // we already have an unused image
1243  // (maybe it was set before reading the header)
1244  pic = s->current_picture_ptr;
1245  } else {
1246  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1247  if (i < 0) {
1248  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1249  return i;
1250  }
1251  pic = &s->picture[i];
1252  }
1253 
1254  pic->reference = 0;
1255  if (!s->droppable) {
1256  if (s->pict_type != AV_PICTURE_TYPE_B)
1257  pic->reference = 3;
1258  }
1259 
1261 
1262  if (alloc_picture(s, pic) < 0)
1263  return -1;
1264 
1265  s->current_picture_ptr = pic;
1266  // FIXME use only the vars from current_pic
1268  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1270  if (s->picture_structure != PICT_FRAME)
1273  }
1277 
1279  // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
1280  // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1282 
1283  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1284  s->current_picture_ptr)) < 0)
1285  return ret;
1286 
1287  if (s->pict_type != AV_PICTURE_TYPE_B) {
1289  if (!s->droppable)
1291  }
1292  ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1294  s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1295  s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1297  s->pict_type, s->droppable);
1298 
1299  if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1300  (s->pict_type != AV_PICTURE_TYPE_I)) {
1301  int h_chroma_shift, v_chroma_shift;
1303  &h_chroma_shift, &v_chroma_shift);
1305  av_log(avctx, AV_LOG_DEBUG,
1306  "allocating dummy last picture for B frame\n");
1307  else if (s->pict_type != AV_PICTURE_TYPE_I)
1308  av_log(avctx, AV_LOG_ERROR,
1309  "warning: first frame is no keyframe\n");
1310 
1311  /* Allocate a dummy frame */
1312  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1313  if (i < 0) {
1314  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1315  return i;
1316  }
1317  s->last_picture_ptr = &s->picture[i];
1318 
1319  s->last_picture_ptr->reference = 3;
1320  s->last_picture_ptr->f->key_frame = 0;
1322 
1323  if (alloc_picture(s, s->last_picture_ptr) < 0) {
1324  s->last_picture_ptr = NULL;
1325  return -1;
1326  }
1327 
1328  if (!avctx->hwaccel) {
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,
1331  0x80, avctx->width);
1332  if (s->last_picture_ptr->f->data[2]) {
1333  for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1334  memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1335  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1336  memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1337  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1338  }
1339  }
1340 
1342  for(i=0; i<avctx->height; i++)
1343  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1344  }
1345  }
1346 
1347  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1348  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1349  }
1350  if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1351  s->pict_type == AV_PICTURE_TYPE_B) {
1352  /* Allocate a dummy frame */
1353  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1354  if (i < 0) {
1355  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1356  return i;
1357  }
1358  s->next_picture_ptr = &s->picture[i];
1359 
1360  s->next_picture_ptr->reference = 3;
1361  s->next_picture_ptr->f->key_frame = 0;
1363 
1364  if (alloc_picture(s, s->next_picture_ptr) < 0) {
1365  s->next_picture_ptr = NULL;
1366  return -1;
1367  }
1368  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1369  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1370  }
1371 
1372 #if 0 // BUFREF-FIXME
1373  memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1374  memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1375 #endif
1376  if (s->last_picture_ptr) {
1377  if (s->last_picture_ptr->f->buf[0] &&
1378  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1379  s->last_picture_ptr)) < 0)
1380  return ret;
1381  }
1382  if (s->next_picture_ptr) {
1383  if (s->next_picture_ptr->f->buf[0] &&
1384  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1385  s->next_picture_ptr)) < 0)
1386  return ret;
1387  }
1388 
1390  s->last_picture_ptr->f->buf[0]));
1391 
1392  if (s->picture_structure!= PICT_FRAME) {
1393  int i;
1394  for (i = 0; i < 4; i++) {
1396  s->current_picture.f->data[i] +=
1397  s->current_picture.f->linesize[i];
1398  }
1399  s->current_picture.f->linesize[i] *= 2;
1400  s->last_picture.f->linesize[i] *= 2;
1401  s->next_picture.f->linesize[i] *= 2;
1402  }
1403  }
1404 
1405  /* set dequantizer, we can't do it during init as
1406  * it might change for MPEG-4 and we can't do it in the header
1407  * decode as init is not called for MPEG-4 there yet */
1408  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1411  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1414  } else {
1417  }
1418 
1419  if (s->avctx->debug & FF_DEBUG_NOMC) {
1421  }
1422 
1423  return 0;
1424 }
1425 
1426 /* called after a frame has been decoded. */
1428 {
1429  emms_c();
1430 
1431  if (s->current_picture.reference)
1433 }
1434 
1436 {
1438  p->qscale_table, p->motion_val, &s->low_delay,
1439  s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
1440 }
1441 
1443 {
1445  int offset = 2*s->mb_stride + 1;
1446  if(!ref)
1447  return AVERROR(ENOMEM);
1448  av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
1449  ref->size -= offset;
1450  ref->data += offset;
1451  return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
1452 }
1453 
1455  uint8_t *dest, uint8_t *src,
1456  int field_based, int field_select,
1457  int src_x, int src_y,
1458  int width, int height, ptrdiff_t stride,
1459  int h_edge_pos, int v_edge_pos,
1460  int w, int h, h264_chroma_mc_func *pix_op,
1461  int motion_x, int motion_y)
1462 {
1463  const int lowres = s->avctx->lowres;
1464  const int op_index = FFMIN(lowres, 3);
1465  const int s_mask = (2 << lowres) - 1;
1466  int emu = 0;
1467  int sx, sy;
1468 
1469  if (s->quarter_sample) {
1470  motion_x /= 2;
1471  motion_y /= 2;
1472  }
1473 
1474  sx = motion_x & s_mask;
1475  sy = motion_y & s_mask;
1476  src_x += motion_x >> lowres + 1;
1477  src_y += motion_y >> lowres + 1;
1478 
1479  src += src_y * stride + src_x;
1480 
1481  if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1482  (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1484  s->linesize, s->linesize,
1485  w + 1, (h + 1) << field_based,
1486  src_x, src_y << field_based,
1487  h_edge_pos, v_edge_pos);
1488  src = s->sc.edge_emu_buffer;
1489  emu = 1;
1490  }
1491 
1492  sx = (sx << 2) >> lowres;
1493  sy = (sy << 2) >> lowres;
1494  if (field_select)
1495  src += s->linesize;
1496  pix_op[op_index](dest, src, stride, h, sx, sy);
1497  return emu;
1498 }
1499 
1500 /* apply one mpeg motion vector to the three components */
1502  uint8_t *dest_y,
1503  uint8_t *dest_cb,
1504  uint8_t *dest_cr,
1505  int field_based,
1506  int bottom_field,
1507  int field_select,
1508  uint8_t **ref_picture,
1509  h264_chroma_mc_func *pix_op,
1510  int motion_x, int motion_y,
1511  int h, int mb_y)
1512 {
1513  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1514  int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
1515  ptrdiff_t uvlinesize, linesize;
1516  const int lowres = s->avctx->lowres;
1517  const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
1518  const int block_s = 8>>lowres;
1519  const int s_mask = (2 << lowres) - 1;
1520  const int h_edge_pos = s->h_edge_pos >> lowres;
1521  const int v_edge_pos = s->v_edge_pos >> lowres;
1522  linesize = s->current_picture.f->linesize[0] << field_based;
1523  uvlinesize = s->current_picture.f->linesize[1] << field_based;
1524 
1525  // FIXME obviously not perfect but qpel will not work in lowres anyway
1526  if (s->quarter_sample) {
1527  motion_x /= 2;
1528  motion_y /= 2;
1529  }
1530 
1531  if(field_based){
1532  motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1533  }
1534 
1535  sx = motion_x & s_mask;
1536  sy = motion_y & s_mask;
1537  src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1538  src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1539 
1540  if (s->out_format == FMT_H263) {
1541  uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1542  uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1543  uvsrc_x = src_x >> 1;
1544  uvsrc_y = src_y >> 1;
1545  } else if (s->out_format == FMT_H261) {
1546  // even chroma mv's are full pel in H261
1547  mx = motion_x / 4;
1548  my = motion_y / 4;
1549  uvsx = (2 * mx) & s_mask;
1550  uvsy = (2 * my) & s_mask;
1551  uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1552  uvsrc_y = mb_y * block_s + (my >> lowres);
1553  } else {
1554  if(s->chroma_y_shift){
1555  mx = motion_x / 2;
1556  my = motion_y / 2;
1557  uvsx = mx & s_mask;
1558  uvsy = my & s_mask;
1559  uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1560  uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1561  } else {
1562  if(s->chroma_x_shift){
1563  //Chroma422
1564  mx = motion_x / 2;
1565  uvsx = mx & s_mask;
1566  uvsy = motion_y & s_mask;
1567  uvsrc_y = src_y;
1568  uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1569  } else {
1570  //Chroma444
1571  uvsx = motion_x & s_mask;
1572  uvsy = motion_y & s_mask;
1573  uvsrc_x = src_x;
1574  uvsrc_y = src_y;
1575  }
1576  }
1577  }
1578 
1579  ptr_y = ref_picture[0] + src_y * linesize + src_x;
1580  ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1581  ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1582 
1583  if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
1584  (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1585  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
1586  linesize >> field_based, linesize >> field_based,
1587  17, 17 + field_based,
1588  src_x, src_y << field_based, h_edge_pos,
1589  v_edge_pos);
1590  ptr_y = s->sc.edge_emu_buffer;
1591  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1592  uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
1593  uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
1594  if (s->workaround_bugs & FF_BUG_IEDGE)
1595  vbuf -= s->uvlinesize;
1596  s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
1597  uvlinesize >> field_based, uvlinesize >> field_based,
1598  9, 9 + field_based,
1599  uvsrc_x, uvsrc_y << field_based,
1600  h_edge_pos >> 1, v_edge_pos >> 1);
1601  s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
1602  uvlinesize >> field_based,uvlinesize >> field_based,
1603  9, 9 + field_based,
1604  uvsrc_x, uvsrc_y << field_based,
1605  h_edge_pos >> 1, v_edge_pos >> 1);
1606  ptr_cb = ubuf;
1607  ptr_cr = vbuf;
1608  }
1609  }
1610 
1611  // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
1612  if (bottom_field) {
1613  dest_y += s->linesize;
1614  dest_cb += s->uvlinesize;
1615  dest_cr += s->uvlinesize;
1616  }
1617 
1618  if (field_select) {
1619  ptr_y += s->linesize;
1620  ptr_cb += s->uvlinesize;
1621  ptr_cr += s->uvlinesize;
1622  }
1623 
1624  sx = (sx << 2) >> lowres;
1625  sy = (sy << 2) >> lowres;
1626  pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1627 
1628  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1629  int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
1630  uvsx = (uvsx << 2) >> lowres;
1631  uvsy = (uvsy << 2) >> lowres;
1632  if (hc) {
1633  pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
1634  pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
1635  }
1636  }
1637  // FIXME h261 lowres loop filter
1638 }
1639 
1641  uint8_t *dest_cb, uint8_t *dest_cr,
1642  uint8_t **ref_picture,
1643  h264_chroma_mc_func * pix_op,
1644  int mx, int my)
1645 {
1646  const int lowres = s->avctx->lowres;
1647  const int op_index = FFMIN(lowres, 3);
1648  const int block_s = 8 >> lowres;
1649  const int s_mask = (2 << lowres) - 1;
1650  const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1651  const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1652  int emu = 0, src_x, src_y, sx, sy;
1653  ptrdiff_t offset;
1654  uint8_t *ptr;
1655 
1656  if (s->quarter_sample) {
1657  mx /= 2;
1658  my /= 2;
1659  }
1660 
1661  /* In case of 8X8, we construct a single chroma motion vector
1662  with a special rounding */
1663  mx = ff_h263_round_chroma(mx);
1664  my = ff_h263_round_chroma(my);
1665 
1666  sx = mx & s_mask;
1667  sy = my & s_mask;
1668  src_x = s->mb_x * block_s + (mx >> lowres + 1);
1669  src_y = s->mb_y * block_s + (my >> lowres + 1);
1670 
1671  offset = src_y * s->uvlinesize + src_x;
1672  ptr = ref_picture[1] + offset;
1673  if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1674  (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1676  s->uvlinesize, s->uvlinesize,
1677  9, 9,
1678  src_x, src_y, h_edge_pos, v_edge_pos);
1679  ptr = s->sc.edge_emu_buffer;
1680  emu = 1;
1681  }
1682  sx = (sx << 2) >> lowres;
1683  sy = (sy << 2) >> lowres;
1684  pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1685 
1686  ptr = ref_picture[2] + offset;
1687  if (emu) {
1689  s->uvlinesize, s->uvlinesize,
1690  9, 9,
1691  src_x, src_y, h_edge_pos, v_edge_pos);
1692  ptr = s->sc.edge_emu_buffer;
1693  }
1694  pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1695 }
1696 
1697 /**
1698  * motion compensation of a single macroblock
1699  * @param s context
1700  * @param dest_y luma destination pointer
1701  * @param dest_cb chroma cb/u destination pointer
1702  * @param dest_cr chroma cr/v destination pointer
1703  * @param dir direction (0->forward, 1->backward)
1704  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1705  * @param pix_op halfpel motion compensation function (average or put normally)
1706  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1707  */
1708 static inline void MPV_motion_lowres(MpegEncContext *s,
1709  uint8_t *dest_y, uint8_t *dest_cb,
1710  uint8_t *dest_cr,
1711  int dir, uint8_t **ref_picture,
1712  h264_chroma_mc_func *pix_op)
1713 {
1714  int mx, my;
1715  int mb_x, mb_y, i;
1716  const int lowres = s->avctx->lowres;
1717  const int block_s = 8 >>lowres;
1718 
1719  mb_x = s->mb_x;
1720  mb_y = s->mb_y;
1721 
1722  switch (s->mv_type) {
1723  case MV_TYPE_16X16:
1724  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1725  0, 0, 0,
1726  ref_picture, pix_op,
1727  s->mv[dir][0][0], s->mv[dir][0][1],
1728  2 * block_s, mb_y);
1729  break;
1730  case MV_TYPE_8X8:
1731  mx = 0;
1732  my = 0;
1733  for (i = 0; i < 4; i++) {
1734  hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
1735  s->linesize) * block_s,
1736  ref_picture[0], 0, 0,
1737  (2 * mb_x + (i & 1)) * block_s,
1738  (2 * mb_y + (i >> 1)) * block_s,
1739  s->width, s->height, s->linesize,
1740  s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1741  block_s, block_s, pix_op,
1742  s->mv[dir][i][0], s->mv[dir][i][1]);
1743 
1744  mx += s->mv[dir][i][0];
1745  my += s->mv[dir][i][1];
1746  }
1747 
1748  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
1749  chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
1750  pix_op, mx, my);
1751  break;
1752  case MV_TYPE_FIELD:
1753  if (s->picture_structure == PICT_FRAME) {
1754  /* top field */
1755  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1756  1, 0, s->field_select[dir][0],
1757  ref_picture, pix_op,
1758  s->mv[dir][0][0], s->mv[dir][0][1],
1759  block_s, mb_y);
1760  /* bottom field */
1761  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1762  1, 1, s->field_select[dir][1],
1763  ref_picture, pix_op,
1764  s->mv[dir][1][0], s->mv[dir][1][1],
1765  block_s, mb_y);
1766  } else {
1767  if (s->picture_structure != s->field_select[dir][0] + 1 &&
1768  s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
1769  ref_picture = s->current_picture_ptr->f->data;
1770 
1771  }
1772  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1773  0, 0, s->field_select[dir][0],
1774  ref_picture, pix_op,
1775  s->mv[dir][0][0],
1776  s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1777  }
1778  break;
1779  case MV_TYPE_16X8:
1780  for (i = 0; i < 2; i++) {
1781  uint8_t **ref2picture;
1782 
1783  if (s->picture_structure == s->field_select[dir][i] + 1 ||
1784  s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
1785  ref2picture = ref_picture;
1786  } else {
1787  ref2picture = s->current_picture_ptr->f->data;
1788  }
1789 
1790  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1791  0, 0, s->field_select[dir][i],
1792  ref2picture, pix_op,
1793  s->mv[dir][i][0], s->mv[dir][i][1] +
1794  2 * block_s * i, block_s, mb_y >> 1);
1795 
1796  dest_y += 2 * block_s * s->linesize;
1797  dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1798  dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1799  }
1800  break;
1801  case MV_TYPE_DMV:
1802  if (s->picture_structure == PICT_FRAME) {
1803  for (i = 0; i < 2; i++) {
1804  int j;
1805  for (j = 0; j < 2; j++) {
1806  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1807  1, j, j ^ i,
1808  ref_picture, pix_op,
1809  s->mv[dir][2 * i + j][0],
1810  s->mv[dir][2 * i + j][1],
1811  block_s, mb_y);
1812  }
1814  }
1815  } else {
1816  for (i = 0; i < 2; i++) {
1817  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1818  0, 0, s->picture_structure != i + 1,
1819  ref_picture, pix_op,
1820  s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
1821  2 * block_s, mb_y >> 1);
1822 
1823  // after put we make avg of the same block
1825 
1826  // opposite parity is always in the same
1827  // frame if this is second field
1828  if (!s->first_field) {
1829  ref_picture = s->current_picture_ptr->f->data;
1830  }
1831  }
1832  }
1833  break;
1834  default:
1835  av_assert2(0);
1836  }
1837 }
1838 
1839 /**
1840  * find the lowest MB row referenced in the MVs
1841  */
1843 {
1844  int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1845  int my, off, i, mvs;
1846 
1847  if (s->picture_structure != PICT_FRAME || s->mcsel)
1848  goto unhandled;
1849 
1850  switch (s->mv_type) {
1851  case MV_TYPE_16X16:
1852  mvs = 1;
1853  break;
1854  case MV_TYPE_16X8:
1855  mvs = 2;
1856  break;
1857  case MV_TYPE_8X8:
1858  mvs = 4;
1859  break;
1860  default:
1861  goto unhandled;
1862  }
1863 
1864  for (i = 0; i < mvs; i++) {
1865  my = s->mv[dir][i][1];
1866  my_max = FFMAX(my_max, my);
1867  my_min = FFMIN(my_min, my);
1868  }
1869 
1870  off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
1871 
1872  return av_clip(s->mb_y + off, 0, s->mb_height - 1);
1873 unhandled:
1874  return s->mb_height-1;
1875 }
1876 
1877 /* put block[] to dest[] */
1878 static inline void put_dct(MpegEncContext *s,
1879  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1880 {
1881  s->dct_unquantize_intra(s, block, i, qscale);
1882  s->idsp.idct_put(dest, line_size, block);
1883 }
1884 
1885 /* add block[] to dest[] */
1886 static inline void add_dct(MpegEncContext *s,
1887  int16_t *block, int i, uint8_t *dest, int line_size)
1888 {
1889  if (s->block_last_index[i] >= 0) {
1890  s->idsp.idct_add(dest, line_size, block);
1891  }
1892 }
1893 
1894 static inline void add_dequant_dct(MpegEncContext *s,
1895  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1896 {
1897  if (s->block_last_index[i] >= 0) {
1898  s->dct_unquantize_inter(s, block, i, qscale);
1899 
1900  s->idsp.idct_add(dest, line_size, block);
1901  }
1902 }
1903 
1904 /**
1905  * Clean dc, ac, coded_block for the current non-intra MB.
1906  */
1908 {
1909  int wrap = s->b8_stride;
1910  int xy = s->block_index[0];
1911 
1912  s->dc_val[0][xy ] =
1913  s->dc_val[0][xy + 1 ] =
1914  s->dc_val[0][xy + wrap] =
1915  s->dc_val[0][xy + 1 + wrap] = 1024;
1916  /* ac pred */
1917  memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1918  memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1919  if (s->msmpeg4_version>=3) {
1920  s->coded_block[xy ] =
1921  s->coded_block[xy + 1 ] =
1922  s->coded_block[xy + wrap] =
1923  s->coded_block[xy + 1 + wrap] = 0;
1924  }
1925  /* chroma */
1926  wrap = s->mb_stride;
1927  xy = s->mb_x + s->mb_y * wrap;
1928  s->dc_val[1][xy] =
1929  s->dc_val[2][xy] = 1024;
1930  /* ac pred */
1931  memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1932  memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1933 
1934  s->mbintra_table[xy]= 0;
1935 }
1936 
1937 /* generic function called after a macroblock has been parsed by the
1938  decoder or after it has been encoded by the encoder.
1939 
1940  Important variables used:
1941  s->mb_intra : true if intra macroblock
1942  s->mv_dir : motion vector direction
1943  s->mv_type : motion vector type
1944  s->mv : motion vector
1945  s->interlaced_dct : true if interlaced dct used (mpeg2)
1946  */
1947 static av_always_inline
1949  int lowres_flag, int is_mpeg12)
1950 {
1951  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1952 
1953  if (CONFIG_XVMC &&
1954  s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
1955  s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
1956  return;
1957  }
1958 
1959  if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1960  /* print DCT coefficients */
1961  int i,j;
1962  av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1963  for(i=0; i<6; i++){
1964  for(j=0; j<64; j++){
1965  av_log(s->avctx, AV_LOG_DEBUG, "%5d",
1966  block[i][s->idsp.idct_permutation[j]]);
1967  }
1968  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1969  }
1970  }
1971 
1972  s->current_picture.qscale_table[mb_xy] = s->qscale;
1973 
1974  /* update DC predictors for P macroblocks */
1975  if (!s->mb_intra) {
1976  if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1977  if(s->mbintra_table[mb_xy])
1979  } else {
1980  s->last_dc[0] =
1981  s->last_dc[1] =
1982  s->last_dc[2] = 128 << s->intra_dc_precision;
1983  }
1984  }
1985  else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1986  s->mbintra_table[mb_xy]=1;
1987 
1989  !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
1990  s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
1991  uint8_t *dest_y, *dest_cb, *dest_cr;
1992  int dct_linesize, dct_offset;
1993  op_pixels_func (*op_pix)[4];
1994  qpel_mc_func (*op_qpix)[16];
1995  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
1996  const int uvlinesize = s->current_picture.f->linesize[1];
1997  const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1998  const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1999 
2000  /* avoid copy if macroblock skipped in last frame too */
2001  /* skip only during decoding as we might trash the buffers during encoding a bit */
2002  if(!s->encoding){
2003  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2004 
2005  if (s->mb_skipped) {
2006  s->mb_skipped= 0;
2008  *mbskip_ptr = 1;
2009  } else if(!s->current_picture.reference) {
2010  *mbskip_ptr = 1;
2011  } else{
2012  *mbskip_ptr = 0; /* not skipped */
2013  }
2014  }
2015 
2016  dct_linesize = linesize << s->interlaced_dct;
2017  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2018 
2019  if(readable){
2020  dest_y= s->dest[0];
2021  dest_cb= s->dest[1];
2022  dest_cr= s->dest[2];
2023  }else{
2024  dest_y = s->sc.b_scratchpad;
2025  dest_cb= s->sc.b_scratchpad+16*linesize;
2026  dest_cr= s->sc.b_scratchpad+32*linesize;
2027  }
2028 
2029  if (!s->mb_intra) {
2030  /* motion handling */
2031  /* decoding or more than one mb_type (MC was already done otherwise) */
2032  if(!s->encoding){
2033 
2034  if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2035  if (s->mv_dir & MV_DIR_FORWARD) {
2037  lowest_referenced_row(s, 0),
2038  0);
2039  }
2040  if (s->mv_dir & MV_DIR_BACKWARD) {
2042  lowest_referenced_row(s, 1),
2043  0);
2044  }
2045  }
2046 
2047  if(lowres_flag){
2049 
2050  if (s->mv_dir & MV_DIR_FORWARD) {
2051  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
2053  }
2054  if (s->mv_dir & MV_DIR_BACKWARD) {
2055  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
2056  }
2057  }else{
2058  op_qpix = s->me.qpel_put;
2059  if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2060  op_pix = s->hdsp.put_pixels_tab;
2061  }else{
2062  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2063  }
2064  if (s->mv_dir & MV_DIR_FORWARD) {
2065  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2066  op_pix = s->hdsp.avg_pixels_tab;
2067  op_qpix= s->me.qpel_avg;
2068  }
2069  if (s->mv_dir & MV_DIR_BACKWARD) {
2070  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2071  }
2072  }
2073  }
2074 
2075  /* skip dequant / idct if we are really late ;) */
2076  if(s->avctx->skip_idct){
2079  || s->avctx->skip_idct >= AVDISCARD_ALL)
2080  goto skip_idct;
2081  }
2082 
2083  /* add dct residue */
2085  || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2086  add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2087  add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2088  add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2089  add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2090 
2091  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2092  if (s->chroma_y_shift){
2093  add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2094  add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2095  }else{
2096  dct_linesize >>= 1;
2097  dct_offset >>=1;
2098  add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2099  add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2100  add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2101  add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2102  }
2103  }
2104  } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2105  add_dct(s, block[0], 0, dest_y , dct_linesize);
2106  add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2107  add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2108  add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2109 
2110  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2111  if(s->chroma_y_shift){//Chroma420
2112  add_dct(s, block[4], 4, dest_cb, uvlinesize);
2113  add_dct(s, block[5], 5, dest_cr, uvlinesize);
2114  }else{
2115  //chroma422
2116  dct_linesize = uvlinesize << s->interlaced_dct;
2117  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2118 
2119  add_dct(s, block[4], 4, dest_cb, dct_linesize);
2120  add_dct(s, block[5], 5, dest_cr, dct_linesize);
2121  add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2122  add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2123  if(!s->chroma_x_shift){//Chroma444
2124  add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2125  add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2126  add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2127  add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2128  }
2129  }
2130  }//fi gray
2131  }
2132  else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2133  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2134  }
2135  } else {
2136  /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
2137  TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
2138  if (s->avctx->bits_per_raw_sample > 8){
2139  const int act_block_size = block_size * 2;
2140 
2141  if(s->dpcm_direction == 0) {
2142  s->idsp.idct_put(dest_y, dct_linesize, (int16_t*)(*s->block32)[0]);
2143  s->idsp.idct_put(dest_y + act_block_size, dct_linesize, (int16_t*)(*s->block32)[1]);
2144  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, (int16_t*)(*s->block32)[2]);
2145  s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)(*s->block32)[3]);
2146 
2147  dct_linesize = uvlinesize << s->interlaced_dct;
2148  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2149 
2150  s->idsp.idct_put(dest_cb, dct_linesize, (int16_t*)(*s->block32)[4]);
2151  s->idsp.idct_put(dest_cr, dct_linesize, (int16_t*)(*s->block32)[5]);
2152  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)(*s->block32)[6]);
2153  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)(*s->block32)[7]);
2154  if(!s->chroma_x_shift){//Chroma444
2155  s->idsp.idct_put(dest_cb + act_block_size, dct_linesize, (int16_t*)(*s->block32)[8]);
2156  s->idsp.idct_put(dest_cr + act_block_size, dct_linesize, (int16_t*)(*s->block32)[9]);
2157  s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[10]);
2158  s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[11]);
2159  }
2160  } else if(s->dpcm_direction == 1) {
2161  int i, w, h;
2162  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2163  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2164  for(i = 0; i < 3; i++) {
2165  int idx = 0;
2166  int vsub = i ? s->chroma_y_shift : 0;
2167  int hsub = i ? s->chroma_x_shift : 0;
2168  for(h = 0; h < (16 >> vsub); h++){
2169  for(w = 0; w < (16 >> hsub); w++)
2170  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2171  dest_pcm[i] += linesize[i] / 2;
2172  }
2173  }
2174  } else if(s->dpcm_direction == -1) {
2175  int i, w, h;
2176  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2177  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2178  for(i = 0; i < 3; i++) {
2179  int idx = 0;
2180  int vsub = i ? s->chroma_y_shift : 0;
2181  int hsub = i ? s->chroma_x_shift : 0;
2182  dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub) - 1);
2183  for(h = (16 >> vsub)-1; h >= 1; h--){
2184  for(w = (16 >> hsub)-1; w >= 1; w--)
2185  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2186  dest_pcm[i] -= linesize[i] / 2;
2187  }
2188  }
2189  }
2190  }
2191  /* dct only in intra block */
2193  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2194  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2195  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2196  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2197 
2198  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2199  if(s->chroma_y_shift){
2200  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2201  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2202  }else{
2203  dct_offset >>=1;
2204  dct_linesize >>=1;
2205  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2206  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2207  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2208  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2209  }
2210  }
2211  }else{
2212  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
2213  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2214  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
2215  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2216 
2217  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2218  if(s->chroma_y_shift){
2219  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2220  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2221  }else{
2222 
2223  dct_linesize = uvlinesize << s->interlaced_dct;
2224  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2225 
2226  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
2227  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
2228  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2229  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2230  if(!s->chroma_x_shift){//Chroma444
2231  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2232  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2233  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2234  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2235  }
2236  }
2237  }//gray
2238  }
2239  }
2240 skip_idct:
2241  if(!readable){
2242  s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2243  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2244  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2245  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2246  }
2247  }
2248  }
2249 }
2250 
2252 {
2253 #if !CONFIG_SMALL
2254  if(s->out_format == FMT_MPEG1) {
2255  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
2256  else mpv_reconstruct_mb_internal(s, block, 0, 1);
2257  } else
2258 #endif
2259  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
2260  else mpv_reconstruct_mb_internal(s, block, 0, 0);
2261 }
2262 
2264 {
2267  s->first_field, s->low_delay);
2268 }
2269 
2270 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2271  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2272  const int uvlinesize = s->current_picture.f->linesize[1];
2273  const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
2274  const int height_of_mb = 4 - s->avctx->lowres;
2275 
2276  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2277  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2278  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2279  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2280  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2281  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;
2282  //block_index is not used by mpeg2, so it is not affected by chroma_format
2283 
2284  s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb);
2285  s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2286  s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2287 
2289  {
2290  if(s->picture_structure==PICT_FRAME){
2291  s->dest[0] += s->mb_y * linesize << height_of_mb;
2292  s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2293  s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2294  }else{
2295  s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb;
2296  s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2297  s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2299  }
2300  }
2301 }
2302 
2304  int i;
2305  MpegEncContext *s = avctx->priv_data;
2306 
2307  if (!s || !s->picture)
2308  return;
2309 
2310  for (i = 0; i < MAX_PICTURE_COUNT; i++)
2311  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2313 
2317 
2318  s->mb_x= s->mb_y= 0;
2319  s->closed_gop= 0;
2320 
2321  s->parse_context.state= -1;
2323  s->parse_context.overread= 0;
2325  s->parse_context.index= 0;
2326  s->parse_context.last_index= 0;
2327  s->bitstream_buffer_size=0;
2328  s->pp_time=0;
2329 }
2330 
2331 /**
2332  * set qscale and update qscale dependent variables.
2333  */
2334 void ff_set_qscale(MpegEncContext * s, int qscale)
2335 {
2336  if (qscale < 1)
2337  qscale = 1;
2338  else if (qscale > 31)
2339  qscale = 31;
2340 
2341  s->qscale = qscale;
2342  s->chroma_qscale= s->chroma_qscale_table[qscale];
2343 
2344  s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2346 }
2347 
2349 {
2352 }
int last_time_base
Definition: mpegvideo.h:388
int bitstream_buffer_size
Definition: mpegvideo.h:416
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free.
Definition: motion_est.h:52
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:935
int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)
Definition: frame.c:55
IDCTDSPContext idsp
Definition: mpegvideo.h:230
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
#define NULL
Definition: coverity.c:32
static int init_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:357
int ff_thread_can_start_frame(AVCodecContext *avctx)
const struct AVCodec * codec
Definition: avcodec.h:1630
int16_t(* b_bidir_back_mv_table_base)[2]
Definition: mpegvideo.h:244
av_cold void ff_mpv_common_init_arm(MpegEncContext *s)
Definition: mpegvideo_arm.c:43
discard all frames except keyframes
Definition: avcodec.h:828
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2270
int picture_number
Definition: mpegvideo.h:127
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
Definition: wmv2.c:83
av_cold void ff_mpv_common_init_neon(MpegEncContext *s)
Definition: mpegvideo.c:126
ScanTable intra_v_scantable
Definition: mpegvideo.h:93
av_cold void ff_mpegvideodsp_init(MpegVideoDSPContext *c)
Definition: mpegvideodsp.c:110
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int16_t(* p_mv_table)[2]
MV table (1MV per MB) P-frame encoding.
Definition: mpegvideo.h:248
int dpcm_direction
Definition: mpegvideo.h:513
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:153
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:188
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:1809
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:68
void(* dct_unquantize_h263_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:531
static av_always_inline void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
Definition: mpegvideo.c:1948
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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:1640
uint8_t * coded_block_base
Definition: mpegvideo.h:191
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:486
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:154
int16_t(*[3] ac_val)[16]
used for MPEG-4 AC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:194
MJPEG encoder.
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:132
h264_chroma_mc_func put_h264_chroma_pixels_tab[4]
Definition: h264chroma.h:28
#define me
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:275
static void gray_frame(AVFrame *frame)
Definition: mpegvideo.c:1183
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:438
int needs_realloc
Picture needs to be reallocated (eg due to a frame size change)
Definition: mpegpicture.h:85
uint8_t * bitstream_buffer
Definition: mpegvideo.h:415
enum AVCodecID codec_id
Definition: mpegvideo.h:112
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:79
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1831
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced P-frame encoding.
Definition: mpegvideo.h:254
int16_t(* p_mv_table_base)[2]
Definition: mpegvideo.h:240
int studio_profile
Definition: mpegvideo.h:384
uint8_t raster_end[64]
Definition: idctdsp.h:34
static int lowest_referenced_row(MpegEncContext *s, int dir)
find the lowest MB row referenced in the MVs
Definition: mpegvideo.c:1842
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
uint32_t * score_map
map to store the scores
Definition: motion_est.h:59
mpegvideo header.
discard all
Definition: avcodec.h:829
uint8_t permutated[64]
Definition: idctdsp.h:33
static void free_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:414
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2852
int padding_bug_score
used to detect the VERY common padding bug in MPEG-4
Definition: mpegvideo.h:411
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:366
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:133
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2785
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them.reget_buffer() and buffer age optimizations no longer work.*The contents of buffers must not be written to after ff_thread_report_progress() has been called on them.This includes draw_edges().Porting codecs to frame threading
#define src
Definition: vp8dsp.c:254
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:51
int frame_start_found
Definition: parser.h:34
int qscale
QP.
Definition: mpegvideo.h:204
int h263_aic
Advanced INTRA Coding (AIC)
Definition: mpegvideo.h:87
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode B-frame encoding.
Definition: mpegvideo.h:250
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, &#39;draw_horiz_band&#39; is called by the libavcodec decoder to draw a horizontal band...
Definition: avcodec.h:1856
enum AVPictureType last_picture
Definition: movenc.c:68
int chroma_x_shift
Definition: mpegvideo.h:486
int encoding
true if we are encoding (vs decoding)
Definition: mpegvideo.h:114
int field_select[2][2]
Definition: mpegvideo.h:277
int block_wrap[6]
Definition: mpegvideo.h:294
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:81
Macro definitions for various function/variable attributes.
int16_t(* b_back_mv_table_base)[2]
Definition: mpegvideo.h:242
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
Definition: mpegvideo.c:436
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:1907
const uint8_t ff_mpeg2_non_linear_qscale[32]
Definition: mpegvideodata.c:26
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
#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:2263
int context_reinit
Definition: mpegvideo.h:564
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
int16_t * dc_val_base
Definition: mpegvideo.h:186
ScratchpadContext sc
Definition: mpegvideo.h:202
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define ME_MAP_SIZE
Definition: motion_est.h:38
#define av_cold
Definition: attributes.h:82
av_cold void ff_mpv_common_init_axp(MpegEncContext *s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
enum OutputFormat out_format
output format
Definition: mpegvideo.h:104
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define f(width, name)
Definition: cbs_vp9.c:255
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1050
int noise_reduction
Definition: mpegvideo.h:582
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:200
Multithreading support functions.
int frame_skip_threshold
Definition: mpegvideo.h:576
qpel_mc_func(* qpel_put)[16]
Definition: motion_est.h:91
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:465
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
Definition: mpegvideo.h:284
int interlaced_dct
Definition: mpegvideo.h:491
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:451
int intra_dc_precision
Definition: mpegvideo.h:464
quarterpel DSP functions
void ff_mpv_common_init_ppc(MpegEncContext *s)
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define height
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
Definition: mpegvideo.h:251
float * cplx_tab
Definition: mpegvideo.h:560
#define ff_dlog(a,...)
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:392
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:329
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2860
int mpeg4_studio_profile
Definition: idctdsp.h:99
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
Definition: mpegvideo.h:120
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:901
int16_t(*[2][2] p_field_mv_table_base)[2]
Definition: mpegvideo.h:246
#define FF_BUG_IEDGE
Definition: avcodec.h:2670
#define av_log(a,...)
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2334
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:269
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:102
ThreadFrame tf
Definition: mpegpicture.h:47
#define U(x)
Definition: vp56_arith.h:37
int16_t * dc_val[3]
used for MPEG-4 DC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:187
enum AVCodecID id
Definition: avcodec.h:3569
int h263_plus
H.263+ headers.
Definition: mpegvideo.h:109
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:156
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
unsigned int buffer_size
Definition: parser.h:32
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
static void add_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size)
Definition: mpegvideo.c:1886
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:195
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
int chroma_y_shift
Definition: mpegvideo.h:487
int partitioned_frame
is current frame partitioned
Definition: mpegvideo.h:405
uint8_t * rd_scratchpad
scratchpad for rate distortion mb decision
Definition: mpegpicture.h:37
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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:2577
ERContext er
Definition: mpegvideo.h:566
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2899
int last_lambda_for[5]
last lambda for a specific pict type
Definition: mpegvideo.h:219
int reference
Definition: mpegpicture.h:87
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
#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:140
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1701
#define wrap(func)
Definition: neontest.h:65
static void put_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1878
simple assert() macros that are a bit more flexible than ISO C assert().
int overread_index
the index into ParseContext.buffer of the overread bytes
Definition: parser.h:36
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:52
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:401
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
Definition: mpegvideo.h:291
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:406
uint8_t *[2][2] b_field_select_table
Definition: mpegvideo.h:257
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:283
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1129
#define FFMAX(a, b)
Definition: common.h:94
av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
Definition: mpegvideo.c:454
#define fail()
Definition: checkasm.h:122
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2303
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:126
int * lambda_table
Definition: mpegvideo.h:208
uint8_t * error_status_table
const uint8_t ff_alternate_horizontal_scan[64]
Definition: mpegvideodata.c:84
int ff_mpeg_er_init(MpegEncContext *s)
Definition: mpeg_er.c:100
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:500
common internal API header
#define MAX_THREADS
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:282
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1442
int progressive_frame
Definition: mpegvideo.h:489
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define UPDATE_PICTURE(pic)
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:926
int top_field_first
Definition: mpegvideo.h:466
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2891
uint8_t * er_temp_buffer
int overread
the number of bytes which where irreversibly read from the next frame
Definition: parser.h:35
#define FFMIN(a, b)
Definition: common.h:96
int last_index
Definition: parser.h:31
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed B-frames
Definition: mpegvideo.h:360
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:174
Picture new_picture
copy of the source picture structure for encoding.
Definition: mpegvideo.h:174
#define width
void(* dct_unquantize_mpeg1_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:521
int width
picture width / height.
Definition: avcodec.h:1794
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:196
uint8_t w
Definition: llviddspenc.c:38
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
Picture.
Definition: mpegpicture.h:45
int alternate_scan
Definition: mpegvideo.h:471
unsigned int allocated_bitstream_buffer_size
Definition: mpegvideo.h:417
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:193
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:905
void(* idct_add)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:79
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2892
int16_t(*[2][2][2] b_field_mv_table_base)[2]
Definition: mpegvideo.h:247
int16_t(* b_forw_mv_table_base)[2]
Definition: mpegvideo.h:241
static int alloc_picture(MpegEncContext *s, Picture *pic)
Definition: mpegvideo.c:349
int16_t(*[12] pblocks)[64]
Definition: mpegvideo.h:506
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
MotionEstContext me
Definition: mpegvideo.h:282
int frame_skip_factor
Definition: mpegvideo.h:577
int n
Definition: avisynth_c.h:760
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
av_cold void ff_mpv_common_init_mips(MpegEncContext *s)
int mb_decision
macroblock decision mode
Definition: avcodec.h:2109
uint8_t * mbintra_table
used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
Definition: mpegvideo.h:198
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:72
void(* dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:527
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: mpegutils.c:103
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:491
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:222
void ff_mpv_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:667
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2880
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:293
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
Definition: mpegvideo.h:297
int first_field
is 1 for the first field of a field picture 0 otherwise
Definition: mpegvideo.h:492
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
static void clear_context(MpegEncContext *s)
Definition: mpegvideo.c:808
AVBufferRef * qscale_table_buf
Definition: mpegpicture.h:49
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:263
int16_t(* b_bidir_forw_mv_table_base)[2]
Definition: mpegvideo.h:243
int coded_picture_number
picture number in bitstream order
Definition: frame.h:409
uint16_t inter_matrix[64]
Definition: mpegvideo.h:302
uint8_t * buffer
Definition: parser.h:29
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:155
Libavcodec external API header.
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
BlockDSPContext bdsp
Definition: mpegvideo.h:226
enum AVDiscard skip_idct
Skip IDCT/dequantization for selected frames.
Definition: avcodec.h:3089
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
int debug
debug
Definition: avcodec.h:2706
main external API structure.
Definition: avcodec.h:1621
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:236
ScanTable intra_scantable
Definition: mpegvideo.h:91
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:192
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1646
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:110
void(* dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:525
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:268
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1435
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
Picture * picture
main picture buffer
Definition: mpegvideo.h:136
int progressive_sequence
Definition: mpegvideo.h:456
int coded_height
Definition: avcodec.h:1809
ScanTable intra_h_scantable
Definition: mpegvideo.h:92
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
Definition: hpeldsp.h:82
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced B-frame encoding.
Definition: mpegvideo.h:255
uint8_t * cbp_table
used to store cbp, ac_pred for partitioned decoding
Definition: mpegvideo.h:199
int closed_gop
MPEG1/2 GOP is closed.
Definition: mpegvideo.h:211
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:58
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1819
#define FF_DEBUG_DCT_COEFF
Definition: avcodec.h:2718
struct AVFrame * f
Definition: mpegpicture.h:46
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:2112
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:529
int context_initialized
Definition: mpegvideo.h:124
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:135
#define s1
Definition: regdef.h:38
static int ff_h263_round_chroma(int x)
Definition: motion_est.h:101
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1203
int f_code
forward MV resolution
Definition: mpegvideo.h:238
#define COPY(a)
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
int max_b_frames
max number of B-frames for encoding
Definition: mpegvideo.h:115
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
int size
Size of data in bytes.
Definition: buffer.h:93
int h263_pred
use MPEG-4/H.263 ac/dc predictions
Definition: mpegvideo.h:105
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
Definition: mpegvideo.h:252
static int init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
Definition: mpegvideo.c:687
uint8_t *[2] p_field_select_table
Definition: mpegvideo.h:256
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode B-frame encoding.
Definition: mpegvideo.h:253
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:189
uint8_t level
Definition: svq3.c:209
qpel_mc_func(* qpel_avg)[16]
Definition: motion_est.h:92
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode B-frame encoding.
Definition: mpegvideo.h:249
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:131
static void dct_unquantize_h263_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:208
MpegEncContext.
Definition: mpegvideo.h:81
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:183
int8_t * qscale_table
Definition: mpegpicture.h:50
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:299
A reference to a data buffer.
Definition: buffer.h:81
discard all non reference
Definition: avcodec.h:825
void(* dct_unquantize_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:535
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
int
MpegVideoDSPContext mdsp
Definition: mpegvideo.h:232
int(* dct_error_sum)[64]
Definition: mpegvideo.h:332
common internal api header.
int32_t(* block32)[12][64]
Definition: mpegvideo.h:512
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:130
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Definition: mpegvideo.c:672
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
const uint8_t ff_default_chroma_qscale_table[32]
Definition: mpegvideodata.c:21
uint8_t * dest[3]
Definition: mpegvideo.h:295
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
Definition: internal.h:140
static av_cold int dct_init(MpegEncContext *s)
Definition: mpegvideo.c:282
int last_pict_type
Definition: mpegvideo.h:214
static void dct_unquantize_h263_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:242
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:162
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:94
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:182
Bi-dir predicted.
Definition: avutil.h:276
int index
Definition: parser.h:30
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:2655
uint8_t * b_scratchpad
scratchpad used for writing into write only buffers
Definition: mpegpicture.h:39
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (H.263)
Definition: mpegvideo.h:190
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:95
uint32_t * map
map to avoid duplicate evaluations
Definition: motion_est.h:58
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:466
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:808
static int lowres
Definition: ffplay.c:335
H264ChromaContext h264chroma
Definition: mpegvideo.h:228
int16_t(* blocks)[12][64]
Definition: mpegvideo.h:509
h264_chroma_mc_func avg_h264_chroma_pixels_tab[4]
Definition: h264chroma.h:29
int slices
Number of slices.
Definition: avcodec.h:2272
void * priv_data
Definition: avcodec.h:1648
#define PICT_FRAME
Definition: mpegutils.h:39
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:890
int picture_structure
Definition: mpegvideo.h:461
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:236
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1427
void(* dct_unquantize_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:533
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:270
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2251
uint8_t * obmc_scratchpad
Definition: mpegpicture.h:38
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:508
ParseContext parse_context
Definition: mpegvideo.h:362
static void add_dequant_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1894
Picture next_picture
copy of the next picture structure.
Definition: mpegvideo.h:168
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
#define FF_DEBUG_NOMC
Definition: avcodec.h:2731
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:1501
int chroma_qscale
chroma QP
Definition: mpegvideo.h:205
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a it should return
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding). ...
Definition: mpegvideo.c:644
static void free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution.
Definition: mpegvideo.c:1001
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:1454
int height
Definition: frame.h:353
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:300
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
#define av_freep(p)
int16_t(* dpcm_macroblock)[3][256]
Definition: mpegvideo.h:514
void(* decode_mb)(struct MpegEncContext *s)
Called for every Macroblock in a slice.
Definition: avcodec.h:3849
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
Definition: mpegvideo.h:119
ScanTable inter_scantable
if inter == intra then intra should be used to reduce the cache usage
Definition: mpegvideo.h:90
#define av_always_inline
Definition: attributes.h:39
uint8_t * temp
Definition: motion_est.h:56
#define FFSWAP(type, a, b)
Definition: common.h:99
#define stride
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:267
int16_t(* b_direct_mv_table_base)[2]
Definition: mpegvideo.h:245
int b_code
backward MV resolution for B-frames (MPEG-4)
Definition: mpegvideo.h:239
float * bits_tab
Definition: mpegvideo.h:560
void(* dct_unquantize_mpeg1_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:523
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2348
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:75
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:1708
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:149
Predicted.
Definition: avutil.h:275
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
HpelDSPContext hdsp
Definition: mpegvideo.h:229