support for adding new components (syntax: ffmpeg -i input_file [output options] output_file [[component output options] {-newaudio|-newvideo|-newsubtitle}]... - added subtitle support - added '-alang' option

Originally committed as revision 4351 to svn://svn.ffmpeg.org/ffmpeg/trunk
20 years ago · cf7fc795ae
parent ae27975dfe
commit cf7fc795ae
1 changed files with 550 additions and 357 deletions
--- a/ffmpeg.c
+++ b/ffmpeg.c
@ -98,7 +98,7 @@ static int frame_topBand  = 0;
 static int frame_bottomBand = 0;
 static int frame_leftBand  = 0;
 static int frame_rightBand = 0;
-static int max_frames[3] = {INT_MAX, INT_MAX, INT_MAX};
+static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 static int frame_rate = 25;
 static int frame_rate_base = 1;
 static int video_bit_rate = 200*1000;
@ -219,6 +219,10 @@ static int audio_disable = 0;
 static int audio_channels = 1;
 static int audio_codec_id = CODEC_ID_NONE;
 static int audio_codec_tag = 0;
+static char *audio_language = NULL;
+
+static int subtitle_codec_id = CODEC_ID_NONE;
+static char *subtitle_language = NULL;

 static int mux_rate= 0;
 static int mux_packet_size= 0;
@ -244,6 +248,7 @@ static int bitexact = 0;
 static char *pass_logfilename = NULL;
 static int audio_stream_copy = 0;
 static int video_stream_copy = 0;
+static int subtitle_stream_copy = 0;
 static int video_sync_method= 1;
 static int audio_sync_method= 0;
 static int copy_ts= 0;
@ -693,6 +698,58 @@ static void fill_pad_region(AVPicture* img, int height, int width,
    }
 }

+static void do_subtitle_out(AVFormatContext *s, 
+                            AVOutputStream *ost, 
+                            AVInputStream *ist,
+                            AVSubtitle *sub,
+                            int64_t pts)
+{
+    static uint8_t *subtitle_out = NULL;
+    int subtitle_out_max_size = 65536;
+    int subtitle_out_size, nb, i;
+    AVCodecContext *enc;
+    AVPacket pkt;
+
+    if (pts == AV_NOPTS_VALUE) {
+        fprintf(stderr, "Subtitle packets must have a pts\n");
+        return;
+    }
+
+    enc = &ost->st->codec;
+
+    if (!subtitle_out) {
+        subtitle_out = av_malloc(subtitle_out_max_size);
+    }
+
+    /* Note: DVB subtitle need one packet to draw them and one other
+       packet to clear them */
+    /* XXX: signal it in the codec context ? */
+    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
+        nb = 2;
+    else
+        nb = 1;
+
+    for(i = 0; i < nb; i++) {
+        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out, 
+                                                    subtitle_out_max_size, sub);
+        
+        av_init_packet(&pkt);
+        pkt.stream_index = ost->index;
+        pkt.data = subtitle_out;
+        pkt.size = subtitle_out_size;
+        pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
+        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
+            /* XXX: the pts correction is handled here. Maybe handling
+               it in the codec would be better */
+            if (i == 0)
+                pkt.pts += 90 * sub->start_display_time;
+            else
+                pkt.pts += 90 * sub->end_display_time;
+        }
+        av_interleaved_write_frame(s, &pkt);
+    }
+}
+
 static int bit_buffer_size= 1024*256;
 static uint8_t *bit_buffer= NULL;

