video_export.c File Reference

#include <assert.h>
#include <compat/platform_semaphore.h>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "types.h"
#include "utils/fs.h"
#include "video_codec.h"
#include "video_export.h"
#include "video_frame.h"

Include dependency graph for video_export.c:

Go to the source code of this file.

Classes
struct	output_entry
struct	video_export

Macros
#define	MAX_QUEUE_SIZE   300

Functions
void	output_summary (struct video_export *s)
void	video_export (struct video_export *s, struct video_frame *frame)
void	video_export_destroy (struct video_export *s)
struct video_export *	video_export_init (const char *path)
static void *	video_export_thread (void *arg)

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file video_export.c.

Macro Definition Documentation

MAX_QUEUE_SIZE

#define MAX_QUEUE_SIZE   300

Definition at line 52 of file video_export.c.

Referenced by hd_rum_decompress::state_transcoder_decompress::frame_arrived(), and video_export().

Function Documentation

output_summary()

void output_summary

(

struct video_export *

s

)

Definition at line 148 of file video_export.c.

{
        char name[MAX_PATH_SIZE];
        snprintf(name, sizeof name, "%s/video.info", s->path);
 
        FILE *summary = fopen(name, "w");
 
        if(!summary) {
                perror("Cannot write video export summary file");
                return;
        }
 
        fprintf(summary, "version %d\n", VIDEO_EXPORT_SUMMARY_VERSION);
        fprintf(summary, "width %d\n", s->saved_desc.width);
        fprintf(summary, "height %d\n", s->saved_desc.height);
        uint32_t fourcc = get_fourcc(s->saved_desc.color_spec);
        fprintf(summary, "fourcc %.4s\n", (char *) &fourcc);
        fprintf(summary, "fps %.2f\n", s->saved_desc.fps);
        fprintf(summary, "interlacing %d\n", (int) s->saved_desc.interlacing);
        fprintf(summary, "count %d\n", s->total);
 
        fclose(summary);
}

References video_desc::color_spec, video_desc::fps, get_fourcc(), video_desc::height, video_desc::interlacing, MAX_PATH_SIZE, name, video_export::path, video_export::saved_desc, video_export::total, VIDEO_EXPORT_SUMMARY_VERSION, and video_desc::width.

Referenced by video_export_destroy().

Here is the call graph for this function:

video_export()

void video_export	(	struct video_export *	s,
		struct video_frame *	frame )

Definition at line 203 of file video_export.c.

{
        if(!s) {
                return;
        }
 
        assert(frame != NULL);
        s->total += 1;
 
        if(s->saved_desc.width == 0) {
                s->saved_desc = video_desc_from_frame(frame);
        } else {
                if(!video_desc_eq(s->saved_desc, video_desc_from_frame(frame))) {
                        fprintf(stderr, "[Video export] Format change detected, not exporting.\n");
                        return;
                }
        }
 
        for (unsigned int i = 0; i < frame->tile_count; ++i) {
                assert(frame->tiles[i].data != NULL && frame->tiles[i].data_len != 0);
 
                struct output_entry *entry = malloc(sizeof(struct output_entry));
 
                entry->data_len = frame->tiles[i].data_len;
                entry->data = (char *) malloc(entry->data_len);
                entry->filename = malloc(MAX_PATH_SIZE);
                entry->next = NULL;
 
                if(frame->tile_count == 1) {
                        snprintf(entry->filename, MAX_PATH_SIZE, "%s/%08d.%s", s->path,
                                 s->total,
                                 get_codec_file_extension(frame->color_spec));
                } else {
                        // add also tile index
                        snprintf(entry->filename, MAX_PATH_SIZE, "%s/%08d_%d.%s", s->path,
                                 s->total, i,
                                 get_codec_file_extension(frame->color_spec));
                }
                memcpy(entry->data, frame->tiles[i].data, entry->data_len);
 
                pthread_mutex_lock(&s->lock);
                {
                        // check if we do not occupy too much memory
                        if(s->queue_len >= MAX_QUEUE_SIZE) {
                                fprintf(stderr, "[Video export] Maximal queue size (%d) exceeded, not saving frame %d.\n",
                                                MAX_QUEUE_SIZE,
                                                s->total); // we increment total size to keep the index
                                pthread_mutex_unlock(&s->lock);
                                free(entry->data);
                                free(entry);
                                return;
                        }
 
                        if(s->head) {
                                s->tail->next = entry;
                                s->tail = entry;
                        } else {
                                s->head = s->tail = entry;
                        }
                        s->queue_len += 1;
                }
                pthread_mutex_unlock(&s->lock);
 
                platform_sem_post(&s->semaphore);
        }
}

