mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
623 lines
21 KiB
623 lines
21 KiB
/* |
|
Copyright (c) 2012, Broadcom Europe Ltd |
|
All rights reserved. |
|
|
|
Redistribution and use in source and binary forms, with or without |
|
modification, are permitted provided that the following conditions are met: |
|
* Redistributions of source code must retain the above copyright |
|
notice, this list of conditions and the following disclaimer. |
|
* Redistributions in binary form must reproduce the above copyright |
|
notice, this list of conditions and the following disclaimer in the |
|
documentation and/or other materials provided with the distribution. |
|
* Neither the name of the copyright holder nor the |
|
names of its contributors may be used to endorse or promote products |
|
derived from this software without specific prior written permission. |
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY |
|
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
*/ |
|
#include <stdlib.h> |
|
#include <limits.h> |
|
#include <string.h> |
|
#include <stdio.h> |
|
#include "containers/containers.h" |
|
#include "containers/core/containers_common.h" |
|
#include "containers/core/containers_logging.h" |
|
#include "containers/core/containers_utils.h" |
|
#include "containers/core/containers_io.h" |
|
|
|
#define BUFFER_SIZE 256*1024 |
|
#define MAX_TRACKS 16 |
|
#define MAX_SEEKS 16 |
|
|
|
static int container_test_info(VC_CONTAINER_T *ctx, bool b_reader); |
|
static int container_test_parse_cmdline(int argc, char **argv); |
|
|
|
/* Client i/o wrapper */ |
|
static VC_CONTAINER_IO_T *client_io_open(const char *, VC_CONTAINER_STATUS_T *); |
|
|
|
static bool b_info = 0, b_seek = 0, b_dump = 0; |
|
static bool b_audio = 1, b_video = 1, b_subs = 1, b_errorcode = 1; |
|
static const char *psz_in = 0, *psz_out = 0; |
|
static long packets_num = 0; |
|
static long track_num = -1; |
|
static FILE *dump_file = 0; |
|
static bool b_client_io = 0; |
|
static bool b_packetize = 0; |
|
|
|
static struct |
|
{ |
|
uint32_t mapping; |
|
uint32_t frames; |
|
uint32_t packets; |
|
uint64_t bytes; |
|
uint32_t frame_size; |
|
int64_t first_dts; |
|
int64_t first_pts; |
|
int64_t last_dts; |
|
int64_t last_pts; |
|
} tracks[MAX_TRACKS]; |
|
|
|
static unsigned int seeks = 0; |
|
static long seek_offsets[MAX_SEEKS]; |
|
static long seek_flags[MAX_SEEKS]; |
|
static int32_t verbosity = VC_CONTAINER_LOG_ERROR|VC_CONTAINER_LOG_INFO; |
|
static int32_t verbosity_input = -1, verbosity_output = -1; |
|
|
|
/*****************************************************************************/ |
|
int main(int argc, char **argv) |
|
{ |
|
int retval = 0; |
|
VC_CONTAINER_T *p_ctx = 0, *p_writer_ctx = 0; |
|
VC_CONTAINER_STATUS_T status; |
|
unsigned int i, j; |
|
uint8_t *buffer = malloc(BUFFER_SIZE); |
|
int64_t seek_time; |
|
|
|
if(container_test_parse_cmdline(argc, argv)) |
|
goto error_silent; |
|
|
|
/* Set the general verbosity */ |
|
vc_container_log_set_verbosity(0, verbosity); |
|
|
|
if(verbosity_input < 0) verbosity_input = verbosity; |
|
if(verbosity_output < 0) verbosity_output = verbosity; |
|
|
|
/* Open a dump file if it was requested */ |
|
if(b_dump) |
|
{ |
|
char *psz_dump; |
|
|
|
if (psz_out) |
|
{ |
|
psz_dump = vcos_strdup(psz_out); |
|
} else { |
|
psz_dump = strrchr(psz_in, '\\'); if(psz_dump) psz_dump++; |
|
if(!psz_dump) {psz_dump = strrchr(psz_in, '/'); if(psz_dump) psz_dump++;} |
|
if(!psz_dump) psz_dump = vcos_strdup(psz_in); |
|
else psz_dump = vcos_strdup(psz_dump); |
|
psz_dump[strlen(psz_dump)-1] = '1'; |
|
} |
|
dump_file = fopen(psz_dump, "wb"); |
|
if(!dump_file) LOG_ERROR(0, "error opening dump file %s", psz_dump); |
|
else LOG_INFO(0, "data packets will dumped to %s", psz_dump); |
|
free(psz_dump); |
|
if(!dump_file) goto error; |
|
} |
|
|
|
/* Open a writer if an output was requested */ |
|
if(psz_out && !b_dump) |
|
{ |
|
vc_container_log_set_default_verbosity(verbosity_output); |
|
p_writer_ctx = vc_container_open_writer(psz_out, &status, 0, 0); |
|
if(!p_writer_ctx) |
|
{ |
|
LOG_ERROR(0, "error opening file %s (%i)", psz_out, status); |
|
goto error; |
|
} |
|
} |
|
|
|
vc_container_log_set_default_verbosity(verbosity_input); |
|
|
|
/* Open the container */ |
|
if(b_client_io) |
|
{ |
|
VC_CONTAINER_IO_T *p_io; |
|
|
|
LOG_INFO(0, "Using client I/O for %s", psz_in); |
|
p_io = client_io_open(psz_in, &status); |
|
if(!p_io) |
|
{ |
|
LOG_ERROR(0, "error creating io for %s (%i)", psz_in, status); |
|
goto error; |
|
} |
|
|
|
p_ctx = vc_container_open_reader_with_io(p_io, psz_in, &status, 0, 0); |
|
if(!p_ctx) |
|
vc_container_io_close(p_io); |
|
} |
|
else |
|
{ |
|
p_ctx = vc_container_open_reader(psz_in, &status, 0, 0); |
|
} |
|
|
|
if(!p_ctx) |
|
{ |
|
LOG_ERROR(0, "error opening file %s (%i)", psz_in, status); |
|
goto error; |
|
} |
|
|
|
/* Disabling tracks which are not requested and enable packetisation if requested */ |
|
for(i = 0; i < p_ctx->tracks_num; i++) |
|
{ |
|
VC_CONTAINER_TRACK_T *track = p_ctx->tracks[i]; |
|
unsigned int disable = 0; |
|
|
|
switch(track->format->es_type) |
|
{ |
|
case VC_CONTAINER_ES_TYPE_VIDEO: if(!b_video) disable = 1; break; |
|
case VC_CONTAINER_ES_TYPE_AUDIO: if(!b_audio) disable = 1; break; |
|
case VC_CONTAINER_ES_TYPE_SUBPICTURE: if(!b_subs) disable = 1; break; |
|
default: break; |
|
} |
|
if(disable) |
|
{ |
|
track->is_enabled = 0; |
|
LOG_INFO(0, "disabling track: %i, fourcc: %4.4s", i, (char *)&track->format->codec); |
|
} |
|
|
|
if(track->is_enabled && b_packetize && !(track->format->flags & VC_CONTAINER_ES_FORMAT_FLAG_FRAMED)) |
|
{ |
|
status = vc_container_control(p_ctx, VC_CONTAINER_CONTROL_TRACK_PACKETIZE, i, track->format->codec_variant); |
|
if(status != VC_CONTAINER_SUCCESS) |
|
{ |
|
LOG_ERROR(0, "packetization not supported on track: %i, fourcc: %4.4s", i, (char *)&track->format->codec); |
|
track->is_enabled = 0; |
|
} |
|
} |
|
} |
|
|
|
container_test_info(p_ctx, true); |
|
if(b_info) goto end; |
|
|
|
if(p_writer_ctx) |
|
{ |
|
LOG_INFO(0, "----Writer Information----"); |
|
for(i = 0; i < p_ctx->tracks_num; i++) |
|
{ |
|
VC_CONTAINER_TRACK_T *track = p_ctx->tracks[i]; |
|
if(!track->is_enabled) continue; |
|
tracks[p_writer_ctx->tracks_num].mapping = i; |
|
LOG_INFO(0, "adding track: %i, fourcc: %4.4s", i, (char *)&track->format->codec); |
|
status = vc_container_control(p_writer_ctx, VC_CONTAINER_CONTROL_TRACK_ADD, track->format); |
|
if(status) |
|
{ |
|
LOG_INFO(0, "unsupported track type (%i, %i)", status, i); |
|
track->is_enabled = 0; /* disable track */ |
|
} |
|
} |
|
if(p_writer_ctx->tracks_num) |
|
{ |
|
status = vc_container_control(p_writer_ctx, VC_CONTAINER_CONTROL_TRACK_ADD_DONE); |
|
if(status) LOG_INFO(0, "could not add tracks (%i)", status); |
|
} |
|
LOG_INFO(0, "--------------------------"); |
|
LOG_INFO(0, ""); |
|
} |
|
|
|
for(i = 0; i < seeks; i++) |
|
{ |
|
LOG_DEBUG(0, "TEST seek to %ims", seek_offsets[i]); |
|
seek_time = ((int64_t)(seek_offsets[i])) * 1000; |
|
status = vc_container_seek(p_ctx, &seek_time, VC_CONTAINER_SEEK_MODE_TIME, seek_flags[i]); |
|
LOG_DEBUG(0, "TEST seek done (%i) to %ims", status, (int)(seek_time/1000)); |
|
} |
|
|
|
LOG_DEBUG(0, "TEST start reading"); |
|
for(i = 0; !packets_num || (long)i < packets_num; i++) |
|
{ |
|
VC_CONTAINER_PACKET_T packet = {0}; |
|
int32_t frame_num = 0; |
|
|
|
status = vc_container_read(p_ctx, &packet, VC_CONTAINER_READ_FLAG_INFO); |
|
if(status != VC_CONTAINER_SUCCESS) {LOG_DEBUG(0, "TEST info status: %i", status); break;} |
|
|
|
if(packet.track < MAX_TRACKS) |
|
{ |
|
if((packet.flags & VC_CONTAINER_PACKET_FLAG_FRAME_START)) |
|
{ |
|
tracks[packet.track].frames++; |
|
tracks[packet.track].frame_size = 0; |
|
} |
|
frame_num = tracks[packet.track].frames; |
|
} |
|
|
|
tracks[packet.track].frame_size += packet.size; |
|
|
|
LOG_DEBUG(0, "packet info: track %i, size %i/%i/%i, pts %"PRId64", flags %x%s, num %i", |
|
packet.track, packet.size, packet.frame_size, tracks[packet.track].frame_size, packet.pts, packet.flags, |
|
(packet.flags & VC_CONTAINER_PACKET_FLAG_KEYFRAME) ? " (keyframe)" : "", |
|
frame_num-1); |
|
|
|
if(track_num >= 0 && packet.track != (uint32_t)track_num) |
|
{ |
|
status = vc_container_read(p_ctx, 0, VC_CONTAINER_READ_FLAG_SKIP); |
|
if(status != VC_CONTAINER_SUCCESS) {LOG_DEBUG(0, "TEST skip status: %i", status); break;} |
|
continue; |
|
} |
|
|
|
packet.buffer_size = BUFFER_SIZE; |
|
packet.data = buffer; |
|
packet.size = 0; |
|
status = vc_container_read(p_ctx, &packet, 0); |
|
if(status != VC_CONTAINER_SUCCESS) {LOG_DEBUG(0, "TEST read status: %i", status); break;} |
|
|
|
LOG_DEBUG(0, "packet: track %i, size %i, pts %"PRId64", flags %x", packet.track, packet.size, packet.pts, packet.flags); |
|
|
|
if (tracks[packet.track].packets) |
|
{ |
|
tracks[packet.track].last_dts = packet.dts; |
|
tracks[packet.track].last_pts = packet.pts; |
|
} else { |
|
tracks[packet.track].first_dts = packet.dts; |
|
tracks[packet.track].first_pts = packet.pts; |
|
} |
|
|
|
if(packet.track < MAX_TRACKS) |
|
{ |
|
tracks[packet.track].packets++; |
|
tracks[packet.track].bytes += packet.size; |
|
} |
|
|
|
if(dump_file) fwrite(packet.data, packet.size, 1, dump_file); |
|
|
|
if(p_writer_ctx) |
|
{ |
|
packet.track = tracks[packet.track].mapping; |
|
status = vc_container_write(p_writer_ctx, &packet); |
|
if(status != VC_CONTAINER_SUCCESS) {LOG_DEBUG(0, "TEST write status: %i", status); break;} |
|
} |
|
} |
|
LOG_DEBUG(0, "TEST stop reading"); |
|
|
|
if(b_seek) |
|
{ |
|
LOG_DEBUG(0, "TEST start seeking"); |
|
for(j = 0, seek_time = 100; j < 20; j++) |
|
{ |
|
LOG_DEBUG(0, "seeking to %ims", (int)(seek_time/1000)); |
|
status = vc_container_seek(p_ctx, &seek_time, VC_CONTAINER_SEEK_MODE_TIME, VC_CONTAINER_SEEK_FLAG_FORWARD); |
|
LOG_DEBUG(0, "seek done (%i) to %ims", status, (int)(seek_time/1000)); |
|
|
|
for(i = 0; i < 1; i++) |
|
{ |
|
VC_CONTAINER_PACKET_T packet = {0}; |
|
packet.buffer_size = BUFFER_SIZE; |
|
packet.data = buffer; |
|
|
|
status = vc_container_read(p_ctx, &packet, 0); |
|
if(status) LOG_DEBUG(0, "TEST read status: %i", status); |
|
if(status == VC_CONTAINER_ERROR_EOS) break; |
|
if(status == VC_CONTAINER_ERROR_CORRUPTED) break; |
|
if(status == VC_CONTAINER_ERROR_FORMAT_INVALID) break; |
|
seek_time = packet.pts + 800000; |
|
} |
|
} |
|
LOG_DEBUG(0, "TEST stop seeking"); |
|
} |
|
|
|
/* Output stats */ |
|
for(i = 0; i < p_ctx->tracks_num; i++) |
|
{ |
|
LOG_INFO(0, "track %u: read %u samples in %u packets for a total of %"PRIu64" bytes", |
|
i, tracks[i].frames, tracks[i].packets, tracks[i].bytes); |
|
LOG_INFO(0, "Starting at %"PRId64"us (decode at %"PRId64"us), ending at %"PRId64"us (decode at %"PRId64"us)", |
|
tracks[i].first_pts, tracks[i].first_dts, tracks[i].last_pts, tracks[i].last_dts); |
|
} |
|
|
|
end: |
|
if(p_ctx) vc_container_close(p_ctx); |
|
if(p_writer_ctx) |
|
{ |
|
container_test_info(p_writer_ctx, false); |
|
vc_container_close(p_writer_ctx); |
|
} |
|
if(dump_file) fclose(dump_file); |
|
free(buffer); |
|
|
|
#ifdef _MSC_VER |
|
getchar(); |
|
#endif |
|
|
|
LOG_ERROR(0, "TEST ENDED (%i)", retval); |
|
return b_errorcode ? retval : 0; |
|
|
|
error: |
|
LOG_ERROR(0, "TEST FAILED"); |
|
error_silent: |
|
retval = -1; |
|
goto end; |
|
} |
|
|
|
static int container_test_parse_cmdline(int argc, char **argv) |
|
{ |
|
int i, j, k; |
|
int32_t *p_verbosity; |
|
|
|
/* Parse the command line arguments */ |
|
for(i = 1; i < argc; i++) |
|
{ |
|
if(!argv[i]) continue; |
|
|
|
if(argv[i][0] != '-') |
|
{ |
|
/* Not an option argument so will be the input URI */ |
|
psz_in = argv[i]; |
|
continue; |
|
} |
|
|
|
/* We are now dealing with command line options */ |
|
switch(argv[i][1]) |
|
{ |
|
case 'i': b_info = 1; break; |
|
case 'S': b_seek = 1; break; |
|
case 'd': b_dump = 1; break; |
|
case 'c': b_client_io = 1; break; |
|
case 'v': |
|
if(argv[i][2] == 'i') {j = 3; p_verbosity = &verbosity_input;} |
|
else if(argv[i][2] == 'o') {j = 3; p_verbosity = &verbosity_output;} |
|
else {j = 2; p_verbosity = &verbosity;} |
|
*p_verbosity = VC_CONTAINER_LOG_ERROR|VC_CONTAINER_LOG_INFO; |
|
for(k = 0; k < 2 && argv[i][j+k] == 'v'; k++) |
|
*p_verbosity = (*p_verbosity << 1) | 1 ; |
|
break; |
|
case 's': |
|
if(i+1 == argc || !argv[i+1]) goto invalid_option; |
|
if(seeks >= MAX_SEEKS) goto invalid_option; |
|
seek_flags[seeks] = argv[i][2] == 'f' ? VC_CONTAINER_SEEK_FLAG_FORWARD : 0; |
|
seek_offsets[seeks] = strtol(argv[++i], 0, 0); |
|
if(seek_offsets[seeks] < 0 || seek_offsets[seeks] == LONG_MAX) goto invalid_option; |
|
seeks++; |
|
break; |
|
case 'n': |
|
if(argv[i][2] == 'a') b_audio = 0; |
|
else if(argv[i][2] == 'v') b_video = 0; |
|
else if(argv[i][2] == 's') b_subs = 0; |
|
else if(argv[i][2] == 'r') b_errorcode = 0; |
|
else goto invalid_option; |
|
break; |
|
case 'e': |
|
if(argv[i][2] == 'p') b_packetize = 1; |
|
else goto invalid_option; |
|
break; |
|
case 'o': |
|
if(i+1 == argc || !argv[i+1] || argv[i+1][0] == '-') goto invalid_option; |
|
psz_out = argv[++i]; |
|
break; |
|
case 'p': |
|
if(i+1 == argc || !argv[i+1]) goto invalid_option; |
|
packets_num = strtol(argv[++i], 0, 0); |
|
if(packets_num < 0 || packets_num == LONG_MAX) goto invalid_option; |
|
break; |
|
case 't': |
|
if(i+1 == argc || !argv[i+1]) goto invalid_option; |
|
track_num = strtol(argv[++i], 0, 0); |
|
if(track_num == LONG_MIN || track_num == LONG_MAX) goto invalid_option; |
|
break; |
|
case 'h': goto usage; |
|
default: goto invalid_option; |
|
} |
|
continue; |
|
} |
|
|
|
/* Sanity check that we have at least an input uri */ |
|
if(!psz_in) |
|
{ |
|
LOG_ERROR(0, "missing uri argument"); |
|
goto usage; |
|
} |
|
|
|
return 0; |
|
|
|
invalid_option: |
|
LOG_ERROR(0, "invalid command line option (%s)", argv[i]); |
|
|
|
usage: |
|
psz_in = strrchr(argv[0], '\\'); if(psz_in) psz_in++; |
|
if(!psz_in) {psz_in = strrchr(argv[0], '/'); if(psz_in) psz_in++;} |
|
if(!psz_in) psz_in = argv[0]; |
|
LOG_INFO(0, ""); |
|
LOG_INFO(0, "usage: %s [options] uri", psz_in); |
|
LOG_INFO(0, "options list:"); |
|
LOG_INFO(0, " -i : only print information on the container"); |
|
LOG_INFO(0, " -p X : read only X packets from the container"); |
|
LOG_INFO(0, " -t X : read only packets from track X"); |
|
LOG_INFO(0, " -s X : seek to X milliseconds before starting reading"); |
|
LOG_INFO(0, " -sf X : seek forward to X milliseconds before starting reading"); |
|
LOG_INFO(0, " -S : do seek testing"); |
|
LOG_INFO(0, " -d : dump the data read from the container to files (-o to name file)"); |
|
LOG_INFO(0, " -o uri: output to another uri (i.e. re-muxing)"); |
|
LOG_INFO(0, " -na : disable audio"); |
|
LOG_INFO(0, " -nv : disable video"); |
|
LOG_INFO(0, " -ns : disable subtitles"); |
|
LOG_INFO(0, " -nr : always return an error code of 0 (even in case of failure)"); |
|
LOG_INFO(0, " -ep : enable packetization if data is not already packetized"); |
|
LOG_INFO(0, " -c : use the client i/o functions"); |
|
LOG_INFO(0, " -vxx : general verbosity level (replace xx with a number of \'v\')"); |
|
LOG_INFO(0, " -vixx : verbosity specific to the input container"); |
|
LOG_INFO(0, " -voxx : verbosity specific to the output container"); |
|
LOG_INFO(0, " -h : help"); |
|
return 1; |
|
} |
|
|
|
static int container_test_info(VC_CONTAINER_T *ctx, bool b_reader) |
|
{ |
|
const char *name_type; |
|
unsigned int i; |
|
|
|
LOG_INFO(0, ""); |
|
if(b_reader) LOG_INFO(0, "----Reader Information----"); |
|
else LOG_INFO(0, "----Writer Information----"); |
|
|
|
LOG_INFO(0, "duration: %2.2fs, size: %"PRId64, ctx->duration/1000000.0, ctx->size); |
|
LOG_INFO(0, "capabilities: %x", ctx->capabilities); |
|
LOG_INFO(0, ""); |
|
|
|
for(i = 0; i < ctx->tracks_num; i++) |
|
{ |
|
VC_CONTAINER_TRACK_T *track = ctx->tracks[i]; |
|
|
|
switch(track->format->es_type) |
|
{ |
|
case VC_CONTAINER_ES_TYPE_AUDIO: name_type = "audio"; break; |
|
case VC_CONTAINER_ES_TYPE_VIDEO: name_type = "video"; break; |
|
case VC_CONTAINER_ES_TYPE_SUBPICTURE: name_type = "subpicture"; break; |
|
default: name_type = "unknown"; break; |
|
} |
|
|
|
LOG_INFO(0, "track: %i, type: %s, fourcc: %4.4s", i, name_type, (char *)&track->format->codec); |
|
LOG_INFO(0, " bitrate: %i, framed: %i, enabled: %i", track->format->bitrate, |
|
!!(track->format->flags & VC_CONTAINER_ES_FORMAT_FLAG_FRAMED), track->is_enabled); |
|
LOG_INFO(0, " extra data: %i, %p", track->format->extradata_size, track->format->extradata); |
|
switch(track->format->es_type) |
|
{ |
|
case VC_CONTAINER_ES_TYPE_AUDIO: |
|
LOG_INFO(0, " samplerate: %i, channels: %i, bps: %i, block align: %i", |
|
track->format->type->audio.sample_rate, track->format->type->audio.channels, |
|
track->format->type->audio.bits_per_sample, track->format->type->audio.block_align); |
|
LOG_INFO(0, " gapless delay: %i gapless padding: %i", |
|
track->format->type->audio.gap_delay, track->format->type->audio.gap_padding); |
|
LOG_INFO(0, " language: %4.4s", track->format->language); |
|
break; |
|
|
|
case VC_CONTAINER_ES_TYPE_VIDEO: |
|
LOG_INFO(0, " width: %i, height: %i, (%i,%i,%i,%i)", |
|
track->format->type->video.width, track->format->type->video.height, |
|
track->format->type->video.x_offset, track->format->type->video.y_offset, |
|
track->format->type->video.visible_width, track->format->type->video.visible_height); |
|
LOG_INFO(0, " pixel aspect ratio: %i/%i, frame rate: %i/%i", |
|
track->format->type->video.par_num, track->format->type->video.par_den, |
|
track->format->type->video.frame_rate_num, track->format->type->video.frame_rate_den); |
|
break; |
|
|
|
case VC_CONTAINER_ES_TYPE_SUBPICTURE: |
|
LOG_INFO(0, " language: %4.4s, encoding: %i", track->format->language, |
|
track->format->type->subpicture.encoding); |
|
break; |
|
|
|
default: break; |
|
} |
|
} |
|
|
|
for (i = 0; i < ctx->meta_num; ++i) |
|
{ |
|
const char *name, *value; |
|
if (i == 0) LOG_INFO(0, ""); |
|
name = vc_container_metadata_id_to_string(ctx->meta[i]->key); |
|
value = ctx->meta[i]->value; |
|
if(!name) continue; |
|
LOG_INFO(0, "metadata(%i) : %s : %s", i, name, value); |
|
} |
|
|
|
LOG_INFO(0, "--------------------------"); |
|
LOG_INFO(0, ""); |
|
|
|
return 0; |
|
} |
|
|
|
/***************************************************************************** |
|
* Client I/O wrapper. Only used when the right cmd line option is passed. |
|
*****************************************************************************/ |
|
static VC_CONTAINER_STATUS_T client_io_close( VC_CONTAINER_IO_T *p_ctx ) |
|
{ |
|
FILE *fd = (FILE *)p_ctx->module; |
|
fclose(fd); |
|
return VC_CONTAINER_SUCCESS; |
|
} |
|
|
|
/*****************************************************************************/ |
|
static size_t client_io_read(VC_CONTAINER_IO_T *p_ctx, void *buffer, size_t size) |
|
{ |
|
FILE *fd = (FILE *)p_ctx->module; |
|
size_t ret = fread(buffer, 1, size, fd); |
|
if(ret != size) |
|
{ |
|
/* Sanity check return value. Some platforms (e.g. Android) can return -1 */ |
|
if( ((int)ret) < 0 ) ret = 0; |
|
|
|
if( feof(fd) ) p_ctx->status = VC_CONTAINER_ERROR_EOS; |
|
else p_ctx->status = VC_CONTAINER_ERROR_FAILED; |
|
} |
|
LOG_DEBUG( 0, "read: %i", ret ); |
|
return ret; |
|
} |
|
|
|
/*****************************************************************************/ |
|
static VC_CONTAINER_STATUS_T client_io_seek(VC_CONTAINER_IO_T *p_ctx, int64_t offset) |
|
{ |
|
VC_CONTAINER_STATUS_T status = VC_CONTAINER_SUCCESS; |
|
FILE *fd = (FILE *)p_ctx->module; |
|
int ret; |
|
|
|
//FIXME: no large file support |
|
if (offset > (int64_t)UINT_MAX) |
|
{ |
|
LOG_ERROR( 0, "no large file support"); |
|
p_ctx->status = VC_CONTAINER_ERROR_EOS; |
|
return VC_CONTAINER_ERROR_EOS; |
|
} |
|
|
|
ret = fseek(fd, (long)offset, SEEK_SET); |
|
if(ret) |
|
{ |
|
if( feof(fd) ) status = VC_CONTAINER_ERROR_EOS; |
|
else status = VC_CONTAINER_ERROR_FAILED; |
|
} |
|
|
|
p_ctx->status = status; |
|
return status; |
|
} |
|
|
|
/*****************************************************************************/ |
|
static VC_CONTAINER_IO_T *client_io_open( const char *psz_uri, VC_CONTAINER_STATUS_T *status ) |
|
{ |
|
VC_CONTAINER_IO_T *p_io; |
|
VC_CONTAINER_IO_CAPABILITIES_T capabilities = VC_CONTAINER_IO_CAPS_NO_CACHING; |
|
FILE *fd; |
|
|
|
fd = fopen(psz_uri, "rb"); |
|
if (!fd) |
|
{ |
|
*status = VC_CONTAINER_ERROR_URI_OPEN_FAILED; |
|
return NULL; |
|
} |
|
|
|
p_io = vc_container_io_create( psz_uri, 0, capabilities, status ); |
|
if(!p_io) |
|
{ |
|
LOG_ERROR(0, "error creating io (%i)", *status); |
|
fclose(fd); |
|
return NULL; |
|
} |
|
|
|
p_io->module = (struct VC_CONTAINER_IO_MODULE_T *)fd; |
|
p_io->pf_close = client_io_close; |
|
p_io->pf_read = client_io_read; |
|
p_io->pf_seek = client_io_seek; |
|
|
|
//FIXME: no large file support |
|
fseek(fd, 0, SEEK_END); |
|
p_io->size = ftell(fd); |
|
fseek(fd, 0, SEEK_SET); |
|
|
|
*status = VC_CONTAINER_SUCCESS; |
|
return p_io; |
|
}
|
|
|