MythTV  master
mythavutil.cpp
Go to the documentation of this file.
1 //
2 // mythavutil.cpp
3 // MythTV
4 //
5 // Created by Jean-Yves Avenard on 28/06/2014.
6 // Copyright (c) 2014 Bubblestuff Pty Ltd. All rights reserved.
7 //
8 
9 // Qt
10 #include <QMutexLocker>
11 #include <QFile>
12 
13 // MythTV
14 #include "mythconfig.h"
15 #include "mythlogging.h"
16 #include "mythdeinterlacer.h"
17 #include "mythavutil.h"
18 
19 // FFmpeg
20 extern "C" {
21 #include "libavcodec/avcodec.h"
22 #include "libavutil/imgutils.h"
23 #include "libavformat/avformat.h"
24 }
25 
27 {
28  switch (Type)
29  {
30  case FMT_YV12: return AV_PIX_FMT_YUV420P;
31  case FMT_YUV420P9: return AV_PIX_FMT_YUV420P9;
32  case FMT_YUV420P10: return AV_PIX_FMT_YUV420P10;
33  case FMT_YUV420P12: return AV_PIX_FMT_YUV420P12;
34  case FMT_YUV420P14: return AV_PIX_FMT_YUV420P14;
35  case FMT_YUV420P16: return AV_PIX_FMT_YUV420P16;
36  case FMT_NV12: return AV_PIX_FMT_NV12;
37  case FMT_P010: return AV_PIX_FMT_P010;
38  case FMT_P016: return AV_PIX_FMT_P016;
39  case FMT_YUV422P: return AV_PIX_FMT_YUV422P;
40  case FMT_YUV422P9: return AV_PIX_FMT_YUV422P9;
41  case FMT_YUV422P10: return AV_PIX_FMT_YUV422P10;
42  case FMT_YUV422P12: return AV_PIX_FMT_YUV422P12;
43  case FMT_YUV422P14: return AV_PIX_FMT_YUV422P14;
44  case FMT_YUV422P16: return AV_PIX_FMT_YUV422P16;
45  case FMT_YUV444P: return AV_PIX_FMT_YUV444P;
46  case FMT_YUV444P9: return AV_PIX_FMT_YUV444P9;
47  case FMT_YUV444P10: return AV_PIX_FMT_YUV444P10;
48  case FMT_YUV444P12: return AV_PIX_FMT_YUV444P12;
49  case FMT_YUV444P14: return AV_PIX_FMT_YUV444P14;
50  case FMT_YUV444P16: return AV_PIX_FMT_YUV444P16;
51  case FMT_RGB24: return AV_PIX_FMT_RGB24;
52  case FMT_BGRA: return AV_PIX_FMT_BGRA; // NOLINT(bugprone-branch-clone)
53  case FMT_RGB32: return AV_PIX_FMT_RGB32;
54  case FMT_ARGB32: return AV_PIX_FMT_ARGB;
55  case FMT_RGBA32: return AV_PIX_FMT_RGBA;
56  case FMT_YUY2: return AV_PIX_FMT_UYVY422;
57  case FMT_VDPAU: return AV_PIX_FMT_VDPAU;
58  case FMT_VTB: return AV_PIX_FMT_VIDEOTOOLBOX;
59  case FMT_VAAPI: return AV_PIX_FMT_VAAPI;
60  case FMT_MEDIACODEC: return AV_PIX_FMT_MEDIACODEC;
61  case FMT_NVDEC: return AV_PIX_FMT_CUDA;
62  case FMT_DXVA2: return AV_PIX_FMT_DXVA2_VLD;
63  case FMT_MMAL: return AV_PIX_FMT_MMAL;
64  case FMT_DRMPRIME: return AV_PIX_FMT_DRM_PRIME;
65  case FMT_NONE: break;
66  }
67  return AV_PIX_FMT_NONE;
68 }
69 
71 {
72  switch (Fmt)
73  {
74  case AV_PIX_FMT_YUVJ420P:
75  case AV_PIX_FMT_YUV420P: return FMT_YV12;
76  case AV_PIX_FMT_YUV420P9: return FMT_YUV420P9;
77  case AV_PIX_FMT_YUV420P10: return FMT_YUV420P10;
78  case AV_PIX_FMT_YUV420P12: return FMT_YUV420P12;
79  case AV_PIX_FMT_YUV420P14: return FMT_YUV420P14;
80  case AV_PIX_FMT_YUV420P16: return FMT_YUV420P16;
81  case AV_PIX_FMT_NV12: return FMT_NV12;
82  case AV_PIX_FMT_P010: return FMT_P010;
83  case AV_PIX_FMT_P016: return FMT_P016;
84  case AV_PIX_FMT_YUVJ422P:
85  case AV_PIX_FMT_YUV422P: return FMT_YUV422P;
86  case AV_PIX_FMT_YUV422P9: return FMT_YUV422P9;
87  case AV_PIX_FMT_YUV422P10: return FMT_YUV422P10;
88  case AV_PIX_FMT_YUV422P12: return FMT_YUV422P12;
89  case AV_PIX_FMT_YUV422P14: return FMT_YUV422P14;
90  case AV_PIX_FMT_YUV422P16: return FMT_YUV422P16;
91  case AV_PIX_FMT_YUVJ444P:
92  case AV_PIX_FMT_YUV444P: return FMT_YUV444P;
93  case AV_PIX_FMT_YUV444P9: return FMT_YUV444P9;
94  case AV_PIX_FMT_YUV444P10: return FMT_YUV444P10;
95  case AV_PIX_FMT_YUV444P12: return FMT_YUV444P12;
96  case AV_PIX_FMT_YUV444P14: return FMT_YUV444P14;
97  case AV_PIX_FMT_YUV444P16: return FMT_YUV444P16;
98  case AV_PIX_FMT_UYVY422: return FMT_YUY2;
99  case AV_PIX_FMT_RGB24: return FMT_RGB24;
100  case AV_PIX_FMT_ARGB: return FMT_ARGB32;
101  case AV_PIX_FMT_RGBA: return FMT_RGBA32;
102  case AV_PIX_FMT_BGRA: return FMT_BGRA;
103  case AV_PIX_FMT_CUDA: return FMT_NVDEC;
104  case AV_PIX_FMT_MMAL: return FMT_MMAL;
105  case AV_PIX_FMT_VDPAU: return FMT_VDPAU;
106  case AV_PIX_FMT_VIDEOTOOLBOX: return FMT_VTB;
107  case AV_PIX_FMT_VAAPI: return FMT_VAAPI;
108  case AV_PIX_FMT_DXVA2_VLD: return FMT_DXVA2;
109  case AV_PIX_FMT_MEDIACODEC: return FMT_MEDIACODEC;
110  case AV_PIX_FMT_DRM_PRIME: return FMT_DRMPRIME;
111  default: break;
112  }
113  return FMT_NONE;
114 }
115 
122 {
123  if (!Frame)
124  return;
125 
126  // Create a wrapper frame and set it up
127  // (yes - this will end up being a wrapper around a wrapper!)
128  if (VideoFrameType type = PixelFormatToFrameType(static_cast<AVPixelFormat>(Frame->format));
130  {
131  MythVideoFrame mythframe(type, Frame->data[0],
132  MythVideoFrame::GetBufferSize(type, Frame->width, Frame->height),
133  Frame->width, Frame->height);
134  mythframe.m_offsets[0] = 0;
135  mythframe.m_offsets[1] = static_cast<int>(Frame->data[1] - Frame->data[0]);
136  mythframe.m_offsets[2] = static_cast<int>(Frame->data[2] - Frame->data[0]);
137  mythframe.m_pitches[0] = Frame->linesize[0];
138  mythframe.m_pitches[1] = Frame->linesize[1];
139  mythframe.m_pitches[2] = Frame->linesize[2];
140 
142  mythframe.m_deinterlaceAllowed = DEINT_ALL;
143  MythDeinterlacer deinterlacer;
144  deinterlacer.Filter(&mythframe, kScan_Interlaced, nullptr, true);
145  // Must remove buffer before mythframe is deleted
146  mythframe.m_buffer = nullptr;
147  }
148 
149 
150 }
151 
153 int MythAVUtil::FillAVFrame(AVFrame *Frame, const MythVideoFrame *From, AVPixelFormat Fmt)
154 {
155  if (Fmt == AV_PIX_FMT_NONE)
156  Fmt = FrameTypeToPixelFormat(From->m_type);
157 
158  av_image_fill_arrays(Frame->data, Frame->linesize, From->m_buffer,
159  Fmt, From->m_width, From->m_height, IMAGE_ALIGN);
160  Frame->data[1] = From->m_buffer + From->m_offsets[1];
161  Frame->data[2] = From->m_buffer + From->m_offsets[2];
162  Frame->linesize[0] = From->m_pitches[0];
163  Frame->linesize[1] = From->m_pitches[1];
164  Frame->linesize[2] = From->m_pitches[2];
165  return static_cast<int>(MythVideoFrame::GetBufferSize(From->m_type, From->m_width, From->m_height));
166 }
167 
172 {
173  sws_freeContext(m_swsctx);
174 }
175 
176 int MythAVCopy::SizeData(int Width, int Height, AVPixelFormat Fmt)
177 {
178  if (Width == m_width && Height == m_height && Fmt == m_format)
179  return m_size;
180 
181  m_size = av_image_get_buffer_size(Fmt, Width, Height, IMAGE_ALIGN);
182  m_width = Width;
183  m_height = Height;
184  m_format = Fmt;
185  return m_size;
186 }
187 
188 int MythAVCopy::Copy(AVFrame* To, AVPixelFormat ToFmt, const AVFrame* From, AVPixelFormat FromFmt,
189  int Width, int Height)
190 {
191  int newwidth = Width;
192 #if ARCH_ARM
193  // The ARM build of FFMPEG has a bug that if sws_scale is
194  // called with source and dest sizes the same, and
195  // formats as shown below, it causes a bus error and the
196  // application core dumps. To avoid this I make a -1
197  // difference in the new width, causing it to bypass
198  // the code optimization which is failing.
199  if (FromFmt == AV_PIX_FMT_YUV420P && ToFmt == AV_PIX_FMT_BGRA)
200  newwidth = Width - 1;
201 #endif
202  m_swsctx = sws_getCachedContext(m_swsctx, Width, Height, FromFmt,
203  newwidth, Height, ToFmt, SWS_FAST_BILINEAR,
204  nullptr, nullptr, nullptr);
205  if (m_swsctx == nullptr)
206  return -1;
207  sws_scale(m_swsctx, From->data, From->linesize, 0, Height, To->data, To->linesize);
208  return SizeData(Width, Height, ToFmt);
209 }
210 
218  unsigned char* Buffer, AVPixelFormat Fmt)
219 {
220  if (!Buffer)
221  return 0;
222  AVFrame frame;
223  AVPixelFormat fromfmt = MythAVUtil::FrameTypeToPixelFormat(From->m_type);
224  MythAVUtil::FillAVFrame(&frame, From, fromfmt);
225  av_image_fill_arrays(To->data, To->linesize, Buffer, Fmt, From->m_width, From->m_height, IMAGE_ALIGN);
226  return Copy(To, Fmt, &frame, fromfmt, From->m_width, From->m_height);
227 }
228 
234 {
235  FreeAllContexts();
236 }
237 
238 AVCodecContext *MythCodecMap::GetCodecContext(const AVStream* Stream,
239  const AVCodec* Codec,
240  bool NullCodec)
241 {
242  QMutexLocker lock(&m_mapLock);
243  AVCodecContext* avctx = m_streamMap.value(Stream, nullptr);
244  if (!avctx)
245  {
246  if (Stream == nullptr || Stream->codecpar == nullptr)
247  return nullptr;
248 
249  if (NullCodec)
250  {
251  Codec = nullptr;
252  }
253  else
254  {
255  if (!Codec)
256  Codec = avcodec_find_decoder(Stream->codecpar->codec_id);
257 
258  if (!Codec)
259  {
260  LOG(VB_GENERAL, LOG_WARNING, QString("avcodec_find_decoder fail for %1")
261  .arg(Stream->codecpar->codec_id));
262  return nullptr;
263  }
264  }
265  avctx = avcodec_alloc_context3(Codec);
266  if (avcodec_parameters_to_context(avctx, Stream->codecpar) < 0)
267  avcodec_free_context(&avctx);
268 
269  if (avctx)
270  {
271  avctx->pkt_timebase = Stream->time_base;
272  m_streamMap.insert(Stream, avctx);
273  }
274  }
275  return avctx;
276 }
277 
278 AVCodecContext *MythCodecMap::FindCodecContext(const AVStream* Stream)
279 {
280  return m_streamMap.value(Stream, nullptr);
281 }
282 
286 void MythCodecMap::FreeCodecContext(const AVStream* Stream)
287 {
288  QMutexLocker lock(&m_mapLock);
289  AVCodecContext* avctx = m_streamMap.take(Stream);
290  if (avctx)
291  {
292  if (avctx->internal)
293  avcodec_flush_buffers(avctx);
294  avcodec_free_context(&avctx);
295  }
296 }
297 
299 {
300  QMutexLocker lock(&m_mapLock);
301  QMap<const AVStream*, AVCodecContext*>::iterator i = m_streamMap.begin();
302  while (i != m_streamMap.end())
303  {
304  const AVStream *stream = i.key();
305  ++i;
306  FreeCodecContext(stream);
307  }
308 }
309 
311 {
312  const int probeBufferSize = 8 * 1024;
313  AVInputFormat *fmt = nullptr;
314  AVProbeData probe;
315  memset(&probe, 0, sizeof(AVProbeData));
316  probe.filename = "";
317  probe.buf = new unsigned char[probeBufferSize + AVPROBE_PADDING_SIZE];
318  probe.buf_size = probeBufferSize;
319  memset(probe.buf, 0, probeBufferSize + AVPROBE_PADDING_SIZE);
320  av_log_set_level(AV_LOG_FATAL);
321  m_errorCode = 0;
322  if (filename == "")
323  m_errorCode = 97;
324  QFile infile(filename);
325  if (m_errorCode == 0 && !infile.open(QIODevice::ReadOnly))
326  m_errorCode = 99;
327  if (m_errorCode==0) {
328  int64_t leng = infile.read(reinterpret_cast<char*>(probe.buf), probeBufferSize);
329  probe.buf_size = static_cast<int>(leng);
330  infile.close();
331  fmt = av_probe_input_format(&probe, static_cast<int>(true));
332  if (fmt == nullptr)
333  m_errorCode = 98;
334  }
335  AVFormatContext *ctx = nullptr;
336  if (m_errorCode==0)
337  {
338  ctx = avformat_alloc_context();
339  m_errorCode = avformat_open_input(&ctx, filename.toUtf8(), fmt, nullptr);
340  }
341  if (m_errorCode==0)
342  m_errorCode = avformat_find_stream_info(ctx, nullptr);
343 
344  if (m_errorCode==0)
345  {
346  for (uint ix = 0; ix < ctx->nb_streams; ix++)
347  {
348  AVStream *stream = ctx->streams[ix];
349  if (stream == nullptr)
350  continue;
351  AVCodecParameters *codecpar = stream->codecpar;
352  const AVCodecDescriptor* desc = nullptr;
353  MythStreamInfo info;
354  info.m_codecType = ' ';
355  if (codecpar != nullptr)
356  {
357  desc = avcodec_descriptor_get(codecpar->codec_id);
358  switch (codecpar->codec_type)
359  {
360  case AVMEDIA_TYPE_VIDEO:
361  info.m_codecType = 'V';
362  break;
363  case AVMEDIA_TYPE_AUDIO:
364  info.m_codecType = 'A';
365  break;
366  case AVMEDIA_TYPE_SUBTITLE:
367  info.m_codecType = 'S';
368  break;
369  default:
370  continue;
371  }
372  }
373  if (desc != nullptr)
374  info.m_codecName = desc->name;
375  info.m_duration = stream->duration * stream->time_base.num / stream->time_base.den;
376  if (info.m_codecType == 'V')
377  {
378  if (codecpar != nullptr)
379  {
380  info.m_width = codecpar->width;
381  info.m_height = codecpar->height;
382  info.m_SampleAspectRatio = static_cast<float>(codecpar->sample_aspect_ratio.num)
383  / static_cast<float>(codecpar->sample_aspect_ratio.den);
384  switch (codecpar->field_order)
385  {
386  case AV_FIELD_PROGRESSIVE:
387  info.m_fieldOrder = "PR";
388  break;
389  case AV_FIELD_TT:
390  info.m_fieldOrder = "TT";
391  break;
392  case AV_FIELD_BB:
393  info.m_fieldOrder = "BB";
394  break;
395  case AV_FIELD_TB:
396  info.m_fieldOrder = "TB";
397  break;
398  case AV_FIELD_BT:
399  info.m_fieldOrder = "BT";
400  break;
401  default:
402  break;
403  }
404  }
405  info.m_frameRate = static_cast<float>(stream->r_frame_rate.num)
406  / static_cast<float>(stream->r_frame_rate.den);
407  info.m_avgFrameRate = static_cast<float>(stream->avg_frame_rate.num)
408  / static_cast<float>(stream->avg_frame_rate.den);
409  }
410  if (info.m_codecType == 'A')
411  info.m_channels = codecpar->channels;
412  m_streamInfoList.append(info);
413  }
414  }
415  if (m_errorCode != 0)
416  {
417  switch(m_errorCode) {
418  case 97:
419  m_errorMsg = "File Not Found";
420  break;
421  case 98:
422  m_errorMsg = "av_probe_input_format returned no result";
423  break;
424  case 99:
425  m_errorMsg = "File could not be opened";
426  break;
427  default:
428  std::string errbuf;
429  if (av_strerror_stdstring(m_errorCode, errbuf) == 0)
430  m_errorMsg = QString::fromStdString(errbuf);
431  else
432  m_errorMsg = "UNKNOWN";
433  }
434  LOG(VB_GENERAL, LOG_ERR,
435  QString("MythStreamInfoList failed for %1. Error code:%2 Message:%3")
437 
438  }
439 
440  if (ctx != nullptr)
441  {
442  avformat_close_input(&ctx);
443  avformat_free_context(ctx);
444  }
445  delete [] probe.buf;
446 }
MythStreamInfoList::m_errorMsg
QString m_errorMsg
Definition: mythavutil.h:97
FMT_MEDIACODEC
@ FMT_MEDIACODEC
Definition: mythframe.h:61
MythAVCopy::m_size
int m_size
Definition: mythavutil.h:56
MythAVCopy::m_format
AVPixelFormat m_format
Definition: mythavutil.h:52
MythStreamInfo::m_codecName
QString m_codecName
Definition: mythavutil.h:72
DEINT_MEDIUM
@ DEINT_MEDIUM
Definition: mythframe.h:71
MythStreamInfo::m_height
int m_height
Definition: mythavutil.h:76
FMT_YUV420P10
@ FMT_YUV420P10
Definition: mythframe.h:26
FMT_YUV420P16
@ FMT_YUV420P16
Definition: mythframe.h:29
FMT_VTB
@ FMT_VTB
Definition: mythframe.h:62
MythCodecMap::GetCodecContext
AVCodecContext * GetCodecContext(const AVStream *Stream, const AVCodec *Codec=nullptr, bool NullCodec=false)
Definition: mythavutil.cpp:238
FMT_YUV420P14
@ FMT_YUV420P14
Definition: mythframe.h:28
MythVideoFrame::m_deinterlaceAllowed
MythDeintType m_deinterlaceAllowed
Definition: mythframe.h:160
FMT_DRMPRIME
@ FMT_DRMPRIME
Definition: mythframe.h:64
FMT_YUV444P10
@ FMT_YUV444P10
Definition: mythframe.h:46
FMT_YUV422P14
@ FMT_YUV422P14
Definition: mythframe.h:41
MythStreamInfo::m_codecType
char m_codecType
Definition: mythavutil.h:71
MythStreamInfo::m_avgFrameRate
float m_avgFrameRate
Definition: mythavutil.h:84
Frame
Definition: zmdefines.h:93
MythStreamInfo
Definition: mythavutil.h:68
MythAVUtil::DeinterlaceAVFrame
static void DeinterlaceAVFrame(AVFrame *Frame)
Deinterlace an AVFrame.
Definition: mythavutil.cpp:121
FMT_P010
@ FMT_P010
Definition: mythframe.h:54
arg
arg(title).arg(filename).arg(doDelete))
MythCodecMap::FreeAllContexts
void FreeAllContexts()
Definition: mythavutil.cpp:298
MythVideoFrame::m_width
int m_width
Definition: mythframe.h:121
FMT_YUV422P
@ FMT_YUV422P
Definition: mythframe.h:37
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
MythStreamInfo::m_duration
int64_t m_duration
Definition: mythavutil.h:73
DEINT_ALL
@ DEINT_ALL
Definition: mythframe.h:76
MythAVCopy::m_height
int m_height
Definition: mythavutil.h:55
MythVideoFrame::m_offsets
FrameOffsets m_offsets
Definition: mythframe.h:143
mythdeinterlacer.h
FMT_YUV444P14
@ FMT_YUV444P14
Definition: mythframe.h:48
FMT_YUV444P
@ FMT_YUV444P
Definition: mythframe.h:44
FMT_NONE
@ FMT_NONE
Definition: mythframe.h:22
DEINT_CPU
@ DEINT_CPU
Definition: mythframe.h:73
MythCodecMap::FindCodecContext
AVCodecContext * FindCodecContext(const AVStream *Stream)
Definition: mythavutil.cpp:278
AVFrame
struct AVFrame AVFrame
Definition: BorderDetector.h:15
MythStreamInfoList::m_errorCode
int m_errorCode
Definition: mythavutil.h:96
MythVideoFrame::YUVFormat
static bool YUVFormat(VideoFrameType Type)
Definition: mythframe.h:466
MythAVCopy::m_swsctx
SwsContext * m_swsctx
Definition: mythavutil.h:53
MythVideoFrame::GetBufferSize
static size_t GetBufferSize(VideoFrameType Type, int Width, int Height, int Aligned=MYTH_WIDTH_ALIGNMENT)
Definition: mythframe.cpp:412
MythStreamInfo::m_width
int m_width
Definition: mythavutil.h:75
mythlogging.h
av_strerror_stdstring
int av_strerror_stdstring(int errnum, std::string &errbuf)
Definition: mythaverror.cpp:27
FMT_YUV444P9
@ FMT_YUV444P9
Definition: mythframe.h:45
FMT_YV12
@ FMT_YV12
Definition: mythframe.h:24
FMT_YUV422P10
@ FMT_YUV422P10
Definition: mythframe.h:39
FMT_YUV444P16
@ FMT_YUV444P16
Definition: mythframe.h:49
MythStreamInfo::m_channels
int m_channels
Definition: mythavutil.h:86
FMT_BGRA
@ FMT_BGRA
Definition: mythframe.h:32
MythStreamInfo::m_SampleAspectRatio
float m_SampleAspectRatio
Definition: mythavutil.h:77
MythDeinterlacer::Filter
void Filter(MythVideoFrame *Frame, FrameScanType Scan, MythVideoProfile *Profile, bool Force=false)
Deinterlace Frame if needed.
Definition: mythdeinterlacer.cpp:70
FMT_YUV420P12
@ FMT_YUV420P12
Definition: mythframe.h:27
MythDeinterlacer
Handles software based deinterlacing of video frames.
Definition: mythdeinterlacer.h:15
filename
QString filename
Definition: mythplugins/mytharchive/mytharchivehelper/main.cpp:637
MythCodecMap::FreeCodecContext
void FreeCodecContext(const AVStream *Stream)
Definition: mythavutil.cpp:286
uint
unsigned int uint
Definition: compat.h:140
MythAVCopy::m_width
int m_width
Definition: mythavutil.h:54
FMT_YUV444P12
@ FMT_YUV444P12
Definition: mythframe.h:47
FMT_ARGB32
@ FMT_ARGB32
Definition: mythframe.h:34
MythAVUtil::PixelFormatToFrameType
static VideoFrameType PixelFormatToFrameType(AVPixelFormat Fmt)
Definition: mythavutil.cpp:70
MythVideoFrame::m_pitches
FramePitches m_pitches
Definition: mythframe.h:142
MythStreamInfo::m_frameRate
float m_frameRate
Definition: mythavutil.h:83
FMT_NVDEC
@ FMT_NVDEC
Definition: mythframe.h:63
FMT_YUV422P9
@ FMT_YUV422P9
Definition: mythframe.h:38
MythStreamInfo::m_fieldOrder
QString m_fieldOrder
Definition: mythavutil.h:82
Buffer
Definition: MythExternControl.h:36
FMT_YUV420P9
@ FMT_YUV420P9
Definition: mythframe.h:25
FMT_VDPAU
@ FMT_VDPAU
Definition: mythframe.h:57
kScan_Interlaced
@ kScan_Interlaced
Definition: videoouttypes.h:98
MythVideoFrame::m_type
VideoFrameType m_type
Definition: mythframe.h:119
FMT_YUV422P16
@ FMT_YUV422P16
Definition: mythframe.h:42
FMT_YUY2
@ FMT_YUY2
Definition: mythframe.h:51
FMT_DXVA2
@ FMT_DXVA2
Definition: mythframe.h:59
FMT_RGB24
@ FMT_RGB24
Definition: mythframe.h:31
FMT_YUV422P12
@ FMT_YUV422P12
Definition: mythframe.h:40
MythAVUtil::FrameTypeToPixelFormat
static AVPixelFormat FrameTypeToPixelFormat(VideoFrameType Type)
Definition: mythavutil.cpp:26
mythavutil.h
MythCodecMap::m_mapLock
QMutex m_mapLock
Definition: mythavutil.h:35
MythStreamInfoList::MythStreamInfoList
MythStreamInfoList(const QString &filename)
Definition: mythavutil.cpp:310
MythCodecMap::~MythCodecMap
~MythCodecMap()
Definition: mythavutil.cpp:233
MythVideoFrame::m_height
int m_height
Definition: mythframe.h:122
FMT_RGB32
@ FMT_RGB32
endian dependent format, ARGB or BGRA
Definition: mythframe.h:33
FMT_MMAL
@ FMT_MMAL
Definition: mythframe.h:60
VideoFrameType
VideoFrameType
Definition: mythframe.h:20
FMT_VAAPI
@ FMT_VAAPI
Definition: mythframe.h:58
MythCodecMap::m_streamMap
QMap< const AVStream *, AVCodecContext * > m_streamMap
Definition: mythavutil.h:34
MythAVCopy::~MythAVCopy
~MythAVCopy()
Definition: mythavutil.cpp:171
MythVideoFrame
Definition: mythframe.h:88
FMT_NV12
@ FMT_NV12
Definition: mythframe.h:53
MythAVCopy::Copy
int Copy(AVFrame *To, const MythVideoFrame *From, unsigned char *Buffer, AVPixelFormat Fmt=AV_PIX_FMT_YUV420P)
Initialise AVFrame and copy contents of VideoFrame frame into it, performing any required conversion.
Definition: mythavutil.cpp:217
FMT_P016
@ FMT_P016
Definition: mythframe.h:55
MythAVCopy::SizeData
int SizeData(int Width, int Height, AVPixelFormat Fmt)
Definition: mythavutil.cpp:176
MythAVUtil::FillAVFrame
static int FillAVFrame(AVFrame *Frame, const MythVideoFrame *From, AVPixelFormat Fmt=AV_PIX_FMT_NONE)
Initialise AVFrame with content from MythVideoFrame.
Definition: mythavutil.cpp:153
MythVideoFrame::m_deinterlaceSingle
MythDeintType m_deinterlaceSingle
Definition: mythframe.h:158
FMT_RGBA32
@ FMT_RGBA32
Definition: mythframe.h:35
MythVideoFrame::m_buffer
uint8_t * m_buffer
Definition: mythframe.h:120
MythStreamInfoList::m_streamInfoList
QVector< MythStreamInfo > m_streamInfoList
Definition: mythavutil.h:98