@@ -19,6 +19,9 @@ API changes, most recent first:

 2011-10-20 - b35e9e1 - lavu 51.22.0

   Add av_strtok() to avstring.h.

+2011-11-xx - xxxxxxx - lavu 51.16.0

+  Add av_timegm()

+

 2011-11-06 - ba04ecf - lavu 51.14.0

   Add av_strcasecmp() and av_strncasecmp() to avstring.h.

@@ -339,7 +339,7 @@ static int cinepak_decode (CinepakContext *s)

              * by the container file, this data likely comes from a Sega FILM/CPK file.

              * If the frame header is followed by the bytes FE 00 00 06 00 00 then

              * this is probably one of the two known files that have 6 extra bytes

-             * after the frame header. Else, assume 2 extra bytes. The container size

+             * after the frame header. Else, assume 2 extra bytes. The container

              * size also cannot be a multiple of the encoded size. */

             if (s->size >= 16 &&

                 (s->data[10] == 0xFE) &&

@@ -51,6 +51,8 @@ typedef struct LagarithContext {

     DSPContext dsp;

     int zeros;                  /**< number of consecutive zero bytes encountered */

     int zeros_rem;              /**< number of zero bytes remaining to output */

+    uint8_t *rgb_planes;

+    int rgb_stride;

 } LagarithContext;

 /**

@@ -245,21 +247,21 @@ static void lag_pred_line(LagarithContext *l, uint8_t *buf,

 {

     int L, TL;

+    /* Left pixel is actually prev_row[width] */

+    L = buf[width - stride - 1];

     if (!line) {

         /* Left prediction only for first line */

         L = l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1,

                                             width - 1, buf[0]);

         return;

     } else if (line == 1) {

-        /* Second line, left predict first pixel, the rest of the line is median predicted */

-        /* FIXME: In the case of RGB this pixel is top predicted */

-        TL = buf[-stride];

+        /* Second line, left predict first pixel, the rest of the line is median predicted

+         * NOTE: In the case of RGB this pixel is top predicted */

+        TL = l->avctx->pix_fmt == PIX_FMT_YUV420P ? buf[-stride] : L;

     } else {

         /* Top left is 2 rows back, last pixel */

         TL = buf[width - (2 * stride) - 1];

     }

-    /* Left pixel is actually prev_row[width] */

-    L = buf[width - stride - 1];

     add_lag_median_prediction(buf, buf - stride, buf,

                               width, &L, &TL);

