[Ffmpeg-devel] [patch] DVB subtitle decoder, revised patch
Ian Caulfield
imc25
Sat Jul 16 02:15:38 CEST 2005
Hi all,
I've addressed (I think) all the issues with the patch previously, and
I've also hacked ffplay to be able to display subtitles (just press T to
switch tracks). Revised version is attached.
Ian
-------------- next part --------------
Index: ffmpeg.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/ffmpeg.c,v
retrieving revision 1.337
diff -u -r1.337 ffmpeg.c
--- ffmpeg.c 11 Jul 2005 22:15:58 -0000 1.337
+++ ffmpeg.c 16 Jul 2005 00:01:45 -0000
@@ -1423,8 +1423,14 @@
av_free(buffer_to_free);
/* XXX: allocate the subtitles in the codec ? */
if (subtitle_to_free) {
- av_free(subtitle_to_free->bitmap);
- av_free(subtitle_to_free->rgba_palette);
+ if (subtitle_to_free->rects != NULL) {
+ for (i = 0; i < subtitle_to_free->num_rects; i++) {
+ av_free(subtitle_to_free->rects[i].bitmap);
+ av_free(subtitle_to_free->rects[i].rgba_palette);
+ }
+ av_freep(&subtitle_to_free->rects);
+ }
+ subtitle_to_free->num_rects = 0;
subtitle_to_free = NULL;
}
}
Index: ffplay.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/ffplay.c,v
retrieving revision 1.45
diff -u -r1.45 ffplay.c
--- ffplay.c 28 Jun 2005 08:35:38 -0000 1.45
+++ ffplay.c 16 Jul 2005 00:01:49 -0000
@@ -57,6 +57,7 @@
#define MAX_VIDEOQ_SIZE (5 * 256 * 1024)
#define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
+#define MAX_SUBTITLEQ_SIZE (5 * 16 * 1024)
/* SDL audio buffer size, in samples. Should be small to have precise
A/V sync as SDL does not have hardware buffer fullness info. */
@@ -86,6 +87,7 @@
} PacketQueue;
#define VIDEO_PICTURE_QUEUE_SIZE 1
+#define SUBPICTURE_QUEUE_SIZE 4
typedef struct VideoPicture {
double pts; /* presentation time stamp for this picture */
@@ -94,6 +96,11 @@
int allocated;
} VideoPicture;
+typedef struct SubPicture {
+ double pts; /* presentation time stamp for this picture */
+ AVSubtitle sub;
+} SubPicture;
+
enum {
AV_SYNC_AUDIO_MASTER, /* default choice */
AV_SYNC_VIDEO_MASTER,
@@ -142,6 +149,16 @@
int sample_array_index;
int last_i_start;
+ SDL_Thread *subtitle_tid;
+ int subtitle_stream;
+ int subtitle_stream_changed;
+ AVStream *subtitle_st;
+ PacketQueue subtitleq;
+ SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
+ int subpq_size, subpq_rindex, subpq_windex;
+ SDL_mutex *subpq_mutex;
+ SDL_cond *subpq_cond;
+
double frame_timer;
double frame_last_pts;
double frame_last_delay;
@@ -163,6 +180,7 @@
SDL_mutex *video_decoder_mutex;
SDL_mutex *audio_decoder_mutex;
+ SDL_mutex *subtitle_decoder_mutex;
// QETimer *video_timer;
char filename[1024];
@@ -366,12 +384,270 @@
}
#endif
+
+
+#define SCALEBITS 10
+#define ONE_HALF (1 << (SCALEBITS - 1))
+#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
+
+#define RGB_TO_Y_CCIR(r, g, b) \
+((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
+ FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
+
+#define RGB_TO_U_CCIR(r1, g1, b1, shift)\
+(((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 + \
+ FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
+
+#define RGB_TO_V_CCIR(r1, g1, b1, shift)\
+(((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 - \
+ FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
+
+#define ALPHA_BLEND(a, oldp, newp, s)\
+((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
+
+#define RGBA_IN(r, g, b, a, s)\
+{\
+ unsigned int v = ((const uint32_t *)(s))[0];\
+ a = (v >> 24) & 0xff;\
+ r = (v >> 16) & 0xff;\
+ g = (v >> 8) & 0xff;\
+ b = v & 0xff;\
+}
+
+#define YUVA_IN(y, u, v, a, s, pal)\
+{\
+ unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)s];\
+ a = (val >> 24) & 0xff;\
+ y = (val >> 16) & 0xff;\
+ u = (val >> 8) & 0xff;\
+ v = val & 0xff;\
+}
+
+#define YUVA_OUT(d, y, u, v, a)\
+{\
+ ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
+}
+
+
+#define BPP 1
+
+static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
+{
+ int wrap, wrap3, width2, skip2;
+ int y, u, v, a, u1, v1, a1, w, h;
+ uint8_t *lum, *cb, *cr;
+ const uint8_t *p;
+ const uint32_t *pal;
+
+ lum = dst->data[0] + rect->y * dst->linesize[0];
+ cb = dst->data[1] + (rect->y >> 1) * dst->linesize[1];
+ cr = dst->data[2] + (rect->y >> 1) * dst->linesize[2];
+
+ width2 = (rect->w + 1) >> 1;
+ skip2 = rect->x >> 1;
+ wrap = dst->linesize[0];
+ wrap3 = rect->linesize;
+ p = rect->bitmap;
+ pal = rect->rgba_palette; /* Now in YCrCb! */
+
+ if (rect->y % 1) {
+ lum += rect->x;
+ cb += skip2;
+ cr += skip2;
+
+ if (rect->x % 1) {
+ YUVA_IN(y, u, v, a, p, pal);
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
+ cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
+ cb++;
+ cr++;
+ lum++;
+ p += BPP;
+ }
+ for(w = rect->w - (rect->x % 1); w >= 2; w -= 2) {
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 = u;
+ v1 = v;
+ a1 = a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+
+ YUVA_IN(y, u, v, a, p + BPP, pal);
+ u1 += u;
+ v1 += v;
+ a1 += a;
+ lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
+ cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
+ cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
+ cb++;
+ cr++;
+ p += 2 * BPP;
+ lum += 2;
+ }
+ if (w) {
+ YUVA_IN(y, u, v, a, p, pal);
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
+ cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
+ }
+ p += wrap3 + (wrap3 - rect->w * BPP);
+ lum += wrap + (wrap - rect->w - rect->x);
+ cb += dst->linesize[1] - width2 - skip2;
+ cr += dst->linesize[2] - width2 - skip2;
+ }
+ for(h = rect->h - (rect->y % 1); h >= 2; h -= 2) {
+ lum += rect->x;
+ cb += skip2;
+ cr += skip2;
+
+ if (rect->x % 1) {
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 = u;
+ v1 = v;
+ a1 = a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ p += wrap3;
+ lum += wrap;
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 += u;
+ v1 += v;
+ a1 += a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
+ cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
+ cb++;
+ cr++;
+ p += -wrap3 + BPP;
+ lum += -wrap + 1;
+ }
+ for(w = rect->w - (rect->x % 1); w >= 2; w -= 2) {
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 = u;
+ v1 = v;
+ a1 = a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 += u;
+ v1 += v;
+ a1 += a;
+ lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
+ p += wrap3;
+ lum += wrap;
+
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 += u;
+ v1 += v;
+ a1 += a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 += u;
+ v1 += v;
+ a1 += a;
+ lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
+
+ cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
+ cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
+
+ cb++;
+ cr++;
+ p += -wrap3 + 2 * BPP;
+ lum += -wrap + 2;
+ }
+ if (w) {
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 = u;
+ v1 = v;
+ a1 = a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ p += wrap3;
+ lum += wrap;
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 += u;
+ v1 += v;
+ a1 += a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
+ cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
+ cb++;
+ cr++;
+ p += -wrap3 + BPP;
+ lum += -wrap + 1;
+ }
+ p += wrap3 + (wrap3 - rect->w * BPP);
+ lum += wrap + (wrap - rect->w - rect->x);
+ cb += dst->linesize[1] - width2 - skip2;
+ cr += dst->linesize[2] - width2 - skip2;
+ }
+ /* handle odd height */
+ if (h) {
+ lum += rect->x;
+ cb += skip2;
+ cr += skip2;
+
+ if (rect->x % 1) {
+ YUVA_IN(y, u, v, a, p, pal);
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
+ cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
+ cb++;
+ cr++;
+ lum++;
+ p += BPP;
+ }
+ for(w = rect->w - (rect->x % 1); w >= 2; w -= 2) {
+ YUVA_IN(y, u, v, a, p, pal);
+ u1 = u;
+ v1 = v;
+ a1 = a;
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+
+ YUVA_IN(y, u, v, a, p + BPP, pal);
+ u1 += u;
+ v1 += v;
+ a1 += a;
+ lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
+ cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
+ cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
+ cb++;
+ cr++;
+ p += 2 * BPP;
+ lum += 2;
+ }
+ if (w) {
+ YUVA_IN(y, u, v, a, p, pal);
+ lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
+ cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
+ cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
+ }
+ }
+}
+
+static void free_subpicture(SubPicture *sp)
+{
+ int i;
+
+ for (i = 0; i < sp->sub.num_rects; i++)
+ {
+ av_free(sp->sub.rects[i].bitmap);
+ av_free(sp->sub.rects[i].rgba_palette);
+ }
+
+ av_free(sp->sub.rects);
+
+ memset(&sp->sub, 0, sizeof(AVSubtitle));
+}
+
static void video_image_display(VideoState *is)
{
VideoPicture *vp;
+ SubPicture *sp;
+ AVPicture pict;
float aspect_ratio;
int width, height, x, y;
SDL_Rect rect;
+ int i;
vp = &is->pictq[is->pictq_rindex];
if (vp->bmp) {
@@ -419,6 +695,33 @@
}
#endif
+ if (is->subtitle_st)
+ {
+ if (is->subpq_size > 0)
+ {
+ sp = &is->subpq[is->subpq_rindex];
+
+ if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000))
+ {
+ SDL_LockYUVOverlay (vp->bmp);
+
+ pict.data[0] = vp->bmp->pixels[0];
+ pict.data[1] = vp->bmp->pixels[2];
+ pict.data[2] = vp->bmp->pixels[1];
+
+ pict.linesize[0] = vp->bmp->pitches[0];
+ pict.linesize[1] = vp->bmp->pitches[2];
+ pict.linesize[2] = vp->bmp->pitches[1];
+
+ for (i = 0; i < sp->sub.num_rects; i++)
+ blend_subrect(&pict, &sp->sub.rects[i]);
+
+ SDL_UnlockYUVOverlay (vp->bmp);
+ }
+ }
+ }
+
+
/* XXX: we suppose the screen has a 1.0 pixel ratio */
height = is->height;
width = ((int)rint(height * aspect_ratio)) & -3;
@@ -637,6 +940,7 @@
VideoPicture *vp;
double actual_delay, delay, sync_threshold, ref_clock, diff;
+ SubPicture *sp, *sp2;
if (is->video_st) {
if (is->pictq_size == 0) {
@@ -697,6 +1001,50 @@
delay, actual_delay, vp->pts, -diff);
#endif
+ if(is->subtitle_st) {
+ if (is->subtitle_stream_changed) {
+ SDL_LockMutex(is->subpq_mutex);
+
+ while (is->subpq_size) {
+ free_subpicture(&is->subpq[is->subpq_rindex]);
+
+ /* update queue size and signal for next picture */
+ if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
+ is->subpq_rindex = 0;
+
+ is->subpq_size--;
+ }
+ is->subtitle_stream_changed = 0;
+
+ SDL_CondSignal(is->subpq_cond);
+ SDL_UnlockMutex(is->subpq_mutex);
+ } else {
+ if (is->subpq_size > 0) {
+ sp = &is->subpq[is->subpq_rindex];
+
+ if (is->subpq_size > 1)
+ sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
+ else
+ sp2 = NULL;
+
+ if ((is->video_current_pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
+ || (sp2 && is->video_current_pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
+ {
+ free_subpicture(sp);
+
+ /* update queue size and signal for next picture */
+ if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
+ is->subpq_rindex = 0;
+
+ SDL_LockMutex(is->subpq_mutex);
+ is->subpq_size--;
+ SDL_CondSignal(is->subpq_cond);
+ SDL_UnlockMutex(is->subpq_mutex);
+ }
+ }
+ }
+ }
+
/* display picture */
video_display(is);
@@ -725,22 +1073,25 @@
if (show_status) {
static int64_t last_time;
int64_t cur_time;
- int aqsize, vqsize;
+ int aqsize, vqsize, sqsize;
double av_diff;
cur_time = av_gettime();
if (!last_time || (cur_time - last_time) >= 500 * 1000) {
aqsize = 0;
vqsize = 0;
+ sqsize = 0;
if (is->audio_st)
aqsize = is->audioq.size;
if (is->video_st)
vqsize = is->videoq.size;
+ if (is->subtitle_st)
+ sqsize = is->subtitleq.size;
av_diff = 0;
if (is->audio_st && is->video_st)
av_diff = get_audio_clock(is) - get_video_clock(is);
- printf("%7.2f A-V:%7.3f aq=%5dKB vq=%5dKB \r",
- get_master_clock(is), av_diff, aqsize / 1024, vqsize / 1024);
+ printf("%7.2f A-V:%7.3f aq=%5dKB vq=%5dKB sq=%5dB \r",
+ get_master_clock(is), av_diff, aqsize / 1024, vqsize / 1024, sqsize);
fflush(stdout);
last_time = cur_time;
}
@@ -943,6 +1294,79 @@
return 0;
}
+static int subtitle_thread(void *arg)
+{
+ VideoState *is = arg;
+ SubPicture *sp;
+ AVPacket pkt1, *pkt = &pkt1;
+ int len1, got_subtitle;
+ double pts;
+ int i, j;
+ int r, g, b, y, u, v, a;
+
+ for(;;) {
+ while (is->paused && !is->subtitleq.abort_request) {
+ SDL_Delay(10);
+ }
+ if (packet_queue_get(&is->subtitleq, pkt, 1) < 0)
+ break;
+
+ SDL_LockMutex(is->subpq_mutex);
+ while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
+ !is->subtitleq.abort_request) {
+ SDL_CondWait(is->subpq_cond, is->subpq_mutex);
+ }
+ SDL_UnlockMutex(is->subpq_mutex);
+
+ if (is->subtitleq.abort_request)
+ goto the_end;
+
+ sp = &is->subpq[is->subpq_windex];
+
+ /* NOTE: ipts is the PTS of the _first_ picture beginning in
+ this packet, if any */
+ pts = 0;
+ if (pkt->pts != AV_NOPTS_VALUE)
+ pts = av_q2d(is->subtitle_st->time_base)*pkt->pts;
+
+ SDL_LockMutex(is->subtitle_decoder_mutex);
+ len1 = avcodec_decode_subtitle(&is->subtitle_st->codec,
+ &sp->sub, &got_subtitle,
+ pkt->data, pkt->size);
+ SDL_UnlockMutex(is->subtitle_decoder_mutex);
+// if (len1 < 0)
+// break;
+ if (got_subtitle && sp->format == 0) {
+ sp->pts = pts;
+
+ for (i = 0; i < sp->sub.num_rects; i++)
+ {
+ for (j = 0; j < sp->sub.rects[i].nb_colors; j++)
+ {
+ RGBA_IN(r, g, b, a, sp->sub.rects[i].rgba_palette + j);
+ y = RGB_TO_Y_CCIR(r, g, b);
+ u = RGB_TO_U_CCIR(r, g, b, 0);
+ v = RGB_TO_V_CCIR(r, g, b, 0);
+ YUVA_OUT(sp->sub.rects[i].rgba_palette + j, y, u, v, a);
+ }
+ }
+
+ /* now we can update the picture count */
+ if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
+ is->subpq_windex = 0;
+ SDL_LockMutex(is->subpq_mutex);
+ is->subpq_size++;
+ SDL_UnlockMutex(is->subpq_mutex);
+ }
+ av_free_packet(pkt);
+// if (step)
+// if (cur_stream)
+// stream_pause(cur_stream);
+ }
+ the_end:
+ return 0;
+}
+
/* copy samples for viewing in editor window */
static void update_sample_display(VideoState *is, short *samples, int samples_size)
{
@@ -1227,6 +1651,13 @@
packet_queue_init(&is->videoq);
is->video_tid = SDL_CreateThread(video_thread, is);
break;
+ case CODEC_TYPE_SUBTITLE:
+ is->subtitle_stream = stream_index;
+ is->subtitle_st = ic->streams[stream_index];
+ packet_queue_init(&is->subtitleq);
+
+ is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
+ break;
default:
break;
}
@@ -1238,6 +1669,8 @@
AVFormatContext *ic = is->ic;
AVCodecContext *enc;
+ if (stream_index < 0 || stream_index >= ic->nb_streams)
+ return;
enc = &ic->streams[stream_index]->codec;
switch(enc->codec_type) {
@@ -1261,6 +1694,21 @@
packet_queue_end(&is->videoq);
break;
+ case CODEC_TYPE_SUBTITLE:
+ packet_queue_abort(&is->subtitleq);
+
+ /* note: we also signal this mutex to make sure we deblock the
+ video thread in all cases */
+ SDL_LockMutex(is->subpq_mutex);
+ is->subtitle_stream_changed = 1;
+
+ SDL_CondSignal(is->subpq_cond);
+ SDL_UnlockMutex(is->subpq_mutex);
+
+ SDL_WaitThread(is->subtitle_tid, NULL);
+
+ packet_queue_end(&is->subtitleq);
+ break;
default:
break;
}
@@ -1275,6 +1723,10 @@
is->video_st = NULL;
is->video_stream = -1;
break;
+ case CODEC_TYPE_SUBTITLE:
+ is->subtitle_st = NULL;
+ is->subtitle_stream = -1;
+ break;
default:
break;
}
@@ -1318,6 +1770,7 @@
audio_index = -1;
is->video_stream = -1;
is->audio_stream = -1;
+ is->subtitle_stream = -1;
global_video_state = is;
url_set_interrupt_cb(decode_interrupt_cb);
@@ -1436,6 +1889,7 @@
/* XXX: must lock decoder threads */
SDL_LockMutex(is->video_decoder_mutex);
SDL_LockMutex(is->audio_decoder_mutex);
+ SDL_LockMutex(is->subtitle_decoder_mutex);
ret = av_seek_frame(is->ic, -1, is->seek_pos, is->seek_flags);
if (ret < 0) {
fprintf(stderr, "%s: error while seeking\n", is->ic->filename);
@@ -1443,11 +1897,15 @@
if (is->audio_stream >= 0) {
packet_queue_flush(&is->audioq);
}
+ if (is->subtitle_stream >= 0) {
+ packet_queue_flush(&is->subtitleq);
+ }
if (is->video_stream >= 0) {
packet_queue_flush(&is->videoq);
avcodec_flush_buffers(&ic->streams[video_index]->codec);
}
}
+ SDL_UnlockMutex(is->subtitle_decoder_mutex);
SDL_UnlockMutex(is->audio_decoder_mutex);
SDL_UnlockMutex(is->video_decoder_mutex);
is->seek_req = 0;
@@ -1456,6 +1914,7 @@
/* if the queue are full, no need to read more */
if (is->audioq.size > MAX_AUDIOQ_SIZE ||
is->videoq.size > MAX_VIDEOQ_SIZE ||
+ is->subtitleq.size > MAX_SUBTITLEQ_SIZE ||
url_feof(&ic->pb)) {
/* wait 10 ms */
SDL_Delay(10);
@@ -1473,6 +1932,8 @@
packet_queue_put(&is->audioq, pkt);
} else if (pkt->stream_index == is->video_stream) {
packet_queue_put(&is->videoq, pkt);
+ } else if (pkt->stream_index == is->subtitle_stream) {
+ packet_queue_put(&is->subtitleq, pkt);
} else {
av_free_packet(pkt);
}
@@ -1492,6 +1953,8 @@
stream_component_close(is, is->audio_stream);
if (is->video_stream >= 0)
stream_component_close(is, is->video_stream);
+ if (is->subtitle_stream >= 0)
+ stream_component_close(is, is->subtitle_stream);
if (is->ic) {
av_close_input_file(is->ic);
is->ic = NULL; /* safety */
@@ -1528,6 +1991,10 @@
is->pictq_mutex = SDL_CreateMutex();
is->pictq_cond = SDL_CreateCond();
+ is->subpq_mutex = SDL_CreateMutex();
+ is->subpq_cond = SDL_CreateCond();
+
+ is->subtitle_decoder_mutex = SDL_CreateMutex();
is->audio_decoder_mutex = SDL_CreateMutex();
is->video_decoder_mutex = SDL_CreateMutex();
@@ -1561,6 +2028,9 @@
}
SDL_DestroyMutex(is->pictq_mutex);
SDL_DestroyCond(is->pictq_cond);
+ SDL_DestroyMutex(is->subpq_mutex);
+ SDL_DestroyCond(is->subpq_cond);
+ SDL_DestroyMutex(is->subtitle_decoder_mutex);
SDL_DestroyMutex(is->audio_decoder_mutex);
SDL_DestroyMutex(is->video_decoder_mutex);
}
@@ -1573,14 +2043,23 @@
if (codec_type == CODEC_TYPE_VIDEO)
start_index = is->video_stream;
- else
+ else if (codec_type == CODEC_TYPE_AUDIO)
start_index = is->audio_stream;
- if (start_index < 0)
+ else
+ start_index = is->subtitle_stream;
+ if (start_index < (codec_type == CODEC_TYPE_SUBTITLE ? -1 : 0))
return;
stream_index = start_index;
for(;;) {
if (++stream_index >= is->ic->nb_streams)
- stream_index = 0;
+ {
+ if (codec_type == CODEC_TYPE_SUBTITLE)
+ {
+ stream_index = -1;
+ goto the_end;
+ } else
+ stream_index = 0;
+ }
if (stream_index == start_index)
return;
st = ic->streams[stream_index];
@@ -1593,6 +2072,7 @@
goto the_end;
break;
case CODEC_TYPE_VIDEO:
+ case CODEC_TYPE_SUBTITLE:
goto the_end;
default:
break;
@@ -1699,6 +2179,10 @@
if (cur_stream)
stream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO);
break;
+ case SDLK_t:
+ if (cur_stream)
+ stream_cycle_channel(cur_stream, CODEC_TYPE_SUBTITLE);
+ break;
case SDLK_w:
toggle_audio_display();
break;
@@ -1888,6 +2372,7 @@
"p, SPC pause\n"
"a cycle audio channel\n"
"v cycle video channel\n"
+ "t cycle subtitle channel\n"
"w show audio waves\n"
"left/right seek backward/forward 10 seconds\n"
"down/up seek backward/forward 1 minute\n"
Index: libavcodec/Makefile
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavcodec/Makefile,v
retrieving revision 1.195
diff -u -r1.195 Makefile
--- libavcodec/Makefile 27 Jun 2005 00:55:28 -0000 1.195
+++ libavcodec/Makefile 16 Jul 2005 00:01:49 -0000
@@ -17,7 +17,7 @@
ratecontrol.o adpcm.o eval.o error_resilience.o \
fft.o mdct.o raw.o golomb.o cabac.o\
dpcm.o adx.o rational.o faandct.o parser.o g726.o \
- vp3dsp.o integer.o h264idct.o rangecoder.o pnm.o h263.o msmpeg4.o h263dec.o dvdsub.o dvbsub.o
+ vp3dsp.o integer.o h264idct.o rangecoder.o pnm.o h263.o msmpeg4.o h263dec.o dvdsub.o dvbsub.o dvbsubdec.o
ifeq ($(CONFIG_AASC_DECODER),yes)
OBJS+= aasc.o
Index: libavcodec/allcodecs.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavcodec/allcodecs.c,v
retrieving revision 1.107
diff -u -r1.107 allcodecs.c
--- libavcodec/allcodecs.c 3 Jun 2005 13:59:38 -0000 1.107
+++ libavcodec/allcodecs.c 16 Jul 2005 00:01:50 -0000
@@ -554,6 +554,7 @@
/* subtitles */
register_avcodec(&dvdsub_decoder);
register_avcodec(&dvbsub_encoder);
+ register_avcodec(&dvbsub_decoder);
/* parsers */
av_register_codec_parser(&mpegvideo_parser);
@@ -573,5 +574,6 @@
av_register_codec_parser(&ac3_parser);
#endif
av_register_codec_parser(&dvdsub_parser);
+ av_register_codec_parser(&dvbsub_parser);
}
Index: libavcodec/avcodec.h
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavcodec/avcodec.h,v
retrieving revision 1.405
diff -u -r1.405 avcodec.h
--- libavcodec/avcodec.h 28 Jun 2005 22:46:36 -0000 1.405
+++ libavcodec/avcodec.h 16 Jul 2005 00:01:53 -0000
@@ -1896,18 +1896,23 @@
} AVPaletteControl;
-typedef struct AVSubtitle {
- uint16_t format; /* 0 = graphics */
+typedef struct AVSubtitleRect {
uint16_t x;
uint16_t y;
uint16_t w;
uint16_t h;
uint16_t nb_colors;
- uint32_t start_display_time; /* relative to packet pts, in ms */
- uint32_t end_display_time; /* relative to packet pts, in ms */
int linesize;
uint32_t *rgba_palette;
uint8_t *bitmap;
+} AVSubtitleRect;
+
+typedef struct AVSubtitle {
+ uint16_t format; /* 0 = graphics */
+ uint32_t start_display_time; /* relative to packet pts, in ms */
+ uint32_t end_display_time; /* relative to packet pts, in ms */
+ uint32_t num_rects;
+ AVSubtitleRect *rects;
} AVSubtitle;
extern AVCodec ac3_encoder;
@@ -2100,6 +2105,7 @@
/* subtitles */
extern AVCodec dvdsub_decoder;
extern AVCodec dvbsub_encoder;
+extern AVCodec dvbsub_decoder;
/* resample.c */
@@ -2355,6 +2361,7 @@
extern AVCodecParser mpegaudio_parser;
extern AVCodecParser ac3_parser;
extern AVCodecParser dvdsub_parser;
+extern AVCodecParser dvbsub_parser;
/* memory */
void *av_malloc(unsigned int size);
Index: libavcodec/dvbsub.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavcodec/dvbsub.c,v
retrieving revision 1.1
diff -u -r1.1 dvbsub.c
--- libavcodec/dvbsub.c 3 Jun 2005 13:59:38 -0000 1.1
+++ libavcodec/dvbsub.c 16 Jul 2005 00:01:54 -0000
@@ -192,7 +192,7 @@
#define SCALEBITS 10
#define ONE_HALF (1 << (SCALEBITS - 1))
-#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
+#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
#define RGB_TO_Y_CCIR(r, g, b) \
((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
@@ -225,18 +225,9 @@
q = outbuf;
page_id = 1;
- region_id = 0;
- clut_id = 0;
- object_id = 0;
- if (h->nb_colors <= 4) {
- /* 2 bpp, some decoders do not support it correctly */
- bpp_index = 0;
- } else if (h->nb_colors <= 16) {
- /* 4 bpp, standard encoding */
- bpp_index = 1;
- } else {
+
+ if (h->num_rects == 0 || h->rects == NULL)
return -1;
- }
*q++ = 0x00; /* subtitle_stream_id */
@@ -254,108 +245,153 @@
page_state = 2; /* mode change */
/* page_version = 0 + page_state */
*q++ = s->object_version | (page_state << 2) | 3;
- *q++ = region_id;
- *q++ = 0xff; /* reserved */
- putbe16(&q, 0); /* left pos */
- putbe16(&q, 0); /* top pos */
+
+ for (region_id = 0; region_id < h->num_rects; region_id++) {
+ *q++ = region_id;
+ *q++ = 0xff; /* reserved */
+ putbe16(&q, h->rects[region_id].x); /* left pos */
+ putbe16(&q, h->rects[region_id].y); /* top pos */
+ }
putbe16(&pseg_len, q - pseg_len - 2);
if (!s->hide_state) {
- /* CLUT segment */
+ for (clut_id = 0; clut_id < h->num_rects; clut_id++) {
+
+ /* CLUT segment */
+
+ if (h->rects[clut_id].nb_colors <= 4) {
+ /* 2 bpp, some decoders do not support it correctly */
+ bpp_index = 0;
+ } else if (h->rects[clut_id].nb_colors <= 16) {
+ /* 4 bpp, standard encoding */
+ bpp_index = 1;
+ } else {
+ return -1;
+ }
+
+ *q++ = 0x0f; /* sync byte */
+ *q++ = 0x12; /* CLUT definition segment */
+ putbe16(&q, page_id);
+ pseg_len = q;
+ q += 2; /* segment length */
+ *q++ = clut_id;
+ *q++ = (0 << 4) | 0xf; /* version = 0 */
+
+ for(i = 0; i < h->rects[clut_id].nb_colors; i++) {
+ *q++ = i; /* clut_entry_id */
+ *q++ = (1 << (7 - bpp_index)) | (0xf << 1) | 1; /* 2 bits/pixel full range */
+ {
+ int a, r, g, b;
+ a = (h->rects[clut_id].rgba_palette[i] >> 24) & 0xff;
+ r = (h->rects[clut_id].rgba_palette[i] >> 16) & 0xff;
+ g = (h->rects[clut_id].rgba_palette[i] >> 8) & 0xff;
+ b = (h->rects[clut_id].rgba_palette[i] >> 0) & 0xff;
+
+ *q++ = RGB_TO_Y_CCIR(r, g, b);
+ *q++ = RGB_TO_V_CCIR(r, g, b, 0);
+ *q++ = RGB_TO_U_CCIR(r, g, b, 0);
+ *q++ = 255 - a;
+ }
+ }
+
+ putbe16(&pseg_len, q - pseg_len - 2);
+ }
+ }
+
+ for (region_id = 0; region_id < h->num_rects; region_id++) {
+
+ /* region composition segment */
- *q++ = 0x0f; /* sync byte */
- *q++ = 0x12; /* CLUT definition segment */
+ if (h->rects[region_id].nb_colors <= 4) {
+ /* 2 bpp, some decoders do not support it correctly */
+ bpp_index = 0;
+ } else if (h->rects[region_id].nb_colors <= 16) {
+ /* 4 bpp, standard encoding */
+ bpp_index = 1;
+ } else {
+ return -1;
+ }
+
+ *q++ = 0x0f; /* sync_byte */
+ *q++ = 0x11; /* segment_type */
putbe16(&q, page_id);
pseg_len = q;
q += 2; /* segment length */
- *q++ = clut_id;
- *q++ = (0 << 4) | 0xf; /* version = 0 */
-
- for(i = 0; i < h->nb_colors; i++) {
- *q++ = i; /* clut_entry_id */
- *q++ = (1 << (7 - bpp_index)) | (0xf << 1) | 1; /* 2 bits/pixel full range */
- {
- int a, r, g, b;
- a = (h->rgba_palette[i] >> 24) & 0xff;
- r = (h->rgba_palette[i] >> 16) & 0xff;
- g = (h->rgba_palette[i] >> 8) & 0xff;
- b = (h->rgba_palette[i] >> 0) & 0xff;
-
- *q++ = RGB_TO_Y_CCIR(r, g, b);
- *q++ = RGB_TO_V_CCIR(r, g, b, 0);
- *q++ = RGB_TO_U_CCIR(r, g, b, 0);
- *q++ = 255 - a;
- }
+ *q++ = region_id;
+ *q++ = (s->object_version << 4) | (0 << 3) | 0x07; /* version , no fill */
+ putbe16(&q, h->rects[region_id].w); /* region width */
+ putbe16(&q, h->rects[region_id].h); /* region height */
+ *q++ = ((1 + bpp_index) << 5) | ((1 + bpp_index) << 2) | 0x03;
+ *q++ = region_id; /* clut_id == region_id */
+ *q++ = 0; /* 8 bit fill colors */
+ *q++ = 0x03; /* 4 bit and 2 bit fill colors */
+
+ if (!s->hide_state) {
+ putbe16(&q, region_id); /* object_id == region_id */
+ *q++ = (0 << 6) | (0 << 4);
+ *q++ = 0;
+ *q++ = 0xf0;
+ *q++ = 0;
}
putbe16(&pseg_len, q - pseg_len - 2);
}
- /* region composition segment */
-
- *q++ = 0x0f; /* sync_byte */
- *q++ = 0x11; /* segment_type */
- putbe16(&q, page_id);
- pseg_len = q;
- q += 2; /* segment length */
- *q++ = region_id;
- *q++ = (s->object_version << 4) | (0 << 3) | 0x07; /* version , no fill */
- putbe16(&q, 720); /* region width */
- putbe16(&q, 576); /* region height */
- *q++ = ((1 + bpp_index) << 5) | ((1 + bpp_index) << 2) | 0x03;
- *q++ = clut_id;
- *q++ = 0; /* 8 bit fill colors */
- *q++ = 0x03; /* 4 bit and 2 bit fill colors */
-
- if (!s->hide_state) {
- putbe16(&q, object_id);
- *q++ = (0 << 6) | (0 << 4) | ((h->x >> 8) & 0xf);
- *q++ = h->x;
- *q++ = 0xf0 | ((h->y >> 8) & 0xf);
- *q++ = h->y;
- }
-
- putbe16(&pseg_len, q - pseg_len - 2);
if (!s->hide_state) {
- /* Object Data segment */
+ for (object_id = 0; object_id < h->num_rects; object_id++) {
+ /* Object Data segment */
- *q++ = 0x0f; /* sync byte */
- *q++ = 0x13;
- putbe16(&q, page_id);
- pseg_len = q;
- q += 2; /* segment length */
-
- putbe16(&q, object_id);
- *q++ = (s->object_version << 4) | (0 << 2) | (0 << 1) | 1; /* version = 0,
- onject_coding_method,
- non_modifying_color_flag */
- {
- uint8_t *ptop_field_len, *pbottom_field_len, *top_ptr, *bottom_ptr;
- void (*dvb_encode_rle)(uint8_t **pq,
- const uint8_t *bitmap, int linesize,
- int w, int h);
- ptop_field_len = q;
- q += 2;
- pbottom_field_len = q;
- q += 2;
-
- if (bpp_index == 0)
- dvb_encode_rle = dvb_encode_rle2;
- else
- dvb_encode_rle = dvb_encode_rle4;
-
- top_ptr = q;
- dvb_encode_rle(&q, h->bitmap, h->w * 2, h->w, h->h >> 1);
- bottom_ptr = q;
- dvb_encode_rle(&q, h->bitmap + h->w, h->w * 2, h->w, h->h >> 1);
+ if (h->rects[region_id].nb_colors <= 4) {
+ /* 2 bpp, some decoders do not support it correctly */
+ bpp_index = 0;
+ } else if (h->rects[region_id].nb_colors <= 16) {
+ /* 4 bpp, standard encoding */
+ bpp_index = 1;
+ } else {
+ return -1;
+ }
- putbe16(&ptop_field_len, bottom_ptr - top_ptr);
- putbe16(&pbottom_field_len, q - bottom_ptr);
- }
+ *q++ = 0x0f; /* sync byte */
+ *q++ = 0x13;
+ putbe16(&q, page_id);
+ pseg_len = q;
+ q += 2; /* segment length */
+
+ putbe16(&q, object_id);
+ *q++ = (s->object_version << 4) | (0 << 2) | (0 << 1) | 1; /* version = 0,
+ onject_coding_method,
+ non_modifying_color_flag */
+ {
+ uint8_t *ptop_field_len, *pbottom_field_len, *top_ptr, *bottom_ptr;
+ void (*dvb_encode_rle)(uint8_t **pq,
+ const uint8_t *bitmap, int linesize,
+ int w, int h);
+ ptop_field_len = q;
+ q += 2;
+ pbottom_field_len = q;
+ q += 2;
+
+ if (bpp_index == 0)
+ dvb_encode_rle = dvb_encode_rle2;
+ else
+ dvb_encode_rle = dvb_encode_rle4;
+
+ top_ptr = q;
+ dvb_encode_rle(&q, h->rects[object_id].bitmap, h->rects[object_id].w * 2,
+ h->rects[object_id].w, h->rects[object_id].h >> 1);
+ bottom_ptr = q;
+ dvb_encode_rle(&q, h->rects[object_id].bitmap + h->rects[object_id].w,
+ h->rects[object_id].w * 2, h->rects[object_id].w,
+ h->rects[object_id].h >> 1);
- putbe16(&pseg_len, q - pseg_len - 2);
+ putbe16(&ptop_field_len, bottom_ptr - top_ptr);
+ putbe16(&pbottom_field_len, q - bottom_ptr);
+ }
+
+ putbe16(&pseg_len, q - pseg_len - 2);
+ }
}
/* end of display set segment */
Index: libavcodec/dvdsub.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavcodec/dvdsub.c,v
retrieving revision 1.1
diff -u -r1.1 dvdsub.c
--- libavcodec/dvdsub.c 3 Jun 2005 13:59:38 -0000 1.1
+++ libavcodec/dvdsub.c 16 Jul 2005 00:01:54 -0000
@@ -132,11 +132,12 @@
int cmd_pos, pos, cmd, x1, y1, x2, y2, offset1, offset2, next_cmd_pos;
uint8_t palette[4], alpha[4];
int date;
+ int i;
if (buf_size < 4)
return -1;
- sub_header->bitmap = NULL;
- sub_header->rgba_palette = NULL;
+ sub_header->rects = NULL;
+ sub_header->num_rects = 0;
sub_header->start_display_time = 0;
sub_header->end_display_time = 0;
@@ -230,30 +231,39 @@
if (h < 0)
h = 0;
if (w > 0 && h > 0) {
- av_freep(&sub_header->bitmap);
- av_freep(&sub_header->rgba_palette);
+ if (sub_header->rects != NULL) {
+ for (i = 0; i < sub_header->num_rects; i++) {
+ av_free(sub_header->rects[i].bitmap);
+ av_free(sub_header->rects[i].rgba_palette);
+ }
+ av_freep(&sub_header->rects);
+ sub_header->num_rects = 0;
+ }
+
bitmap = av_malloc(w * h);
- sub_header->rgba_palette = av_malloc(4 * 4);
+ sub_header->rects = av_mallocz(sizeof(AVSubtitleRect));
+ sub_header->num_rects = 1;
+ sub_header->rects[0].rgba_palette = av_malloc(4 * 4);
decode_rle(bitmap, w * 2, w, h / 2,
buf, offset1 * 2, buf_size);
decode_rle(bitmap + w, w * 2, w, h / 2,
buf, offset2 * 2, buf_size);
- guess_palette(sub_header->rgba_palette,
+ guess_palette(sub_header->rects[0].rgba_palette,
palette, alpha, 0xffff00);
- sub_header->x = x1;
- sub_header->y = y1;
- sub_header->w = w;
- sub_header->h = h;
- sub_header->nb_colors = 4;
- sub_header->linesize = w;
- sub_header->bitmap = bitmap;
+ sub_header->rects[0].x = x1;
+ sub_header->rects[0].y = y1;
+ sub_header->rects[0].w = w;
+ sub_header->rects[0].h = h;
+ sub_header->rects[0].nb_colors = 4;
+ sub_header->rects[0].linesize = w;
+ sub_header->rects[0].bitmap = bitmap;
}
}
if (next_cmd_pos == cmd_pos)
break;
cmd_pos = next_cmd_pos;
}
- if (sub_header->bitmap)
+ if (sub_header->num_rects > 0)
return 0;
fail:
return -1;
@@ -278,34 +288,34 @@
int y1, y2, x1, x2, y, w, h, i;
uint8_t *bitmap;
- if (s->w <= 0 || s->h <= 0)
+ if (s->num_rects == 0 || s->rects == NULL || s->rects[0].w <= 0 || s->rects[0].h <= 0)
return 0;
memset(transp_color, 0, 256);
- for(i = 0; i < s->nb_colors; i++) {
- if ((s->rgba_palette[i] >> 24) == 0)
+ for(i = 0; i < s->rects[0].nb_colors; i++) {
+ if ((s->rects[0].rgba_palette[i] >> 24) == 0)
transp_color[i] = 1;
}
y1 = 0;
- while (y1 < s->h && is_transp(s->bitmap + y1 * s->linesize, 1, s->w,
- transp_color))
+ while (y1 < s->rects[0].h && is_transp(s->rects[0].bitmap + y1 * s->rects[0].linesize,
+ 1, s->rects[0].w, transp_color))
y1++;
- if (y1 == s->h) {
- av_freep(&s->bitmap);
- s->w = s->h = 0;
+ if (y1 == s->rects[0].h) {
+ av_freep(&s->rects[0].bitmap);
+ s->rects[0].w = s->rects[0].h = 0;
return 0;
}
- y2 = s->h - 1;
- while (y2 > 0 && is_transp(s->bitmap + y2 * s->linesize, 1, s->w,
- transp_color))
+ y2 = s->rects[0].h - 1;
+ while (y2 > 0 && is_transp(s->rects[0].bitmap + y2 * s->rects[0].linesize, 1,
+ s->rects[0].w, transp_color))
y2--;
x1 = 0;
- while (x1 < (s->w - 1) && is_transp(s->bitmap + x1, s->linesize, s->h,
- transp_color))
+ while (x1 < (s->rects[0].w - 1) && is_transp(s->rects[0].bitmap + x1, s->rects[0].linesize,
+ s->rects[0].h, transp_color))
x1++;
- x2 = s->w - 1;
- while (x2 > 0 && is_transp(s->bitmap + x2, s->linesize, s->h,
+ x2 = s->rects[0].w - 1;
+ while (x2 > 0 && is_transp(s->rects[0].bitmap + x2, s->rects[0].linesize, s->rects[0].h,
transp_color))
x2--;
w = x2 - x1 + 1;
@@ -314,15 +324,15 @@
if (!bitmap)
return 1;
for(y = 0; y < h; y++) {
- memcpy(bitmap + w * y, s->bitmap + x1 + (y1 + y) * s->linesize, w);
+ memcpy(bitmap + w * y, s->rects[0].bitmap + x1 + (y1 + y) * s->rects[0].linesize, w);
}
- av_freep(&s->bitmap);
- s->bitmap = bitmap;
- s->linesize = w;
- s->w = w;
- s->h = h;
- s->x += x1;
- s->y += y1;
+ av_freep(&s->rects[0].bitmap);
+ s->rects[0].bitmap = bitmap;
+ s->rects[0].linesize = w;
+ s->rects[0].w = w;
+ s->rects[0].h = h;
+ s->rects[0].x += x1;
+ s->rects[0].y += y1;
return 1;
}
@@ -379,8 +389,8 @@
av_log(NULL, AV_LOG_INFO, "start=%d ms end =%d ms\n",
sub->start_display_time,
sub->end_display_time);
- ppm_save("/tmp/a.ppm", sub->bitmap,
- sub->w, sub->h, sub->rgba_palette);
+ ppm_save("/tmp/a.ppm", sub->rects[0].bitmap,
+ sub->rects[0].w, sub->rects[0].h, sub->rects[0].rgba_palette);
#endif
*data_size = 1;
Index: libavformat/mpegts.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavformat/mpegts.c,v
retrieving revision 1.29
diff -u -r1.29 mpegts.c
--- libavformat/mpegts.c 26 May 2005 20:17:11 -0000 1.29
+++ libavformat/mpegts.c 16 Jul 2005 00:01:57 -0000
@@ -30,7 +30,10 @@
synchronisation is lost */
#define MAX_RESYNC_SIZE 4096
-static int add_pes_stream(MpegTSContext *ts, int pid, int stream_type);
+typedef struct PESContext PESContext;
+
+static PESContext* add_pes_stream(MpegTSContext *ts, int pid, int stream_type);
+static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code);
enum MpegTSFilterType {
MPEGTS_PES,
@@ -368,8 +371,13 @@
{
MpegTSContext *ts = opaque;
SectionHeader h1, *h = &h1;
- const uint8_t *p, *p_end;
- int program_info_length, pcr_pid, pid, stream_type, desc_length;
+ PESContext *pes;
+ AVStream *st;
+ const uint8_t *p, *p_end, *desc_list_end, *desc_end;
+ int program_info_length, pcr_pid, pid, stream_type;
+ int desc_list_len, desc_len, desc_tag;
+ int comp_page, anc_page;
+ char language[4];
#ifdef DEBUG_SI
printf("PMT:\n");
@@ -399,18 +407,57 @@
if (p >= p_end)
return;
for(;;) {
+ language[0] = 0;
+ st = 0;
stream_type = get8(&p, p_end);
if (stream_type < 0)
break;
pid = get16(&p, p_end) & 0x1fff;
if (pid < 0)
break;
- desc_length = get16(&p, p_end) & 0xfff;
- if (desc_length < 0)
+ desc_list_len = get16(&p, p_end) & 0xfff;
+ if (desc_list_len < 0)
+ break;
+ desc_list_end = p + desc_list_len;
+ if (desc_list_end > p_end)
break;
- p += desc_length;
- if (p > p_end)
- return;
+ for(;;) {
+ desc_tag = get8(&p, desc_list_end);
+ if (desc_tag < 0)
+ break;
+ desc_len = get8(&p, desc_list_end);
+ desc_end = p + desc_len;
+ if (desc_end > desc_list_end)
+ break;
+#ifdef DEBUG_SI
+ printf("tag: 0x%02x len=%d\n", desc_tag, desc_len);
+#endif
+ switch(desc_tag) {
+ case DVB_SUBT_DESCID:
+ if (stream_type == STREAM_TYPE_PRIVATE_DATA)
+ stream_type = STREAM_TYPE_SUBTITLE_DVB;
+
+ language[0] = get8(&p, desc_end);
+ language[1] = get8(&p, desc_end);
+ language[2] = get8(&p, desc_end);
+ language[3] = 0;
+ get8(&p, desc_end);
+ comp_page = get16(&p, desc_end);
+ anc_page = get16(&p, desc_end);
+
+ break;
+ case 0x0a: /* ISO 639 language descriptor */
+ language[0] = get8(&p, desc_end);
+ language[1] = get8(&p, desc_end);
+ language[2] = get8(&p, desc_end);
+ language[3] = 0;
+ break;
+ default:
+ break;
+ }
+ p = desc_end;
+ }
+ p = desc_list_end;
#ifdef DEBUG_SI
printf("stream_type=%d pid=0x%x\n", stream_type, pid);
@@ -427,12 +474,28 @@
case STREAM_TYPE_AUDIO_AAC:
case STREAM_TYPE_AUDIO_AC3:
case STREAM_TYPE_AUDIO_DTS:
- add_pes_stream(ts, pid, stream_type);
+ case STREAM_TYPE_SUBTITLE_DVB:
+ pes = add_pes_stream(ts, pid, stream_type);
+ if (pes)
+ st = new_pes_av_stream(pes, 0);
break;
default:
/* we ignore the other streams */
break;
}
+
+ if (st) {
+ if (language[0] != 0) {
+ st->language[0] = language[0];
+ st->language[1] = language[1];
+ st->language[2] = language[2];
+ st->language[3] = language[3];
+ }
+
+ if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {
+ st->codec.sub_id = (anc_page << 16) | comp_page;
+ }
+ }
}
/* all parameters are there */
ts->set_service_cb(ts->set_service_opaque, 0);
@@ -653,7 +716,7 @@
#define PES_START_SIZE 9
#define MAX_PES_HEADER_SIZE (9 + 255)
-typedef struct PESContext {
+struct PESContext {
int pid;
int stream_type;
MpegTSContext *ts;
@@ -666,7 +729,7 @@
int pes_header_size;
int64_t pts, dts;
uint8_t header[MAX_PES_HEADER_SIZE];
-} PESContext;
+};
static int64_t get_pts(const uint8_t *p)
{
@@ -687,9 +750,8 @@
{
PESContext *pes = opaque;
MpegTSContext *ts = pes->ts;
- AVStream *st;
const uint8_t *p;
- int len, code, codec_type, codec_id;
+ int len, code;
if (is_start) {
pes->state = MPEGTS_HEADER;
@@ -722,59 +784,7 @@
goto skip;
if (!pes->st) {
/* allocate stream */
- switch(pes->stream_type){
- case STREAM_TYPE_AUDIO_MPEG1:
- case STREAM_TYPE_AUDIO_MPEG2:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_MP3;
- break;
- case STREAM_TYPE_VIDEO_MPEG1:
- case STREAM_TYPE_VIDEO_MPEG2:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_MPEG2VIDEO;
- break;
- case STREAM_TYPE_VIDEO_MPEG4:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_MPEG4;
- break;
- case STREAM_TYPE_VIDEO_H264:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_H264;
- break;
- case STREAM_TYPE_AUDIO_AAC:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_AAC;
- break;
- case STREAM_TYPE_AUDIO_AC3:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_AC3;
- break;
- case STREAM_TYPE_AUDIO_DTS:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_DTS;
- break;
- default:
- if (code >= 0x1c0 && code <= 0x1df) {
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_MP2;
- } else if (code == 0x1bd) {
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_AC3;
- } else {
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_MPEG1VIDEO;
- }
- break;
- }
- st = av_new_stream(pes->stream, pes->pid);
- if (st) {
- av_set_pts_info(st, 33, 1, 90000);
- st->priv_data = pes;
- st->codec.codec_type = codec_type;
- st->codec.codec_id = codec_id;
- st->need_parsing = 1;
- pes->st = st;
- }
+ new_pes_av_stream(pes, code);
}
pes->state = MPEGTS_PESHEADER_FILL;
pes->total_size = (pes->header[4] << 8) | pes->header[5];
@@ -854,7 +864,73 @@
}
}
-static int add_pes_stream(MpegTSContext *ts, int pid, int stream_type)
+static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code)
+{
+ AVStream *st;
+ int codec_type, codec_id;
+
+ switch(pes->stream_type){
+ case STREAM_TYPE_AUDIO_MPEG1:
+ case STREAM_TYPE_AUDIO_MPEG2:
+ codec_type = CODEC_TYPE_AUDIO;
+ codec_id = CODEC_ID_MP3;
+ break;
+ case STREAM_TYPE_VIDEO_MPEG1:
+ case STREAM_TYPE_VIDEO_MPEG2:
+ codec_type = CODEC_TYPE_VIDEO;
+ codec_id = CODEC_ID_MPEG2VIDEO;
+ break;
+ case STREAM_TYPE_VIDEO_MPEG4:
+ codec_type = CODEC_TYPE_VIDEO;
+ codec_id = CODEC_ID_MPEG4;
+ break;
+ case STREAM_TYPE_VIDEO_H264:
+ codec_type = CODEC_TYPE_VIDEO;
+ codec_id = CODEC_ID_H264;
+ break;
+ case STREAM_TYPE_AUDIO_AAC:
+ codec_type = CODEC_TYPE_AUDIO;
+ codec_id = CODEC_ID_AAC;
+ break;
+ case STREAM_TYPE_AUDIO_AC3:
+ codec_type = CODEC_TYPE_AUDIO;
+ codec_id = CODEC_ID_AC3;
+ break;
+ case STREAM_TYPE_AUDIO_DTS:
+ codec_type = CODEC_TYPE_AUDIO;
+ codec_id = CODEC_ID_DTS;
+ break;
+ case STREAM_TYPE_SUBTITLE_DVB:
+ codec_type = CODEC_TYPE_SUBTITLE;
+ codec_id = CODEC_ID_DVB_SUBTITLE;
+ break;
+ default:
+ if (code >= 0x1c0 && code <= 0x1df) {
+ codec_type = CODEC_TYPE_AUDIO;
+ codec_id = CODEC_ID_MP2;
+ } else if (code == 0x1bd) {
+ codec_type = CODEC_TYPE_AUDIO;
+ codec_id = CODEC_ID_AC3;
+ } else {
+ codec_type = CODEC_TYPE_VIDEO;
+ codec_id = CODEC_ID_MPEG1VIDEO;
+ }
+ break;
+ }
+ st = av_new_stream(pes->stream, pes->pid);
+ if (st) {
+ av_set_pts_info(st, 33, 1, 90000);
+ st->priv_data = pes;
+ st->codec.codec_type = codec_type;
+ st->codec.codec_id = codec_id;
+ st->need_parsing = 1;
+ pes->st = st;
+ }
+ return st;
+}
+
+
+static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int stream_type)
{
MpegTSFilter *tss;
PESContext *pes;
@@ -862,7 +938,7 @@
/* if no pid found, then add a pid context */
pes = av_mallocz(sizeof(PESContext));
if (!pes)
- return -1;
+ return 0;
pes->ts = ts;
pes->stream = ts->stream;
pes->pid = pid;
@@ -870,9 +946,9 @@
tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
if (!tss) {
av_free(pes);
- return -1;
+ return 0;
}
- return 0;
+ return pes;
}
/* handle one TS packet */
@@ -1131,11 +1207,11 @@
}
if (ts->nb_services <= 0) {
- /* raw transport stream */
- ts->auto_guess = 1;
- s->ctx_flags |= AVFMTCTX_NOHEADER;
- goto do_pcr;
- }
+ /* raw transport stream */
+ ts->auto_guess = 1;
+ s->ctx_flags |= AVFMTCTX_NOHEADER;
+ goto do_pcr;
+ }
/* tune to first service found */
for(i=0; i<ts->nb_services && ts->set_service_ret; i++){
Index: libavformat/mpegts.h
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavformat/mpegts.h,v
retrieving revision 1.7
diff -u -r1.7 mpegts.h
--- libavformat/mpegts.h 14 Jul 2004 01:32:14 -0000 1.7
+++ libavformat/mpegts.h 16 Jul 2005 00:01:57 -0000
@@ -31,6 +31,9 @@
#define PMT_TID 0x02
#define SDT_TID 0x42
+/* descriptor ids */
+#define DVB_SUBT_DESCID 0x59
+
#define STREAM_TYPE_VIDEO_MPEG1 0x01
#define STREAM_TYPE_VIDEO_MPEG2 0x02
#define STREAM_TYPE_AUDIO_MPEG1 0x03
@@ -44,6 +47,8 @@
#define STREAM_TYPE_AUDIO_AC3 0x81
#define STREAM_TYPE_AUDIO_DTS 0x8a
+#define STREAM_TYPE_SUBTITLE_DVB 0x100
+
unsigned int mpegts_crc32(const uint8_t *data, int len);
extern AVOutputFormat mpegts_mux;
Index: libavformat/utils.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavformat/utils.c,v
retrieving revision 1.157
diff -u -r1.157 utils.c
--- libavformat/utils.c 8 Jul 2005 09:14:05 -0000 1.157
+++ libavformat/utils.c 16 Jul 2005 00:02:01 -0000
@@ -2508,6 +2508,9 @@
if (flags & AVFMT_SHOW_IDS) {
av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
}
+ if (strlen(st->language) > 0) {
+ av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
+ }
av_log(NULL, AV_LOG_INFO, ": %s\n", buf);
}
}
-------------- next part --------------
/*
* DVB subtitle decoding for ffmpeg
* Copyright (c) 2005 Ian Caulfield.
*
* 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"
#include "dsputil.h"
#include "bitstream.h"
//#define DEBUG
//#define DEBUG_PACKET_CONTENTS
//#define DEBUG_SAVE_IMAGES
#define DVBSUB_PAGE_SEGMENT 0x10
#define DVBSUB_REGION_SEGMENT 0x11
#define DVBSUB_CLUT_SEGMENT 0x12
#define DVBSUB_OBJECT_SEGMENT 0x13
#define DVBSUB_DISPLAY_SEGMENT 0x80
static unsigned char *cm;
#ifdef DEBUG_SAVE_IMAGES
#undef fprintf
#if 0
static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
uint32_t *rgba_palette)
{
int x, y, v;
FILE *f;
char fname[40], fname2[40];
char command[1024];
snprintf(fname, 40, "%s.ppm", filename);
f = fopen(fname, "w");
if (!f) {
perror(fname);
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++) {
v = rgba_palette[bitmap[y * w + x]];
putc((v >> 16) & 0xff, f);
putc((v >> 8) & 0xff, f);
putc((v >> 0) & 0xff, f);
}
}
fclose(f);
snprintf(fname2, 40, "%s-a.pgm", filename);
f = fopen(fname2, "w");
if (!f) {
perror(fname2);
exit(1);
}
fprintf(f, "P5\n"
"%d %d\n"
"%d\n",
w, h, 255);
for(y = 0; y < h; y++) {
for(x = 0; x < w; x++) {
v = rgba_palette[bitmap[y * w + x]];
putc((v >> 24) & 0xff, f);
}
}
fclose(f);
snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
system(command);
snprintf(command, 1024, "rm %s %s", fname, fname2);
system(command);
}
#endif
static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)
{
int x, y, v;
FILE *f;
char fname[40], fname2[40];
char command[1024];
snprintf(fname, 40, "%s.ppm", filename);
f = fopen(fname, "w");
if (!f) {
perror(fname);
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++) {
v = bitmap[y * w + x];
putc((v >> 16) & 0xff, f);
putc((v >> 8) & 0xff, f);
putc((v >> 0) & 0xff, f);
}
}
fclose(f);
snprintf(fname2, 40, "%s-a.pgm", filename);
f = fopen(fname2, "w");
if (!f) {
perror(fname2);
exit(1);
}
fprintf(f, "P5\n"
"%d %d\n"
"%d\n",
w, h, 255);
for(y = 0; y < h; y++) {
for(x = 0; x < w; x++) {
v = bitmap[y * w + x];
putc((v >> 24) & 0xff, f);
}
}
fclose(f);
snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
system(command);
snprintf(command, 1024, "rm %s %s", fname, fname2);
system(command);
}
#endif
#define RGBA(r,g,b,a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
typedef struct DVBSubCLUT {
int id;
uint32_t clut4[4];
uint32_t clut16[16];
uint32_t clut256[256];
struct DVBSubCLUT *next;
} DVBSubCLUT;
static DVBSubCLUT default_clut;
typedef struct DVBSubObjectDisplay {
int object_id;
int region_id;
int x_pos;
int y_pos;
int fgcolour;
int bgcolour;
struct DVBSubObjectDisplay *region_list_next;
struct DVBSubObjectDisplay *object_list_next;
} DVBSubObjectDisplay;
typedef struct DVBSubObject {
int id;
int type;
DVBSubObjectDisplay *display_list;
struct DVBSubObject *next;
} DVBSubObject;
typedef struct DVBSubRegionDisplay {
int region_id;
int x_pos;
int y_pos;
struct DVBSubRegionDisplay *next;
} DVBSubRegionDisplay;
typedef struct DVBSubRegion {
int id;
int width;
int height;
int depth;
int clut;
int bgcolour;
uint8_t *pbuf;
int buf_size;
DVBSubObjectDisplay *display_list;
struct DVBSubRegion *next;
} DVBSubRegion;
typedef struct DVBSubContext {
int composition_id;
int ancillary_id;
int time_out;
DVBSubRegion *region_list;
DVBSubCLUT *clut_list;
DVBSubObject *object_list;
int display_list_size;
DVBSubRegionDisplay *display_list;
} DVBSubContext;
static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
{
DVBSubObject *ptr = ctx->object_list;
while (ptr != NULL && ptr->id != object_id) {
ptr = ptr->next;
}
return ptr;
}
static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
{
DVBSubCLUT *ptr = ctx->clut_list;
while (ptr != NULL && ptr->id != clut_id) {
ptr = ptr->next;
}
return ptr;
}
static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
{
DVBSubRegion *ptr = ctx->region_list;
while (ptr != NULL && ptr->id != region_id) {
ptr = ptr->next;
}
return ptr;
}
static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
{
DVBSubObject *object, *obj2, **obj2_ptr;
DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
while (region->display_list != NULL) {
display = region->display_list;
object = get_object(ctx, display->object_id);
if (object != NULL) {
obj_disp = object->display_list;
obj_disp_ptr = &object->display_list;
while (obj_disp != NULL && obj_disp != display) {
obj_disp_ptr = &obj_disp->object_list_next;
obj_disp = obj_disp->object_list_next;
}
if (obj_disp) {
*obj_disp_ptr = obj_disp->object_list_next;
if (object->display_list == NULL) {
obj2 = ctx->object_list;
obj2_ptr = &ctx->object_list;
while (obj2 != NULL && obj2 != object) {
obj2_ptr = &obj2->next;
obj2 = obj2->next;
}
*obj2_ptr = obj2->next;
av_free(obj2);
}
}
}
region->display_list = display->region_list_next;
av_free(display);
}
}
static void delete_state(DVBSubContext *ctx)
{
DVBSubRegion *region;
DVBSubCLUT *clut;
while (ctx->region_list != NULL)
{
region = ctx->region_list;
ctx->region_list = region->next;
delete_region_display_list(ctx, region);
if (region->pbuf != NULL)
av_free(region->pbuf);
av_free(region);
}
while (ctx->clut_list != NULL)
{
clut = ctx->clut_list;
ctx->clut_list = clut->next;
av_free(clut);
}
/* Should already be null */
if (ctx->object_list != NULL)
av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");
}
static int dvbsub_init_decoder(AVCodecContext *avctx)
{
int i, r, g, b, a = 0;
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
cm = cropTbl + MAX_NEG_CROP;
memset(avctx->priv_data, 0, sizeof(DVBSubContext));
ctx->composition_id = avctx->sub_id & 0xffff;
ctx->ancillary_id = avctx->sub_id >> 16;
default_clut.id = -1;
default_clut.next = NULL;
default_clut.clut4[0] = RGBA( 0, 0, 0, 0);
default_clut.clut4[1] = RGBA(255, 255, 255, 255);
default_clut.clut4[2] = RGBA( 0, 0, 0, 255);
default_clut.clut4[3] = RGBA(127, 127, 127, 255);
default_clut.clut16[0] = RGBA( 0, 0, 0, 0);
for (i = 1; i < 16; i++) {
if (i < 8) {
r = (i & 1) ? 255 : 0;
g = (i & 2) ? 255 : 0;
b = (i & 4) ? 255 : 0;
} else {
r = (i & 1) ? 127 : 0;
g = (i & 2) ? 127 : 0;
b = (i & 4) ? 127 : 0;
}
default_clut.clut16[i] = RGBA(r, g, b, 255);
}
default_clut.clut256[0] = RGBA( 0, 0, 0, 0);
for (i = 1; i < 256; i++) {
if (i < 8) {
r = (i & 1) ? 255 : 0;
g = (i & 2) ? 255 : 0;
b = (i & 4) ? 255 : 0;
a = 63;
} else {
switch (i & 0x88) {
case 0x00:
r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
a = 255;
break;
case 0x08:
r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
a = 127;
break;
case 0x80:
r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
a = 255;
break;
case 0x88:
r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
a = 255;
break;
}
}
default_clut.clut256[i] = RGBA(r, g, b, a);
}
return 0;
}
static int dvbsub_close_decoder(AVCodecContext *avctx)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
DVBSubRegionDisplay *display;
delete_state(ctx);
while (ctx->display_list != NULL)
{
display = ctx->display_list;
ctx->display_list = display->next;
av_free(display);
}
return 0;
}
static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
uint8_t **srcbuf, int buf_size,
int non_mod, uint8_t *map_table)
{
GetBitContext gb;
int bits;
int run_length;
int pixels_read = 0;
init_get_bits(&gb, *srcbuf, buf_size << 8);
while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
bits = get_bits(&gb, 2);
if (bits != 0) {
if (non_mod != 1 || bits != 1) {
if (map_table != NULL)
*destbuf++ = map_table[bits];
else
*destbuf++ = bits;
}
pixels_read++;
} else {
bits = get_bits(&gb, 1);
if (bits == 1) {
run_length = get_bits(&gb, 3) + 3;
bits = get_bits(&gb, 2);
if (non_mod == 1 && bits == 1)
pixels_read += run_length;
else {
if (map_table != NULL)
bits = map_table[bits];
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
}
} else {
bits = get_bits(&gb, 1);
if (bits == 0) {
bits = get_bits(&gb, 2);
if (bits == 2) {
run_length = get_bits(&gb, 4) + 12;
bits = get_bits(&gb, 2);
if (non_mod == 1 && bits == 1)
pixels_read += run_length;
else {
if (map_table != NULL)
bits = map_table[bits];
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
}
} else if (bits == 3) {
run_length = get_bits(&gb, 8) + 29;
bits = get_bits(&gb, 2);
if (non_mod == 1 && bits == 1)
pixels_read += run_length;
else {
if (map_table != NULL)
bits = map_table[bits];
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
}
} else if (bits == 1) {
pixels_read += 2;
if (map_table != NULL)
bits = map_table[0];
else
bits = 0;
if (pixels_read <= dbuf_len) {
*destbuf++ = bits;
*destbuf++ = bits;
}
} else {
(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
return pixels_read;
}
} else {
if (map_table != NULL)
bits = map_table[0];
else
bits = 0;
*destbuf++ = bits;
pixels_read++;
}
}
}
}
if (get_bits(&gb, 6) != 0)
av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
return pixels_read;
}
static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
uint8_t **srcbuf, int buf_size,
int non_mod, uint8_t *map_table)
{
GetBitContext gb;
int bits;
int run_length;
int pixels_read = 0;
init_get_bits(&gb, *srcbuf, buf_size << 8);
while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
bits = get_bits(&gb, 4);
if (bits != 0) {
if (non_mod != 1 || bits != 1) {
if (map_table != NULL)
*destbuf++ = map_table[bits];
else
*destbuf++ = bits;
}
pixels_read++;
} else {
bits = get_bits(&gb, 1);
if (bits == 0) {
run_length = get_bits(&gb, 3);
if (run_length == 0) {
(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
return pixels_read;
}
run_length += 2;
if (map_table != NULL)
bits = map_table[0];
else
bits = 0;
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
} else {
bits = get_bits(&gb, 1);
if (bits == 0) {
run_length = get_bits(&gb, 2) + 4;
bits = get_bits(&gb, 4);
if (non_mod == 1 && bits == 1)
pixels_read += run_length;
else {
if (map_table != NULL)
bits = map_table[bits];
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
}
} else {
bits = get_bits(&gb, 2);
if (bits == 2) {
run_length = get_bits(&gb, 4) + 9;
bits = get_bits(&gb, 4);
if (non_mod == 1 && bits == 1)
pixels_read += run_length;
else {
if (map_table != NULL)
bits = map_table[bits];
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
}
} else if (bits == 3) {
run_length = get_bits(&gb, 8) + 25;
bits = get_bits(&gb, 4);
if (non_mod == 1 && bits == 1)
pixels_read += run_length;
else {
if (map_table != NULL)
bits = map_table[bits];
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
}
} else if (bits == 1) {
pixels_read += 2;
if (map_table != NULL)
bits = map_table[0];
else
bits = 0;
if (pixels_read <= dbuf_len) {
*destbuf++ = bits;
*destbuf++ = bits;
}
} else {
if (map_table != NULL)
bits = map_table[0];
else
bits = 0;
*destbuf++ = bits;
pixels_read ++;
}
}
}
}
}
if (get_bits(&gb, 8) != 0)
av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
return pixels_read;
}
static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,
uint8_t **srcbuf, int buf_size,
int non_mod, uint8_t *map_table)
{
uint8_t *sbuf_end = (*srcbuf) + buf_size;
int bits;
int run_length;
int pixels_read = 0;
while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
bits = *(*srcbuf)++;
if (bits != 0) {
if (non_mod != 1 || bits != 1) {
if (map_table != NULL)
*destbuf++ = map_table[bits];
else
*destbuf++ = bits;
}
pixels_read++;
} else {
bits = *(*srcbuf)++;
run_length = bits & 0x7f;
if ((bits & 0x80) == 0) {
if (run_length == 0) {
return pixels_read;
}
if (map_table != NULL)
bits = map_table[0];
else
bits = 0;
while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
} else {
bits = *(*srcbuf)++;
if (non_mod == 1 && bits == 1)
pixels_read += run_length;
if (map_table != NULL)
bits = map_table[bits];
else while (run_length-- > 0 && pixels_read < dbuf_len) {
*destbuf++ = bits;
pixels_read++;
}
}
}
}
if (*(*srcbuf)++ != 0)
av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
return pixels_read;
}
static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
uint8_t *buf, int buf_size, int top_bottom, int non_mod)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
DVBSubRegion *region = get_region(ctx, display->region_id);
uint8_t *buf_end = buf + buf_size;
uint8_t *pbuf;
int x_pos, y_pos;
int i;
uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
uint8_t *map_table;
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "DVB pixel block size %d, %s field:\n", buf_size,
top_bottom ? "bottom" : "top");
#endif
#ifdef DEBUG_PACKET_CONTENTS
for (i = 0; i < buf_size; i++)
{
if (i % 16 == 0)
av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i);
av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
if (i % 16 == 15)
av_log(avctx, AV_LOG_INFO, "\n");
}
if (i % 16 != 0)
av_log(avctx, AV_LOG_INFO, "\n");
#endif
if (region == 0)
return;
pbuf = region->pbuf;
x_pos = display->x_pos;
y_pos = display->y_pos;
if ((y_pos & 1) != top_bottom)
y_pos++;
while (buf < buf_end) {
if (x_pos > region->width || y_pos > region->height) {
av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
return;
}
switch (*buf++) {
case 0x10:
if (region->depth == 8)
map_table = map2to8;
else if (region->depth == 4)
map_table = map2to4;
else
map_table = NULL;
x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, map_table);
break;
case 0x11:
if (region->depth < 4) {
av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
return;
}
if (region->depth == 8)
map_table = map4to8;
else
map_table = NULL;
x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, map_table);
break;
case 0x12:
if (region->depth < 8) {
av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
return;
}
x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, NULL);
break;
case 0x20:
map2to4[0] = (*buf) >> 4;
map2to4[1] = (*buf++) & 0xf;
map2to4[2] = (*buf) >> 4;
map2to4[3] = (*buf++) & 0xf;
break;
case 0x21:
for (i = 0; i < 4; i++)
map2to8[i] = *buf++;
break;
case 0x22:
for (i = 0; i < 16; i++)
map4to8[i] = *buf++;
break;
case 0xf0:
x_pos = display->x_pos;
y_pos += 2;
break;
default:
av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
}
}
}
static void dvbsub_parse_object_segment(AVCodecContext *avctx,
uint8_t *buf, int buf_size)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
uint8_t *buf_end = buf + buf_size;
uint8_t *block;
int object_id;
DVBSubObject *object;
DVBSubObjectDisplay *display;
int top_field_len, bottom_field_len;
int coding_method, non_modifying_colour;
object_id = BE_16(buf);
buf += 2;
object = get_object(ctx, object_id);
if (!object)
return;
coding_method = ((*buf) >> 2) & 3;
non_modifying_colour = ((*buf++) >> 1) & 1;
if (coding_method == 0) {
top_field_len = BE_16(buf);
buf += 2;
bottom_field_len = BE_16(buf);
buf += 2;
if (buf + top_field_len + bottom_field_len > buf_end) {
av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
return;
}
for (display = object->display_list; display != 0; display = display->object_list_next) {
block = buf;
dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
non_modifying_colour);
if (bottom_field_len > 0)
block = buf + top_field_len;
else
bottom_field_len = top_field_len;
dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1,
non_modifying_colour);
}
/* } else if (coding_method == 1) {*/
} else {
av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
}
}
#define SCALEBITS 10
#define ONE_HALF (1 << (SCALEBITS - 1))
#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
#define YUV_TO_RGB1_CCIR(cb1, cr1)\
{\
cb = (cb1) - 128;\
cr = (cr1) - 128;\
r_add = FIX(1.40200*255.0/224.0) * cr + ONE_HALF;\
g_add = - FIX(0.34414*255.0/224.0) * cb - FIX(0.71414*255.0/224.0) * cr + \
ONE_HALF;\
b_add = FIX(1.77200*255.0/224.0) * cb + ONE_HALF;\
}
#define YUV_TO_RGB2_CCIR(r, g, b, y1)\
{\
y = ((y1) - 16) * FIX(255.0/219.0);\
r = cm[(y + r_add) >> SCALEBITS];\
g = cm[(y + g_add) >> SCALEBITS];\
b = cm[(y + b_add) >> SCALEBITS];\
}
static void dvbsub_parse_clut_segment(AVCodecContext *avctx,
uint8_t *buf, int buf_size)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
uint8_t *buf_end = buf + buf_size;
int clut_id;
DVBSubCLUT *clut;
int entry_id, depth , full_range;
int y, cr, cb, alpha;
int r, g, b, r_add, g_add, b_add;
#ifdef DEBUG_PACKET_CONTENTS
int i;
av_log(avctx, AV_LOG_INFO, "DVB clut packet:\n");
for (i=0; i < buf_size; i++)
{
av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
if (i % 16 == 15)
av_log(avctx, AV_LOG_INFO, "\n");
}
if (i % 16 != 0)
av_log(avctx, AV_LOG_INFO, "\n");
#endif
clut_id = *buf++;
buf += 1;
clut = get_clut(ctx, clut_id);
if (clut == NULL) {
clut = av_malloc(sizeof(DVBSubCLUT));
memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
clut->id = clut_id;
clut->next = ctx->clut_list;
ctx->clut_list = clut;
}
while (buf + 4 < buf_end)
{
entry_id = *buf++;
depth = (*buf) & 0xe0;
if (depth == 0) {
av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
return;
}
full_range = (*buf++) & 1;
if (full_range) {
y = *buf++;
cr = *buf++;
cb = *buf++;
alpha = *buf++;
} else {
y = buf[0] & 0xfc;
cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
cb = (buf[1] << 2) & 0xf0;
alpha = (buf[1] << 6) & 0xc0;
buf += 2;
}
if (y == 0)
alpha = 0xff;
YUV_TO_RGB1_CCIR(cb, cr);
YUV_TO_RGB2_CCIR(r, g, b, y);
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
#endif
if (depth & 0x80)
clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
if (depth & 0x40)
clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
if (depth & 0x20)
clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
}
}
static void dvbsub_parse_region_segment(AVCodecContext *avctx,
uint8_t *buf, int buf_size)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
uint8_t *buf_end = buf + buf_size;
int region_id, object_id;
DVBSubRegion *region;
DVBSubObject *object;
DVBSubObjectDisplay *display;
int fill;
if (buf_size < 10)
return;
region_id = *buf++;
region = get_region(ctx, region_id);
if (region == NULL)
{
region = av_mallocz(sizeof(DVBSubRegion));
region->id = region_id;
region->next = ctx->region_list;
ctx->region_list = region;
}
fill = ((*buf++) >> 3) & 1;
region->width = BE_16(buf);
buf += 2;
region->height = BE_16(buf);
buf += 2;
if (region->width * region->height != region->buf_size) {
if (region->pbuf != 0)
av_free(region->pbuf);
region->buf_size = region->width * region->height;
region->pbuf = av_malloc(region->buf_size);
fill = 1;
}
region->depth = 1 << (((*buf++) >> 2) & 7);
region->clut = *buf++;
if (region->depth == 8)
region->bgcolour = *buf++;
else {
buf += 1;
if (region->depth == 4)
region->bgcolour = (((*buf++) >> 4) & 15);
else
region->bgcolour = (((*buf++) >> 2) & 3);
}
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
#endif
if (fill) {
memset(region->pbuf, region->bgcolour, region->buf_size);
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Fill region (%d)\n", region->bgcolour);
#endif
}
delete_region_display_list(ctx, region);
while (buf + 5 < buf_end) {
object_id = BE_16(buf);
buf += 2;
object = get_object(ctx, object_id);
if (object == NULL) {
object = av_mallocz(sizeof(DVBSubObject));
object->id = object_id;
object->next = ctx->object_list;
ctx->object_list = object;
}
object->type = (*buf) >> 6;
display = av_mallocz(sizeof(DVBSubObjectDisplay));
display->object_id = object_id;
display->region_id = region_id;
display->x_pos = BE_16(buf) & 0xfff;
buf += 2;
display->y_pos = BE_16(buf) & 0xfff;
buf += 2;
if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
display->fgcolour = *buf++;
display->bgcolour = *buf++;
}
display->region_list_next = region->display_list;
region->display_list = display;
display->object_list_next = object->display_list;
object->display_list = display;
}
}
static void dvbsub_parse_page_segment(AVCodecContext *avctx,
uint8_t *buf, int buf_size)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
DVBSubRegionDisplay *display;
DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
uint8_t *buf_end = buf + buf_size;
int region_id;
int page_state;
if (buf_size < 1)
return;
ctx->time_out = *buf++;
page_state = ((*buf++) >> 2) & 3;
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Page time out %ds, state %d\n", ctx->time_out, page_state);
#endif
if (page_state == 2)
{
delete_state(ctx);
}
tmp_display_list = ctx->display_list;
ctx->display_list = NULL;
ctx->display_list_size = 0;
while (buf + 5 < buf_end) {
region_id = *buf++;
buf += 1;
display = tmp_display_list;
tmp_ptr = &tmp_display_list;
while (display != NULL && display->region_id != region_id) {
tmp_ptr = &display->next;
display = display->next;
}
if (display == NULL)
display = av_mallocz(sizeof(DVBSubRegionDisplay));
display->region_id = region_id;
display->x_pos = BE_16(buf);
buf += 2;
display->y_pos = BE_16(buf);
buf += 2;
*tmp_ptr = display->next;
display->next = ctx->display_list;
ctx->display_list = display;
ctx->display_list_size++;
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
#endif
}
while (tmp_display_list != 0) {
display = tmp_display_list;
tmp_display_list = display->next;
av_free(display);
}
}
#ifdef DEBUG_SAVE_IMAGES
static void save_display_set(DVBSubContext *ctx)
{
DVBSubRegion *region;
DVBSubRegionDisplay *display;
DVBSubCLUT *clut;
uint32_t *clut_table;
int x_pos, y_pos, width, height;
int x, y, y_off, x_off;
uint32_t *pbuf;
char filename[32];
static int fileno_index = 0;
x_pos = -1;
y_pos = -1;
width = 0;
height = 0;
for (display = ctx->display_list; display != NULL; display = display->next) {
region = get_region(ctx, display->region_id);
if (x_pos == -1) {
x_pos = display->x_pos;
y_pos = display->y_pos;
width = region->width;
height = region->height;
} else {
if (display->x_pos < x_pos) {
width += (x_pos - display->x_pos);
x_pos = display->x_pos;
}
if (display->y_pos < y_pos) {
height += (y_pos - display->y_pos);
y_pos = display->y_pos;
}
if (display->x_pos + region->width > x_pos + width) {
width = display->x_pos + region->width - x_pos;
}
if (display->y_pos + region->height > y_pos + height) {
height = display->y_pos + region->height - y_pos;
}
}
}
if (x_pos >= 0) {
pbuf = av_malloc(width * height * 4);
for (display = ctx->display_list; display != NULL; display = display->next) {
region = get_region(ctx, display->region_id);
x_off = display->x_pos - x_pos;
y_off = display->y_pos - y_pos;
clut = get_clut(ctx, region->clut);
if (clut == 0)
clut = &default_clut;
switch (region->depth) {
case 2:
clut_table = clut->clut4;
break;
case 8:
clut_table = clut->clut256;
break;
case 4:
default:
clut_table = clut->clut16;
break;
}
for (y = 0; y < region->height; y++) {
for (x = 0; x < region->width; x++) {
pbuf[((y + y_off) * width) + x_off + x] =
clut_table[region->pbuf[y * region->width + x]];
}
}
}
snprintf(filename, 32, "dvbs.%d", fileno_index);
png_save2(filename, pbuf, width, height);
av_free(pbuf);
}
fileno_index++;
}
#endif
static int dvbsub_display_end_segment(AVCodecContext *avctx, uint8_t *buf,
int buf_size, AVSubtitle *sub)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
DVBSubRegion *region;
DVBSubRegionDisplay *display;
AVSubtitleRect *rect;
DVBSubCLUT *clut;
uint32_t *clut_table;
int i;
sub->rects = NULL;
sub->start_display_time = 0;
sub->end_display_time = ctx->time_out * 1000;
sub->format = 0;
sub->num_rects = ctx->display_list_size;
if (sub->num_rects == 0)
return 0;
sub->rects = av_mallocz(sizeof(AVSubtitleRect) * sub->num_rects);
i = 0;
for (display = ctx->display_list; display != NULL; display = display->next) {
region = get_region(ctx, display->region_id);
rect = &sub->rects[i];
if (region == NULL)
continue;
rect->x = display->x_pos;
rect->y = display->y_pos;
rect->w = region->width;
rect->h = region->height;
rect->nb_colors = 16;
rect->linesize = region->width;
clut = get_clut(ctx, region->clut);
if (clut == NULL)
clut = &default_clut;
switch (region->depth) {
case 2:
clut_table = clut->clut4;
break;
case 8:
clut_table = clut->clut256;
break;
case 4:
default:
clut_table = clut->clut16;
break;
}
rect->rgba_palette = av_malloc((1 << region->depth) * sizeof(uint32_t));
memcpy(rect->rgba_palette, clut_table, (1 << region->depth) * sizeof(uint32_t));
rect->bitmap = av_malloc(region->buf_size);
memcpy(rect->bitmap, region->pbuf, region->buf_size);
i++;
}
sub->num_rects = i;
#ifdef DEBUG_SAVE_IMAGES
save_display_set(ctx);
#endif
return 1;
}
static int dvbsub_decode(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
AVSubtitle *sub = (AVSubtitle*) data;
uint8_t *p, *p_end;
int segment_type;
int page_id;
int segment_length;
#ifdef DEBUG_PACKET_CONTENTS
int i;
av_log(avctx, AV_LOG_INFO, "DVB sub packet:\n");
for (i=0; i < buf_size; i++)
{
av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
if (i % 16 == 15)
av_log(avctx, AV_LOG_INFO, "\n");
}
if (i % 16 != 0)
av_log(avctx, AV_LOG_INFO, "\n");
#endif
if (buf_size <= 2)
return -1;
p = buf;
p_end = buf + buf_size;
while (p < p_end && *p == 0x0f)
{
p += 1;
segment_type = *p++;
page_id = BE_16(p);
p += 2;
segment_length = BE_16(p);
p += 2;
if (page_id == ctx->composition_id || page_id == ctx->ancillary_id) {
switch (segment_type) {
case DVBSUB_PAGE_SEGMENT:
dvbsub_parse_page_segment(avctx, p, segment_length);
break;
case DVBSUB_REGION_SEGMENT:
dvbsub_parse_region_segment(avctx, p, segment_length);
break;
case DVBSUB_CLUT_SEGMENT:
dvbsub_parse_clut_segment(avctx, p, segment_length);
break;
case DVBSUB_OBJECT_SEGMENT:
dvbsub_parse_object_segment(avctx, p, segment_length);
break;
case DVBSUB_DISPLAY_SEGMENT:
*data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
break;
default:
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Subtitling segment type 0x%x, page id %d, length %d\n",
segment_type, page_id, segment_length);
#endif
break;
}
}
p += segment_length;
}
if (p != p_end)
{
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Junk at end of packet\n");
#endif
return -1;
}
return 0;
}
AVCodec dvbsub_decoder = {
"dvbsub",
CODEC_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE,
sizeof(DVBSubContext),
dvbsub_init_decoder,
NULL,
dvbsub_close_decoder,
dvbsub_decode,
};
/* Parser (mostly) copied from dvdsub.c */
#define PARSE_BUF_SIZE (65536)
/* parser definition */
typedef struct DVBSubParseContext {
uint8_t *packet_buf;
int packet_start;
int packet_index;
int in_packet;
} DVBSubParseContext;
static int dvbsub_parse_init(AVCodecParserContext *s)
{
DVBSubParseContext *pc = s->priv_data;
pc->packet_buf = av_malloc(PARSE_BUF_SIZE);
return 0;
}
static int dvbsub_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
DVBSubParseContext *pc = s->priv_data;
uint8_t *p, *p_end;
int len, buf_pos = 0;
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "DVB parse packet pts=%Lx, lpts=%Lx, cpts=%Lx:\n",
s->pts, s->last_pts, s->cur_frame_pts[s->cur_frame_start_index]);
#endif
#ifdef DEBUG_PACKET_CONTENTS
int i;
for (i=0; i < buf_size; i++)
{
av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
if (i % 16 == 15)
av_log(avctx, AV_LOG_INFO, "\n");
}
if (i % 16 != 0)
av_log(avctx, AV_LOG_INFO, "\n");
#endif
*poutbuf = NULL;
*poutbuf_size = 0;
s->fetch_timestamp = 1;
if (s->last_pts != s->pts && s->last_pts != AV_NOPTS_VALUE) /* Start of a new packet */
{
if (pc->packet_index != pc->packet_start)
{
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Discarding %d bytes\n",
pc->packet_index - pc->packet_start);
#endif
}
pc->packet_start = 0;
pc->packet_index = 0;
if (buf_size < 2 || buf[0] != 0x20 || buf[1] != 0x00) {
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Bad packet header\n");
#endif
return -1;
}
buf_pos = 2;
pc->in_packet = 1;
} else {
if (pc->packet_start != 0)
{
if (pc->packet_index != pc->packet_start)
{
memmove(pc->packet_buf, pc->packet_buf + pc->packet_start,
pc->packet_index - pc->packet_start);
pc->packet_index -= pc->packet_start;
pc->packet_start = 0;
} else {
pc->packet_start = 0;
pc->packet_index = 0;
}
}
}
if (buf_size - buf_pos + pc->packet_index > PARSE_BUF_SIZE)
return -1;
/* if not currently in a packet, discard data */
if (pc->in_packet == 0)
return buf_size;
memcpy(pc->packet_buf + pc->packet_index, buf + buf_pos, buf_size - buf_pos);
pc->packet_index += buf_size - buf_pos;
p = pc->packet_buf;
p_end = pc->packet_buf + pc->packet_index;
while (p < p_end)
{
if (*p == 0x0f)
{
if (p + 6 <= p_end)
{
len = BE_16(p + 4);
if (p + len + 6 <= p_end)
{
*poutbuf_size += len + 6;
p += len + 6;
} else
break;
} else
break;
} else if (*p == 0xff) {
if (p + 1 < p_end)
{
#ifdef DEBUG
av_log(avctx, AV_LOG_INFO, "Junk at end of packet\n");
#endif
}
pc->packet_index = p - pc->packet_buf;
pc->in_packet = 0;
break;
} else {
av_log(avctx, AV_LOG_ERROR, "Junk in packet\n");
pc->packet_index = p - pc->packet_buf;
pc->in_packet = 0;
break;
}
}
if (*poutbuf_size > 0)
{
*poutbuf = pc->packet_buf;
pc->packet_start = *poutbuf_size;
}
if (s->last_pts == AV_NOPTS_VALUE)
s->last_pts = s->pts;
return buf_size;
}
static void dvbsub_parse_close(AVCodecParserContext *s)
{
DVBSubParseContext *pc = s->priv_data;
av_freep(&pc->packet_buf);
}
AVCodecParser dvbsub_parser = {
{ CODEC_ID_DVB_SUBTITLE },
sizeof(DVBSubParseContext),
dvbsub_parse_init,
dvbsub_parse,
dvbsub_parse_close,
};
More information about the ffmpeg-devel
mailing list