FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
mpegvideo_dec.c
Go to the documentation of this file.
1 /*
2  * Common mpeg video decoding code
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <limits.h>
24 
25 #include "config_components.h"
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/emms.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/internal.h"
32 
33 #include "avcodec.h"
34 #include "decode.h"
35 #include "h263.h"
36 #include "h264chroma.h"
37 #include "internal.h"
38 #include "mpegutils.h"
39 #include "mpegvideo.h"
40 #include "mpegvideodec.h"
41 #include "mpeg4videodec.h"
42 #include "libavutil/refstruct.h"
43 #include "thread.h"
44 #include "threadprogress.h"
45 #include "wmv2dec.h"
46 
48 {
49  enum ThreadingStatus thread_status;
50 
52 
53  s->avctx = avctx;
54  s->width = avctx->coded_width;
55  s->height = avctx->coded_height;
56  s->codec_id = avctx->codec->id;
57  s->workaround_bugs = avctx->workaround_bugs;
58 
59  /* convert fourcc to upper case */
60  s->codec_tag = ff_toupper4(avctx->codec_tag);
61 
63 
64  ff_h264chroma_init(&s->h264chroma, 8); //for lowres
65 
66  if (s->picture_pool) // VC-1 can call this multiple times
67  return 0;
68 
69  thread_status = ff_thread_sync_ref(avctx, offsetof(MpegEncContext, picture_pool));
70  if (thread_status != FF_THREAD_IS_COPY) {
71  s->picture_pool = ff_mpv_alloc_pic_pool(thread_status != FF_THREAD_NO_FRAME_THREADING);
72  if (!s->picture_pool)
73  return AVERROR(ENOMEM);
74  }
75  return 0;
76 }
77 
79  const AVCodecContext *src)
80 {
81  MpegEncContext *const s1 = src->priv_data;
82  MpegEncContext *const s = dst->priv_data;
83  int ret = 0;
84 
85  if (dst == src)
86  return 0;
87 
88  av_assert0(s != s1);
89 
90  if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
91  s->height = s1->height;
92  s->width = s1->width;
94  return ret;
95  ret = 1;
96  }
97 
98  s->quarter_sample = s1->quarter_sample;
99 
100  ff_mpv_replace_picture(&s->cur_pic, &s1->cur_pic);
101  ff_mpv_replace_picture(&s->last_pic, &s1->last_pic);
102  ff_mpv_replace_picture(&s->next_pic, &s1->next_pic);
103 
104  s->linesize = s1->linesize;
105  s->uvlinesize = s1->uvlinesize;
106 
107  // Error/bug resilience
108  s->workaround_bugs = s1->workaround_bugs;
109 
110  // MPEG-4 timing info
111  memcpy(&s->last_time_base, &s1->last_time_base,
112  (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
113  (char *) &s1->last_time_base);
114 
115  // B-frame info
116  s->low_delay = s1->low_delay;
117 
118  // MPEG-2/interlacing info
119  memcpy(&s->progressive_sequence, &s1->progressive_sequence,
120  (char *) &s1->first_field + sizeof(s1->first_field) - (char *) &s1->progressive_sequence);
121 
122  return ret;
123 }
124 
126 {
128 
129  av_refstruct_pool_uninit(&s->picture_pool);
131  return 0;
132 }
133 
135 {
136  int err = 0;
137 
138  if (!s->context_initialized)
139  return AVERROR(EINVAL);
140 
142 
143  ff_mpv_unref_picture(&s->last_pic);
144  ff_mpv_unref_picture(&s->next_pic);
145  ff_mpv_unref_picture(&s->cur_pic);
146 
147  if ((s->width || s->height) &&
148  (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
149  goto fail;
150 
151  /* set chroma shifts */
152  err = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
153  &s->chroma_x_shift,
154  &s->chroma_y_shift);
155  if (err < 0)
156  goto fail;
157 
158  if ((err = ff_mpv_init_context_frame(s)))
159  goto fail;
160 
161  memset(s->thread_context, 0, sizeof(s->thread_context));
162  s->thread_context[0] = s;
163 
164  if (s->width && s->height) {
166  if (err < 0)
167  goto fail;
168  }
169  s->context_reinit = 0;
170 
171  return 0;
172  fail:
174  s->context_reinit = 1;
175  return err;
176 }
177 
178 static int alloc_picture(MpegEncContext *s, MPVWorkPicture *dst, int reference)
179 {
180  AVCodecContext *avctx = s->avctx;
181  MPVPicture *pic = av_refstruct_pool_get(s->picture_pool);
182  int ret;
183 
184  if (!pic)
185  return AVERROR(ENOMEM);
186 
187  dst->ptr = pic;
188 
189  pic->reference = reference;
190 
191  /* WM Image / Screen codecs allocate internal buffers with different
192  * dimensions / colorspaces; ignore user-defined callbacks for these. */
197  reference ? AV_GET_BUFFER_FLAG_REF : 0);
198  } else {
199  pic->f->width = avctx->width;
200  pic->f->height = avctx->height;
201  pic->f->format = avctx->pix_fmt;
203  }
204  if (ret < 0)
205  goto fail;
206 
207  ret = ff_mpv_pic_check_linesize(avctx, pic->f, &s->linesize, &s->uvlinesize);
208  if (ret < 0)
209  goto fail;
210 
212  if (ret < 0)
213  goto fail;
214 
215  av_assert1(s->mb_width == s->buffer_pools.alloc_mb_width);
216  av_assert1(s->mb_height == s->buffer_pools.alloc_mb_height ||
217  FFALIGN(s->mb_height, 2) == s->buffer_pools.alloc_mb_height);
218  av_assert1(s->mb_stride == s->buffer_pools.alloc_mb_stride);
219  ret = ff_mpv_alloc_pic_accessories(s->avctx, dst, &s->sc,
220  &s->buffer_pools, s->mb_height);
221  if (ret < 0)
222  goto fail;
223 
224  return 0;
225 fail:
227  return ret;
228 }
229 
231 {
232  MPVPicture *pic;
233  int ret = alloc_picture(s, dst, 1);
234  if (ret < 0)
235  return ret;
236 
237  pic = dst->ptr;
238  pic->dummy = 1;
239 
240  ff_thread_progress_report(&pic->progress, INT_MAX);
241 
242  return 0;
243 }
244 
245 static void color_frame(AVFrame *frame, int luma)
246 {
247  int h_chroma_shift, v_chroma_shift;
248 
249  for (int i = 0; i < frame->height; i++)
250  memset(frame->data[0] + frame->linesize[0] * i, luma, frame->width);
251 
252  if (!frame->data[1])
253  return;
254  av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
255  for (int i = 0; i < AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
256  memset(frame->data[1] + frame->linesize[1] * i,
257  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
258  memset(frame->data[2] + frame->linesize[2] * i,
259  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
260  }
261 }
262 
264 {
265  AVCodecContext *avctx = s->avctx;
266  int ret;
267 
268  av_assert1(!s->last_pic.ptr || s->last_pic.ptr->f->buf[0]);
269  av_assert1(!s->next_pic.ptr || s->next_pic.ptr->f->buf[0]);
270  if (!s->last_pic.ptr && s->pict_type != AV_PICTURE_TYPE_I) {
271  if (s->pict_type == AV_PICTURE_TYPE_B && s->next_pic.ptr)
273  "allocating dummy last picture for B frame\n");
274  else if (s->codec_id != AV_CODEC_ID_H261 /* H.261 has no keyframes */ &&
275  (s->picture_structure == PICT_FRAME || s->first_field))
277  "warning: first frame is no keyframe\n");
278 
279  /* Allocate a dummy frame */
280  ret = alloc_dummy_frame(s, &s->last_pic);
281  if (ret < 0)
282  return ret;
283 
284  if (!avctx->hwaccel) {
285  int luma_val = s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263 ? 16 : 0x80;
286  color_frame(s->last_pic.ptr->f, luma_val);
287  }
288  }
289  if (!s->next_pic.ptr && s->pict_type == AV_PICTURE_TYPE_B) {
290  /* Allocate a dummy frame */
291  ret = alloc_dummy_frame(s, &s->next_pic);
292  if (ret < 0)
293  return ret;
294  }
295 
296  av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_pic.ptr &&
297  s->last_pic.ptr->f->buf[0]));
298 
299  return 0;
300 }
301 
302 /**
303  * generic function called after decoding
304  * the header and before a frame is decoded.
305  */
307 {
308  int ret;
309 
310  s->mb_skipped = 0;
311 
313  av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
314  return AVERROR_BUG;
315  }
316 
317  ff_mpv_unref_picture(&s->cur_pic);
318  ret = alloc_picture(s, &s->cur_pic,
319  s->pict_type != AV_PICTURE_TYPE_B && !s->droppable);
320  if (ret < 0)
321  return ret;
322 
323  s->cur_pic.ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!s->top_field_first;
324  s->cur_pic.ptr->f->flags |= AV_FRAME_FLAG_INTERLACED *
325  (!s->progressive_frame && !s->progressive_sequence);
326  s->cur_pic.ptr->field_picture = s->picture_structure != PICT_FRAME;
327 
328  s->cur_pic.ptr->f->pict_type = s->pict_type;
329  if (s->pict_type == AV_PICTURE_TYPE_I)
330  s->cur_pic.ptr->f->flags |= AV_FRAME_FLAG_KEY;
331  else
332  s->cur_pic.ptr->f->flags &= ~AV_FRAME_FLAG_KEY;
333 
334  if (s->pict_type != AV_PICTURE_TYPE_B) {
335  ff_mpv_workpic_from_pic(&s->last_pic, s->next_pic.ptr);
336  if (!s->droppable)
337  ff_mpv_workpic_from_pic(&s->next_pic, s->cur_pic.ptr);
338  }
339  ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
340  (void*)s->last_pic.ptr, (void*)s->next_pic.ptr, (void*)s->cur_pic.ptr,
341  s->last_pic.ptr ? s->last_pic.ptr->f->data[0] : NULL,
342  s->next_pic.ptr ? s->next_pic.ptr->f->data[0] : NULL,
343  s->cur_pic.ptr ? s->cur_pic.ptr->f->data[0] : NULL,
344  s->pict_type, s->droppable);
345 
347  if (ret < 0)
348  return ret;
349 
350  if (s->avctx->debug & FF_DEBUG_NOMC)
351  color_frame(s->cur_pic.ptr->f, 0x80);
352 
353  return 0;
354 }
355 
356 /* called after a frame has been decoded. */
358 {
359  emms_c();
360 
361  if (s->cur_pic.reference)
362  ff_thread_progress_report(&s->cur_pic.ptr->progress, INT_MAX);
363 }
364 
366 {
367  ff_print_debug_info2(s->avctx, pict, p->mb_type,
368  p->qscale_table, p->motion_val,
369  p->mb_width, p->mb_height, p->mb_stride, s->quarter_sample);
370 }
371 
373  const MPVPicture *p, int qp_type)
374 {
375  AVVideoEncParams *par;
376  int mult = (qp_type == FF_MPV_QSCALE_TYPE_MPEG1) ? 2 : 1;
377  unsigned int nb_mb = p->mb_height * p->mb_width;
378 
379  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS))
380  return 0;
381 
383  if (!par)
384  return AVERROR(ENOMEM);
385 
386  for (unsigned y = 0; y < p->mb_height; y++)
387  for (unsigned x = 0; x < p->mb_width; x++) {
388  const unsigned int block_idx = y * p->mb_width + x;
389  const unsigned int mb_xy = y * p->mb_stride + x;
390  AVVideoBlockParams *const b = av_video_enc_params_block(par, block_idx);
391 
392  b->src_x = x * 16;
393  b->src_y = y * 16;
394  b->w = 16;
395  b->h = 16;
396 
397  b->delta_qp = p->qscale_table[mb_xy] * mult;
398  }
399 
400  return 0;
401 }
402 
404 {
405  ff_draw_horiz_band(s->avctx, s->cur_pic.ptr->f,
406  s->last_pic.ptr ? s->last_pic.ptr->f : NULL,
407  y, h, s->picture_structure,
408  s->first_field, s->low_delay);
409 }
410 
412 {
413  MpegEncContext *const s = avctx->priv_data;
414 
415  ff_mpv_unref_picture(&s->cur_pic);
416  ff_mpv_unref_picture(&s->last_pic);
417  ff_mpv_unref_picture(&s->next_pic);
418 
419  s->mb_x = s->mb_y = 0;
420 
421  s->pp_time = 0;
422 }
423 
425  uint8_t *dest, const uint8_t *src,
426  int field_based, int field_select,
427  int src_x, int src_y,
428  int width, int height, ptrdiff_t stride,
429  int h_edge_pos, int v_edge_pos,
430  int w, int h, const h264_chroma_mc_func *pix_op,
431  int motion_x, int motion_y)
432 {
433  const int lowres = s->avctx->lowres;
434  const int op_index = lowres;
435  const int s_mask = (2 << lowres) - 1;
436  int emu = 0;
437  int sx, sy;
438 
439  av_assert2(op_index <= 3);
440 
441  if (s->quarter_sample) {
442  motion_x /= 2;
443  motion_y /= 2;
444  }
445 
446  sx = motion_x & s_mask;
447  sy = motion_y & s_mask;
448  src_x += motion_x >> lowres + 1;
449  src_y += motion_y >> lowres + 1;
450 
451  src += src_y * stride + src_x;
452 
453  if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
454  (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
455  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src,
456  s->linesize, s->linesize,
457  w + 1, (h + 1) << field_based,
458  src_x, src_y * (1 << field_based),
460  src = s->sc.edge_emu_buffer;
461  emu = 1;
462  }
463 
464  sx = (sx << 2) >> lowres;
465  sy = (sy << 2) >> lowres;
466  if (field_select)
467  src += s->linesize;
468  pix_op[op_index](dest, src, stride, h, sx, sy);
469  return emu;
470 }
471 
472 /* apply one mpeg motion vector to the three components */
474  uint8_t *dest_y,
475  uint8_t *dest_cb,
476  uint8_t *dest_cr,
477  int field_based,
478  int bottom_field,
479  int field_select,
480  uint8_t *const *ref_picture,
481  const h264_chroma_mc_func *pix_op,
482  int motion_x, int motion_y,
483  int h, int mb_y)
484 {
485  const uint8_t *ptr_y, *ptr_cb, *ptr_cr;
486  int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
487  ptrdiff_t uvlinesize, linesize;
488  const int lowres = s->avctx->lowres;
489  const int op_index = lowres - 1 + s->chroma_x_shift;
490  const int block_s = 8 >> lowres;
491  const int s_mask = (2 << lowres) - 1;
492  const int h_edge_pos = s->h_edge_pos >> lowres;
493  const int v_edge_pos = s->v_edge_pos >> lowres;
494  int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
495 
496  av_assert2(op_index <= 3);
497 
498  linesize = s->cur_pic.linesize[0] << field_based;
499  uvlinesize = s->cur_pic.linesize[1] << field_based;
500 
501  // FIXME obviously not perfect but qpel will not work in lowres anyway
502  if (s->quarter_sample) {
503  motion_x /= 2;
504  motion_y /= 2;
505  }
506 
507  if (field_based) {
508  motion_y += (bottom_field - field_select)*((1 << lowres)-1);
509  }
510 
511  sx = motion_x & s_mask;
512  sy = motion_y & s_mask;
513  src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
514  src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
515 
516  if (s->out_format == FMT_H263) {
517  uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
518  uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
519  uvsrc_x = src_x >> 1;
520  uvsrc_y = src_y >> 1;
521  } else if (s->out_format == FMT_H261) {
522  // even chroma mv's are full pel in H261
523  mx = motion_x / 4;
524  my = motion_y / 4;
525  uvsx = (2 * mx) & s_mask;
526  uvsy = (2 * my) & s_mask;
527  uvsrc_x = s->mb_x * block_s + (mx >> lowres);
528  uvsrc_y = mb_y * block_s + (my >> lowres);
529  } else {
530  if (s->chroma_y_shift) {
531  mx = motion_x / 2;
532  my = motion_y / 2;
533  uvsx = mx & s_mask;
534  uvsy = my & s_mask;
535  uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
536  uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
537  } else {
538  if (s->chroma_x_shift) {
539  //Chroma422
540  mx = motion_x / 2;
541  uvsx = mx & s_mask;
542  uvsy = motion_y & s_mask;
543  uvsrc_y = src_y;
544  uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
545  } else {
546  //Chroma444
547  uvsx = motion_x & s_mask;
548  uvsy = motion_y & s_mask;
549  uvsrc_x = src_x;
550  uvsrc_y = src_y;
551  }
552  }
553  }
554 
555  ptr_y = ref_picture[0] + src_y * linesize + src_x;
556  ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
557  ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
558 
559  if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
560  (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - FFMAX(h, hc<<s->chroma_y_shift), 0)) {
561  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
562  linesize >> field_based, linesize >> field_based,
563  17, 17 + field_based,
564  src_x, src_y * (1 << field_based), h_edge_pos,
565  v_edge_pos);
566  ptr_y = s->sc.edge_emu_buffer;
567  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
568  uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
569  uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
570  if (s->workaround_bugs & FF_BUG_IEDGE)
571  vbuf -= s->uvlinesize;
572  s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
573  uvlinesize >> field_based, uvlinesize >> field_based,
574  9, 9 + field_based,
575  uvsrc_x, uvsrc_y * (1 << field_based),
576  h_edge_pos >> 1, v_edge_pos >> 1);
577  s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
578  uvlinesize >> field_based,uvlinesize >> field_based,
579  9, 9 + field_based,
580  uvsrc_x, uvsrc_y * (1 << field_based),
581  h_edge_pos >> 1, v_edge_pos >> 1);
582  ptr_cb = ubuf;
583  ptr_cr = vbuf;
584  }
585  }
586 
587  // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
588  if (bottom_field) {
589  dest_y += s->linesize;
590  dest_cb += s->uvlinesize;
591  dest_cr += s->uvlinesize;
592  }
593 
594  if (field_select) {
595  ptr_y += s->linesize;
596  ptr_cb += s->uvlinesize;
597  ptr_cr += s->uvlinesize;
598  }
599 
600  sx = (sx << 2) >> lowres;
601  sy = (sy << 2) >> lowres;
602  pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
603 
604  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
605  uvsx = (uvsx << 2) >> lowres;
606  uvsy = (uvsy << 2) >> lowres;
607  if (hc) {
608  pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
609  pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
610  }
611  }
612  // FIXME h261 lowres loop filter
613 }
614 
616  uint8_t *dest_cb, uint8_t *dest_cr,
617  uint8_t *const *ref_picture,
618  const h264_chroma_mc_func * pix_op,
619  int mx, int my)
620 {
621  const int lowres = s->avctx->lowres;
622  const int op_index = lowres;
623  const int block_s = 8 >> lowres;
624  const int s_mask = (2 << lowres) - 1;
625  const int h_edge_pos = s->h_edge_pos >> lowres + 1;
626  const int v_edge_pos = s->v_edge_pos >> lowres + 1;
627  int emu = 0, src_x, src_y, sx, sy;
628  ptrdiff_t offset;
629  const uint8_t *ptr;
630 
631  av_assert2(op_index <= 3);
632 
633  if (s->quarter_sample) {
634  mx /= 2;
635  my /= 2;
636  }
637 
638  /* In case of 8X8, we construct a single chroma motion vector
639  with a special rounding */
642 
643  sx = mx & s_mask;
644  sy = my & s_mask;
645  src_x = s->mb_x * block_s + (mx >> lowres + 1);
646  src_y = s->mb_y * block_s + (my >> lowres + 1);
647 
648  offset = src_y * s->uvlinesize + src_x;
649  ptr = ref_picture[1] + offset;
650  if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
651  (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
652  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
653  s->uvlinesize, s->uvlinesize,
654  9, 9,
655  src_x, src_y, h_edge_pos, v_edge_pos);
656  ptr = s->sc.edge_emu_buffer;
657  emu = 1;
658  }
659  sx = (sx << 2) >> lowres;
660  sy = (sy << 2) >> lowres;
661  pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
662 
663  ptr = ref_picture[2] + offset;
664  if (emu) {
665  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
666  s->uvlinesize, s->uvlinesize,
667  9, 9,
668  src_x, src_y, h_edge_pos, v_edge_pos);
669  ptr = s->sc.edge_emu_buffer;
670  }
671  pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
672 }
673 
674 /**
675  * motion compensation of a single macroblock
676  * @param s context
677  * @param dest_y luma destination pointer
678  * @param dest_cb chroma cb/u destination pointer
679  * @param dest_cr chroma cr/v destination pointer
680  * @param dir direction (0->forward, 1->backward)
681  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
682  * @param pix_op halfpel motion compensation function (average or put normally)
683  * the motion vectors are taken from s->mv and the MV type from s->mv_type
684  */
685 static inline void MPV_motion_lowres(MpegEncContext *s,
686  uint8_t *dest_y, uint8_t *dest_cb,
687  uint8_t *dest_cr,
688  int dir, uint8_t *const *ref_picture,
689  const h264_chroma_mc_func *pix_op)
690 {
691  int mx, my;
692  int mb_x, mb_y;
693  const int lowres = s->avctx->lowres;
694  const int block_s = 8 >>lowres;
695 
696  mb_x = s->mb_x;
697  mb_y = s->mb_y;
698 
699  switch (s->mv_type) {
700  case MV_TYPE_16X16:
701  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
702  0, 0, 0,
703  ref_picture, pix_op,
704  s->mv[dir][0][0], s->mv[dir][0][1],
705  2 * block_s, mb_y);
706  break;
707  case MV_TYPE_8X8:
708  mx = 0;
709  my = 0;
710  for (int i = 0; i < 4; i++) {
711  hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
712  s->linesize) * block_s,
713  ref_picture[0], 0, 0,
714  (2 * mb_x + (i & 1)) * block_s,
715  (2 * mb_y + (i >> 1)) * block_s,
716  s->width, s->height, s->linesize,
717  s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
718  block_s, block_s, pix_op,
719  s->mv[dir][i][0], s->mv[dir][i][1]);
720 
721  mx += s->mv[dir][i][0];
722  my += s->mv[dir][i][1];
723  }
724 
725  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
726  chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
727  pix_op, mx, my);
728  break;
729  case MV_TYPE_FIELD:
730  if (s->picture_structure == PICT_FRAME) {
731  /* top field */
732  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
733  1, 0, s->field_select[dir][0],
734  ref_picture, pix_op,
735  s->mv[dir][0][0], s->mv[dir][0][1],
736  block_s, mb_y);
737  /* bottom field */
738  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
739  1, 1, s->field_select[dir][1],
740  ref_picture, pix_op,
741  s->mv[dir][1][0], s->mv[dir][1][1],
742  block_s, mb_y);
743  } else {
744  if (s->picture_structure != s->field_select[dir][0] + 1 &&
745  s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
746  ref_picture = s->cur_pic.ptr->f->data;
747  }
748  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
749  0, 0, s->field_select[dir][0],
750  ref_picture, pix_op,
751  s->mv[dir][0][0],
752  s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
753  }
754  break;
755  case MV_TYPE_16X8:
756  for (int i = 0; i < 2; i++) {
757  uint8_t *const *ref2picture;
758 
759  if (s->picture_structure == s->field_select[dir][i] + 1 ||
760  s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
761  ref2picture = ref_picture;
762  } else {
763  ref2picture = s->cur_pic.ptr->f->data;
764  }
765 
766  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
767  0, 0, s->field_select[dir][i],
768  ref2picture, pix_op,
769  s->mv[dir][i][0], s->mv[dir][i][1] +
770  2 * block_s * i, block_s, mb_y >> 1);
771 
772  dest_y += 2 * block_s * s->linesize;
773  dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
774  dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
775  }
776  break;
777  case MV_TYPE_DMV:
778  if (s->picture_structure == PICT_FRAME) {
779  for (int i = 0; i < 2; i++) {
780  for (int j = 0; j < 2; j++) {
781  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
782  1, j, j ^ i,
783  ref_picture, pix_op,
784  s->mv[dir][2 * i + j][0],
785  s->mv[dir][2 * i + j][1],
786  block_s, mb_y);
787  }
788  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
789  }
790  } else {
791  for (int i = 0; i < 2; i++) {
792  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
793  0, 0, s->picture_structure != i + 1,
794  ref_picture, pix_op,
795  s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
796  2 * block_s, mb_y >> 1);
797 
798  // after put we make avg of the same block
799  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
800 
801  // opposite parity is always in the same
802  // frame if this is second field
803  if (!s->first_field) {
804  ref_picture = s->cur_pic.ptr->f->data;
805  }
806  }
807  }
808  break;
809  default:
810  av_unreachable("No other mpegvideo MV types exist");
811  }
812 }
813 
814 /**
815  * find the lowest MB row referenced in the MVs
816  */
818 {
819  int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
820  int off, mvs;
821 
822  if (s->picture_structure != PICT_FRAME || s->mcsel)
823  goto unhandled;
824 
825  switch (s->mv_type) {
826  case MV_TYPE_16X16:
827  mvs = 1;
828  break;
829  case MV_TYPE_16X8:
830  mvs = 2;
831  break;
832  case MV_TYPE_8X8:
833  mvs = 4;
834  break;
835  default:
836  goto unhandled;
837  }
838 
839  for (int i = 0; i < mvs; i++) {
840  int my = s->mv[dir][i][1];
841  my_max = FFMAX(my_max, my);
842  my_min = FFMIN(my_min, my);
843  }
844 
845  off = ((FFMAX(-my_min, my_max) << qpel_shift) + 63) >> 6;
846 
847  return av_clip(s->mb_y + off, 0, s->mb_height - 1);
848 unhandled:
849  return s->mb_height - 1;
850 }
851 
852 /* add block[] to dest[] */
853 static inline void add_dct(MpegEncContext *s,
854  int16_t block[][64], int i, uint8_t *dest, int line_size)
855 {
856  if (s->block_last_index[i] >= 0) {
857  s->idsp.idct_add(dest, line_size, block[i]);
858  }
859 }
860 
861 /* put block[] to dest[] */
862 static inline void put_dct(MpegEncContext *s,
863  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
864 {
865  s->dct_unquantize_intra(s, block, i, qscale);
866  s->idsp.idct_put(dest, line_size, block);
867 }
868 
869 static inline void add_dequant_dct(MpegEncContext *s,
870  int16_t block[][64], int i, uint8_t *dest, int line_size, int qscale)
871 {
872  if (s->block_last_index[i] >= 0) {
873  s->dct_unquantize_inter(s, block[i], i, qscale);
874 
875  s->idsp.idct_add(dest, line_size, block[i]);
876  }
877 }
878 
879 #define NOT_MPEG12_H261 0
880 #define MAY_BE_MPEG12_H261 1
881 #define DEFINITELY_MPEG12_H261 2
882 
883 /* generic function called after a macroblock has been parsed by the decoder.
884 
885  Important variables used:
886  s->mb_intra : true if intra macroblock
887  s->mv_dir : motion vector direction
888  s->mv_type : motion vector type
889  s->mv : motion vector
890  s->interlaced_dct : true if interlaced dct used (mpeg2)
891  */
892 static av_always_inline
894  int lowres_flag, int is_mpeg12)
895 {
896 #define IS_MPEG12_H261(s) (is_mpeg12 == MAY_BE_MPEG12_H261 ? ((s)->out_format <= FMT_H261) : is_mpeg12)
897  uint8_t *dest_y = s->dest[0], *dest_cb = s->dest[1], *dest_cr = s->dest[2];
898  int dct_linesize, dct_offset;
899  const int linesize = s->cur_pic.linesize[0]; //not s->linesize as this would be wrong for field pics
900  const int uvlinesize = s->cur_pic.linesize[1];
901  const int block_size = lowres_flag ? 8 >> s->avctx->lowres : 8;
902 
903  dct_linesize = linesize << s->interlaced_dct;
904  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
905 
906  if (!s->mb_intra) {
907  /* motion handling */
908  if (HAVE_THREADS && is_mpeg12 != DEFINITELY_MPEG12_H261 &&
909  s->avctx->active_thread_type & FF_THREAD_FRAME) {
910  if (s->mv_dir & MV_DIR_FORWARD) {
911  ff_thread_progress_await(&s->last_pic.ptr->progress,
913  }
914  if (s->mv_dir & MV_DIR_BACKWARD) {
915  ff_thread_progress_await(&s->next_pic.ptr->progress,
917  }
918  }
919 
920  if (lowres_flag) {
921  const h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
922 
923  if (s->mv_dir & MV_DIR_FORWARD) {
924  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_pic.data, op_pix);
925  op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
926  }
927  if (s->mv_dir & MV_DIR_BACKWARD) {
928  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_pic.data, op_pix);
929  }
930  } else {
931  const op_pixels_func (*op_pix)[4];
932  const qpel_mc_func (*op_qpix)[16];
933 
934  if ((is_mpeg12 == DEFINITELY_MPEG12_H261 || !s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
935  op_pix = s->hdsp.put_pixels_tab;
936  op_qpix = s->qdsp.put_qpel_pixels_tab;
937  } else {
938  op_pix = s->hdsp.put_no_rnd_pixels_tab;
939  op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
940  }
941  if (s->mv_dir & MV_DIR_FORWARD) {
942  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_pic.data, op_pix, op_qpix);
943  op_pix = s->hdsp.avg_pixels_tab;
944  op_qpix = s->qdsp.avg_qpel_pixels_tab;
945  }
946  if (s->mv_dir & MV_DIR_BACKWARD) {
947  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_pic.data, op_pix, op_qpix);
948  }
949  }
950 
951  /* skip dequant / idct if we are really late ;) */
952  if (s->avctx->skip_idct) {
953  if ( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
954  ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
955  || s->avctx->skip_idct >= AVDISCARD_ALL)
956  return;
957  }
958 
959  /* add dct residue */
960  if (is_mpeg12 != DEFINITELY_MPEG12_H261 && s->dct_unquantize_inter) {
961  // H.263, H.263+, H.263I, FLV, RV10, RV20 and MPEG-4 with MPEG-2 quantization
962  add_dequant_dct(s, block, 0, dest_y , dct_linesize, s->qscale);
963  add_dequant_dct(s, block, 1, dest_y + block_size, dct_linesize, s->qscale);
964  add_dequant_dct(s, block, 2, dest_y + dct_offset , dct_linesize, s->qscale);
965  add_dequant_dct(s, block, 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
966 
967  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
968  av_assert2(s->chroma_y_shift);
969  add_dequant_dct(s, block, 4, dest_cb, uvlinesize, s->chroma_qscale);
970  add_dequant_dct(s, block, 5, dest_cr, uvlinesize, s->chroma_qscale);
971  }
972  } else if (is_mpeg12 == DEFINITELY_MPEG12_H261 || lowres_flag || (s->codec_id != AV_CODEC_ID_WMV2)) {
973  // H.261, MPEG-1, MPEG-2, MPEG-4 with H.263 quantization,
974  // MSMP4V1-3 and WMV1.
975  // Also RV30, RV40 and the VC-1 family when performing error resilience,
976  // but all blocks are skipped in this case.
977  add_dct(s, block, 0, dest_y , dct_linesize);
978  add_dct(s, block, 1, dest_y + block_size, dct_linesize);
979  add_dct(s, block, 2, dest_y + dct_offset , dct_linesize);
980  add_dct(s, block, 3, dest_y + dct_offset + block_size, dct_linesize);
981 
982  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
983  if (s->chroma_y_shift) {//Chroma420
984  add_dct(s, block, 4, dest_cb, uvlinesize);
985  add_dct(s, block, 5, dest_cr, uvlinesize);
986  } else {
987  //chroma422
988  dct_linesize = uvlinesize << s->interlaced_dct;
989  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
990 
991  add_dct(s, block, 4, dest_cb, dct_linesize);
992  add_dct(s, block, 5, dest_cr, dct_linesize);
993  add_dct(s, block, 6, dest_cb + dct_offset, dct_linesize);
994  add_dct(s, block, 7, dest_cr + dct_offset, dct_linesize);
995  if (!s->chroma_x_shift) {//Chroma444
996  add_dct(s, block, 8, dest_cb + block_size, dct_linesize);
997  add_dct(s, block, 9, dest_cr + block_size, dct_linesize);
998  add_dct(s, block, 10, dest_cb + block_size + dct_offset, dct_linesize);
999  add_dct(s, block, 11, dest_cr + block_size + dct_offset, dct_linesize);
1000  }
1001  }
1002  } //fi gray
1003  } else if (CONFIG_WMV2_DECODER) {
1004  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1005  }
1006  } else {
1007  /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
1008  TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
1009  if (is_mpeg12 != DEFINITELY_MPEG12_H261 && CONFIG_MPEG4_DECODER &&
1010  /* s->codec_id == AV_CODEC_ID_MPEG4 && */
1011  s->avctx->bits_per_raw_sample > 8) {
1012  ff_mpeg4_decode_studio(s, dest_y, dest_cb, dest_cr, block_size,
1013  uvlinesize, dct_linesize, dct_offset);
1014  } else if (!IS_MPEG12_H261(s)) {
1015  /* dct only in intra block */
1016  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1017  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1018  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1019  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1020 
1021  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1022  if (s->chroma_y_shift) {
1023  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1024  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1025  } else {
1026  dct_offset >>= 1;
1027  dct_linesize >>= 1;
1028  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1029  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1030  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1031  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1032  }
1033  }
1034  } else {
1035  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
1036  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1037  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
1038  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1039 
1040  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1041  if (s->chroma_y_shift) {
1042  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
1043  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
1044  } else {
1045  dct_linesize = uvlinesize << s->interlaced_dct;
1046  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
1047 
1048  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
1049  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
1050  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1051  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1052  if (!s->chroma_x_shift) { //Chroma444
1053  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
1054  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
1055  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
1056  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
1057  }
1058  }
1059  } //gray
1060  }
1061  }
1062 }
1063 
1064 static av_cold void debug_dct_coeffs(MPVContext *s, const int16_t block[][64])
1065 {
1066  if (!block) // happens when called via error resilience
1067  return;
1068 
1069  void *const logctx = s->avctx;
1070  const uint8_t *const idct_permutation = s->idsp.idct_permutation;
1071 
1072  /* print DCT coefficients */
1073  av_log(logctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1074  for (int i = 0; i < 6; i++) {
1075  for (int j = 0; j < 64; j++) {
1076  av_log(logctx, AV_LOG_DEBUG, "%5d",
1077  block[i][idct_permutation[j]]);
1078  }
1079  av_log(logctx, AV_LOG_DEBUG, "\n");
1080  }
1081 }
1082 
1084 {
1085  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1086  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1087 
1088  s->cur_pic.qscale_table[mb_xy] = s->qscale;
1089 
1090  /* avoid copy if macroblock skipped in last frame too */
1091  if (s->mb_skipped) {
1092  s->mb_skipped = 0;
1093  av_assert2(s->pict_type != AV_PICTURE_TYPE_I);
1094  *mbskip_ptr = 1;
1095  } else if (!s->cur_pic.reference) {
1096  *mbskip_ptr = 1;
1097  } else{
1098  *mbskip_ptr = 0; /* not skipped */
1099  }
1100 
1101  if (s->avctx->debug & FF_DEBUG_DCT_COEFF)
1103 
1104  av_assert2((s->out_format <= FMT_H261) == (s->out_format == FMT_H261 || s->out_format == FMT_MPEG1));
1105  if (!s->avctx->lowres) {
1106 #if !CONFIG_SMALL
1107  if (s->out_format <= FMT_H261)
1109  else
1111 #else
1113 #endif
1114  } else
1116 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
ff_draw_horiz_band
void ff_draw_horiz_band(AVCodecContext *avctx, const AVFrame *cur, const AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:54
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1405
h264_chroma_mc_func
void(* h264_chroma_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:175
MpegEncContext::progressive_sequence
int progressive_sequence
Definition: mpegvideo.h:248
av_clip
#define av_clip
Definition: common.h:100
ff_thread_progress_report
void ff_thread_progress_report(ThreadProgress *pro, int n)
This function is a no-op in no-op mode; otherwise it notifies other threads that a certain level of p...
Definition: threadprogress.c:53
AVERROR
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
AVCodecContext::workaround_bugs
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:1327
ff_mpv_decode_init
av_cold int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:47
threadprogress.h
ff_mpv_motion
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t *const *ref_picture, const op_pixels_func(*pix_op)[4], const qpel_mc_func(*qpix_op)[16])
Definition: mpegvideo_motion.c:821
ff_mpv_init_duplicate_contexts
av_cold int ff_mpv_init_duplicate_contexts(MpegEncContext *s)
Initialize an MpegEncContext's thread contexts.
Definition: mpegvideo.c:118
mpeg4videodec.h
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:177
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: pthread_frame.c:1012
put_dct
static void put_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo_dec.c:862
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
MpegEncContext::workaround_bugs
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
Definition: mpegvideo.h:92
AVFrame::width
int width
Definition: frame.h:493
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
b
#define b
Definition: input.c:42
ff_toupper4
unsigned int ff_toupper4(unsigned int x)
Definition: to_upper4.h:29
MpegEncContext::dest
uint8_t * dest[3]
Definition: mpegvideo.h:199
mpegvideo.h
ff_wmv2_add_mb
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: wmv2dec.c:86
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:81
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
MAY_BE_MPEG12_H261
#define MAY_BE_MPEG12_H261
Definition: mpegvideo_dec.c:880
FMT_H261
@ FMT_H261
Definition: mpegvideo.h:54
MpegEncContext::height
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:86
mpegutils.h
thread.h
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:172
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:179
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:55
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:649
AV_VIDEO_ENC_PARAMS_MPEG2
@ AV_VIDEO_ENC_PARAMS_MPEG2
Definition: video_enc_params.h:65
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:57
MPVPicture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:68
FMT_MPEG1
@ FMT_MPEG1
Definition: mpegvideo.h:53
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:440
fail
#define fail()
Definition: checkasm.h:198
MpegEncContext::linesize
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:103
MPVPicture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:65
av_pix_fmt_get_chroma_sub_sample
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:3469
hpel_motion_lowres
static int hpel_motion_lowres(MpegEncContext *s, uint8_t *dest, const 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, const h264_chroma_mc_func *pix_op, int motion_x, int motion_y)
Definition: mpegvideo_dec.c:424
MpegEncContext::width
int width
Definition: mpegvideo.h:86
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:607
refstruct.h
AVVideoEncParams
Video encoding parameters for a given frame.
Definition: video_enc_params.h:73
ff_mpv_init_context_frame
av_cold int ff_mpv_init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
Definition: mpegvideo.c:210
MPVPicture::dummy
int dummy
Picture is a dummy and should not be output.
Definition: mpegpicture.h:81
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:60
avassert.h
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:636
emms_c
#define emms_c()
Definition: emms.h:63
ff_mpeg_flush
av_cold void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:411
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2181
s
#define s(width, name)
Definition: cbs_vp9.c:198
MpegEncContext::last_time_base
int last_time_base
Definition: mpegvideo.h:221
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
MpegEncContext::h_edge_pos
int h_edge_pos
Definition: mpegvideo.h:101
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:411
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1048
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:70
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
decode.h
limits.h
AV_CODEC_ID_VC1IMAGE
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:204
MpegEncContext::cur_pic
MPVWorkPicture cur_pic
copy of the current picture structure.
Definition: mpegvideo.h:134
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:441
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:57
FMT_H263
@ FMT_H263
Definition: mpegvideo.h:55
ff_mpv_common_end
av_cold void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:447
ff_mpv_unref_picture
void ff_mpv_unref_picture(MPVWorkPicture *pic)
Definition: mpegpicture.c:98
MpegEncContext::low_delay
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:231
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:229
MpegEncContext::picture_pool
struct AVRefStructPool * picture_pool
Pool for MPVPictures.
Definition: mpegvideo.h:105
MpegEncContext::field_select
int field_select[2][2]
Definition: mpegvideo.h:186
ff_thread_progress_await
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
This function is a no-op in no-op mode; otherwise it waits until other threads have reached a certain...
Definition: threadprogress.c:64
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const MPVPicture *p, int qp_type)
Definition: mpegvideo_dec.c:372
NULL
#define NULL
Definition: coverity.c:32
MpegEncContext::mb_y
int mb_y
Definition: mpegvideo.h:194
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:96
MpegEncContext::next_pic
MPVWorkPicture next_pic
copy of the next picture structure.
Definition: mpegvideo.h:128
ff_mpv_common_defaults
av_cold void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
Definition: mpegvideo.c:190
ff_mpv_decode_close
av_cold int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:125
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition: avassert.h:109
DEFINITELY_MPEG12_H261
#define DEFINITELY_MPEG12_H261
Definition: mpegvideo_dec.c:881
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
FF_BUG_IEDGE
#define FF_BUG_IEDGE
Definition: avcodec.h:1342
av_refstruct_pool_get
void * av_refstruct_pool_get(AVRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
IS_MPEG12_H261
#define IS_MPEG12_H261(s)
lowres
static int lowres
Definition: ffplay.c:330
FF_THREAD_IS_COPY
@ FF_THREAD_IS_COPY
Definition: thread.h:61
alloc_dummy_frame
static int av_cold alloc_dummy_frame(MpegEncContext *s, MPVWorkPicture *dst)
Definition: mpegvideo_dec.c:230
op_pixels_func
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
FF_MPV_QSCALE_TYPE_MPEG1
#define FF_MPV_QSCALE_TYPE_MPEG1
Definition: mpegvideodec.h:40
MPVPicture::reference
int reference
Definition: mpegpicture.h:86
qpel_mc_func
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
MV_TYPE_8X8
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:176
ff_mpv_alloc_dummy_frames
int ff_mpv_alloc_dummy_frames(MpegEncContext *s)
Ensure that the dummy frames are allocated according to pict_type if necessary.
Definition: mpegvideo_dec.c:263
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
MpegEncContext::pb_field_time
uint16_t pb_field_time
like above, just for interlaced
Definition: mpegvideo.h:228
av_video_enc_params_create_side_data
AVVideoEncParams * av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type, unsigned int nb_blocks)
Allocates memory for AVEncodeInfoFrame plus an array of.
Definition: video_enc_params.c:58
FF_DEBUG_DCT_COEFF
#define FF_DEBUG_DCT_COEFF
Definition: avcodec.h:1380
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:228
f
f
Definition: af_crystalizer.c:122
MPVPicture::mb_stride
int mb_stride
mb_stride of the tables
Definition: mpegpicture.h:79
ff_print_debug_info2
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, const uint32_t *mbtype_table, const int8_t *qscale_table, int16_t(*const motion_val[2])[2], int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:155
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:302
MpegEncContext::qscale
int qscale
QP.
Definition: mpegvideo.h:155
height
#define height
Definition: dsp.h:89
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
ff_h263_round_chroma
static int ff_h263_round_chroma(int x)
Definition: h263.h:30
MpegEncContext::v_edge_pos
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:101
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:56
h264chroma.h
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo_dec.c:403
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:508
MpegEncContext::quarter_sample
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:230
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo_dec.c:306
add_dequant_dct
static void add_dequant_dct(MpegEncContext *s, int16_t block[][64], int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo_dec.c:869
offset
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
Definition: writing_filters.txt:86
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:178
FF_THREAD_NO_FRAME_THREADING
@ FF_THREAD_NO_FRAME_THREADING
Definition: thread.h:63
color_frame
static void color_frame(AVFrame *frame, int luma)
Definition: mpegvideo_dec.c:245
MPVPicture::mb_width
int mb_width
mb_width of the tables
Definition: mpegpicture.h:77
lowest_referenced_row
static int lowest_referenced_row(MpegEncContext *s, int dir)
find the lowest MB row referenced in the MVs
Definition: mpegvideo_dec.c:817
AV_CODEC_ID_MSS2
@ AV_CODEC_ID_MSS2
Definition: codec_id.h:221
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1572
AVCodec::id
enum AVCodecID id
Definition: codec.h:186
emms.h
MPVPicture::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference for hardware accelerator private data.
Definition: mpegpicture.h:75
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: get_buffer.c:253
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:365
mpv_reconstruct_mb_internal
static av_always_inline void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
Definition: mpegvideo_dec.c:893
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
MpegEncContext::uvlinesize
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:104
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
MPVPicture::qscale_table
int8_t * qscale_table
Definition: mpegpicture.h:62
internal.h
mpeg_motion_lowres
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 *const *ref_picture, const h264_chroma_mc_func *pix_op, int motion_x, int motion_y, int h, int mb_y)
Definition: mpegvideo_dec.c:473
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
MpegEncContext::mb_x
int mb_x
Definition: mpegvideo.h:194
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
add_dct
static void add_dct(MpegEncContext *s, int16_t block[][64], int i, uint8_t *dest, int line_size)
Definition: mpegvideo_dec.c:853
AVVideoBlockParams
Data structure for storing block-level encoding information.
Definition: video_enc_params.h:120
MpegEncContext::last_pic
MPVWorkPicture last_pic
copy of the previous picture structure.
Definition: mpegvideo.h:122
MPVPicture::mb_height
int mb_height
mb_height of the tables
Definition: mpegpicture.h:78
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
MPV_motion_lowres
static void MPV_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t *const *ref_picture, const h264_chroma_mc_func *pix_op)
motion compensation of a single macroblock
Definition: mpegvideo_dec.c:685
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:644
FF_DEBUG_NOMC
#define FF_DEBUG_NOMC
Definition: avcodec.h:1389
avcodec.h
ff_mpv_workpic_from_pic
void ff_mpv_workpic_from_pic(MPVWorkPicture *wpic, MPVPicture *pic)
Definition: mpegpicture.c:128
stride
#define stride
Definition: h264pred_template.c:536
chroma_4mv_motion_lowres
static void chroma_4mv_motion_lowres(MpegEncContext *s, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture, const h264_chroma_mc_func *pix_op, int mx, int my)
Definition: mpegvideo_dec.c:615
ret
ret
Definition: filter_design.txt:187
wmv2dec.h
frame
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
Definition: filter_design.txt:265
ff_thread_sync_ref
enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset)
Allows to synchronize objects whose lifetime is the whole decoding process among all frame threads.
Definition: decode.c:1839
MPVPicture::f
struct AVFrame * f
Definition: mpegpicture.h:59
AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
Definition: avcodec.h:395
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
update_thread_context for mpegvideo-based decoders.
Definition: mpegvideo_dec.c:78
ff_mpeg4_decode_studio
void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int block_size, int uvlinesize, int dct_linesize, int dct_offset)
Definition: mpeg4videodec.c:260
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AVFrame::height
int height
Definition: frame.h:493
alloc_picture
static int alloc_picture(MpegEncContext *s, MPVWorkPicture *dst, int reference)
Definition: mpegvideo_dec.c:178
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:280
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo_dec.c:357
NOT_MPEG12_H261
#define NOT_MPEG12_H261
Definition: mpegvideo_dec.c:879
ff_mpv_pic_check_linesize
int ff_mpv_pic_check_linesize(void *logctx, const AVFrame *f, ptrdiff_t *linesizep, ptrdiff_t *uvlinesizep)
Definition: mpegpicture.c:181
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
ff_mpv_replace_picture
void ff_mpv_replace_picture(MPVWorkPicture *dst, const MPVWorkPicture *src)
Definition: mpegpicture.c:121
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:607
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MPVContext *s, int16_t block[][64])
Definition: mpegvideo_dec.c:1083
MPVWorkPicture
Definition: mpegpicture.h:95
ThreadingStatus
ThreadingStatus
Definition: thread.h:60
MPVPicture::progress
ThreadProgress progress
Definition: mpegpicture.h:92
MpegEncContext::first_field
int first_field
is 1 for the first field of a field picture 0 otherwise
Definition: mpegvideo.h:273
av_refstruct_pool_uninit
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:171
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
imgutils.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_mpv_free_context_frame
av_cold void ff_mpv_free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution as well as the slice thread contex...
Definition: mpegvideo.c:421
av_video_enc_params_block
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
Get the block at the specified.
Definition: video_enc_params.h:143
h
h
Definition: vp9dsp_template.c:2070
AV_CODEC_ID_WMV3IMAGE
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:203
av_image_check_size
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:318
MPVPicture
MPVPicture.
Definition: mpegpicture.h:58
width
#define width
Definition: dsp.h:89
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:73
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:225
ff_mpv_alloc_pic_accessories
int ff_mpv_alloc_pic_accessories(AVCodecContext *avctx, MPVWorkPicture *wpic, ScratchpadContext *sc, BufferPoolContext *pools, int mb_height)
Allocate an MPVPicture's accessories (but not the AVFrame's buffer itself) and set the MPVWorkPicture...
Definition: mpegpicture.c:237
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:63
ff_mpv_alloc_pic_pool
av_cold AVRefStructPool * ff_mpv_alloc_pic_pool(int init_progress)
Allocate a pool of MPVPictures.
Definition: mpegpicture.c:90
src
#define src
Definition: vp8dsp.c:248
video_enc_params.h
debug_dct_coeffs
static av_cold void debug_dct_coeffs(MPVContext *s, const int16_t block[][64])
Definition: mpegvideo_dec.c:1064
ff_mpv_common_frame_size_change
av_cold int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo_dec.c:134
h263.h