mp4: Make most loop variables unsigned.

If the loop variable iterates from zero to some number stored in a
variable of unsigned type, the loop variable should be of the same
unsigned type. This was not always the case, and if it was, the loop
variable was sometimes called i, which is confusing because i usually
indicates a signed quantity.

Quoting Andrew Morton:

	Doing "unsigned i;" is an act of insane vandalism, punishable by
	spending five additional years coding in fortran.

diff --git a/mp4.c b/mp4.c
index e4082549113c5bb89a6c765b9ff50f76d765a60f..9ed0fcbb4dfbfaa07b53893e7e021607a17636ad 100644 (file)
--- a/mp4.c
+++ b/mp4.c
@@ -212,7 +212,6 @@ static void skip_bytes(struct mp4 *f, off_t num_skip)
 static int read_stsz(struct mp4 *f)
 {
        int ret;
-       int32_t i;
        struct mp4_track *t = &f->track;
 
        if (t->state != ATS_SEEN_MP4A || t->stsz_table)
@@ -227,8 +226,8 @@ static int read_stsz(struct mp4 *f)
        if (t->stsz_sample_size != 0)
                return 1;
        t->stsz_table = para_malloc(t->stsz_sample_count * sizeof(int32_t));
-       for (i = 0; i < t->stsz_sample_count; i++) {
-               ret = read_int32(f, &t->stsz_table[i]);
+       for (uint32_t n = 0; n < t->stsz_sample_count; n++) {
+               ret = read_int32(f, &t->stsz_table[n]);
                if (ret <= 0)
                        return ret;
        }
@@ -238,7 +237,6 @@ static int read_stsz(struct mp4 *f)
 static int read_stts(struct mp4 *f)
 {
        int ret;
-       int32_t i;
        struct mp4_track *t = &f->track;
 
        if (t->state != ATS_SEEN_MP4A || t->stts_sample_count)
@@ -249,8 +247,8 @@ static int read_stts(struct mp4 *f)
                return ret;
        t->stts_sample_count = para_malloc(t->stts_entry_count
                * sizeof(int32_t));
-       for (i = 0; i < t->stts_entry_count; i++) {
-               ret = read_int32(f, &t->stts_sample_count[i]);
+       for (uint32_t n = 0; n < t->stts_entry_count; n++) {
+               ret = read_int32(f, &t->stts_sample_count[n]);
                if (ret <= 0)
                        return ret;
                skip_bytes(f, 4); /* sample delta */
@@ -261,7 +259,6 @@ static int read_stts(struct mp4 *f)
 static int read_stsc(struct mp4 *f)
 {
        int ret;
-       int32_t i;
        struct mp4_track *t = &f->track;
 
        if (t->state != ATS_SEEN_MP4A)
@@ -275,11 +272,11 @@ static int read_stsc(struct mp4 *f)
        t->stsc_first_chunk = para_malloc(t->stsc_entry_count * sizeof(int32_t));
        t->stsc_samples_per_chunk = para_malloc(t->stsc_entry_count
                * sizeof (int32_t));
-       for (i = 0; i < t->stsc_entry_count; i++) {
-               ret = read_int32(f, &t->stsc_first_chunk[i]);
+       for (uint32_t n = 0; n < t->stsc_entry_count; n++) {
+               ret = read_int32(f, &t->stsc_first_chunk[n]);
                if (ret <= 0)
                        return ret;
-               ret = read_int32(f, &t->stsc_samples_per_chunk[i]);
+               ret = read_int32(f, &t->stsc_samples_per_chunk[n]);
                if (ret <= 0)
                        return ret;
                skip_bytes(f, 4); /* sample desc index */
@@ -290,7 +287,6 @@ static int read_stsc(struct mp4 *f)
 static int read_stco(struct mp4 *f)
 {
        int ret;
-       int32_t i;
        struct mp4_track *t = &f->track;
 
        if (t->state != ATS_SEEN_MP4A || t->stco_chunk_offset)
@@ -301,8 +297,8 @@ static int read_stco(struct mp4 *f)
                return ret;
        t->stco_chunk_offset = para_malloc(t->stco_entry_count
                * sizeof(int32_t));
-       for (i = 0; i < t->stco_entry_count; i++) {
-               ret = read_int32(f, &t->stco_chunk_offset[i]);
+       for (uint32_t n = 0; n < t->stco_entry_count; n++) {
+               ret = read_int32(f, &t->stco_chunk_offset[n]);
                if (ret <= 0)
                        return ret;
        }
@@ -312,7 +308,7 @@ static int read_stco(struct mp4 *f)
 static int read_stsd(struct mp4 *f)
 {
        int ret;
-       uint32_t i, entry_count;
+       uint32_t entry_count;
 
        if (f->track.state != ATS_INITIAL)
                return 1;
@@ -320,7 +316,7 @@ static int read_stsd(struct mp4 *f)
        ret = read_int32(f, &entry_count);
        if (ret <= 0)
                return ret;
-       for (i = 0; i < entry_count; i++) {
+       for (uint32_t n = 0; n < entry_count; n++) {
                uint64_t skip = get_position(f);
                uint64_t size;
                uint8_t atom_type = 0;
@@ -611,16 +607,14 @@ int mp4_open_read(const struct mp4_callback *cb, struct mp4 **result)
 
 void mp4_close(struct mp4 *f)
 {
-       int32_t i;
-
        free(f->track.stsz_table);
        free(f->track.stts_sample_count);
        free(f->track.stsc_first_chunk);
        free(f->track.stsc_samples_per_chunk);
        free(f->track.stco_chunk_offset);
-       for (i = 0; i < f->meta.count; i++) {
-               free(f->meta.tags[i].item);
-               free(f->meta.tags[i].value);
+       for (uint32_t n = 0; n < f->meta.count; n++) {
+               free(f->meta.tags[n].item);
+               free(f->meta.tags[n].value);
        }
        free(f->meta.tags);
        free(f);
@@ -631,15 +625,15 @@ static int32_t chunk_of_sample(const struct mp4 *f, int32_t sample,
 {
        const struct mp4_track *t = &f->track;
        uint32_t *fc = t->stsc_first_chunk, *spc = t->stsc_samples_per_chunk;
-       int32_t chunk1, chunk1samples, n, total, i;
+       uint32_t chunk1, chunk1samples, n, total, k;
 
-       for (i = 1, total = 0; i < t->stsc_entry_count; i++, total += n) {
-               n = (fc[i] - fc[i - 1]) * spc[i - 1]; /* number of samples */
+       for (k = 1, total = 0; k < t->stsc_entry_count; k++, total += n) {
+               n = (fc[k] - fc[k - 1]) * spc[k - 1]; /* number of samples */
                if (sample < total + n)
                        break;
        }
-       chunk1 = fc[i - 1];
-       chunk1samples = spc[i - 1];
+       chunk1 = fc[k - 1];
+       chunk1samples = spc[k - 1];
        if (chunk1samples != 0)
                *chunk = (sample - total) / chunk1samples + chunk1;
        else
@@ -708,11 +702,10 @@ uint32_t mp4_get_channel_count(const struct mp4 *f)
 int32_t mp4_num_samples(const struct mp4 *f)
 {
        const struct mp4_track *t = &f->track;
-       int32_t i;
        int32_t total = 0;
 
-       for (i = 0; i < t->stts_entry_count; i++)
-               total += t->stts_sample_count[i];
+       for (uint32_t n = 0; n < t->stts_entry_count; n++)
+               total += t->stts_sample_count[n];
        return total;
 }
 
@@ -909,10 +902,8 @@ free_moov:
  */
 char *mp4_get_tag_value(const struct mp4 *f, const char *item)
 {
-       uint32_t i;
-
-       for (i = 0; i < f->meta.count; i++)
-               if (!strcasecmp(f->meta.tags[i].item, item))
-                       return para_strdup(f->meta.tags[i].value);
+       for (unsigned n = 0; n < f->meta.count; n++)
+               if (!strcasecmp(f->meta.tags[n].item, item))
+                       return para_strdup(f->meta.tags[n].value);
        return NULL;
 }