/*!
|
* 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 2010
|
*/
|
|
// minivideo headers
|
#include "import.h"
|
#include "minitraces.h"
|
#include "minivideo_typedef.h"
|
#include "minivideo_containers.h"
|
// minivideo headers
|
#include "minivideo_mediafile.h"
|
|
// C standard libraries
|
#include <cstdio>
|
#include <cstdlib>
|
#include <cstring>
|
#include <cmath>
|
|
// C POSIX library
|
#ifdef _MSC_VER
|
#include <direct.h>
|
#define getcwd _getcwd
|
#else
|
#include <unistd.h>
|
#endif
|
|
/* ************************************************************************** */
|
|
/*!
|
* \brief Get various from a media filepath.
|
* \param[in] *media: A pointer to a MediaFile_t structure, containing every informations available about the current media file.
|
*
|
* Get absolute file path, file directory, file name and extension.
|
* This function will only work with Unix-style file systems.
|
*/
|
static void getInfosFromPath(MediaFile_t *media)
|
{
|
TRACE_2(IO, "getInfosFromPath()");
|
|
// Check if mediaFile->filepath is an absolute path
|
char *pos_first_slash_p = strchr(media->file_path, '/');
|
|
if ((pos_first_slash_p != NULL) && ((pos_first_slash_p - media->file_path) == 0))
|
{
|
TRACE_2(IO, "* mediaFile->file_path seems to be an absolute path already (first caracter is /)");
|
}
|
else
|
{
|
char cwd[4096];
|
char absolute_filepath[4096];
|
FILE *temp = NULL;
|
|
// First attempt
|
if (getcwd(cwd, sizeof(cwd)) != NULL)
|
{
|
strncpy(absolute_filepath, strncat(cwd, media->file_path, sizeof(cwd) - 1), sizeof(absolute_filepath) - 1);
|
temp = fopen(absolute_filepath, "rb");
|
}
|
|
if (temp != NULL)
|
{
|
TRACE_2(IO, "* New absolute file path found, new using method 1: '%s'", absolute_filepath);
|
strncpy(media->file_path, absolute_filepath, sizeof(media->file_path) - 1);
|
fclose(temp);
|
}
|
else
|
{
|
// Second attempt
|
if (getcwd(cwd, sizeof(cwd)) != NULL)
|
{
|
strncpy(absolute_filepath, strncat(cwd, "/", 1), sizeof(absolute_filepath) - 1);
|
strncat(absolute_filepath, media->file_path, sizeof(absolute_filepath) - 1);
|
temp = fopen(absolute_filepath, "rb");
|
}
|
|
if (temp != NULL)
|
{
|
TRACE_2(IO, "* New absolute file path found, new using method 2");
|
strncpy(media->file_path, absolute_filepath, sizeof(media->file_path) - 1);
|
fclose(temp);
|
}
|
else
|
{
|
TRACE_2(IO, "* mediaFile->file_path seems to be an absolute path already");
|
}
|
}
|
}
|
|
// Get directory
|
char *pos_last_slash_p = strrchr(media->file_path, '/');
|
if (pos_last_slash_p != NULL)
|
{
|
unsigned int pos_last_slash_i = pos_last_slash_p - media->file_path + 1;
|
if (pos_last_slash_i > sizeof(media->file_directory) - 1)
|
{
|
pos_last_slash_i = sizeof(media->file_directory) - 1;
|
}
|
|
// Set directory
|
strncpy(media->file_directory, media->file_path, pos_last_slash_i);
|
|
// Get file name
|
char *pos_last_dot_p = strrchr(media->file_path, '.');
|
if (pos_last_dot_p != NULL)
|
{
|
unsigned int pos_last_dot_i = pos_last_dot_p - media->file_path - pos_last_slash_i;
|
if (pos_last_dot_i > sizeof(media->file_name) - 1)
|
{
|
pos_last_dot_i = sizeof(media->file_name) - 1;
|
}
|
|
// Set file name
|
strncpy(media->file_name, pos_last_slash_p + 1, pos_last_dot_i);
|
|
// Set file extension (without the dot)
|
strncpy(media->file_extension, pos_last_dot_p + 1, sizeof(media->file_extension) - 1);
|
}
|
else
|
{
|
TRACE_WARNING(IO, "* Cannot find file extension!");
|
|
// Set file name (without the extension)
|
strncpy(media->file_name, pos_last_slash_p + 1, 254);
|
}
|
}
|
else
|
{
|
TRACE_WARNING(IO, "* Cannot find file directory, name and extension!");
|
}
|
|
// Print results
|
TRACE_1(IO, "* File path : '%s'", media->file_path);
|
TRACE_1(IO, "* File directory : '%s'", media->file_directory);
|
TRACE_1(IO, "* File name : '%s'", media->file_name);
|
TRACE_1(IO, "* File extension : '%s'", media->file_extension);
|
}
|
|
/* ************************************************************************** */
|
|
/*!
|
* \brief Get media file size.
|
* \param[in] *media: A pointer to a MediaFile_t structure containing various informations about the file.
|
*/
|
static void getSize(MediaFile_t *media)
|
{
|
TRACE_2(IO, "getSize()");
|
|
fseek(media->file_pointer, 0, SEEK_END);
|
media->file_size = (int64_t)ftell(media->file_pointer);
|
rewind(media->file_pointer);
|
|
if (media->file_size < 1024) // < 1 KiB
|
{
|
TRACE_1(IO, "* File size : %i bytes", media->file_size);
|
}
|
else if (media->file_size < 1048576) // < 1 MiB
|
{
|
TRACE_1(IO, "* File size : %.2f KiB (%.2f KB)", (double)media->file_size / 1024.0, (double)media->file_size / 1000.0);
|
}
|
else // >= 1 MiB
|
{
|
TRACE_1(IO, "* File size : %.2f MiB (%.2f MB)", (double)media->file_size / 1024.0 / 1024.0, (double)media->file_size / 1000.0 / 1000.0);
|
}
|
}
|
|
/* ************************************************************************** */
|
|
/*!
|
* \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.
|
*/
|
static void getContainer(MediaFile_t *media)
|
{
|
media->container = CONTAINER_UNKNOWN;
|
|
// Detect container format using start codes, by readind the first bytes of the file
|
rewind(media->file_pointer);
|
uint8_t buffer[16];
|
if (fread(buffer, sizeof(uint8_t), sizeof(buffer), media->file_pointer) == sizeof(buffer))
|
{
|
media->container = getContainerUsingStartcodes(buffer);
|
}
|
|
if (media->container == CONTAINER_UNKNOWN)
|
{
|
TRACE_WARNING(IO, "* Unknown container format: startcodes detection failed...");
|
|
// Fallback: detect container format using file extension
|
std::string ext = media->file_extension;
|
media->container = getContainerUsingExtension(ext);
|
|
if (media->container == CONTAINER_UNKNOWN)
|
{
|
TRACE_ERROR(IO, "* Unknown container format: file extension detection failed...");
|
}
|
}
|
}
|
|
/* ************************************************************************** */
|
/* ************************************************************************** */
|
|
/*!
|
* \brief Open a file and check what's inside it.
|
* \param[in] *filepath: The path of the file to load.
|
* \param[in,out] **media_ptr: A pointer to a MediaFile_t structure, containing every informations available about the current media file.
|
*
|
* Some more informations about supported files:
|
* Size and offset are coded on int64_t (signed long long), so this library should
|
* be able to handle file of 1073741824 GiB if Large File Support is enabled during
|
* compilation, 2 GiB otherwise.
|
* The filename is limited to 255 caracters (including file extension) and the
|
* complete filepath is limited to 4096 caracters.
|
*
|
* These parameters will only work on POSIX compliant operating system.
|
*/
|
int import_fileOpen(const char *filepath, MediaFile_t **media_ptr)
|
{
|
TRACE_INFO(IO, BLD_GREEN "import_fileOpen()" CLR_RESET);
|
|
int retcode = FAILURE;
|
|
if (filepath == NULL)
|
{
|
TRACE_ERROR(IO, "* File path is invalid");
|
}
|
else
|
{
|
// Allocate media structure and create a shortcut
|
*media_ptr = (MediaFile_t*)calloc(1, sizeof(MediaFile_t));
|
|
if (*media_ptr == NULL)
|
{
|
TRACE_ERROR(IO, "* Unable to allocate a MediaFile_t structure!");
|
}
|
else
|
{
|
MediaFile_t *media = (*media_ptr);
|
|
// Set filepath in MediaFile_t
|
strncpy(media->file_path, filepath, sizeof(media->file_path) - 1);
|
TRACE_INFO(IO, "* File path (raw): '%s'", filepath);
|
|
// Open file, read only
|
media->file_pointer = fopen(filepath, "rb");
|
|
if (media->file_pointer == NULL)
|
{
|
TRACE_ERROR(IO, "Unable to open the media file: '%s'!", filepath);
|
free(*media_ptr);
|
*media_ptr = NULL;
|
}
|
else
|
{
|
TRACE_1(IO, "* File successfully opened");
|
|
// Extract some informations from the media file
|
getInfosFromPath(media);
|
getSize(media);
|
getContainer(media);
|
|
retcode = SUCCESS;
|
}
|
}
|
}
|
|
return retcode;
|
}
|
|
/* ************************************************************************** */
|
|
/*!
|
* \brief Close a file.
|
* \param[in,out] **media_ptr: A pointer of pointer to a MediaFile_t structure.
|
* \return 1 if success, 0 otherwise.
|
*/
|
int import_fileClose(MediaFile_t **media_ptr)
|
{
|
TRACE_INFO(IO, BLD_GREEN "import_fileClose()" CLR_RESET);
|
int retcode = SUCCESS;
|
int i = 0;
|
|
if ((*media_ptr) != NULL)
|
{
|
if ((*media_ptr)->file_pointer != NULL)
|
{
|
if (fclose((*media_ptr)->file_pointer) == 0)
|
{
|
TRACE_1(IO, "* File successfully closed");
|
retcode = SUCCESS;
|
}
|
else
|
{
|
TRACE_ERROR(IO, "Unable to close that file!");
|
retcode = FAILURE;
|
}
|
}
|
|
{
|
free(*media_ptr);
|
*media_ptr = NULL;
|
|
TRACE_1(IO, ">> MediaFile freed");
|
}
|
}
|
|
return retcode;
|
}
|
|
/* ************************************************************************** */
|
|
/*!
|
* \brief Print various informations about a file.
|
* \param[in] *media: A pointer to a MediaFile_t structure, containing every informations available about the current media file.
|
*/
|
void import_fileStatus(MediaFile_t *media)
|
{
|
TRACE_INFO(IO, BLD_GREEN "import_fileStatus()" CLR_RESET);
|
|
unsigned i = 0;
|
|
// File
|
if (media->file_pointer)
|
{
|
TRACE_1(IO, "file_pointer is " BLD_GREEN "open" CLR_RESET);
|
}
|
else
|
{
|
TRACE_1(IO, "file_pointer is " BLD_RED "closed" CLR_RESET);
|
}
|
|
// File info
|
TRACE_1(IO, "* File path : '%s'", media->file_path);
|
TRACE_1(IO, "* File directory : '%s'", media->file_directory);
|
TRACE_1(IO, "* File name : '%s'", media->file_name);
|
TRACE_1(IO, "* File extension : '%s'", media->file_extension);
|
TRACE_1(IO, "* File size : %i MiB / %i MB",
|
media->file_size / 1024 / 1024,
|
media->file_size / 1000 / 1000);
|
|
// File format
|
TRACE_1(IO, "* File container : '%s'", getContainerString(media->container, 1));
|
|
}
|
|
/* ************************************************************************** */
|
