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