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