@ -1130,6 +1187,8 @@ static int output_packet(AVInputStream *ist, int ist_index,
    void *buffer_to_free;
    static int samples_size= 0;
    static short *samples= NULL;
+    AVSubtitle subtitle, *subtitle_to_free;
+    int got_subtitle;
    
    if(!pkt){
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
@ -1153,6 +1212,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
        /* decode the packet if needed */
        data_buf = NULL; /* fail safe */
        data_size = 0;
+        subtitle_to_free = NULL;
        if (ist->decoding_needed) {
            switch(ist->st->codec.codec_type) {
            case CODEC_TYPE_AUDIO:{
@ -1197,6 +1257,17 @@ static int output_packet(AVInputStream *ist, int ist_index,
                    }
                    len = 0;
                    break;
+            case CODEC_TYPE_SUBTITLE:
+                ret = avcodec_decode_subtitle(&ist->st->codec, 
+                                              &subtitle, &got_subtitle, ptr, len);
+                if (ret < 0)
+                    goto fail_decode;
+                if (!got_subtitle) {
+                    goto discard_packet;
+                }
+                subtitle_to_free = &subtitle;
+                len = 0;
+                break;
            default:
                goto fail_decode;
            }
@ -1293,6 +1364,10 @@ static int output_packet(AVInputStream *ist, int ist_index,
                                    if (do_vstats && frame_size)
                                        do_video_stats(os, ost, frame_size);
                                break;
+                            case CODEC_TYPE_SUBTITLE:
+                                do_subtitle_out(os, ost, ist, &subtitle,
+                                                pkt->pts);
+                                break;
                            default:
                                av_abort();
                            }
@ -1322,9 +1397,16 @@ static int output_packet(AVInputStream *ist, int ist_index,
                                opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
                            else
                                opkt.pts= AV_NOPTS_VALUE;
-                            opkt.dts= av_rescale_q(av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
-                            opkt.flags= pkt->flags;

+                            {
+                                int64_t dts;
+                                if (pkt->dts == AV_NOPTS_VALUE)
+                                    dts = ist->next_pts;
+                                else
+                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
+                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
+                            }
+                            opkt.flags= pkt->flags;
                            av_interleaved_write_frame(os, &opkt);
                            ost->st->codec.frame_number++;
                            ost->frame_number++;
@ -1332,6 +1414,12 @@ static int output_packet(AVInputStream *ist, int ist_index,
                    }
                }
            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);
+                subtitle_to_free = NULL;
+            }
        }
 discard_packet:
    if (pkt == NULL) {
@ -1579,6 +1667,8 @@ static int av_encode(AVFormatContext **output_files,
                codec->height = icodec->height;
                codec->has_b_frames = icodec->has_b_frames;
                break;
+            case CODEC_TYPE_SUBTITLE:
+                break;
            default:
                av_abort();
            }
@ -1686,8 +1776,13 @@ static int av_encode(AVFormatContext **output_files,
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
                break;
+            case CODEC_TYPE_SUBTITLE:
+                ost->encoding_needed = 1;
+                ist->decoding_needed = 1;
+                break;
            default:
                av_abort();
+                break;
            }
            /* two pass mode */
            if (ost->encoding_needed && 
@ -2722,28 +2817,34 @@ static void opt_audio_device(const char *arg)
    audio_device = av_strdup(arg);
 }

-static void opt_audio_codec(const char *arg)
+static void opt_codec(int *pstream_copy, int *pcodec_id,
+                      int codec_type, const char *arg)
 {
    AVCodec *p;

    if (!strcmp(arg, "copy")) {
-        audio_stream_copy = 1;
+        *pstream_copy = 1;
    } else {
        p = first_avcodec;
        while (p) {
-            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
+            if (!strcmp(p->name, arg) && p->type == codec_type)
                break;
            p = p->next;
        }
        if (p == NULL) {
-            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
+            fprintf(stderr, "Unknown codec '%s'\n", arg);
            exit(1);
        } else {
-            audio_codec_id = p->id;
+            *pcodec_id = p->id;
        }
    }
 }

+static void opt_audio_codec(const char *arg)
+{
+    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
+}
+
 static void opt_audio_tag(const char *arg)
 {
    char *tail;
@ -2811,24 +2912,12 @@ static void opt_motion_estimation(const char *arg)

 static void opt_video_codec(const char *arg)
 {
-    AVCodec *p;
+    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
+}

-    if (!strcmp(arg, "copy")) {
-        video_stream_copy = 1;
-    } else {
-        p = first_avcodec;
-        while (p) {
-            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
-                break;
-            p = p->next;
-        }
-        if (p == NULL) {
-            fprintf(stderr, "Unknown video codec '%s'\n", arg);
-            exit(1);
-        } else {
-            video_codec_id = p->id;
-        }
-    }
+static void opt_subtitle_codec(const char *arg)
+{
+    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
 }

 static void opt_map(const char *arg)
@ -3011,6 +3100,8 @@ static void opt_input_file(const char *filename)
            break;
        case CODEC_TYPE_DATA:
            break;
+        case CODEC_TYPE_SUBTITLE:
+            break;
        default:
            av_abort();
        }
@ -3058,6 +3149,7 @@ static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
                has_video = 1;
                break;
            case CODEC_TYPE_DATA:
+            case CODEC_TYPE_SUBTITLE:
                break;
            default:
                av_abort();
@ -3068,65 +3160,13 @@ static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
    *has_audio_ptr = has_audio;
 }

-static void opt_output_file(const char *filename)
+static void new_video_stream(AVFormatContext *oc)
 {
    AVStream *st;
-    AVFormatContext *oc;
-    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
-    int codec_id;
-    AVFormatParameters params, *ap = &params;
-
-    if (!strcmp(filename, "-"))
-        filename = "pipe:";
-
-    oc = av_alloc_format_context();
-
-    if (!file_oformat) {
-        file_oformat = guess_format(NULL, filename, NULL);
-        if (!file_oformat) {
-            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
-                    filename);
-            exit(1);
-        }
-    }
-    
-    oc->oformat = file_oformat;
-
-    if (!strcmp(file_oformat->name, "ffm") && 
-        strstart(filename, "http:", NULL)) {
-        /* special case for files sent to ffserver: we get the stream
-           parameters from ffserver */
-        if (read_ffserver_streams(oc, filename) < 0) {
-            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
-            exit(1);
-        }
-    } else {
-        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
-        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
-
-        /* disable if no corresponding type found and at least one
-           input file */
-        if (nb_input_files > 0) {
-            check_audio_video_inputs(&input_has_video, &input_has_audio);
-            if (!input_has_video)
-                use_video = 0;
-            if (!input_has_audio)
-                use_audio = 0;
-        }
-
-        /* manual disable */
-        if (audio_disable) {
-            use_audio = 0;
-        }
-        if (video_disable) {
-            use_video = 0;
-        }
-        
-        nb_streams = 0;
-        if (use_video) {
    AVCodecContext *video_enc;
+    int codec_id;
    
-            st = av_new_stream(oc, nb_streams++);
+    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
@ -3141,7 +3181,7 @@ static void opt_output_file(const char *filename)
    if(video_codec_tag)
        video_enc->codec_tag= video_codec_tag;
    
-            if (file_oformat->flags & AVFMT_GLOBALHEADER) 
+    if (oc->oformat->flags & AVFMT_GLOBALHEADER) 
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
    if (video_stream_copy) {
        st->stream_copy = 1;
@ -3151,7 +3191,7 @@ static void opt_output_file(const char *filename)
        int i;
        AVCodec *codec;
        
-                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
+        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
        if (video_codec_id != CODEC_ID_NONE)
            codec_id = video_codec_id;
                
@ -3395,12 +3435,20 @@ static void opt_output_file(const char *filename)
            }
        }
    }
-        }

-        if (use_audio) {
+    /* reset some key parameters */
+    video_disable = 0;
+    video_codec_id = CODEC_ID_NONE;
+    video_stream_copy = 0;
+}
+
+static void new_audio_stream(AVFormatContext *oc)
+{
+    AVStream *st;
    AVCodecContext *audio_enc;
+    int codec_id;
            
-            st = av_new_stream(oc, nb_streams++);
+    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
@ -3416,13 +3464,13 @@ static void opt_output_file(const char *filename)
    if(audio_codec_tag)
        audio_enc->codec_tag= audio_codec_tag;
    
-            if (file_oformat->flags & AVFMT_GLOBALHEADER) 
+    if (oc->oformat->flags & AVFMT_GLOBALHEADER) 
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
    if (audio_stream_copy) {
        st->stream_copy = 1;
        audio_enc->channels = audio_channels;
    } else {
-                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
+        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
        if (audio_codec_id != CODEC_ID_NONE)
            codec_id = audio_codec_id;
        audio_enc->codec_id = codec_id;
@ -3439,11 +3487,138 @@ static void opt_output_file(const char *filename)
            audio_enc->channels = audio_channels;
    }
    audio_enc->sample_rate = audio_sample_rate;
+    if (audio_language) {
+        pstrcpy(st->language, sizeof(st->language), audio_language);
+        av_free(audio_language);
+        audio_language = NULL;
+    }
+
+    /* reset some key parameters */
+    audio_disable = 0;
+    audio_codec_id = CODEC_ID_NONE;
+    audio_stream_copy = 0;
+}
+
+static void opt_new_subtitle_stream(void)
+{
+    AVFormatContext *oc;
+    AVStream *st;
+    AVCodecContext *subtitle_enc;
+            
+    if (nb_output_files <= 0) {
+        fprintf(stderr, "At least one output file must be specified\n");
+        exit(1);
+    }
+    oc = output_files[nb_output_files - 1];
+
+    st = av_new_stream(oc, oc->nb_streams);
+    if (!st) {
+        fprintf(stderr, "Could not alloc stream\n");
+        exit(1);
+    }
+
+    subtitle_enc = &st->codec;
+    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
+    if (subtitle_stream_copy) {
+        st->stream_copy = 1;
+    } else {
+        subtitle_enc->codec_id = subtitle_codec_id;
+    }
+
+    if (subtitle_language) {
+        pstrcpy(st->language, sizeof(st->language), subtitle_language);
+        av_free(subtitle_language);
+        subtitle_language = NULL;
+    }
+
+    subtitle_codec_id = CODEC_ID_NONE;
+    subtitle_stream_copy = 0;
+}
+
+static void opt_new_audio_stream(void)
+{
+    AVFormatContext *oc;
+    if (nb_output_files <= 0) {
+        fprintf(stderr, "At least one output file must be specified\n");
+        exit(1);
+    }
+    oc = output_files[nb_output_files - 1];
+    new_audio_stream(oc);
+}
+
+static void opt_new_video_stream(void)
+{
+    AVFormatContext *oc;
+    if (nb_output_files <= 0) {
+        fprintf(stderr, "At least one output file must be specified\n");
+        exit(1);
+    }
+    oc = output_files[nb_output_files - 1];
+    new_video_stream(oc);
+}
+
+static void opt_output_file(const char *filename)
+{
+    AVFormatContext *oc;
+    int use_video, use_audio, input_has_video, input_has_audio;
+    AVFormatParameters params, *ap = &params;
+
+    if (!strcmp(filename, "-"))
+        filename = "pipe:";
+
+    oc = av_alloc_format_context();
+
+    if (!file_oformat) {
+        file_oformat = guess_format(NULL, filename, NULL);
+        if (!file_oformat) {
+            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
+                    filename);
+            exit(1);
+        }
+    }
+    
+    oc->oformat = file_oformat;
+    pstrcpy(oc->filename, sizeof(oc->filename), filename);
+
+    if (!strcmp(file_oformat->name, "ffm") && 
+        strstart(filename, "http:", NULL)) {
+        /* special case for files sent to ffserver: we get the stream
+           parameters from ffserver */
+        if (read_ffserver_streams(oc, filename) < 0) {
+            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
+            exit(1);
+        }
+    } else {
+        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
+        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
+
+        /* disable if no corresponding type found and at least one
+           input file */
+        if (nb_input_files > 0) {
+            check_audio_video_inputs(&input_has_video, &input_has_audio);
+            if (!input_has_video)
+                use_video = 0;
+            if (!input_has_audio)
+                use_audio = 0;
        }

-        oc->nb_streams = nb_streams;
+        /* manual disable */
+        if (audio_disable) {
+            use_audio = 0;
+        }
+        if (video_disable) {
+            use_video = 0;
+        }
        
-        if (!nb_streams) {
+        if (use_video) {
+            new_video_stream(oc);
+        }
+    
+        if (use_audio) {
+            new_audio_stream(oc);
+        }
+
+        if (!oc->nb_streams) {
            fprintf(stderr, "No audio or video streams available\n");
            exit(1);
        }
@ -3462,8 +3637,6 @@ static void opt_output_file(const char *filename)

    output_files[nb_output_files++] = oc;

-    pstrcpy(oc->filename, sizeof(oc->filename), filename);
-
    /* check filename in case of an image number is expected */
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
        if (filename_number_test(oc->filename) < 0) {
@ -3520,12 +3693,6 @@ static void opt_output_file(const char *filename)
    file_oformat = NULL;
    file_iformat = NULL;
    image_format = NULL;
-    audio_disable = 0;
-    video_disable = 0;
-    audio_codec_id = CODEC_ID_NONE;
-    video_codec_id = CODEC_ID_NONE;
-    audio_stream_copy = 0;
-    video_stream_copy = 0;
 }

 /* prepare dummy protocols for grab */
@ -3722,6 +3889,7 @@ static void show_formats(void)
        int decode=0;
        int encode=0;
        int cap=0;
+        const char *type_str;

        p2=NULL;
        for(p = first_avcodec; p != NULL; p = p->next) {
@ -3740,11 +3908,25 @@ static void show_formats(void)
            break;
        last_name= p2->name;
        
+        switch(p2->type) {
+        case CODEC_TYPE_VIDEO:
+            type_str = "V";
+            break;
+        case CODEC_TYPE_AUDIO:
+            type_str = "A";
+            break;
+        case CODEC_TYPE_SUBTITLE:
+            type_str = "S";
+            break;
+        default:
+            type_str = "?";
+            break;
+        }
        printf(
            " %s%s%s%s%s%s %s", 
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
            encode ? "E":" ", 
-            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
+            type_str,
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
            cap & CODEC_CAP_DR1 ? "D":" ",
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
@ -4132,7 +4314,8 @@ const OptionDef options[] = {
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
    { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
-    { "gray", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { &gray_only }, "encode/decode grayscale" },
+    { "gray", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&gray_only }, "encode/decode grayscale" },
+    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },

    /* audio options */
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
@ -4142,6 +4325,13 @@ const OptionDef options[] = {
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
+    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
+    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
+
+    /* subtitle options */
+    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
+    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
+    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
    
    /* grab options */
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
@ -4233,6 +4423,9 @@ static void show_help(void)
    show_help_options(options, "\nAdvanced Audio options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
                      OPT_AUDIO | OPT_EXPERT);
+    show_help_options(options, "\nSubtitle options:\n",
+                      OPT_SUBTITLE | OPT_GRAB, 
+                      OPT_SUBTITLE);
    show_help_options(options, "\nAudio/Video grab options:\n",
                      OPT_GRAB, 
                      OPT_GRAB);