mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-23 12:43:46 +02:00
374 lines
8.0 KiB
C
374 lines
8.0 KiB
C
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <netinet/in.h>
|
|
#include <linux/videodev.h>
|
|
#include <linux/soundcard.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
#include <errno.h>
|
|
#include <sys/time.h>
|
|
#include <getopt.h>
|
|
#include <string.h>
|
|
|
|
#include "mpegenc.h"
|
|
|
|
AVFormat *first_format;
|
|
/* XXX: suppress it ! */
|
|
int data_out_size;
|
|
|
|
const char *comment_string =
|
|
"+title=Test Video +author=FFMpeg +copyright=Free +comment=Generated by FFMpeg 1.0";
|
|
|
|
void register_avformat(AVFormat *format)
|
|
{
|
|
AVFormat **p;
|
|
p = &first_format;
|
|
while (*p != NULL) p = &(*p)->next;
|
|
*p = format;
|
|
format->next = NULL;
|
|
}
|
|
|
|
AVFormat *guess_format(const char *short_name, const char *filename, const char *mime_type)
|
|
{
|
|
AVFormat *fmt, *fmt_found;
|
|
int score_max, score;
|
|
const char *ext, *p;
|
|
char ext1[32], *q;
|
|
|
|
/* find the proper file type */
|
|
fmt_found = NULL;
|
|
score_max = 0;
|
|
fmt = first_format;
|
|
while (fmt != NULL) {
|
|
score = 0;
|
|
if (fmt->name && short_name && !strcmp(fmt->name, short_name))
|
|
score += 100;
|
|
if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
|
|
score += 10;
|
|
if (filename && fmt->extensions) {
|
|
ext = strrchr(filename, '.');
|
|
if (ext) {
|
|
ext++;
|
|
p = fmt->extensions;
|
|
for(;;) {
|
|
q = ext1;
|
|
while (*p != '\0' && *p != ',')
|
|
*q++ = *p++;
|
|
*q = '\0';
|
|
if (!strcasecmp(ext1, ext)) {
|
|
score += 5;
|
|
break;
|
|
}
|
|
if (*p == '\0')
|
|
break;
|
|
p++;
|
|
}
|
|
}
|
|
}
|
|
if (score > score_max) {
|
|
score_max = score;
|
|
fmt_found = fmt;
|
|
}
|
|
fmt = fmt->next;
|
|
}
|
|
return fmt_found;
|
|
}
|
|
|
|
/* return TRUE if val is a prefix of str. If it returns TRUE, ptr is
|
|
set to the next character in 'str' after the prefix */
|
|
int strstart(const char *str, const char *val, const char **ptr)
|
|
{
|
|
const char *p, *q;
|
|
p = str;
|
|
q = val;
|
|
while (*q != '\0') {
|
|
if (*p != *q)
|
|
return 0;
|
|
p++;
|
|
q++;
|
|
}
|
|
if (ptr)
|
|
*ptr = p;
|
|
return 1;
|
|
}
|
|
|
|
/* simple formats */
|
|
int raw_write_header(struct AVFormatContext *s)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int raw_write_audio(struct AVFormatContext *s,
|
|
unsigned char *buf, int size)
|
|
{
|
|
put_buffer(&s->pb, buf, size);
|
|
put_flush_packet(&s->pb);
|
|
return 0;
|
|
}
|
|
|
|
int raw_write_video(struct AVFormatContext *s,
|
|
unsigned char *buf, int size)
|
|
{
|
|
put_buffer(&s->pb, buf, size);
|
|
put_flush_packet(&s->pb);
|
|
return 0;
|
|
}
|
|
|
|
int raw_write_trailer(struct AVFormatContext *s)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AVFormat mp2_format = {
|
|
"mp2",
|
|
"MPEG audio layer 2",
|
|
"audio/x-mpeg",
|
|
"mp2,mp3",
|
|
CODEC_ID_MP2,
|
|
0,
|
|
raw_write_header,
|
|
raw_write_audio,
|
|
NULL,
|
|
raw_write_trailer,
|
|
};
|
|
|
|
AVFormat ac3_format = {
|
|
"ac3",
|
|
"raw ac3",
|
|
"audio/x-ac3",
|
|
"ac3",
|
|
CODEC_ID_AC3,
|
|
0,
|
|
raw_write_header,
|
|
raw_write_audio,
|
|
NULL,
|
|
raw_write_trailer,
|
|
};
|
|
|
|
AVFormat h263_format = {
|
|
"h263",
|
|
"raw h263",
|
|
"video/x-h263",
|
|
"h263",
|
|
0,
|
|
CODEC_ID_H263,
|
|
raw_write_header,
|
|
NULL,
|
|
raw_write_video,
|
|
raw_write_trailer,
|
|
};
|
|
|
|
AVFormat mpeg1video_format = {
|
|
"mpeg1video",
|
|
"MPEG1 video",
|
|
"video/mpeg",
|
|
"mpg,mpeg",
|
|
0,
|
|
CODEC_ID_MPEG1VIDEO,
|
|
raw_write_header,
|
|
NULL,
|
|
raw_write_video,
|
|
raw_write_trailer,
|
|
};
|
|
|
|
/* encoder management */
|
|
AVEncoder *first_encoder;
|
|
|
|
void register_avencoder(AVEncoder *format)
|
|
{
|
|
AVEncoder **p;
|
|
p = &first_encoder;
|
|
while (*p != NULL) p = &(*p)->next;
|
|
*p = format;
|
|
format->next = NULL;
|
|
}
|
|
|
|
int avencoder_open(AVEncodeContext *avctx, AVEncoder *codec)
|
|
{
|
|
int ret;
|
|
|
|
avctx->codec = codec;
|
|
avctx->frame_number = 0;
|
|
avctx->priv_data = malloc(codec->priv_data_size);
|
|
if (!avctx->priv_data)
|
|
return -ENOMEM;
|
|
memset(avctx->priv_data, 0, codec->priv_data_size);
|
|
ret = avctx->codec->init(avctx);
|
|
if (ret < 0) {
|
|
free(avctx->priv_data);
|
|
avctx->priv_data = NULL;
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int avencoder_encode(AVEncodeContext *avctx, UINT8 *buf, int buf_size, void *data)
|
|
{
|
|
int ret;
|
|
|
|
ret = avctx->codec->encode(avctx, buf, buf_size, data);
|
|
avctx->frame_number++;
|
|
return ret;
|
|
}
|
|
|
|
int avencoder_close(AVEncodeContext *avctx)
|
|
{
|
|
if (avctx->codec->close)
|
|
avctx->codec->close(avctx);
|
|
free(avctx->priv_data);
|
|
avctx->priv_data = NULL;
|
|
return 0;
|
|
}
|
|
|
|
AVEncoder *avencoder_find(enum CodecID id)
|
|
{
|
|
AVEncoder *p;
|
|
p = first_encoder;
|
|
while (p) {
|
|
if (p->id == id)
|
|
return p;
|
|
p = p->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void avencoder_string(char *buf, int buf_size, AVEncodeContext *enc)
|
|
{
|
|
switch(enc->codec->type) {
|
|
case CODEC_TYPE_VIDEO:
|
|
snprintf(buf, buf_size,
|
|
"Video: %s, %dx%d, %d fps, %d kb/s",
|
|
enc->codec->name, enc->width, enc->height, enc->rate, enc->bit_rate / 1000);
|
|
break;
|
|
case CODEC_TYPE_AUDIO:
|
|
snprintf(buf, buf_size,
|
|
"Audio: %s, %d Hz, %s, %d kb/s",
|
|
enc->codec->name, enc->rate,
|
|
enc->channels == 2 ? "stereo" : "mono",
|
|
enc->bit_rate / 1000);
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
}
|
|
|
|
/* PutByteFormat */
|
|
|
|
int init_put_byte(PutByteContext *s,
|
|
unsigned char *buffer,
|
|
int buffer_size,
|
|
void *opaque,
|
|
void (*write_packet)(void *opaque, UINT8 *buf, int buf_size),
|
|
int (*write_seek)(void *opaque, long long offset, int whence))
|
|
{
|
|
s->buffer = buffer;
|
|
s->buf_ptr = buffer;
|
|
s->buf_end = buffer + buffer_size;
|
|
s->opaque = opaque;
|
|
s->write_packet = write_packet;
|
|
s->write_seek = write_seek;
|
|
s->pos = 0;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void flush_buffer(PutByteContext *s)
|
|
{
|
|
if (s->buf_ptr > s->buffer) {
|
|
if (s->write_packet)
|
|
s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
|
|
s->pos += s->buf_ptr - s->buffer;
|
|
}
|
|
s->buf_ptr = s->buffer;
|
|
}
|
|
|
|
void put_byte(PutByteContext *s, int b)
|
|
{
|
|
*(s->buf_ptr)++ = b;
|
|
if (s->buf_ptr >= s->buf_end)
|
|
flush_buffer(s);
|
|
}
|
|
|
|
void put_buffer(PutByteContext *s, unsigned char *buf, int size)
|
|
{
|
|
int len;
|
|
|
|
while (size > 0) {
|
|
len = (s->buf_end - s->buf_ptr);
|
|
if (len > size)
|
|
len = size;
|
|
memcpy(s->buf_ptr, buf, len);
|
|
s->buf_ptr += len;
|
|
|
|
if (s->buf_ptr >= s->buf_end)
|
|
flush_buffer(s);
|
|
|
|
buf += len;
|
|
size -= len;
|
|
}
|
|
}
|
|
|
|
void put_flush_packet(PutByteContext *s)
|
|
{
|
|
flush_buffer(s);
|
|
}
|
|
|
|
/* XXX: this seek is not correct if we go after the end of the written data */
|
|
long long put_seek(PutByteContext *s, long long offset, int whence)
|
|
{
|
|
long long offset1;
|
|
|
|
if (whence != SEEK_CUR && whence != SEEK_SET)
|
|
return -1;
|
|
if (whence == SEEK_CUR)
|
|
offset += s->pos + s->buf_ptr - s->buffer;
|
|
|
|
offset1 = offset - s->pos;
|
|
if (offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) {
|
|
/* can do the seek inside the buffer */
|
|
s->buf_ptr = s->buffer + offset1;
|
|
} else {
|
|
if (!s->write_seek)
|
|
return -1;
|
|
flush_buffer(s);
|
|
s->write_seek(s->opaque, offset, whence);
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
long long put_pos(PutByteContext *s)
|
|
{
|
|
return put_seek(s, 0, SEEK_CUR);
|
|
}
|
|
|
|
void put_le32(PutByteContext *s, unsigned int val)
|
|
{
|
|
put_byte(s, val);
|
|
put_byte(s, val >> 8);
|
|
put_byte(s, val >> 16);
|
|
put_byte(s, val >> 24);
|
|
}
|
|
|
|
void put_le64(PutByteContext *s, unsigned long long val)
|
|
{
|
|
put_le32(s, val & 0xffffffff);
|
|
put_le32(s, val >> 32);
|
|
}
|
|
|
|
void put_le16(PutByteContext *s, unsigned int val)
|
|
{
|
|
put_byte(s, val);
|
|
put_byte(s, val >> 8);
|
|
}
|
|
|
|
void put_tag(PutByteContext *s, char *tag)
|
|
{
|
|
while (*tag) {
|
|
put_byte(s, *tag++);
|
|
}
|
|
}
|
|
|