tools: K&R reformatting cosmetics

tools/aviocat.c

@@ -21,6 +21,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+
 #include "libavformat/avformat.h"
 
 static int usage(const char *argv0, int ret)
@@ -80,13 +81,14 @@ int main(int argc, char **argv)
         stream_pos += n;
         if (bps) {
             avio_flush(output);
-            while ((av_gettime() - start_time)*bps/AV_TIME_BASE < stream_pos)
-                usleep(50*1000);
+            while ((av_gettime() - start_time) * bps / AV_TIME_BASE < stream_pos)
+                usleep(50 * 1000);
         }
     }
 
     avio_flush(output);
     avio_close(output);
+
 fail:
     avio_close(input);
     avformat_network_deinit();

tools/cws2fws.c

@@ -26,46 +26,42 @@ int main(int argc, char *argv[])
     z_stream zstream;
     struct stat statbuf;
 
-    if (argc < 3)
-    {
+    if (argc < 3) {
         printf("Usage: %s <infile.swf> <outfile.swf>\n", argv[0]);
         return 1;
     }
 
     fd_in = open(argv[1], O_RDONLY);
-    if (fd_in < 0)
-    {
+    if (fd_in < 0) {
         perror("Error opening input file");
         return 1;
     }
 
-    fd_out = open(argv[2], O_WRONLY|O_CREAT, 00644);
-    if (fd_out < 0)
-    {
+    fd_out = open(argv[2], O_WRONLY | O_CREAT, 00644);
+    if (fd_out < 0) {
         perror("Error opening output file");
         close(fd_in);
         return 1;
     }
 
-    if (read(fd_in, &buf_in, 8) != 8)
-    {
+    if (read(fd_in, &buf_in, 8) != 8) {
         printf("Header error\n");
         close(fd_in);
         close(fd_out);
         return 1;
     }
 
-    if (buf_in[0] != 'C' || buf_in[1] != 'W' || buf_in[2] != 'S')
-    {
+    if (buf_in[0] != 'C' || buf_in[1] != 'W' || buf_in[2] != 'S') {
         printf("Not a compressed flash file\n");
         return 1;
     }
 
     fstat(fd_in, &statbuf);
-    comp_len = statbuf.st_size;
+    comp_len   = statbuf.st_size;
     uncomp_len = buf_in[4] | (buf_in[5] << 8) | (buf_in[6] << 16) | (buf_in[7] << 24);
 
-    printf("Compressed size: %d Uncompressed size: %d\n", comp_len-4, uncomp_len-4);
+    printf("Compressed size: %d Uncompressed size: %d\n",
+           comp_len - 4, uncomp_len - 4);
 
     // write out modified header
     buf_in[0] = 'F';
@@ -75,36 +71,35 @@ int main(int argc, char *argv[])
     }
 
     zstream.zalloc = NULL;
-    zstream.zfree = NULL;
+    zstream.zfree  = NULL;
     zstream.opaque = NULL;
     inflateInit(&zstream);
 
-    for (i = 0; i < comp_len-8;)
-    {
+    for (i = 0; i < comp_len - 8;) {
         int ret, len = read(fd_in, &buf_in, 1024);
 
         dbgprintf("read %d bytes\n", len);
 
         last_out = zstream.total_out;
 
-        zstream.next_in = &buf_in[0];
-        zstream.avail_in = len;
-        zstream.next_out = &buf_out[0];
+        zstream.next_in   = &buf_in[0];
+        zstream.avail_in  = len;
+        zstream.next_out  = &buf_out[0];
         zstream.avail_out = 65536;
 
         ret = inflate(&zstream, Z_SYNC_FLUSH);
-        if (ret != Z_STREAM_END && ret != Z_OK)
-        {
+        if (ret != Z_STREAM_END && ret != Z_OK) {
             printf("Error while decompressing: %d\n", ret);
             inflateEnd(&zstream);
             return 1;
         }
 
         dbgprintf("a_in: %d t_in: %lu a_out: %d t_out: %lu -- %lu out\n",
-            zstream.avail_in, zstream.total_in, zstream.avail_out, zstream.total_out,
-            zstream.total_out-last_out);
+                  zstream.avail_in, zstream.total_in, zstream.avail_out,
+                  zstream.total_out, zstream.total_out - last_out);
 
-        if (write(fd_out, &buf_out, zstream.total_out - last_out) < zstream.total_out - last_out) {
+        if (write(fd_out, &buf_out, zstream.total_out - last_out) <
+            zstream.total_out - last_out) {
             perror("Error writing output file");
             return 1;
         }
@@ -115,15 +110,14 @@ int main(int argc, char *argv[])
             break;
     }
 
-    if (zstream.total_out != uncomp_len-8)
-    {
+    if (zstream.total_out != uncomp_len - 8) {
         printf("Size mismatch (%lu != %d), updating header...\n",
-            zstream.total_out, uncomp_len-8);
+               zstream.total_out, uncomp_len - 8);
 
-        buf_in[0] = (zstream.total_out+8) & 0xff;
-        buf_in[1] = ((zstream.total_out+8) >> 8) & 0xff;
-        buf_in[2] = ((zstream.total_out+8) >> 16) & 0xff;
-        buf_in[3] = ((zstream.total_out+8) >> 24) & 0xff;
+        buf_in[0] =  (zstream.total_out + 8)        & 0xff;
+        buf_in[1] = ((zstream.total_out + 8) >>  8) & 0xff;
+        buf_in[2] = ((zstream.total_out + 8) >> 16) & 0xff;
+        buf_in[3] = ((zstream.total_out + 8) >> 24) & 0xff;
 
         lseek(fd_out, 4, SEEK_SET);
         if (write(fd_out, &buf_in, 4) < 4) {

tools/graph2dot.c

@@ -63,19 +63,25 @@ static void print_digraph(FILE *outfile, AVFilterGraph *graph)
                 char dst_filter_ctx_label[128];
                 const AVFilterContext *dst_filter_ctx = link->dst;
 
-                snprintf(dst_filter_ctx_label, sizeof(dst_filter_ctx_label), "%s (%s)",
+                snprintf(dst_filter_ctx_label, sizeof(dst_filter_ctx_label),
+                         "%s (%s)",
                          dst_filter_ctx->name,
                          dst_filter_ctx->filter->name);
 
-                fprintf(outfile, "\"%s\" -> \"%s\"", filter_ctx_label, dst_filter_ctx_label);
+                fprintf(outfile, "\"%s\" -> \"%s\"",
+                        filter_ctx_label, dst_filter_ctx_label);
                 if (link->type == AVMEDIA_TYPE_VIDEO) {
-                    fprintf(outfile, " [ label= \"fmt:%s w:%d h:%d tb:%d/%d\" ]",
+                    fprintf(outfile,
+                            " [ label= \"fmt:%s w:%d h:%d tb:%d/%d\" ]",
                             av_pix_fmt_descriptors[link->format].name,
-                            link->w, link->h, link->time_base.num, link->time_base.den);
+                            link->w, link->h, link->time_base.num,
+                            link->time_base.den);
                 } else if (link->type == AVMEDIA_TYPE_AUDIO) {
                     char buf[255];
-                    av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
-                    fprintf(outfile, " [ label= \"fmt:%s sr:%"PRId64" cl:%s\" ]",
+                    av_get_channel_layout_string(buf, sizeof(buf), -1,
+                                                 link->channel_layout);
+                    fprintf(outfile,
+                            " [ label= \"fmt:%s sr:%"PRId64 " cl:%s\" ]",
                             av_get_sample_fmt_name(link->format),
                             link->sample_rate, buf);
                 }
@@ -89,17 +95,17 @@ static void print_digraph(FILE *outfile, AVFilterGraph *graph)
 int main(int argc, char **argv)
 {
     const char *outfilename = NULL;
-    const char *infilename = NULL;
-    FILE *outfile = NULL;
-    FILE *infile = NULL;
-    char *graph_string = NULL;
+    const char *infilename  = NULL;
+    FILE *outfile           = NULL;
+    FILE *infile            = NULL;
+    char *graph_string      = NULL;
     AVFilterGraph *graph = av_mallocz(sizeof(AVFilterGraph));
     char c;
 
     av_log_set_level(AV_LOG_DEBUG);
 
     while ((c = getopt(argc, argv, "hi:o:")) != -1) {
-        switch(c) {
+        switch (c) {
         case 'h':
             usage();
             return 0;
@@ -118,7 +124,8 @@ int main(int argc, char **argv)
         infilename = "/dev/stdin";
     infile = fopen(infilename, "r");
     if (!infile) {
-        fprintf(stderr, "Impossible to open input file '%s': %s\n", infilename, strerror(errno));
+        fprintf(stderr, "Impossible to open input file '%s': %s\n",
+                infilename, strerror(errno));
         return 1;
     }
 
@@ -126,7 +133,8 @@ int main(int argc, char **argv)
         outfilename = "/dev/stdout";
     outfile = fopen(outfilename, "w");
     if (!outfile) {
-        fprintf(stderr, "Impossible to open output file '%s': %s\n", outfilename, strerror(errno));
+        fprintf(stderr, "Impossible to open output file '%s': %s\n",
+                outfilename, strerror(errno));
         return 1;
     }
 
@@ -141,7 +149,7 @@ int main(int argc, char **argv)
             struct line *new_line = av_malloc(sizeof(struct line));
             count += strlen(last_line->data);
             last_line->next = new_line;
-            last_line = new_line;
+            last_line       = new_line;
         }
         last_line->next = NULL;
 

tools/ismindex.c

@@ -35,6 +35,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
+
 #include "libavformat/avformat.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/mathematics.h"
@@ -82,7 +83,7 @@ static int copy_tag(AVIOContext *in, AVIOContext *out, int32_t tag_name)
     int32_t size, tag;
 
     size = avio_rb32(in);
-    tag = avio_rb32(in);
+    tag  = avio_rb32(in);
     avio_wb32(out, size);
     avio_wb32(out, tag);
     if (tag != tag_name)
@@ -123,7 +124,7 @@ static int write_fragments(struct VideoFiles *files, int start_index,
 
     for (i = start_index; i < files->nb_files; i++) {
         struct VideoFile *vf = files->files[i];
-        const char *type = vf->is_video ? "video" : "audio";
+        const char *type     = vf->is_video ? "video" : "audio";
         snprintf(dirname, sizeof(dirname), "QualityLevels(%d)", vf->bitrate);
         mkdir(dirname, 0777);
         for (j = 0; j < vf->chunks; j++) {
@@ -140,7 +141,7 @@ static int read_tfra(struct VideoFiles *files, int start_index, AVIOContext *f)
 {
     int ret = AVERROR_EOF, track_id;
     int version, fieldlength, i, j;
-    int64_t pos = avio_tell(f);
+    int64_t pos   = avio_tell(f);
     uint32_t size = avio_rb32(f);
     struct VideoFile *vf = NULL;
 
@@ -149,17 +150,16 @@ static int read_tfra(struct VideoFiles *files, int start_index, AVIOContext *f)
     version = avio_r8(f);
     avio_rb24(f);
     track_id = avio_rb32(f); /* track id */
-    for (i = start_index; i < files->nb_files && !vf; i++) {
+    for (i = start_index; i < files->nb_files && !vf; i++)
         if (files->files[i]->track_id == track_id)
             vf = files->files[i];
-    }
     if (!vf) {
         /* Ok, continue parsing the next atom */
         ret = 0;
         goto fail;
     }
     fieldlength = avio_rb32(f);
-    vf->chunks = avio_rb32(f);
+    vf->chunks  = avio_rb32(f);
     vf->offsets = av_mallocz(sizeof(*vf->offsets) * vf->chunks);
     if (!vf->offsets) {
         ret = AVERROR(ENOMEM);
@@ -167,10 +167,10 @@ static int read_tfra(struct VideoFiles *files, int start_index, AVIOContext *f)
     }
     for (i = 0; i < vf->chunks; i++) {
         if (version == 1) {
-            vf->offsets[i].time = avio_rb64(f);
+            vf->offsets[i].time   = avio_rb64(f);
             vf->offsets[i].offset = avio_rb64(f);
         } else {
-            vf->offsets[i].time = avio_rb32(f);
+            vf->offsets[i].time   = avio_rb32(f);
             vf->offsets[i].offset = avio_rb32(f);
         }
         for (j = 0; j < ((fieldlength >> 4) & 3) + 1; j++)
@@ -187,6 +187,7 @@ static int read_tfra(struct VideoFiles *files, int start_index, AVIOContext *f)
         vf->offsets[vf->chunks - 1].duration = vf->duration -
                                                vf->offsets[vf->chunks - 1].time;
     ret = 0;
+
 fail:
     avio_seek(f, pos + size, SEEK_SET);
     return ret;
@@ -224,7 +225,7 @@ fail:
 static int get_private_data(struct VideoFile *vf, AVCodecContext *codec)
 {
     vf->codec_private_size = codec->extradata_size;
-    vf->codec_private = av_mallocz(codec->extradata_size);
+    vf->codec_private      = av_mallocz(codec->extradata_size);
     if (!vf->codec_private)
         return AVERROR(ENOMEM);
     memcpy(vf->codec_private, codec->extradata, codec->extradata_size);
@@ -254,6 +255,7 @@ static int get_video_private_data(struct VideoFile *vf, AVCodecContext *codec)
     avio_wb32(io, 0x00000001);
     avio_write(io, &codec->extradata[11 + sps_size], pps_size);
     err = 0;
+
 fail:
     vf->codec_private_size = avio_close_dyn_buf(io, &vf->codec_private);
     return err;
@@ -291,24 +293,25 @@ static int handle_file(struct VideoFiles *files, const char *file, int split)
         AVStream *st = ctx->streams[i];
         vf = av_mallocz(sizeof(*vf));
         files->files = av_realloc(files->files,
-                                  sizeof(*files->files)*(files->nb_files + 1));
+                                  sizeof(*files->files) * (files->nb_files + 1));
         files->files[files->nb_files] = vf;
 
         vf->name = file;
         if ((ptr = strrchr(file, '/')) != NULL)
             vf->name = ptr + 1;
 
-        vf->bitrate = st->codec->bit_rate;
-        vf->track_id = st->id;
+        vf->bitrate   = st->codec->bit_rate;
+        vf->track_id  = st->id;
         vf->timescale = st->time_base.den;
-        vf->duration = av_rescale_rnd(ctx->duration, vf->timescale,
-                                      AV_TIME_BASE, AV_ROUND_UP);
-        vf->is_audio = st->codec->codec_type == AVMEDIA_TYPE_AUDIO;
-        vf->is_video = st->codec->codec_type == AVMEDIA_TYPE_VIDEO;
+        vf->duration  = av_rescale_rnd(ctx->duration, vf->timescale,
+                                       AV_TIME_BASE, AV_ROUND_UP);
+        vf->is_audio  = st->codec->codec_type == AVMEDIA_TYPE_AUDIO;
+        vf->is_video  = st->codec->codec_type == AVMEDIA_TYPE_VIDEO;
 
         if (!vf->is_audio && !vf->is_video) {
-            fprintf(stderr, "Track %d in %s is neither video nor audio, "
-                            "skipping\n", vf->track_id, file);
+            fprintf(stderr,
+                    "Track %d in %s is neither video nor audio, skipping\n",
+                    vf->track_id, file);
             av_freep(&files->files[files->nb_files]);
             continue;
         }
@@ -317,15 +320,15 @@ static int handle_file(struct VideoFiles *files, const char *file, int split)
             if (files->audio_file < 0)
                 files->audio_file = files->nb_files;
             files->nb_audio_files++;
-            vf->channels = st->codec->channels;
+            vf->channels    = st->codec->channels;
             vf->sample_rate = st->codec->sample_rate;
             if (st->codec->codec_id == CODEC_ID_AAC) {
-                vf->fourcc = "AACL";
-                vf->tag = 255;
+                vf->fourcc    = "AACL";
+                vf->tag       = 255;
                 vf->blocksize = 4;
             } else if (st->codec->codec_id == CODEC_ID_WMAPRO) {
-                vf->fourcc = "WMAP";
-                vf->tag = st->codec->codec_tag;
+                vf->fourcc    = "WMAP";
+                vf->tag       = st->codec->codec_tag;
                 vf->blocksize = st->codec->block_align;
             }
             get_private_data(vf, st->codec);
@@ -334,7 +337,7 @@ static int handle_file(struct VideoFiles *files, const char *file, int split)
             if (files->video_file < 0)
                 files->video_file = files->nb_files;
             files->nb_video_files++;
-            vf->width = st->codec->width;
+            vf->width  = st->codec->width;
             vf->height = st->codec->height;
             if (st->codec->codec_id == CODEC_ID_H264)
                 vf->fourcc = "H264";
@@ -379,7 +382,7 @@ static void output_server_manifest(struct VideoFiles *files,
     fprintf(out, "\t\t<switch>\n");
     for (i = 0; i < files->nb_files; i++) {
         struct VideoFile *vf = files->files[i];
-        const char *type = vf->is_video ? "video" : "audio";
+        const char *type     = vf->is_video ? "video" : "audio";
         fprintf(out, "\t\t\t<%s src=\"%s\" systemBitrate=\"%d\">\n",
                 type, vf->name, vf->bitrate);
         fprintf(out, "\t\t\t\t<param name=\"trackID\" value=\"%d\" "
@@ -410,22 +413,24 @@ static void output_client_manifest(struct VideoFiles *files,
     }
     fprintf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
     fprintf(out, "<SmoothStreamingMedia MajorVersion=\"2\" MinorVersion=\"0\" "
-                 "Duration=\"%"PRId64"\">\n", files->duration * 10);
+                 "Duration=\"%"PRId64 "\">\n", files->duration * 10);
     if (files->video_file >= 0) {
         struct VideoFile *vf = files->files[files->video_file];
         int index = 0;
-        fprintf(out, "\t<StreamIndex Type=\"video\" QualityLevels=\"%d\" "
-                     "Chunks=\"%d\" "
-                     "Url=\"QualityLevels({bitrate})/Fragments(video={start time})\">\n",
-                     files->nb_video_files, vf->chunks);
+        fprintf(out,
+                "\t<StreamIndex Type=\"video\" QualityLevels=\"%d\" "
+                "Chunks=\"%d\" "
+                "Url=\"QualityLevels({bitrate})/Fragments(video={start time})\">\n",
+                files->nb_video_files, vf->chunks);
         for (i = 0; i < files->nb_files; i++) {
             vf = files->files[i];
             if (!vf->is_video)
                 continue;
-            fprintf(out, "\t\t<QualityLevel Index=\"%d\" Bitrate=\"%d\" "
-                         "FourCC=\"%s\" MaxWidth=\"%d\" MaxHeight=\"%d\" "
-                         "CodecPrivateData=\"",
-                         index, vf->bitrate, vf->fourcc, vf->width, vf->height);
+            fprintf(out,
+                    "\t\t<QualityLevel Index=\"%d\" Bitrate=\"%d\" "
+                    "FourCC=\"%s\" MaxWidth=\"%d\" MaxHeight=\"%d\" "
+                    "CodecPrivateData=\"",
+                    index, vf->bitrate, vf->fourcc, vf->width, vf->height);
             for (j = 0; j < vf->codec_private_size; j++)
                 fprintf(out, "%02X", vf->codec_private[j]);
             fprintf(out, "\" />\n");
@@ -440,20 +445,22 @@ static void output_client_manifest(struct VideoFiles *files,
     if (files->audio_file >= 0) {
         struct VideoFile *vf = files->files[files->audio_file];
         int index = 0;
-        fprintf(out, "\t<StreamIndex Type=\"audio\" QualityLevels=\"%d\" "
-                     "Chunks=\"%d\" "
-                     "Url=\"QualityLevels({bitrate})/Fragments(audio={start time})\">\n",
-                     files->nb_audio_files, vf->chunks);
+        fprintf(out,
+                "\t<StreamIndex Type=\"audio\" QualityLevels=\"%d\" "
+                "Chunks=\"%d\" "
+                "Url=\"QualityLevels({bitrate})/Fragments(audio={start time})\">\n",
+                files->nb_audio_files, vf->chunks);
         for (i = 0; i < files->nb_files; i++) {
             vf = files->files[i];
             if (!vf->is_audio)
                 continue;
-            fprintf(out, "\t\t<QualityLevel Index=\"%d\" Bitrate=\"%d\" "
-                         "FourCC=\"%s\" SamplingRate=\"%d\" Channels=\"%d\" "
-                         "BitsPerSample=\"16\" PacketSize=\"%d\" "
-                         "AudioTag=\"%d\" CodecPrivateData=\"",
-                         index, vf->bitrate, vf->fourcc, vf->sample_rate,
-                         vf->channels, vf->blocksize, vf->tag);
+            fprintf(out,
+                    "\t\t<QualityLevel Index=\"%d\" Bitrate=\"%d\" "
+                    "FourCC=\"%s\" SamplingRate=\"%d\" Channels=\"%d\" "
+                    "BitsPerSample=\"16\" PacketSize=\"%d\" "
+                    "AudioTag=\"%d\" CodecPrivateData=\"",
+                    index, vf->bitrate, vf->fourcc, vf->sample_rate,
+                    vf->channels, vf->blocksize, vf->tag);
             for (j = 0; j < vf->codec_private_size; j++)
                 fprintf(out, "%02X", vf->codec_private[j]);
             fprintf(out, "\" />\n");

tools/lavfi-showfiltfmts.c

@@ -50,11 +50,13 @@ int main(int argc, char **argv)
     }
 
     if (avfilter_open(&filter_ctx, filter, NULL) < 0) {
-        fprintf(stderr, "Inpossible to open filter with name '%s'\n", filter_name);
+        fprintf(stderr, "Inpossible to open filter with name '%s'\n",
+                filter_name);
         return 1;
     }
     if (avfilter_init_filter(filter_ctx, filter_args, NULL) < 0) {
-        fprintf(stderr, "Impossible to init filter '%s' with arguments '%s'\n", filter_name, filter_args);
+        fprintf(stderr, "Impossible to init filter '%s' with arguments '%s'\n",
+                filter_name, filter_args);
         return 1;
     }
 

tools/pktdumper.c

@@ -24,9 +24,10 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+
 #include "libavformat/avformat.h"
 
-#define PKTFILESUFF "_%08"PRId64"_%02d_%010"PRId64"_%06d_%c.bin"
+#define PKTFILESUFF "_%08" PRId64 "_%02d_%010" PRId64 "_%06d_%c.bin"
 
 #undef strcat
 
@@ -46,10 +47,10 @@ int main(int argc, char **argv)
     char pktfilename[PATH_MAX];
     AVFormatContext *fctx = NULL;
     AVPacket pkt;
-    int64_t pktnum = 0;
+    int64_t pktnum  = 0;
     int64_t maxpkts = 0;
-    int donotquit = 0;
-    int nowrite = 0;
+    int donotquit   = 0;
+    int nowrite     = 0;
     int err;
 
     if ((argc > 1) && !strncmp(argv[1], "-", 1)) {
@@ -64,16 +65,16 @@ int main(int argc, char **argv)
         return usage(1);
     if (argc > 2)
         maxpkts = atoi(argv[2]);
-    strncpy(fntemplate, argv[1], PATH_MAX-1);
+    strncpy(fntemplate, argv[1], PATH_MAX - 1);
     if (strrchr(argv[1], '/'))
-        strncpy(fntemplate, strrchr(argv[1], '/')+1, PATH_MAX-1);
+        strncpy(fntemplate, strrchr(argv[1], '/') + 1, PATH_MAX - 1);
     if (strrchr(fntemplate, '.'))
         *strrchr(fntemplate, '.') = '\0';
     if (strchr(fntemplate, '%')) {
         fprintf(stderr, "can't use filenames containing '%%'\n");
         return usage(1);
     }
-    if (strlen(fntemplate) + sizeof(PKTFILESUFF) >= PATH_MAX-1) {
+    if (strlen(fntemplate) + sizeof(PKTFILESUFF) >= PATH_MAX - 1) {
         fprintf(stderr, "filename too long\n");
         return usage(1);
     }
@@ -99,11 +100,14 @@ int main(int argc, char **argv)
 
     while ((err = av_read_frame(fctx, &pkt)) >= 0) {
         int fd;
-        snprintf(pktfilename, PATH_MAX-1, fntemplate, pktnum, pkt.stream_index, pkt.pts, pkt.size, (pkt.flags & AV_PKT_FLAG_KEY)?'K':'_');
-        printf(PKTFILESUFF"\n", pktnum, pkt.stream_index, pkt.pts, pkt.size, (pkt.flags & AV_PKT_FLAG_KEY)?'K':'_');
+        snprintf(pktfilename, PATH_MAX - 1, fntemplate, pktnum,
+                 pkt.stream_index, pkt.pts, pkt.size,
+                 (pkt.flags & AV_PKT_FLAG_KEY) ? 'K' : '_');
+        printf(PKTFILESUFF "\n", pktnum, pkt.stream_index, pkt.pts, pkt.size,
+               (pkt.flags & AV_PKT_FLAG_KEY) ? 'K' : '_');
         //printf("open(\"%s\")\n", pktfilename);
         if (!nowrite) {
-            fd = open(pktfilename, O_WRONLY|O_CREAT, 0644);
+            fd  = open(pktfilename, O_WRONLY | O_CREAT, 0644);
             err = write(fd, pkt.data, pkt.size);
             if (err < 0) {
                 fprintf(stderr, "write: error %d\n", err);

tools/probetest.c

@@ -39,7 +39,8 @@ static void probe(AVProbeData *pd, int type, int p, int size)
             int score = fmt->read_probe(pd);
             if (score > score_array[i] && score > AVPROBE_SCORE_MAX / 4) {
                 score_array[i] = score;
-                fprintf(stderr, "Failure of %s probing code with score=%d type=%d p=%X size=%d\n",
+                fprintf(stderr,
+                        "Failure of %s probing code with score=%d type=%d p=%X size=%d\n",
                         fmt->name, score, type, p, size);
                 failures++;
             }
@@ -75,9 +76,8 @@ int main(void)
                     init_put_bits(&pb, pd.buf, size);
                     switch (type) {
                     case 0:
-                        for (i = 0; i < size * 8; i++) {
+                        for (i = 0; i < size * 8; i++)
                             put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20);
-                        }
                         break;
                     case 1:
                         for (i = 0; i < size * 8; i++) {
@@ -89,10 +89,10 @@ int main(void)
                         break;
                     case 2:
                         for (i = 0; i < size * 8; i++) {
-                            unsigned int p2 = (p >> (hist*3)) & 7;
+                            unsigned int p2 = (p >> (hist * 3)) & 7;
                             unsigned int v  = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29;
                             put_bits(&pb, 1, v);
-                            hist = (2*hist + v) & 3;
+                            hist = (2 * hist + v) & 3;
                         }
                         break;
                     case 3:
@@ -100,12 +100,18 @@ int main(void)
                             int c = 0;
                             while (p & 63) {
                                 c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24;
-                                if     (c >= 'a' && c <= 'z' && (p & 1)) break;
-                                else if(c >= 'A' && c <= 'Z' && (p & 2)) break;
-                                else if(c >= '0' && c <= '9' && (p & 4)) break;
-                                else if(c == ' ' && (p &  8)) break;
-                                else if(c ==  0  && (p & 16)) break;
-                                else if(c ==  1  && (p & 32)) break;
+                                if (c >= 'a' && c <= 'z' && (p & 1))
+                                    break;
+                                else if (c >= 'A' && c <= 'Z' && (p & 2))
+                                    break;
+                                else if (c >= '0' && c <= '9' && (p & 4))
+                                    break;
+                                else if (c == ' ' && (p & 8))
+                                    break;
+                                else if (c == 0 && (p & 16))
+                                    break;
+                                else if (c == 1 && (p & 32))
+                                    break;
                             }
                             pd.buf[i] = c;
                         }

tools/qt-faststart.c

@@ -138,7 +138,6 @@ int main(int argc, char *argv[])
             }
             start_offset = ftello(infile);
         } else {
-
             /* 64-bit special case */
             if (atom_size == 1) {
                 if (fread(atom_bytes, ATOM_PREAMBLE_SIZE, 1, infile) != 1) {

tools/trasher.c

@@ -23,47 +23,50 @@
 #include <inttypes.h>
 
 static uint32_t state;
-static uint32_t ran(void){
-    return state= state*1664525+1013904223;
+static uint32_t ran(void)
+{
+    return state = state * 1664525 + 1013904223;
 }
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
     FILE *f;
     int count, maxburst, length;
 
-    if (argc < 5){
+    if (argc < 5) {
         printf("USAGE: trasher <filename> <count> <maxburst> <seed>\n");
         return 1;
     }
 
-    f= fopen(argv[1], "rb+");
-    if (!f){
+    f = fopen(argv[1], "rb+");
+    if (!f) {
         perror(argv[1]);
         return 2;
     }
-    count= atoi(argv[2]);
-    maxburst= atoi(argv[3]);
-    state= atoi(argv[4]);
+    count    = atoi(argv[2]);
+    maxburst = atoi(argv[3]);
+    state    = atoi(argv[4]);
 
     fseek(f, 0, SEEK_END);
-    length= ftell(f);
+    length = ftell(f);
     fseek(f, 0, SEEK_SET);
 
-    while(count--){
-        int burst= 1 + ran() * (uint64_t) (abs(maxburst)-1) / UINT32_MAX;
-        int pos= ran() * (uint64_t) length / UINT32_MAX;
+    while (count--) {
+        int burst = 1 + ran() * (uint64_t) (abs(maxburst) - 1) / UINT32_MAX;
+        int pos   = ran() * (uint64_t) length / UINT32_MAX;
         fseek(f, pos, SEEK_SET);
 
-        if(maxburst<0) burst= -maxburst;
+        if (maxburst < 0)
+            burst = -maxburst;
 
-        if(pos + burst > length)
+        if (pos + burst > length)
             continue;
 
-        while(burst--){
-            int val= ran() * 256ULL / UINT32_MAX;
+        while (burst--) {
+            int val = ran() * 256ULL / UINT32_MAX;
 
-            if(maxburst<0) val=0;
+            if (maxburst < 0)
+                val = 0;
 
             fwrite(&val, 1, 1, f);
         }