@@ -443,6 +445,9 @@ static int lag_decode_frame(AVCodecContext *avctx,

     AVFrame *const p = &l->picture;

     uint8_t frametype = 0;

     uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;

+    int offs[4];

+    uint8_t *srcs[4], *dst;

+    int i, j;

     AVFrame *picture = data;

@@ -458,6 +463,67 @@ static int lag_decode_frame(AVCodecContext *avctx,

     offset_bv = AV_RL32(buf + 5);

     switch (frametype) {

+    case FRAME_SOLID_RGBA:

+        avctx->pix_fmt = PIX_FMT_RGB32;

+

+        if (avctx->get_buffer(avctx, p) < 0) {

+            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

+            return -1;

+        }

+

+        dst = p->data[0];

+        for (j = 0; j < avctx->height; j++) {

+            for (i = 0; i < avctx->width; i++)

+                AV_WN32(dst + i * 4, offset_gu);

+            dst += p->linesize[0];

+        }

+        break;

+    case FRAME_ARITH_RGBA:

+        avctx->pix_fmt = PIX_FMT_RGB32;

+

+        if (avctx->get_buffer(avctx, p) < 0) {

+            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

+            return -1;

+        }

+        offs[0] = offset_bv;

+        offs[1] = offset_gu;

+        offs[2] = 13;

+        offs[3] = AV_RL32(buf + 9);

+

+        if (!l->rgb_planes) {

+            l->rgb_stride = FFALIGN(avctx->width, 16);

+            l->rgb_planes = av_malloc(l->rgb_stride * avctx->height * 4);

+            if (!l->rgb_planes) {

+                av_log(avctx, AV_LOG_ERROR, "cannot allocate temporary buffer\n");

+                return AVERROR(ENOMEM);

+            }

+        }

+        for (i = 0; i < 4; i++)

+            srcs[i] = l->rgb_planes + (i + 1) * l->rgb_stride * avctx->height - l->rgb_stride;

+        for (i = 0; i < 4; i++)

+            lag_decode_arith_plane(l, srcs[i],

+                                   avctx->width, avctx->height,

+                                   -l->rgb_stride, buf + offs[i],

+                                   buf_size);

+        dst = p->data[0];

+        for (i = 0; i < 4; i++)

+            srcs[i] = l->rgb_planes + i * l->rgb_stride * avctx->height;

+        for (j = 0; j < avctx->height; j++) {

+            for (i = 0; i < avctx->width; i++) {

+                uint8_t r, g, b, a;

+                r = srcs[0][i];

+                g = srcs[1][i];

+                b = srcs[2][i];

+                a = srcs[3][i];

+                r += g;

+                b += g;

+                AV_WN32(dst + i * 4, MKBETAG(a, r, g, b));

+            }

+            dst += p->linesize[0];

+            for (i = 0; i < 4; i++)

+                srcs[i] += l->rgb_stride;

+        }

+        break;

     case FRAME_ARITH_YV12:

         avctx->pix_fmt = PIX_FMT_YUV420P;

@@ -504,6 +570,7 @@ static av_cold int lag_decode_end(AVCodecContext *avctx)

     if (l->picture.data[0])

         avctx->release_buffer(avctx, &l->picture);

+    av_freep(&l->rgb_planes);

     return 0;

 }

@@ -33,6 +33,7 @@

 #include "id3v2.h"

 #include "libavutil/avstring.h"

 #include "libavutil/mathematics.h"

+#include "libavutil/parseutils.h"

 #include "riff.h"

 #include "audiointerleave.h"

 #include "url.h"

@@ -4161,9 +4162,14 @@ void ff_make_absolute_url(char *buf, int size, const char *base,

 int64_t ff_iso8601_to_unix_time(const char *datestr)

 {

 #if HAVE_STRPTIME

-    struct tm time = {0};

-    strptime(datestr, "%Y - %m - %dT%T", &time);

-    return mktime(&time);

+    struct tm time1 = {0}, time2 = {0};

+    char *ret1, *ret2;

+    ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);

+    ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);

+    if (ret2 && !ret1)

+        return av_timegm(&time2);

+    else

+        return av_timegm(&time1);

 #else

     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "

                                  "the date string.\n");

@@ -40,7 +40,7 @@

 #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)

 #define LIBAVUTIL_VERSION_MAJOR 51

-#define LIBAVUTIL_VERSION_MINOR 25

+#define LIBAVUTIL_VERSION_MINOR 26

 #define LIBAVUTIL_VERSION_MICRO  0

 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

@@ -471,7 +471,7 @@ static const char *small_strptime(const char *p, const char *fmt, struct tm *dt)

     }

 }

-static time_t mktimegm(struct tm *tm)

+time_t av_timegm(struct tm *tm)

 {

     time_t t;

@@ -592,7 +592,7 @@ int av_parse_time(int64_t *timeval, const char *timestr, int duration)

     } else {

         dt.tm_isdst = -1;       /* unknown */

         if (is_utc) {

-            t = mktimegm(&dt);

+            t = av_timegm(&dt);

         } else {

             t = mktime(&dt);

         }

@@ -19,6 +19,8 @@

 #ifndef AVUTIL_PARSEUTILS_H

 #define AVUTIL_PARSEUTILS_H

+#include <time.h>

+

 #include "rational.h"

 /**

@@ -114,4 +116,9 @@ int av_parse_time(int64_t *timeval, const char *timestr, int duration);

  */

 int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);

+/**

+ * Convert the decomposed UTC time in tm to a time_t value.

+ */

+time_t av_timegm(struct tm *tm);

+

 #endif /* AVUTIL_PARSEUTILS_H */