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