librmff.h

Go to the documentation of this file.

/*
  librmff.h

  Copyright (C) Moritz Bunkus - March 2004

  librmff 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, or (at your option)
  any later version.

  librmff 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 General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with this library; see the file COPYING.  If not, write to
  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef __RMFF_H
#define __RMFF_H

#if defined(__cplusplus)
extern "C" {
#endif

#include "os.h"

#include <inttypes.h>
#include <stdio.h>

#include "mb_file_io.h"

#define RMFF_VERSION_MAJOR 0
#define RMFF_VERSION_MINOR 6
#define RMFF_VERSION_MICRO 2
#define RMFF_VERSION (RMFF_VERSION_MAJOR * 10000 + RMFF_VERSION_MINOR * 100 + \
                      RMFF_VERSION_MICRO)

#define RMFF_FILE_FLAG_SAVE_ENABLED     0x0001

#define RMFF_FILE_FLAG_PERFECT_PLAY     0x0002

#define RMFF_FILE_FLAG_LIVE_BROADCAST   0x0004

#define RMFF_FILE_FLAG_DOWNLOAD_ENABLED 0x0008

typedef struct rmff_object_t {
  uint32_t  id;
  uint32_t size;
  uint16_t version;
} rmff_object_t;

typedef struct rmff_rmf_t {
  rmff_object_t obj;
  uint32_t format_version;
  uint32_t num_headers;
} rmff_rmf_t;

typedef struct rmff_prop_t {
  rmff_object_t obj;
  uint32_t max_bit_rate;
  uint32_t avg_bit_rate;
  uint32_t max_packet_size;
  uint32_t avg_packet_size;
  uint32_t num_packets;
  uint32_t duration;
  uint32_t preroll;
  uint32_t index_offset;
  uint32_t data_offset;
  uint16_t num_streams;
  uint16_t flags;
} rmff_prop_t;

typedef struct rmff_cont_t {
  rmff_object_t obj;
  char *title;
  char *author;
  char *copyright;
  char *comment;
} rmff_cont_t;

typedef struct rmff_mdpr_t {
  rmff_object_t obj;
  uint16_t id;
  uint32_t max_bit_rate;
  uint32_t avg_bit_rate;
  uint32_t max_packet_size;
  uint32_t avg_packet_size;
  uint32_t start_time;
  uint32_t preroll;
  uint32_t duration;
  char *name;
  char *mime_type;
  uint32_t type_specific_size;
  unsigned char *type_specific_data;
} rmff_mdpr_t;

typedef struct __attribute__((__packed__)) real_video_props_t {
  uint32_t size;
  uint32_t fourcc1;
  uint32_t fourcc2;
  uint16_t width;
  uint16_t height;
  uint16_t bpp;
  uint32_t unknown1;
  uint32_t fps;
  uint32_t type1;
  uint32_t type2;
} real_video_props_t;

typedef struct __attribute__((__packed__)) real_audio_v4_props_t {
  uint32_t fourcc1;             /* '.', 'r', 'a', 0xfd */
  uint16_t version1;            /* 4 or 5 */
  uint16_t unknown1;            /* 00 00 */
  uint32_t fourcc2;             /* .ra4 or .ra5 */
  uint32_t stream_length;       /* ??? */
  uint16_t version2;            /* 4 or 5 */
  uint32_t header_size;         /* == 0x4e */
  uint16_t flavor;              /* codec flavor id */
  uint32_t coded_frame_size;    /* coded frame size */
  uint32_t unknown3;            /* big number */
  uint32_t unknown4;            /* bigger number */
  uint32_t unknown5;            /* yet another number */
  uint16_t sub_packet_h;
  uint16_t frame_size;
  uint16_t sub_packet_size;
  uint16_t unknown6;            /* 00 00 */
  uint16_t sample_rate;
  uint16_t unknown8;            /* 0 */
  uint16_t sample_size;
  uint16_t channels;
} real_audio_v4_props_t;

typedef struct __attribute__((__packed__)) real_audio_v5_props_t {
  uint32_t fourcc1;             /* '.', 'r', 'a', 0xfd */
  uint16_t version1;            /* 4 or 5 */
  uint16_t unknown1;            /* 00 00 */
  uint32_t fourcc2;             /* .ra4 or .ra5 */
  uint32_t stream_length;       /* ??? */
  uint16_t version2;            /* 4 or 5 */
  uint32_t header_size;         /* == 0x4e */
  uint16_t flavor;              /* codec flavor id */
  uint32_t coded_frame_size;    /* coded frame size */
  uint32_t unknown3;            /* big number */
  uint32_t unknown4;            /* bigger number */
  uint32_t unknown5;            /* yet another number */
  uint16_t sub_packet_h;
  uint16_t frame_size;
  uint16_t sub_packet_size;
  uint16_t unknown6;            /* 00 00 */
  uint8_t unknown7[6];          /* 0, srate, 0 */
  uint16_t sample_rate;
  uint16_t unknown8;            /* 0 */
  uint16_t sample_size;
  uint16_t channels;
  uint32_t genr;                /* "genr" */
  uint32_t fourcc3;             /* fourcc */
} real_audio_v5_props_t;

typedef struct rmff_index_entry_t {
  uint32_t pos;
  uint32_t timecode;
  uint32_t packet_number;
} rmff_index_entry_t;