References video_frame::color_spec, output_entry::data, tile::data, output_entry::data_len, tile::data_len, output_entry::filename, frame, get_codec_file_extension(), video_export::head, video_export::lock, MAX_PATH_SIZE, MAX_QUEUE_SIZE, output_entry::next, video_export::path, platform_sem_post(), video_export::queue_len, video_export::saved_desc, video_export::semaphore, video_export::tail, video_frame::tile_count, video_frame::tiles, video_export::total, video_desc_eq(), video_desc_from_frame(), and video_desc::width.

Referenced by export_video().

Here is the call graph for this function:

video_export_destroy()

void video_export_destroy

(

struct video_export *

s

)

Definition at line 172 of file video_export.c.

{
        if(s) {
                // poison
                struct output_entry *entry = calloc(1, sizeof(struct output_entry));
 
                pthread_mutex_lock(&s->lock);
                {
                        if(s->head) {
                                s->tail->next = entry;
                                s->tail = entry;
                        } else {
                                s->head = s->tail = entry;
                        }
                }
                pthread_mutex_unlock(&s->lock);
                platform_sem_post(&s->semaphore);
 
                pthread_join(s->thread_id, NULL);
                pthread_mutex_destroy(&s->lock);
 
                // write summary
                if(s->total > 0) {
                        output_summary(s);
                }
 
                free(s->path);
                free(s);
        }
}

References video_export::head, video_export::lock, output_entry::next, output_summary(), video_export::path, platform_sem_post(), video_export::semaphore, video_export::tail, video_export::thread_id, and video_export::total.

Referenced by disable_export(), and enable_export().

Here is the call graph for this function:

video_export_init()

struct video_export * video_export_init

(

const char *

path

)

Definition at line 125 of file video_export.c.

{
        struct video_export *s = calloc(1, sizeof *s);
        assert(s != NULL);
 
        platform_sem_init(&s->semaphore, 0, 0);
        pthread_mutex_init(&s->lock, NULL);
        s->total = s->queue_len = 0;
        assert(path != NULL);
        s->path = strdup(path);
        s->head = s->tail = NULL;
 
        memset(&s->saved_desc, 0, sizeof(s->saved_desc));
 
        if(pthread_create(&s->thread_id, NULL, video_export_thread, s) != 0) {
                fprintf(stderr, "[Video exporter] Failed to create thread.\n");
                free(s);
                return NULL;
        }
 
        return s;
}

References video_export::head, video_export::lock, video_export::path, platform_sem_init(), video_export::queue_len, video_export::saved_desc, video_export::semaphore, video_export::tail, video_export::thread_id, video_export::total, and video_export_thread().

Referenced by enable_export().

Here is the call graph for this function:

video_export_thread()

static void * video_export_thread ( void * arg )

static

Definition at line 84 of file video_export.c.

{
        struct video_export *s = (struct video_export *) arg;
 
        while(1) {
                platform_sem_wait(&s->semaphore);
                struct output_entry *current;
 
                pthread_mutex_lock(&s->lock);
                {
                        current = s->head;
                        s->head = s->head->next;
                        s->queue_len -= 1;
                }
                pthread_mutex_unlock(&s->lock);
 
                assert((current->data == NULL && current->data_len == 0) ||
                                (current->data != NULL && current->data_len != 0));
 
                // poison
                if(current->data == NULL) {
                        return NULL;
                }
 
                FILE *out = fopen(current->filename, "wb");
                if (out == NULL) {
                        perror("fopen");
                } else {
                        if (fwrite(current->data, current->data_len, 1, out) != 1) {
                                perror("fwrite");
                        }
                        fclose(out);
                }
                free(current->data);
                free(current->filename);
                free(current);
        }
 
        // never get here
}

References output_entry::data, output_entry::data_len, output_entry::filename, video_export::head, video_export::lock, output_entry::next, platform_sem_wait(), video_export::queue_len, and video_export::semaphore.

Referenced by video_export_init().

Here is the call graph for this function: