JerryJeong/fmviewer3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
JerryJeong
2026-02-21 17:11:31 +09:00
commit 18b4338361
4001 changed files with 365464 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

803
project/fm_viewer/fav/VideoFormat.cpp Normal file
View File

@@ -0,0 +1,803 @@
/******************************************************************************
QtAV: Multimedia framework based on Qt and FFmpeg
Copyright (C) 2012-2016 Wang Bin <wbsecg1@gmail.com>
* This file is part of QtAV
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
******************************************************************************/
#include "VideoFormat.h"
#include <cmath>
#include <QtCore/QVector>
#ifndef QT_NO_DEBUG_STREAM
#include <QtDebug>
#endif
#include "AVCompat.h"
extern "C" {
#include <libavutil/imgutils.h>
}
#define FF_HAS_YUV12BITS FFMPEG_MODULE_CHECK(LIBAVUTIL, 51, 73, 101)
#if (Q_BYTE_ORDER == Q_BIG_ENDIAN)
#define PIXFMT_NE(B, L) VideoFormat::Format_##B
#else
#define PIXFMT_NE(B, L) VideoFormat::Format_##L
#endif
// ffmpeg3.0 151aa2e/ libav>11 2268db2
#if AV_MODULE_CHECK(LIBAVUTIL, 55, 0, 0, 0, 100)
#define DESC_VAL(X) (X)
#else
#define DESC_VAL(X) (X##_minus1 + 1)
#endif
namespace FAV {
class VideoFormatPrivate : public QSharedData
{
public:
VideoFormatPrivate(VideoFormat::PixelFormat fmt)
: pixfmt(fmt)
, pixfmt_ff(QTAV_PIX_FMT_C(NONE))
, qpixfmt(QImage::Format_Invalid)
, planes(0)
, bpp(0)
, bpp_pad(0)
, bpc(0)
, pixdesc(0)
{
if (fmt == VideoFormat::Format_Invalid) {
pixfmt_ff = QTAV_PIX_FMT_C(NONE);
qpixfmt = QImage::Format_Invalid;
return;
}
init(fmt);
}
VideoFormatPrivate(AVPixelFormat fmt)
: pixfmt(VideoFormat::Format_Invalid)
, pixfmt_ff(fmt)
, qpixfmt(QImage::Format_Invalid)
, planes(0)
, bpp(0)
, bpp_pad(0)
, bpc(0)
, pixdesc(0)
{
init(fmt);
}
VideoFormatPrivate(QImage::Format fmt)
: pixfmt(VideoFormat::Format_Invalid)
, pixfmt_ff(QTAV_PIX_FMT_C(NONE))
, qpixfmt(fmt)
, planes(0)
, bpp(0)
, bpp_pad(0)
, bpc(0)
, pixdesc(0)
{
init(fmt);
}
void init(VideoFormat::PixelFormat fmt) {
pixfmt = fmt;
pixfmt_ff = (AVPixelFormat)VideoFormat::pixelFormatToFFmpeg(pixfmt);
qpixfmt = VideoFormat::imageFormatFromPixelFormat(pixfmt);
init();
}
void init(QImage::Format fmt) {
qpixfmt = fmt;
pixfmt = VideoFormat::pixelFormatFromImageFormat(fmt);
pixfmt_ff = (AVPixelFormat)VideoFormat::pixelFormatToFFmpeg(pixfmt);
init();
}
void init(AVPixelFormat fffmt) {
pixfmt_ff = fffmt;
pixfmt = VideoFormat::pixelFormatFromFFmpeg(pixfmt_ff);
qpixfmt = VideoFormat::imageFormatFromPixelFormat(pixfmt);
init();
}
void init() {
// TODO: what if other formats not supported by ffmpeg? give attributes in QtAV?
if (pixfmt_ff == QTAV_PIX_FMT_C(NONE)) {
qWarning("Invalid pixel format");
return;
}
planes = qMax(av_pix_fmt_count_planes(pixfmt_ff), 0);
bpps.reserve(planes);
channels.reserve(planes);
bpps.resize(planes);
channels.resize(planes);
pixdesc = const_cast<AVPixFmtDescriptor*>(av_pix_fmt_desc_get(pixfmt_ff));
if (!pixdesc)
return;
initBpp();
}
QString name() const {
return QLatin1String(av_get_pix_fmt_name(pixfmt_ff));
}
int flags() const {
if (!pixdesc)
return 0;
return pixdesc->flags;
}
int bytesPerLine(int width, int plane) const {
return av_image_get_linesize(pixfmt_ff, width, plane);
}
VideoFormat::PixelFormat pixfmt;
AVPixelFormat pixfmt_ff;
QImage::Format qpixfmt;
quint8 planes;
quint8 bpp;
quint8 bpp_pad;
quint8 bpc;
QVector<int> bpps;
QVector<int> channels;
AVPixFmtDescriptor *pixdesc;
private:
// from libavutil/pixdesc.c
void initBpp() {
//TODO: call later when bpp need
bpp = 0;
bpp_pad = 0;
//libavutil55: depth, step, offset
bpc = DESC_VAL(pixdesc->comp[0].depth);
const int log2_pixels = pixdesc->log2_chroma_w + pixdesc->log2_chroma_h;
int steps[4];
memset(steps, 0, sizeof(steps));
for (int c = 0; c < pixdesc->nb_components; c++) {
const AVComponentDescriptor *comp = &pixdesc->comp[c];
int s = c == 1 || c == 2 ? 0 : log2_pixels; //?
bpps[comp->plane] += DESC_VAL(comp->depth);
steps[comp->plane] = DESC_VAL(comp->step) << s;
channels[comp->plane] += 1;
bpp += DESC_VAL(comp->depth) << s;
if (DESC_VAL(comp->depth) != bpc)
bpc = 0;
}
for (int i = 0; i < planes; ++i) {
bpp_pad += steps[i];
}
if (!(pixdesc->flags & AV_PIX_FMT_FLAG_BITSTREAM))
bpp_pad *= 8;
bpp >>= log2_pixels;
bpp_pad >>= log2_pixels;
}
};
// TODO: use FFmpeg macros to get right endian
static const struct {
VideoFormat::PixelFormat fmt;
AVPixelFormat ff; //int
} pixfmt_map[] = {
{ VideoFormat::Format_YUV420P, QTAV_PIX_FMT_C(YUV420P) }, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
{ VideoFormat::Format_YV12, QTAV_PIX_FMT_C(YUV420P) }, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
{ VideoFormat::Format_YUYV, QTAV_PIX_FMT_C(YUYV422) }, //?? ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
{ VideoFormat::Format_RGB24, QTAV_PIX_FMT_C(RGB24) }, ///< packed RGB 8:8:8, 24bpp, RGBRGB...
{ VideoFormat::Format_BGR24, QTAV_PIX_FMT_C(BGR24) }, ///< packed RGB 8:8:8, 24bpp, BGRBGR...
{ VideoFormat::Format_YUV422P, QTAV_PIX_FMT_C(YUV422P)}, ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
{ VideoFormat::Format_YUV444P, QTAV_PIX_FMT_C(YUV444P) }, ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
{ VideoFormat::Format_YUV410P, QTAV_PIX_FMT_C(YUV410P) }, ///< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
{ VideoFormat::Format_YUV411P, QTAV_PIX_FMT_C(YUV411P) }, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
{ VideoFormat::Format_Y8, QTAV_PIX_FMT_C(GRAY8) }, ///< Y , 8bpp
//QTAV_PIX_FMT_C(MONOWHITE), ///< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
//QTAV_PIX_FMT_C(MONOBLACK), ///< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
//QTAV_PIX_FMT_C(PAL8), ///< 8 bit with PIX_FMT_RGB32 palette
{ VideoFormat::Format_YUV420P, QTAV_PIX_FMT_C(YUVJ420P) }, ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_range
//QTAV_PIX_FMT_C(YUVJ422P), ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_range
//QTAV_PIX_FMT_C(YUVJ444P), ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_range
//QTAV_PIX_FMT_C(XVMC_MPEG2_MC),///< XVideo Motion Acceleration via common packet passing
//QTAV_PIX_FMT_C(XVMC_MPEG2_IDCT),
{ VideoFormat::Format_UYVY, QTAV_PIX_FMT_C(UYVY422) }, ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
//QTAV_PIX_FMT_C(UYYVYY411), ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
//QTAV_PIX_FMT_C(BGR8), ///< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
//QTAV_PIX_FMT_C(BGR4), ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
//QTAV_PIX_FMT_C(BGR4_BYTE), ///< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
//QTAV_PIX_FMT_C(RGB8), ///< packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
//QTAV_PIX_FMT_C(RGB4), ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
//QTAV_PIX_FMT_C(RGB4_BYTE), ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
{ VideoFormat::Format_NV12, QTAV_PIX_FMT_C(NV12) }, ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
{ VideoFormat::Format_NV21, QTAV_PIX_FMT_C(NV21) }, ///< as above, but U and V bytes are swapped
{ VideoFormat::Format_ARGB32, QTAV_PIX_FMT_C(ARGB) }, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
{ VideoFormat::Format_RGBA32, QTAV_PIX_FMT_C(RGBA) }, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
{ VideoFormat::Format_ABGR32, QTAV_PIX_FMT_C(ABGR) }, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
{ VideoFormat::Format_BGRA32, QTAV_PIX_FMT_C(BGRA) }, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
//QTAV_PIX_FMT_C(GRAY16BE), ///< Y , 16bpp, big-endian
{ VideoFormat::Format_Y16, QTAV_PIX_FMT_C(GRAY16LE) }, ///< Y , 16bpp, little-endian
//QTAV_PIX_FMT_C(YUV440P), ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
//QTAV_PIX_FMT_C(YUVJ440P), ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range
//QTAV_PIX_FMT_C(YUVA420P), ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
/*
QTAV_PIX_FMT_C(VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
QTAV_PIX_FMT_C(VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
QTAV_PIX_FMT_C(VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
QTAV_PIX_FMT_C(VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
QTAV_PIX_FMT_C(VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
*/
{ VideoFormat::Format_RGB48BE, QTAV_PIX_FMT_C(RGB48BE) }, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
{ VideoFormat::Format_RGB48LE, QTAV_PIX_FMT_C(RGB48LE) }, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
{ VideoFormat::Format_RGB565, QTAV_PIX_FMT_C(RGB565) }, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), native-endian
{ VideoFormat::Format_RGB555, QTAV_PIX_FMT_C(RGB555) }, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), native-endian, be: most significant bit to 1
{ VideoFormat::Format_BGR565, QTAV_PIX_FMT_C(BGR565) }, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), native-endian
{ VideoFormat::Format_BGR555, QTAV_PIX_FMT_C(BGR555) }, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), native-endian, be: most significant bit to 1
/*
QTAV_PIX_FMT_C(VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
QTAV_PIX_FMT_C(VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
QTAV_PIX_FMT_C(VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
*/
#if FF_HAS_YUV12BITS
{ VideoFormat::Format_YUV420P16LE, QTAV_PIX_FMT_C(YUV420P16LE) }, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
{ VideoFormat::Format_YUV420P16BE, QTAV_PIX_FMT_C(YUV420P16BE) }, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
{ VideoFormat::Format_YUV422P16LE, QTAV_PIX_FMT_C(YUV422P16LE) }, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
{ VideoFormat::Format_YUV422P16BE, QTAV_PIX_FMT_C(YUV422P16BE) }, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
{ VideoFormat::Format_YUV444P16LE, QTAV_PIX_FMT_C(YUV444P16LE) }, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
{ VideoFormat::Format_YUV444P16BE, QTAV_PIX_FMT_C(YUV444P16BE) }, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
#endif //FF_HAS_YUV12BITS
/*
QTAV_PIX_FMT_C(VDPAU_MPEG4, ///< MPEG4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
QTAV_PIX_FMT_C(DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
QTAV_PIX_FMT_C(RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0
QTAV_PIX_FMT_C(RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0
QTAV_PIX_FMT_C(BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1
QTAV_PIX_FMT_C(BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1
QTAV_PIX_FMT_C(GRAY8A, ///< 8bit gray, 8bit alpha
*/
{ VideoFormat::Format_BGR48BE, QTAV_PIX_FMT_C(BGR48BE) }, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
{ VideoFormat::Format_BGR48LE, QTAV_PIX_FMT_C(BGR48LE) }, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
//the following 10 formats have the disadvantage of needing 1 format for each bit depth, thus
//If you want to support multiple bit depths, then using QTAV_PIX_FMT_C(YUV420P16* with the bpp stored separately
//is better
// the ffmpeg QtAV can build against( >= 0.9) supports 9,10 bits
{ VideoFormat::Format_YUV420P9BE, QTAV_PIX_FMT_C(YUV420P9BE) }, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
{ VideoFormat::Format_YUV420P9LE, QTAV_PIX_FMT_C(YUV420P9LE) }, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
{ VideoFormat::Format_YUV420P10BE, QTAV_PIX_FMT_C(YUV420P10BE) },///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
{ VideoFormat::Format_YUV420P10LE, QTAV_PIX_FMT_C(YUV420P10LE) },///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
{ VideoFormat::Format_YUV422P10BE, QTAV_PIX_FMT_C(YUV422P10BE) },///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
{ VideoFormat::Format_YUV422P10LE, QTAV_PIX_FMT_C(YUV422P10LE) },///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
{ VideoFormat::Format_YUV444P9BE, QTAV_PIX_FMT_C(YUV444P9BE) }, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
{ VideoFormat::Format_YUV444P9LE, QTAV_PIX_FMT_C(YUV444P9LE) }, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
{ VideoFormat::Format_YUV444P10BE, QTAV_PIX_FMT_C(YUV444P10BE) },///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
{ VideoFormat::Format_YUV444P10LE, QTAV_PIX_FMT_C(YUV444P10LE) },///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
{ VideoFormat::Format_YUV422P9BE, QTAV_PIX_FMT_C(YUV422P9BE) }, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
{ VideoFormat::Format_YUV422P9LE, QTAV_PIX_FMT_C(YUV422P9LE) }, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
//QTAV_PIX_FMT_C(VDA_VLD, ///< hardware decoding through VDA
/*
#ifdef AV_PIX_FMT_ABI_GIT_MASTER
QTAV_PIX_FMT_C(RGBA64BE) }, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
QTAV_PIX_FMT_C(RGBA64LE) }, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
QTAV_PIX_FMT_C(BGRA64BE) }, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
QTAV_PIX_FMT_C(BGRA64LE) }, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
#endif
QTAV_PIX_FMT_C(GBRP, ///< planar GBR 4:4:4 24bpp
QTAV_PIX_FMT_C(GBRP9BE, ///< planar GBR 4:4:4 27bpp, big-endian
QTAV_PIX_FMT_C(GBRP9LE, ///< planar GBR 4:4:4 27bpp, little-endian
QTAV_PIX_FMT_C(GBRP10BE, ///< planar GBR 4:4:4 30bpp, big-endian
QTAV_PIX_FMT_C(GBRP10LE, ///< planar GBR 4:4:4 30bpp, little-endian
QTAV_PIX_FMT_C(GBRP16BE, ///< planar GBR 4:4:4 48bpp, big-endian
QTAV_PIX_FMT_C(GBRP16LE, ///< planar GBR 4:4:4 48bpp, little-endian
*/
/**
* duplicated pixel formats for compatibility with libav.
* FFmpeg supports these formats since May 8 2012 and Jan 28 2012 (commits f9ca1ac7 and 143a5c55)
* Libav added them Oct 12 2012 with incompatible values (commit 6d5600e85)
*/
/*
QTAV_PIX_FMT_C(YUVA422P_LIBAV, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
QTAV_PIX_FMT_C(YUVA444P_LIBAV, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
QTAV_PIX_FMT_C(YUVA420P9BE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
QTAV_PIX_FMT_C(YUVA420P9LE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
QTAV_PIX_FMT_C(YUVA422P9BE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
QTAV_PIX_FMT_C(YUVA422P9LE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
QTAV_PIX_FMT_C(YUVA444P9BE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
QTAV_PIX_FMT_C(YUVA444P9LE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
// Y: 2bytes/pix U: 1, V: 1
QTAV_PIX_FMT_C(YUVA420P10BE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
QTAV_PIX_FMT_C(YUVA420P10LE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
QTAV_PIX_FMT_C(YUVA422P10BE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
QTAV_PIX_FMT_C(YUVA422P10LE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
QTAV_PIX_FMT_C(YUVA444P10BE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
QTAV_PIX_FMT_C(YUVA444P10LE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
QTAV_PIX_FMT_C(YUVA420P16BE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
QTAV_PIX_FMT_C(YUVA420P16LE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
QTAV_PIX_FMT_C(YUVA422P16BE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
QTAV_PIX_FMT_C(YUVA422P16LE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
QTAV_PIX_FMT_C(YUVA444P16BE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
QTAV_PIX_FMT_C(YUVA444P16LE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
*/
//QTAV_PIX_FMT_C(VDPAU, ///< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface
// doc/APIChanges: 2014-04-07 - 0a1cc04 / 8b17243 - lavu 52.75.100 / 53.11.0 - pixfmt.h
//Add AV_PIX_FMT_YVYU422 pixel format.
#if (FFMPEG_MODULE_CHECK(LIBAVUTIL, 52, 75, 100) || LIBAV_MODULE_CHECK(LIBAVUTIL, 53, 11, 0))
{ VideoFormat::Format_YVYU, QTAV_PIX_FMT_C(YVYU422) },
#endif
// 2014-03-16 - 6b1ca17 / 1481d24 - lavu 52.67.100 / 53.6.0 before ffmpeg2.2 libav11 RGBA64_LIBAV
#if (QTAV_USE_FFMPEG(LIBAVUTIL) || LIBAV_MODULE_CHECK(LIBAVUTIL, 53, 6, 0))
{ VideoFormat::Format_RGBA64BE, QTAV_PIX_FMT_C(RGBA64BE)}, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
{ VideoFormat::Format_RGBA64LE, QTAV_PIX_FMT_C(RGBA64LE)}, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
{ VideoFormat::Format_BGRA64BE, QTAV_PIX_FMT_C(BGRA64BE)}, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
{ VideoFormat::Format_BGRA64LE, QTAV_PIX_FMT_C(BGRA64LE)}, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
#endif
#if QTAV_USE_FFMPEG(LIBAVUTIL) //still use rgba formats but check hasAplha is required
{ VideoFormat::Format_ARGB32, QTAV_PIX_FMT_C(0RGB)}, ///< packed RGB 8:8:8, 32bpp, 0RGB0RGB...
{ VideoFormat::Format_RGBA32, QTAV_PIX_FMT_C(RGB0)}, ///< packed RGB 8:8:8, 32bpp, RGB0RGB0...
{ VideoFormat::Format_ABGR32, QTAV_PIX_FMT_C(0BGR)}, ///< packed BGR 8:8:8, 32bpp, 0BGR0BGR...
{ VideoFormat::Format_BGRA32, QTAV_PIX_FMT_C(BGR0)}, ///< packed BGR 8:8:8, 32bpp, BGR0BGR0...
#endif //
//QTAV_PIX_FMT_C(YUVA444P, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
//QTAV_PIX_FMT_C(YUVA422P, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
#if FF_HAS_YUV12BITS
{ VideoFormat::Format_YUV420P12BE, QTAV_PIX_FMT_C(YUV420P12BE) }, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
{ VideoFormat::Format_YUV420P12LE, QTAV_PIX_FMT_C(YUV420P12LE) }, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
{ VideoFormat::Format_YUV420P14BE, QTAV_PIX_FMT_C(YUV420P14BE) }, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
{ VideoFormat::Format_YUV420P14LE, QTAV_PIX_FMT_C(YUV420P14LE) }, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
{ VideoFormat::Format_YUV422P12BE, QTAV_PIX_FMT_C(YUV422P12BE) }, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
{ VideoFormat::Format_YUV422P12LE, QTAV_PIX_FMT_C(YUV422P12LE) }, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
{ VideoFormat::Format_YUV422P14BE, QTAV_PIX_FMT_C(YUV422P14BE) }, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
{ VideoFormat::Format_YUV422P14LE, QTAV_PIX_FMT_C(YUV422P14LE) }, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
{ VideoFormat::Format_YUV444P12BE, QTAV_PIX_FMT_C(YUV444P12BE) }, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
{ VideoFormat::Format_YUV444P12LE, QTAV_PIX_FMT_C(YUV444P12LE) }, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
{ VideoFormat::Format_YUV444P14BE, QTAV_PIX_FMT_C(YUV444P14BE) }, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
{ VideoFormat::Format_YUV444P14LE, QTAV_PIX_FMT_C(YUV444P14LE) }, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
#endif //FF_HAS_YUV12BITS
/*
QTAV_PIX_FMT_C(GBRP12BE, ///< planar GBR 4:4:4 36bpp, big-endian
QTAV_PIX_FMT_C(GBRP12LE, ///< planar GBR 4:4:4 36bpp, little-endian
QTAV_PIX_FMT_C(GBRP14BE, ///< planar GBR 4:4:4 42bpp, big-endian
QTAV_PIX_FMT_C(GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian
*/
// native endian formats
// QTAV_PIX_FMT_C(RGB32) is depends on byte order, ARGB for BE, BGRA for LE
{ VideoFormat::Format_RGB32, QTAV_PIX_FMT_C(RGB32) }, //auto endian
// AV_PIX_FMT_BGR32_1: bgra, argb
{ VideoFormat::Format_BGR32, QTAV_PIX_FMT_C(BGR32) }, //auto endian
{ VideoFormat::Format_RGB48, QTAV_PIX_FMT_C(RGB48) }, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
{ VideoFormat::Format_BGR48, QTAV_PIX_FMT_C(BGR48) }, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
#if QTAV_USE_FFMPEG(LIBAVUTIL)
{ VideoFormat::Format_RGBA64, QTAV_PIX_FMT_C(RGBA64) },
{ VideoFormat::Format_BGRA64, QTAV_PIX_FMT_C(BGRA64) },
#endif //QTAV_USE_FFMPEG(LIBAVUTIL)
{ VideoFormat::Format_VYUY, QTAV_PIX_FMT_C(UYVY422) }, // FIXME: hack for invalid ffmpeg formats
{ VideoFormat::Format_VYU, QTAV_PIX_FMT_C(RGB32) },
#ifdef AV_PIX_FMT_XYZ12
{ VideoFormat::Format_XYZ12, QTAV_PIX_FMT_C(XYZ12) },
{ VideoFormat::Format_XYZ12LE, QTAV_PIX_FMT_C(XYZ12LE) },
{ VideoFormat::Format_XYZ12BE, QTAV_PIX_FMT_C(XYZ12BE) },
#endif
{ VideoFormat::Format_Invalid, QTAV_PIX_FMT_C(NONE) },
};
VideoFormat::PixelFormat VideoFormat::pixelFormatFromFFmpeg(int ff)
{
for (unsigned int i = 0; i < sizeof(pixfmt_map)/sizeof(pixfmt_map[0]); ++i) {
if (pixfmt_map[i].ff == ff)
return pixfmt_map[i].fmt;
}
return VideoFormat::Format_Invalid;
}
int VideoFormat::pixelFormatToFFmpeg(VideoFormat::PixelFormat fmt)
{
for (unsigned int i = 0; i < sizeof(pixfmt_map)/sizeof(pixfmt_map[0]); ++i) {
if (pixfmt_map[i].fmt == fmt)
return pixfmt_map[i].ff;
}
return QTAV_PIX_FMT_C(NONE);
}
QVector<int> VideoFormat::pixelFormatsFFmpeg()
{
static QVector<int> sFmts;
if (sFmts.isEmpty()) {
const AVPixFmtDescriptor *desc = NULL;
while ((desc = av_pix_fmt_desc_next(desc))) {
if ((desc->flags & AV_PIX_FMT_FLAG_HWACCEL) == AV_PIX_FMT_FLAG_HWACCEL)
continue;
sFmts.append(av_pix_fmt_desc_get_id(desc));
}
}
return sFmts;
}
/*!
Returns a video pixel format equivalent to an image \a format. If there is no equivalent
format VideoFormat::InvalidType is returned instead.
\note In general \l QImage does not handle YUV formats.
*/
static const struct {
VideoFormat::PixelFormat fmt;
QImage::Format qfmt;
} qpixfmt_map[] = {
// QImage::Format_ARGB32: 0xAARRGGBB, VideoFormat::Format_BGRA32: layout is BBGGRRAA
{ PIXFMT_NE(ARGB32, BGRA32), QImage::Format_ARGB32 },
{ VideoFormat::Format_RGB32, QImage::Format_ARGB32 },
{ VideoFormat::Format_RGB32, QImage::Format_RGB32 },
#if QT_VERSION >= QT_VERSION_CHECK(5, 2, 0)
{ VideoFormat::Format_RGBA32, QImage::Format_RGBA8888 }, //be 0xRRGGBBAA, le 0xAABBGGRR
#endif
{ VideoFormat::Format_RGB565, QImage::Format_RGB16 },
{ VideoFormat::Format_BGR565, (QImage::Format)-QImage::Format_RGB16 },
{ VideoFormat::Format_RGB555, QImage::Format_RGB555 },
{ VideoFormat::Format_BGR555, (QImage::Format)-QImage::Format_RGB555 },
{ VideoFormat::Format_RGB24, QImage::Format_RGB888 },
{ VideoFormat::Format_BGR24, (QImage::Format)-QImage::Format_RGB888 },
{ VideoFormat::Format_Invalid, QImage::Format_Invalid }
};
VideoFormat::PixelFormat VideoFormat::pixelFormatFromImageFormat(QImage::Format format)
{
for (int i = 0; qpixfmt_map[i].fmt != Format_Invalid; ++i) {
if (qpixfmt_map[i].qfmt == format)
return qpixfmt_map[i].fmt;
}
return Format_Invalid;
}
QImage::Format VideoFormat::imageFormatFromPixelFormat(PixelFormat format)
{
for (int i = 0; qpixfmt_map[i].fmt != Format_Invalid; ++i) {
if (qpixfmt_map[i].fmt == format)
return qpixfmt_map[i].qfmt;
}
return QImage::Format_Invalid;
}
VideoFormat::VideoFormat(PixelFormat format)
:d(new VideoFormatPrivate(format))
{
}
VideoFormat::VideoFormat(int formatFF)
:d(new VideoFormatPrivate((AVPixelFormat)formatFF))
{
}
VideoFormat::VideoFormat(QImage::Format fmt)
:d(new VideoFormatPrivate(fmt))
{
}
VideoFormat::VideoFormat(const QString &name)
:d(new VideoFormatPrivate(av_get_pix_fmt(name.toUtf8().constData())))
{
}
VideoFormat::VideoFormat(const VideoFormat &other)
:d(other.d)
{
}
VideoFormat::~VideoFormat()
{
}
/*!
Assigns \a other to this VideoFormat implementation.
*/
VideoFormat& VideoFormat::operator=(const VideoFormat &other)
{
d = other.d;
return *this;
}
VideoFormat& VideoFormat::operator =(VideoFormat::PixelFormat fmt)
{
d = new VideoFormatPrivate(fmt);
return *this;
}
VideoFormat& VideoFormat::operator =(QImage::Format qpixfmt)
{
d = new VideoFormatPrivate(qpixfmt);
return *this;
}
VideoFormat& VideoFormat::operator =(int fffmt)
{
d = new VideoFormatPrivate((AVPixelFormat)fffmt);
return *this;
}
bool VideoFormat::operator==(const VideoFormat &other) const
{
return d->pixfmt_ff == other.d->pixfmt_ff;
}
bool VideoFormat::operator==(VideoFormat::PixelFormat fmt) const
{
return d->pixfmt == fmt;
}
bool VideoFormat::operator==(QImage::Format qpixfmt) const
{
return d->qpixfmt == qpixfmt;
}
bool VideoFormat::operator==(int fffmt) const
{
return d->pixfmt_ff == fffmt;
}
bool VideoFormat::operator!=(const VideoFormat& other) const
{
return !(*this == other);
}
bool VideoFormat::operator!=(VideoFormat::PixelFormat fmt) const
{
return d->pixfmt != fmt;
}
bool VideoFormat::operator!=(QImage::Format qpixfmt) const
{
return d->qpixfmt != qpixfmt;
}
bool VideoFormat::operator!=(int fffmt) const
{
return d->pixfmt_ff != fffmt;
}
bool VideoFormat::isValid() const
{
return d->pixfmt_ff != QTAV_PIX_FMT_C(NONE) || d->pixfmt != Format_Invalid;
}
VideoFormat::PixelFormat VideoFormat::pixelFormat() const
{
return d->pixfmt;
}
int VideoFormat::pixelFormatFFmpeg() const
{
return d->pixfmt_ff;
}
QImage::Format VideoFormat::imageFormat() const
{
return d->qpixfmt;
}
QString VideoFormat::name() const
{
return d->name();
}
void VideoFormat::setPixelFormat(PixelFormat format)
{
d->pixfmt = format;
d->init(format);
}
void VideoFormat::setPixelFormatFFmpeg(int format)
{
d->pixfmt_ff = (AVPixelFormat)format;
d->init((AVPixelFormat)format);
}
int VideoFormat::channels() const
{
if (!d->pixdesc)
return 0;
return d->pixdesc->nb_components;
}
int VideoFormat::channels(int plane) const
{
if (plane > d->channels.size())
return 0;
return d->channels[plane];
}
int VideoFormat::planeCount() const
{
return d->planes;
}
int VideoFormat::bitsPerPixel() const
{
return d->bpp;
}
int VideoFormat::bitsPerPixelPadded() const
{
return d->bpp_pad;
}
int VideoFormat::bitsPerPixel(int plane) const
{
//must be a valid index position in the vector
if (plane >= d->bpps.size())
return 0;
return d->bpps[plane];
}
int VideoFormat::bytesPerPixel() const
{
return (bitsPerPixel() + 7) >> 3;
}
int VideoFormat::bytesPerPixel(int plane) const
{
return (bitsPerPixel(plane) + 7) >> 3;
}
int VideoFormat::bitsPerComponent() const
{
return d->bpc;
}
int VideoFormat::bytesPerLine(int width, int plane) const
{
return d->bytesPerLine(width, plane);
}
int VideoFormat::chromaWidth(int lumaWidth) const
{
return -((-lumaWidth) >> d->pixdesc->log2_chroma_w);
}
int VideoFormat::chromaHeight(int lumaHeight) const
{
return -((-lumaHeight) >> d->pixdesc->log2_chroma_h);
}
int VideoFormat::width(int lumaWidth, int plane) const
{
if (plane <= 0)
return lumaWidth;
return chromaWidth(lumaWidth);
}
int VideoFormat::height(int lumaHeight, int plane) const
{
if (plane <= 0)
return lumaHeight;
return chromaHeight(lumaHeight);
}
qreal VideoFormat::normalizedWidth(int plane) const
{
if (plane <= 0)
return 1.0;
return 1.0/std::pow(2.0, qreal(d->pixdesc->log2_chroma_w));
}
qreal VideoFormat::normalizedHeight(int plane) const
{
if (plane <= 0)
return 1.0;
return 1.0/std::pow(2.0, qreal(d->pixdesc->log2_chroma_h));
}
// test AV_PIX_FMT_FLAG_XXX
bool VideoFormat::isBigEndian() const
{
return (d->flags() & AV_PIX_FMT_FLAG_BE) == AV_PIX_FMT_FLAG_BE;
}
bool VideoFormat::hasPalette() const
{
return (d->flags() & AV_PIX_FMT_FLAG_PAL) == AV_PIX_FMT_FLAG_PAL;
}
bool VideoFormat::isPseudoPaletted() const
{
return (d->flags() & AV_PIX_FMT_FLAG_PSEUDOPAL) == AV_PIX_FMT_FLAG_PSEUDOPAL;
}
bool VideoFormat::isBitStream() const
{
return (d->flags() & AV_PIX_FMT_FLAG_BITSTREAM) == AV_PIX_FMT_FLAG_BITSTREAM;
}
bool VideoFormat::isHWAccelerated() const
{
return (d->flags() & AV_PIX_FMT_FLAG_HWACCEL) == AV_PIX_FMT_FLAG_HWACCEL;
}
bool VideoFormat::isPlanar() const
{
return (d->flags() & AV_PIX_FMT_FLAG_PLANAR) == AV_PIX_FMT_FLAG_PLANAR;
}
bool VideoFormat::isRGB() const
{
return (d->flags() & AV_PIX_FMT_FLAG_RGB) == AV_PIX_FMT_FLAG_RGB && d->pixfmt != Format_VYU;
}
bool VideoFormat::isXYZ() const
{
return d->pixfmt == Format_XYZ12 || d->pixfmt == Format_XYZ12LE || d->pixfmt == Format_XYZ12BE;
}
bool VideoFormat::hasAlpha() const
{
return (d->flags() & AV_PIX_FMT_FLAG_ALPHA) == AV_PIX_FMT_FLAG_ALPHA;
}
bool VideoFormat::isPlanar(PixelFormat pixfmt)
{
return pixfmt == Format_YUV420P || pixfmt == Format_NV12 || pixfmt == Format_NV21 || pixfmt == Format_YV12
|| pixfmt == Format_YUV410P || pixfmt == Format_YUV411P || pixfmt == Format_YUV422P
|| pixfmt == Format_YUV444P || pixfmt == Format_AYUV444
|| pixfmt == Format_IMC1 || pixfmt == Format_IMC2 || pixfmt == Format_IMC3 || pixfmt == Format_IMC4
;
}
bool VideoFormat::isRGB(PixelFormat pixfmt)
{
return pixfmt == Format_RGB32 || pixfmt == Format_ARGB32
|| pixfmt == Format_RGB24 || pixfmt == Format_BGRA32
|| pixfmt == Format_ABGR32 || pixfmt == Format_RGBA32
|| pixfmt == Format_BGR565 || pixfmt == Format_RGB555 || pixfmt == Format_RGB565
|| pixfmt == Format_BGR24 || pixfmt == Format_BGR32 || pixfmt == Format_BGR555
|| pixfmt == Format_RGB48 || pixfmt == Format_RGB48LE || pixfmt == Format_RGB48BE
|| pixfmt == Format_BGR48 || pixfmt == Format_BGR48LE || pixfmt == Format_BGR48BE
|| pixfmt == Format_RGBA64 || pixfmt == Format_RGBA64LE || pixfmt == Format_RGBA64BE
|| pixfmt == Format_BGRA64 || pixfmt == Format_BGRA64LE || pixfmt == Format_BGRA64BE
;
}
bool VideoFormat::hasAlpha(PixelFormat pixfmt)
{
return pixfmt == Format_ARGB32 || pixfmt == Format_BGRA32
|| pixfmt == Format_AYUV444// || pixfmt == Format_RGB555 || pixfmt == Format_BGR555
;
}
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const VideoFormat &fmt)
{
dbg.nospace() << "FAV::VideoFormat(pixelFormat: " << (int)fmt.pixelFormat() << " " << fmt.name() << " alpha: " << fmt.hasAlpha();
dbg.nospace() << ", channels: " << fmt.channels();
dbg.nospace() << ", planes: " << fmt.planeCount();
dbg.nospace() << ", bpc: " << fmt.bitsPerComponent();
dbg.nospace() << ", bpp: " << fmt.bitsPerPixel() << "/" << fmt.bitsPerPixelPadded() << " ";
for (int i = 0; i < fmt.planeCount(); ++i) {
dbg.nospace() << "-" << fmt.bitsPerPixel(i);
}
dbg.nospace() << ")";
return dbg.space();
}
QDebug operator<<(QDebug dbg, VideoFormat::PixelFormat pixFmt)
{
dbg.nospace() << (int)pixFmt << " " << av_get_pix_fmt_name((AVPixelFormat)VideoFormat::pixelFormatToFFmpeg(pixFmt));
return dbg.space();
}
#endif
namespace {
class VideoFormatPrivateRegisterMetaTypes
{
public:
VideoFormatPrivateRegisterMetaTypes()
{
qRegisterMetaType<FAV::VideoFormat>();
qRegisterMetaType<FAV::VideoFormat::PixelFormat>();
}
} _registerMetaTypes;
}
} //namespace FAV