/*!
|
* COPYRIGHT (C) 2020 Emeric Grange - All Rights Reserved
|
*
|
* This file is part of MiniVideo.
|
*
|
* MiniVideo 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 3 of the License, or
|
* (at your option) any later version.
|
*
|
* MiniVideo 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 MiniVideo. If not, see <http://www.gnu.org/licenses/>.
|
*
|
* \author Emeric Grange <emeric.grange@gmail.com>
|
* \date 2018
|
*/
|
|
#include "minivideo_containers.h"
|
#include "minitraces.h"
|
|
#ifdef __GNUC__
|
#pragma GCC diagnostic ignored "-Wswitch"
|
#endif
|
#ifdef __clang__
|
#pragma clang diagnostic ignored "-Wswitch"
|
#endif
|
|
/* ************************************************************************** */
|
|
const char *getContainerString(const Containers_e container, const bool long_description)
|
{
|
switch (container)
|
{
|
case CONTAINER_AVI:
|
if (long_description)
|
return "AVI (Audio Video Interleave)";
|
else
|
return "AVI";
|
|
case CONTAINER_ASF:
|
if (long_description)
|
return "ASF (Advanced Systems Format)";
|
else
|
return "ASF";
|
|
case CONTAINER_MKV:
|
if (long_description)
|
return "MKV (Matroska)";
|
else
|
return "MKV";
|
|
case CONTAINER_MP4:
|
if (long_description)
|
return "MP4 (ISO Base Media format)";
|
else
|
return "MP4";
|
|
case CONTAINER_MPEG_PS:
|
if (long_description)
|
return "MPEG 'Program Stream'";
|
else
|
return "MPEG-PS";
|
case CONTAINER_MPEG_TS:
|
if (long_description)
|
return "MPEG 'Transport Stream'";
|
else
|
return "MPEG-TS";
|
case CONTAINER_MPEG_MT:
|
if (long_description)
|
return "MPEG 'Media Transport'";
|
else
|
return "MPEG-MT";
|
|
case CONTAINER_MXF:
|
if (long_description)
|
return "MXF Material eXchange Format";
|
else
|
return "MXF";
|
|
case CONTAINER_FLV:
|
if (long_description)
|
return "Flash Video file format";
|
else
|
return "FLV";
|
|
case CONTAINER_SWF:
|
if (long_description)
|
return "SWF (Small Web Format)";
|
else
|
return "SWF";
|
|
case CONTAINER_OGG:
|
return "OGG";
|
|
case CONTAINER_RM:
|
return "RealMedia";
|
|
case CONTAINER_R3D:
|
return "Redcode RAW";
|
|
case CONTAINER_FLAC:
|
if (long_description)
|
return "FLAC (Free Lossless Audio Codec)";
|
else
|
return "FLAC";
|
|
case CONTAINER_WAVE:
|
if (long_description)
|
return "WAVE (Waveform Audio File Format)";
|
else
|
return "WAVE";
|
|
case CONTAINER_CAF:
|
if (long_description)
|
return "CAF (Core Audio Format)";
|
else
|
return "CAF";
|
|
case CONTAINER_AU:
|
if (long_description)
|
return "AU (Au file format)";
|
else
|
return "AU";
|
|
case CONTAINER_ES:
|
return "Undefined 'Elementary Stream'";
|
case CONTAINER_ES_AAC:
|
return "AAC 'Elementary Stream'";
|
case CONTAINER_ES_AC3:
|
return "AC3 'Elementary Stream'";
|
case CONTAINER_ES_MP3:
|
return "MP3 'Elementary Stream'";
|
|
case CONTAINER_JPEG:
|
return "JPEG";
|
case CONTAINER_JPEG_XR:
|
return "JPEG XR";
|
case CONTAINER_JPEG_2K:
|
return "JPEG 2000";
|
case CONTAINER_GIF:
|
return "GIF";
|
case CONTAINER_BMP:
|
return "BMP";
|
case CONTAINER_TGA:
|
return "TGA";
|
case CONTAINER_TIFF:
|
return "TIFF";
|
case CONTAINER_ICNS:
|
return "ICNS";
|
case CONTAINER_ICO:
|
return "ICO";
|
case CONTAINER_PNG:
|
return "PNG";
|
case CONTAINER_DNG:
|
return "DNG";
|
case CONTAINER_DPX:
|
return "DPX";
|
case CONTAINER_CIFF:
|
return "CIFF";
|
case CONTAINER_CR2:
|
return "CR2";
|
case CONTAINER_WEBP:
|
return "WebP";
|
case CONTAINER_BPG:
|
return "BPG";
|
case CONTAINER_FLIF:
|
return "FLIF";
|
|
default:
|
return "";
|
}
|
}
|
|
/* ************************************************************************** */
|
|
const char *getContainerProfileString(const ContainerProfiles_e profile, const bool long_description)
|
{
|
switch (profile)
|
{
|
case PROF_AVI:
|
return "AVI v1";
|
case PROF_AVI_OpenDML:
|
return "AVI v2 \"OpenDML\"";
|
case PROF_AVI_DMF:
|
return "AVI DMF \"DivX Media Format\"";
|
|
case PROF_MPEG_PS_1:
|
return "MPEG-PS v1";
|
case PROF_MPEG_PS_2:
|
return "MPEG-PS v2";
|
|
case PROF_ISOBMF_MOV:
|
return "QuickTime File Format";
|
case PROF_ISOBMF_MP4:
|
return "ISO BMF MP4";
|
case PROF_ISOBMF_M4A:
|
return "QuickTime Audio, AAC Codec";
|
case PROF_ISOBMF_F4V:
|
return "Flash Video";
|
case PROF_ISOBMF_3GP:
|
return "ISO BMF 3GP";
|
case PROF_ISOBMF_DASH:
|
return "MPEG-DASH";
|
case PROF_ISOBMF_AVIF:
|
return "AV1 Image File Format";
|
case PROF_ISOBMF_HEIF:
|
return "High Efficiency Image File Format";
|
case PROF_ISOBMF_MJP2:
|
return "ISO BMF Motion Jpeg 2000";
|
case PROF_ISOBMF_PIFF:
|
return "Protected Interoperable File Format";
|
|
case PROF_MKV_MATROSKA:
|
return "Matroska";
|
case PROF_MKV_WEBM:
|
return "WebM";
|
|
case PROF_WAVE_AMB:
|
return "WAVE ambisonic";
|
case PROF_WAVE_RF64:
|
return "RF64";
|
case PROF_WAVE_BWFv1:
|
return "Broadcast Wave Format v1";
|
case PROF_WAVE_BWFv2:
|
return "Broadcast Wave Format v2";
|
case PROF_WAVE_BWF64:
|
return "Broadcast Wave Format 64";
|
|
default:
|
return "";
|
}
|
}
|
|
/* ************************************************************************** */
|
/* ************************************************************************** */
|
|
/*!
|
* \brief Detect the container used by a multimedia file.
|
* \param[in] *media: A pointer to a MediaFile_t structure, containing every informations available about the current media file.
|
* \return container: A ContainerFormat_e value.
|
*
|
* This function check the first 16 bytes of a media file in order to find
|
* evidence of a known file container format.
|
*/
|
Containers_e getContainerUsingStartcodes(uint8_t buffer[16])
|
{
|
TRACE_2(IO, "getContainerUsingStartcodes()");
|
|
Containers_e container = CONTAINER_UNKNOWN;
|
|
// Read the first bytes of the file
|
if (buffer)
|
{
|
// Parse the file to find evidence of a container format
|
if (buffer[0] == 0x47)
|
{
|
TRACE_1(IO, "* File type : TS (MPEG 'Transport Stream') container detected");
|
container = CONTAINER_MPEG_TS;
|
}
|
else if (buffer[0] == 0x1A && buffer[1] == 0x45 && buffer[2] == 0xDF && buffer[3] == 0xA3)
|
{
|
TRACE_1(IO, "* File type : EBML file detected, possibly MKV or WebM container");
|
container = CONTAINER_MKV;
|
}
|
else if (buffer[0] == 0x52 && buffer[1] == 0x49 && buffer[2] == 0x46 && buffer[3] == 0x46)
|
{
|
// RIFF header:
|
// 52 49 46 46 xx xx xx xx // R I F F (size)
|
// then:
|
// 41 56 49 20 4C 49 53 54 // A V I L I S T
|
// 57 41 56 45 66 6D 74 20 // W A V E f m t
|
|
if (buffer[8] == 0x41 && buffer[9] == 0x56 && buffer[10] == 0x49 && buffer[11] == 0x20)
|
{
|
TRACE_1(IO, "* File type : AVI container detected");
|
container = CONTAINER_AVI;
|
}
|
else if (buffer[8] == 0x57 && buffer[9] == 0x41 && buffer[10] == 0x56 && buffer[11] == 0x45)
|
{
|
TRACE_1(IO, "* File type : WAVE container detected");
|
container = CONTAINER_WAVE;
|
}
|
else
|
{
|
TRACE_WARNING(IO, "* File type : Unknown RIFF container detected");
|
}
|
}
|
else if (buffer[0] == 0x00 && buffer[1] == 0x00)
|
{
|
if (buffer[2] == 0x01)
|
{
|
if (buffer[3] == 0xBA)
|
{
|
TRACE_1(IO, "* File type : PS (MPEG 'Program Stream') container detected");
|
container = CONTAINER_MPEG_PS;
|
}
|
else if (buffer[3] == 0xB3)
|
{
|
TRACE_1(IO, "* File type : MPEG-1/2 / H.262 Elementary Stream detected (raw video data)");
|
container = CONTAINER_ES;
|
//media->codec_video = CODEC_MPEG12;
|
}
|
else if (buffer[3] == 0x67)
|
{
|
TRACE_1(IO, "* File type : H.264 'Annex B' Elementary Stream detected (raw video data)");
|
container = CONTAINER_ES;
|
//media->codec_video = CODEC_H264;
|
}
|
}
|
else if (buffer[2] == 0x00 && buffer[3] == 0x01)
|
{
|
if (buffer[4] == 0xBA)
|
{
|
TRACE_1(IO, "* File type : MPEG-PS (MPEG 'Program Stream') container detected");
|
container = CONTAINER_MPEG_PS;
|
}
|
else if (buffer[4] == 0xB3)
|
{
|
TRACE_1(IO, "* File type : MPEG-1/2 / H.262 Elementary Stream detected (raw video data)");
|
container = CONTAINER_ES;
|
//media->codec_video = CODEC_MPEG12;
|
}
|
else if (buffer[4] == 0x67)
|
{
|
TRACE_1(IO, "* File type : H.264 'Annex B' Elementary Stream detected (raw video data)");
|
container = CONTAINER_ES;
|
//media->codec_video = CODEC_H264;
|
}
|
}
|
|
if (buffer[4] == 0x66 && buffer[5] == 0x74 && buffer[6] == 0x79 && buffer[7] == 0x70)
|
{
|
// MP4: 00 00 xx xx 66 74 79 70 // (size) f t y p
|
|
TRACE_1(IO, "* File type : ISO BMF (MOV,MP4, ...) container detected");
|
container = CONTAINER_MP4;
|
}
|
else if (buffer[4] == 0x73 && buffer[5] == 0x74 && buffer[6] == 0x79 && buffer[7] == 0x70)
|
{
|
// MP4: 00 00 xx xx 73 74 79 70 // (size) s t y p
|
|
TRACE_1(IO, "* File type : ISO BMF (MOV,MP4, ...) container detected");
|
container = CONTAINER_MP4;
|
}
|
}
|
else if (buffer[0] == 0x30 && buffer[1] == 0x26 && buffer[2] == 0xB2 && buffer[3] == 0x75)
|
{
|
TRACE_1(IO, "* File type : ASF container detected");
|
container = CONTAINER_ASF;
|
}
|
else if (buffer[0] == 0x4F && buffer[1] == 0x67 && buffer[2] == 0x67 && buffer[3] == 0x53)
|
{
|
TRACE_1(IO, "* File type : OGG container detected");
|
container = CONTAINER_OGG;
|
}
|
else if (buffer[0] == 0x66 && buffer[1] == 0x61 && buffer[2] == 0x4C && buffer[3] == 0x43)
|
{
|
TRACE_1(IO, "* File type : FLAC container detected");
|
container = CONTAINER_FLAC;
|
}
|
else if (buffer[0] == 0x06 && buffer[1] == 0x0E && buffer[2] == 0x2B && buffer[3] == 0x34)
|
{
|
TRACE_1(IO, "* File type : MXF container detected");
|
container = CONTAINER_MXF;
|
}
|
else if (buffer[0] == 0x46 && buffer[1] == 0x4C && buffer[2] == 0x56 && buffer[3] == 0x01)
|
{
|
TRACE_1(IO, "* File type : FLV container detected");
|
container = CONTAINER_FLV;
|
}
|
else if (buffer[0] == 0x63 && buffer[1] == 0x61 && buffer[2] == 0x66 && buffer[3] == 0x66)
|
{
|
TRACE_1(IO, "* File type : CAF container detected");
|
container = CONTAINER_CAF;
|
}
|
else if (buffer[0] == 0x2E && buffer[1] == 0x73 && buffer[2] == 0x6E && buffer[3] == 0x64)
|
{
|
// AU magic number: 2E 73 6E 64 // . s n d
|
TRACE_1(IO, "* File type : AU container detected");
|
container = CONTAINER_AU;
|
}
|
else if (buffer[0] == 0xFF &&
|
(buffer[1] == 0xFE || buffer[1] == 0xFD || buffer[1] == 0xFB))
|
{
|
TRACE_1(IO, "* File type : MP1/2/3 Elementary Stream detected");
|
container = CONTAINER_ES_MP3;
|
}
|
}
|
else
|
{
|
TRACE_ERROR(IO, "Container: no file header data provided...");
|
}
|
|
return container;
|
}
|
|
/*!
|
* \brief Detect the container used by a multimedia file.
|
* \param[in] *media: A pointer to a MediaFile_t structure, containing every informations available about the current media file.
|
* \return container: A ContainerFormat_e value.
|
*
|
* This function check the file extension to guess the container. As this method
|
* is *definitely* not reliable (file extensions are set by users, and users
|
* make mistakes) this code is here mostly for fun. And to list extensions for
|
* whoever is interested.
|
*/
|
Containers_e getContainerUsingExtension(const std::string &ext)
|
{
|
TRACE_2(IO, "getContainerUsingExtension()");
|
|
// Set container to unknown
|
Containers_e container = CONTAINER_UNKNOWN;
|
|
if (ext.size() > 0 && ext.size() < 8)
|
{
|
if (ext == "mov" || ext == "qt" || // QuickTime file format
|
ext == "mp4" || // ISO Base Media file format
|
ext == "m4v" || ext == "m4a" || ext == "m4p" || ext == "m4b" ||
|
ext == "m4s" || ext == "mp4v" || ext == "mp4a" ||
|
ext == "3gp" || ext == "3g2" || ext == "3gpp" || // ISO BMF / 3GP profile
|
ext == "f4v" || ext == "f4p" || ext == "f4a" || ext == "f4b" || // ISO BMF / Flash Video
|
ext == "mj2" || ext == "mjp2") // ISO BMF / Motion JPEG2000 profile
|
{
|
container = CONTAINER_MP4;
|
}
|
else if (ext == "webm" ||
|
ext == "mkv" || ext == "mka" || ext == "mks" || ext == "mk3d")
|
{
|
container = CONTAINER_MKV;
|
}
|
else if (ext == "avi" || ext == "divx")
|
{
|
container = CONTAINER_AVI;
|
}
|
else if (ext == "asf" || ext == "wma" || ext == "wmv")
|
{
|
container = CONTAINER_ASF;
|
}
|
else if (ext == "ps" || ext == "vob" || ext == "evo" ||
|
ext == "m2p" || ext == "m2v" || ext == "mpg" || ext == "mpeg")
|
{
|
container = CONTAINER_MPEG_PS;
|
}
|
else if (ext == "ts" || ext == "trp" ||
|
ext == "mts" || ext == "m2ts")
|
{
|
container = CONTAINER_MPEG_TS;
|
}
|
else if (ext == "mt" || ext == "mmt")
|
{
|
container = CONTAINER_MPEG_MT;
|
}
|
else if (ext == "ogg" || ext == "ogv" || ext == "oga" ||
|
ext == "ogx" || ext == "ogm" || ext == "spx" ||
|
ext == "opus")
|
{
|
container = CONTAINER_OGG;
|
}
|
else if (ext == "mxf")
|
{
|
container = CONTAINER_MXF;
|
}
|
else if (ext == "flv" || ext == "f4v" || ext == "f4p" || ext == "f4a" || ext == "f4b")
|
{
|
container = CONTAINER_FLV;
|
}
|
else if (ext == "swf")
|
{
|
container = CONTAINER_SWF;
|
}
|
else if (ext == "rm" || ext == "rmvb")
|
{
|
container = CONTAINER_RM;
|
}
|
else if (ext == "r3d")
|
{
|
container = CONTAINER_R3D;
|
}
|
|
else if (ext == "flac")
|
{
|
container = CONTAINER_FLAC;
|
}
|
else if (ext == "wav" || ext == "wave" || ext == "amb")
|
{
|
container = CONTAINER_WAVE;
|
}
|
else if (ext == "aiff" || ext == "aif" || ext == "aifc")
|
{
|
container = CONTAINER_AIFF;
|
}
|
else if (ext == "caf")
|
{
|
container = CONTAINER_CAF;
|
}
|
else if (ext == "au" || ext == "snd")
|
{
|
container = CONTAINER_AU;
|
}
|
|
else if (ext == "264" || ext == "h264")
|
{
|
container = CONTAINER_ES;
|
//codec = CODEC_H264;
|
}
|
else if (ext == "265" || ext == "h265")
|
{
|
container = CONTAINER_ES;
|
//codec = CODEC_H265;
|
}
|
else if (ext == "aac")
|
{
|
container = CONTAINER_ES_AAC;
|
//codec = CODEC_AAC;
|
}
|
else if (ext == "ac3")
|
{
|
container = CONTAINER_ES_AC3;
|
//codec = CODEC_AC3;
|
}
|
else if (ext == "mp1" || ext == "mp2" || ext == "mp3")
|
{
|
container = CONTAINER_ES_MP3;
|
//codec = CODEC_MP3;
|
}
|
|
else if (ext == "jpg" || ext == "jpeg" || ext == "jpe" ||
|
ext == "jif" || ext == "jfif" || ext == "jfi")
|
{
|
container = CONTAINER_JPEG;
|
//codec = CODEC_JPEG;
|
}
|
else if (ext == "jxr" || ext == "hdp" || ext == "wdp")
|
{
|
container = CONTAINER_JPEG_XR;
|
//codec = CODEC_JPEG_XR;
|
}
|
else if (ext == "jp2" || ext == "j2k" || ext == "jpf" ||
|
ext == "jpx" || ext == "jpm" || ext == "mj2")
|
{
|
container = CONTAINER_JPEG_2K;
|
//codec = CODEC_JPEG_2K;
|
}
|
else if (ext == "gif")
|
{
|
container = CONTAINER_GIF;
|
//codec = CODEC_GIF;
|
}
|
else if (ext == "bmp" || ext == "dib")
|
{
|
container = CONTAINER_BMP;
|
//codec = CODEC_BMP;
|
}
|
else if (ext == "tga" || ext == "icb" || ext == "vda" || ext == "vst")
|
{
|
container = CONTAINER_TGA;
|
//codec = CODEC_TGA;
|
}
|
else if (ext == "tif" || ext == "tiff")
|
{
|
container = CONTAINER_TIFF;
|
//codec = CODEC_TIFF;
|
}
|
else if (ext == "ico")
|
{
|
container = CONTAINER_ICO;
|
}
|
else if (ext == "icns")
|
{
|
container = CONTAINER_ICNS;
|
}
|
else if (ext == "png")
|
{
|
container = CONTAINER_PNG;
|
//codec = CODEC_PNG;
|
}
|
else if (ext == "dng")
|
{
|
container = CONTAINER_DNG;
|
//codec = CODEC_DNG;
|
}
|
else if (ext == "dpx")
|
{
|
container = CONTAINER_DPX;
|
}
|
else if (ext == "crw")
|
{
|
container = CONTAINER_CIFF;
|
}
|
else if (ext == "cr2")
|
{
|
container = CONTAINER_CR2;
|
}
|
else if (ext == "webp")
|
{
|
container = CONTAINER_WEBP;
|
//codec = CODEC_VP8;
|
}
|
else if (ext == "bpg")
|
{
|
container = CONTAINER_BPG;
|
//codec = CODEC_H265;
|
}
|
else if (ext == "flif")
|
{
|
container = CONTAINER_FLIF;
|
//codec = CODEC_FLIF16;
|
}
|
else if (ext == "heif" || ext == "heic" || ext == "avci")
|
{
|
container = CONTAINER_MP4;
|
//codec = CODEC_H265;
|
}
|
else if (ext == "avif")
|
{
|
container = CONTAINER_MP4;
|
//codec = CODEC_AV1;
|
}
|
|
TRACE_1(IO, "* File extension : '%s' detected", getContainerString(container));
|
}
|
else
|
{
|
TRACE_ERROR(IO, "Container: no extension provided...");
|
}
|
|
return container;
|
}
|
|
/* ************************************************************************** */
|