#define RMFF_FRAME_FLAG_RELIABLE 0x01

#define RMFF_FRAME_FLAG_KEYFRAME 0x02

typedef struct rmff_frame_t {
  unsigned char *data;
  uint32_t size;
  int allocated_by_rmff;

  uint16_t id;
  uint32_t timecode;
  uint8_t reserved;
  uint8_t flags;
} rmff_frame_t;

#define RMFF_TRACK_TYPE_UNKNOWN                        0

#define RMFF_TRACK_TYPE_AUDIO                          1

#define RMFF_TRACK_TYPE_VIDEO                          2

struct rmff_file_t;

typedef struct rmff_track_t {
  uint32_t id;
  int type;
  rmff_mdpr_t mdpr_header;

  rmff_index_entry_t *index;
  int num_index_entries;

  struct rmff_file_t *file;

  void *app_data;
  void *internal;
} rmff_track_t;

typedef struct rmff_file_t {
  mb_file_io_t *io;
  void *handle;
  char *name;
  int open_mode;
  int64_t size;

  int headers_read;

  rmff_rmf_t rmf_header;
  rmff_prop_t prop_header;
  rmff_cont_t cont_header;
  int cont_header_present;
  uint32_t num_packets_in_chunk;
  uint32_t num_packets_read;

  rmff_track_t **tracks;
  int num_tracks;

  void *app_data;
  void *internal;
} rmff_file_t;

#define RMFF_ERR_OK                                    0

#define RMFF_ERR_NOT_RMFF                             -1

#define RMFF_ERR_DATA                                 -2

#define RMFF_ERR_EOF                                  -3

#define RMFF_ERR_IO                                   -4

#define RMFF_ERR_PARAMETERS                           -5

#define RMFF_ERR_CHECK_ERRNO                          -6

#define rmffFOURCC(a, b, c, d) \
  (uint32_t)((((unsigned char)a) << 24) + \
  (((unsigned char)b) << 16) + \
  (((unsigned char)c) << 8) + \
  ((unsigned char)d))

#define RMFF_OPEN_MODE_READING                         0

#define RMFF_OPEN_MODE_WRITING                         1

rmff_file_t *rmff_open_file(const char *path, int mode);

rmff_file_t *rmff_open_file_with_io(const char *path, int mode,
                                    mb_file_io_t *io);

void rmff_close_file(rmff_file_t *file);

int rmff_read_headers(rmff_file_t *file);

int rmff_get_next_frame_size(rmff_file_t *file);

rmff_frame_t *rmff_read_next_frame(rmff_file_t *file, void *buffer);

rmff_frame_t *rmff_allocate_frame(uint32_t size, void *buffer);

void rmff_release_frame(rmff_frame_t *frame);

rmff_track_t *rmff_add_track(rmff_file_t *file, int create_index);

void rmff_set_std_audio_v4_values(real_audio_v4_props_t *props);

void rmff_set_std_audio_v5_values(real_audio_v5_props_t *props);

void rmff_set_std_video_values(real_video_props_t *props);

void rmff_set_cont_header(rmff_file_t *file, const char *title,
                          const char *author, const char *copyright,
                          const char *comment);

void rmff_set_track_data(rmff_track_t *track, const char *name,
                         const char *mime_type);

void rmff_set_type_specific_data(rmff_track_t *track,
                                 const unsigned char *data, uint32_t size);

int rmff_write_headers(rmff_file_t *file);

int rmff_fix_headers(rmff_file_t *file);

int rmff_write_frame(rmff_track_t *track, rmff_frame_t *frame);

int rmff_write_packed_video_frame(rmff_track_t *track, rmff_frame_t *frame);

int rmff_assemble_packed_video_frame(rmff_track_t *track, rmff_frame_t *frame);

rmff_frame_t *rmff_get_packed_video_frame(rmff_track_t *track);

int rmff_write_index(rmff_file_t *file);

void rmff_copy_track_headers(rmff_track_t *dst, rmff_track_t *src);

rmff_track_t *rmff_find_track_with_id(rmff_file_t *file, uint16_t id);

extern int rmff_last_error;

extern const char *rmff_last_error_msg;

const char *rmff_get_error_str(int code);

uint16_t rmff_get_uint16_be(const void *buf);

uint32_t rmff_get_uint32_be(const void *buf);

uint32_t rmff_get_uint32_le(const void *buf);

void rmff_put_uint16_be(void *buf, uint16_t value);

void rmff_put_uint32_be(void *buf, uint32_t value);

void rmff_put_uint32_le(void *buf, uint32_t value);

#if defined(ARCH_LITTLEENDIAN)
# define rmff_get_uint32_me(b) rmff_get_uint32_le(b)
# define rmff_put_uint32_me(b) rmff_put_uint32_le(b)
#elif defined(ARCH_BIGENDIAN)
# define rmff_get_uint32_me(b) rmff_get_uint32_be(b)
# define rmff_put_uint32_me(b) rmff_put_uint32_be(b)
#else
# error Neither ARCH_LITTLEENDIAN nor ARCH_BIGENDIAN has been defined.
#endif

#if defined(__cplusplus)
}
#endif

#endif /* __RMFF_H */

---