Hi all,
As the source of the XSUB encoder are public and in DrFFMPEG here is the
format of the XSUB subtitle in .divx/DMF files :
typedef struct Color
{
uint8_t red;
uint8_t green;
uint8_t blue;
} Color;
// DivX Subpicture Packet header
typedef struct DivxSubPictPackHdr
{
// Duration in the following format
// [HH:MM:SS.XXX-hh:mm:ss.xxx]
// Note: There is no NUL at the end
char duration[27];
// Subpicture dimensions & coordinates
uint16_t width;
uint16_t height;
uint16_t left;
uint16_t top;
uint16_t right;
uint16_t bottom;
uint16_t fieldOffset;
// Background, pattern, emphasis1, emphasis2 colors
Color background;
Color pattern;
Color emphasis1;
Color emphasis2;
} DivxSubPictPackHdr;
#define SIZEOF_XSUB_PACKET 53
This is stored in little-endian with the exact size for each field. I
think Gabest shouldn't have a hard time supporting the format too.
--
robUx4 on blog <
http://robux4.blogspot.com/>
-------------- next part --------------
/*
* DivX subtitle encoding for ffmpeg
* Copyright (c) 2005 DivX, Inc.
*
* This library 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 of the License, or (at your option) any later version.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "avcodec.h"
#ifdef CONFIG_XSUB_ENCODER
// Safe area
const uint32_t SUBTITLE_BOX_TOP_BORDER = 24;
const uint32_t SUBTITLE_BOX_LEFT_BORDER = 44;
const uint32_t SUBTITLE_BOX_BOTTOM_BORDER = 455;
const uint32_t SUBTITLE_BOX_RIGHT_BORDER = 595;
// Default screen
const uint32_t SCREEN_WIDTH = 640;
const uint32_t SCREEN_HEIGHT = 480;
typedef struct Color
{
uint8_t red;
uint8_t green;
uint8_t blue;
} Color;
// DivX Subpicture Packet header
typedef struct DivxSubPictPackHdr
{
// Duration in the following format
// [HH:MM:SS.XXX-hh:mm:ss.xxx]
// Note: There is no NUL at the end
char duration[28];
// Subpicture dimensions & coordinates
uint16_t width;
uint16_t height;
uint16_t left;
uint16_t top;
uint16_t right;
uint16_t bottom;
uint16_t fieldOffset;
// Background, pattern, emphasis1, emphasis2 colors
Color background;
Color pattern;
Color emphasis1;
Color emphasis2;
} DivxSubPictPackHdr;
#define SIZEOF_XSUB_PACKET 53
extern int get_nibble(const uint8_t *buf, int nibble_offset);
static void set_nibble(uint8_t *buffer, int32_t offset, uint8_t value)
{
int32_t b = offset / 2;
int32_t h = (offset % 2 == 1);
if (h == 0)
{
buffer
= (buffer & 0x0F) | (value << 4);
}
else
{
buffer = (buffer & 0xF0) | (value << 0);
}
}
static void xsub_encode_rle(uint8_t **pq,
const uint8_t *bitmap, int linesize,
int w, int h)
{
uint8_t *q;
int x, y, len, x1, color;
int offset = 0;
q = *pq;
for(y = 0; y < h; y++) {
x = 0;
while (x < w) {
x1 = x;
color = bitmap[x1++];
while (x1 < w && bitmap[x1] == color)
x1++;
len = x1 - x;
// Run can't be longer than 255, unless it is the rest of a row
if(x1 < w && len > 255)
{
int32_t diff = len - 255;
len -= diff;
x1 -= diff;
}
if (len >= 1 && len <=3) {
// Set 2-bit len, and 2-bit color
set_nibble(q, offset++, (uint8_t)((len << 2) | color));
} else if (len >= 4 && len <= 15) {
int32_t l = (len & 0x0C) >> 2; // 2 bit left
int32_t right = (len & 0x03) >> 0; // 2 bit right
// Set 2-bit zero, and left 2-bit len
set_nibble(q, offset++, (uint8_t)l);
// Set right 2-bit len and 2-bit color
set_nibble(q, offset++, (uint8_t)((right << 2) | color));
} else if (len >= 16 && len <= 63) {
int32_t l = (len & 0x3C) >> 2; // 4 bit left
int32_t right = (len & 0x03) >> 0; // 2 bit right
// Set 4-bit zero
set_nibble(q, offset++, 0);
// Set left 4-bit len
set_nibble(q, offset++, (uint8_t)l);
// Set right 2-bit len and 2-bit color
set_nibble(q, offset++, (uint8_t)((right << 2) | color));
} else if (len >= 64 && len <= 255) {
int32_t l = (len & 0xC0) >> 6; // 2 bit left
int32_t m = (len & 0x3C) >> 2; // 4 bit middle
int32_t right = (len & 0x03) >> 0; // 2 bit right
// Set 6-bit zero and 2-bit len
set_nibble(q, offset++, 0);
set_nibble(q, offset++, (uint8_t)(0 | l));
// Set middle 4-bit len
set_nibble(q, offset++, (uint8_t)m);
// Set right 2-bit len and 2-bit color
set_nibble(q, offset++, (uint8_t)((right << 2) | color));
} else {
// Set 14-bit zero and 2-bit color
set_nibble(q, offset++, 0);
set_nibble(q, offset++, 0);
set_nibble(q, offset++, 0);
set_nibble(q, offset++, (uint8_t)(0 | color));
}
x += len;
}
// byte align
if (offset % 2) {
set_nibble(q, offset++, 0);
}
bitmap += linesize;
}
*pq = q + offset;
}
#ifdef DEBUG
static sub_pict_count = 0;
#undef fprintf
static void ppm_save(const char *filename, uint8_t *bitmap, int w, int h,
uint32_t *rgba_palette)
{
int x, y, v;
FILE *f;
f = fopen(filename, "w");
if (!f) {
perror(filename);
exit(1);
}
fprintf(f, "P6\n"
"%d %d\n"
"%d\n",
w, h, 255);
for(y = 0; y < h; y++) {
for(x = 0; x < w; x++) {
int uu = bitmap[y * w + x];
v = rgba_palette[uu];
putc((v >> 16) & 0xff, f);
putc((v >> 
& 0xff, f);
putc((v >> 0) & 0xff, f);
}
}
fclose(f);
}
static int decode_rle(uint8_t *bitmap, int linesize, int w, int h,
const uint8_t *buf, int nibble_offset, int buf_size)
{
unsigned int v;
int x, y, len, color, nibble_end;
uint8_t *d;
nibble_end = buf_size * 2;
x = 0;
y = 0;
d = bitmap;
for(;;) {
if (nibble_offset >= nibble_end)
return -1;
v = get_nibble(buf, nibble_offset++);
if (v < 0x4) {
v = (v << 4) | get_nibble(buf, nibble_offset++);
if (v < 0x10) {
v = (v << 4) | get_nibble(buf, nibble_offset++);
if (v < 0x040) {
v = (v << 4) | get_nibble(buf, nibble_offset++);
if (v < 4) {
v |= (w - x) << 2;
}
}
}
}
len = v >> 2;
if (len > (w - x))
len = (w - x);
color = v & 0x03;
memset(d + x, color, len);
x += len;
if (x >= w) {
y++;
if (y >= h)
break;
d += linesize;
x = 0;
/* byte align */
nibble_offset += (nibble_offset & 1);
}
}
return 0;
}
#endif
#define COLOR_TO_BUFFER(col, buffer) \
*buffer++ = col.red; \
*buffer++ = col.green; \
*buffer++ = col.blue;
static void encode_xsub_header_to_buf(DivxSubPictPackHdr *hdr, uint8_t *buf)
{
memcpy( buf, hdr->duration, 27 );
buf += 27;
// Little endian fields
*buf++ = hdr->width & 0xFF;
*buf++ = hdr->width >> 8;
*buf++ = hdr->height & 0xFF;
*buf++ = hdr->height >> 8;
*buf++ = hdr->left & 0xFF;
*buf++ = hdr->left >> 8;
*buf++ = hdr->top & 0xFF;
*buf++ = hdr->top >> 8;
*buf++ = hdr->right & 0xFF;
*buf++ = hdr->right >> 8;
*buf++ = hdr->bottom & 0xFF;
*buf++ = hdr->bottom >> 8;
*buf++ = hdr->fieldOffset & 0xFF;
*buf++ = hdr->fieldOffset >> 8;
COLOR_TO_BUFFER(hdr->background, buf);
COLOR_TO_BUFFER(hdr->pattern, buf);
COLOR_TO_BUFFER(hdr->emphasis1, buf);
COLOR_TO_BUFFER(hdr->emphasis2, buf);
}
static int encode_xsub_subtitles(uint8_t *outbuf, AVSubtitle *h)
{
#ifdef DEBUG
char filename[256];
uint8_t *tmp_bitmap;
#endif
uint8_t *resized_bitmap;
uint32_t executeTime = h->end_display_time - h->start_display_time;
uint32_t startTime = h->pts / 90;
uint32_t endTime = startTime + executeTime;
uint32_t startHrs;
uint32_t startMins;
uint32_t startSecs;
uint32_t startMilliSecs;
uint32_t endHrs;
uint32_t endMins;
uint32_t endSecs;
uint32_t endMilliSecs;
DivxSubPictPackHdr hdr;
uint8_t *q;
uint8_t *top_field_offset;
uint8_t *bottom_field_offset;
uint32_t top_field_len;
uint32_t bottom_field_len;
int r;
int i = 0;
if (h->num_rects == 0 || h->rects == NULL)
return -1;
startMilliSecs = (uint32_t) startTime % 1000;
startTime /= 1000;
startSecs = (uint32_t) startTime % 60;
startTime /= 60;
startMins = (uint32_t) startTime % 60;
startTime /= 60;
startHrs = (uint32_t) startTime;
endMilliSecs = (uint32_t) endTime % 1000;
endTime /= 1000;
endSecs = (uint32_t) endTime % 60;
endTime /= 60;
endMins = (uint32_t) endTime % 60;
endTime /= 60;
endHrs = (uint32_t) endTime;
snprintf(hdr.duration, 28,
"[%02d:%02d:%02d.%03d-%02d:%02d:%02d.%03d]",
startHrs, startMins, startSecs, startMilliSecs,
endHrs, endMins, endSecs, endMilliSecs);
hdr.right = 0;
hdr.bottom = 0;
hdr.width = h->rects[0].w;
hdr.height = h->rects[0].h;
if (hdr.width % 2)
{
hdr.width++;
}
// 2 pixels required on either side of subtitle
hdr.width += 4;
if (hdr.height % 2)
{
hdr.height++;
}
hdr.left = (SCREEN_WIDTH - hdr.width) / 2;
if (hdr.left % 2)
{
hdr.left--;
}
if (hdr.left < SUBTITLE_BOX_LEFT_BORDER)
{
if (hdr.left + hdr.width < SUBTITLE_BOX_RIGHT_BORDER)
{
hdr.left = SUBTITLE_BOX_LEFT_BORDER;
}
}
if (hdr.left + hdr.width > SUBTITLE_BOX_RIGHT_BORDER)
{
if (SUBTITLE_BOX_RIGHT_BORDER - hdr.width > SUBTITLE_BOX_LEFT_BORDER)
{
hdr.left = SUBTITLE_BOX_RIGHT_BORDER - hdr.width;
if (hdr.left % 2)
{
hdr.left--;
}
}
}
//if (SUBTITLE_BOX_BOTTOM_BORDER >= hdr.height)
{
hdr.top = SUBTITLE_BOX_BOTTOM_BORDER - hdr.height;
}
//else
{
//hdr.top = 0;
}
if (hdr.top %2)
{
hdr.top--;
}
hdr.background.red = r = (h->rects[0].rgba_palette[0] >> 16) & 0xff;
hdr.background.green = (h->rects[0].rgba_palette[0] >> & 0xff;
hdr.background.blue = (h->rects[0].rgba_palette[0] >> 0) & 0xff;
hdr.pattern.red = r = (h->rects[0].rgba_palette[1] >> 16) & 0xff;
hdr.pattern.green = (h->rects[0].rgba_palette[1] >> & 0xff;
hdr.pattern.blue = (h->rects[0].rgba_palette[1] >> 0) & 0xff;
hdr.emphasis1.red = r = (h->rects[0].rgba_palette[2] >> 16) & 0xff;
hdr.emphasis1.green = (h->rects[0].rgba_palette[2] >> & 0xff;
hdr.emphasis1.blue = (h->rects[0].rgba_palette[2] >> 0) & 0xff;
hdr.emphasis2.red = r = (h->rects[0].rgba_palette[3] >> 16) & 0xff;
hdr.emphasis2.green = (h->rects[0].rgba_palette[3] >> & 0xff;
hdr.emphasis2.blue = (h->rects[0].rgba_palette[3] >> 0) & 0xff;
q = outbuf + SIZEOF_XSUB_PACKET;
resized_bitmap = av_malloc(hdr.width * hdr.height);
memset(resized_bitmap, 0, hdr.width * hdr.height);
for (i = 0; i < h->rects[0].h; i++)
{
memcpy(resized_bitmap + (hdr.width * i + 2), h->rects[0].bitmap + (h->rects[0].w * i), h->rects[0].w);
}
top_field_offset = q;
xsub_encode_rle(&q, resized_bitmap, hdr.width * 2, hdr.width, hdr.height / 2);
top_field_len = q - top_field_offset;
#ifdef DEBUG
tmp_bitmap = av_malloc(hdr.width * hdr.height / 2);
decode_rle(tmp_bitmap, hdr.width, hdr.width, hdr.height / 2, top_field_offset, 0, top_field_len);
sub_pict_count++;
snprintf(filename, 256, "bt-%d.ppm", sub_pict_count);
ppm_save(filename, tmp_bitmap,
hdr.width, hdr.height / 2, h->rects[0].rgba_palette);
av_free(tmp_bitmap);
#endif
bottom_field_offset = q;
xsub_encode_rle(&q, resized_bitmap + hdr.width, hdr.width * 2, hdr.width, hdr.height / 2);
bottom_field_len = q - bottom_field_offset;
#ifdef DEBUG
tmp_bitmap = av_malloc(hdr.width * hdr.height / 2);
decode_rle(tmp_bitmap, hdr.width, hdr.width, hdr.height / 2, bottom_field_offset, 0, bottom_field_len);
snprintf(filename, 256, "bb-%d.ppm", sub_pict_count);
ppm_save(filename, tmp_bitmap,
hdr.width, hdr.height / 2, h->rects[0].rgba_palette);
av_free(tmp_bitmap);
#endif
av_free(resized_bitmap);
hdr.fieldOffset = top_field_len;
encode_xsub_header_to_buf( &hdr, outbuf);
return (SIZEOF_XSUB_PACKET + bottom_field_len + top_field_len);
}
static int xsub_init_decoder(AVCodecContext *avctx)
{
return 0;
}
static int xsub_close_decoder(AVCodecContext *avctx)
{
return 0;
}
static int xsub_encode(AVCodecContext *avctx,
unsigned char *buf, int buf_size, void *data)
{
AVSubtitle *sub = data;
return encode_xsub_subtitles(buf, sub);
}
AVCodec xsub_encoder = {
"xsub",
CODEC_TYPE_SUBTITLE,
CODEC_ID_XSUB_SUBTITLE,
0,
xsub_init_decoder,
xsub_encode,
xsub_close_decoder,
};
#endif
