Change the strategy for deciding the display size

There are three contributors to the definition of how the
display size is set:

(1) display width/height set in the container.
(2) display size (optional in the frame header)
(3) decoded frame size (from the frame header)

This patch modifies the way that vpxdec defines the display
size to give preference to these three criteria in the order
given above. If the container sets a non-zero size, it is
used, otherwise the display size specified in the first
decoded frame is used (if specified), with the raw
decoded frame size of the first frame used as a last resort.

The display size set in frames other than the first is
always ignored in this implementation.

Change-Id: I7e98d817d3f5894d559dd2aeb0a6cb1959b9092b

diff --git a/vpxdec.c b/vpxdec.c
index 655b7569018abbe8815db7ff78a822bb253aa1d6..69b45049811a9506c3ed36f25f1db6dfd7340fcd 100644 (file)
--- a/vpxdec.c
+++ b/vpxdec.c
@@ -449,6 +449,8 @@ int main_loop(int argc, const char **argv_) {
   int                     num_external_frame_buffers = 0;
   int                     fb_lru_cache = 0;
   vpx_codec_frame_buffer_t *frame_buffers = NULL;
+  int                     display_width = 0;
+  int                     display_height = 0;
 
   struct VpxDecInputContext input = {0};
   struct VpxInputContext vpx_input_ctx = {0};
@@ -818,23 +820,31 @@ int main_loop(int argc, const char **argv_) {
         out_put(out, (const unsigned char*)color, strlen(color), do_md5);
       }
 
-      if (do_scale) {
-        int stream_w = 0, stream_h = 0;
-        if (img && frame_out == 1) {
-          int display_size[2];
-          if (vpx_codec_control(&decoder, VP9D_GET_DISPLAY_SIZE,
-                                display_size)) {
-            // Fallback to use raw image size if display size not available.
-            stream_w = img->d_w;
-            stream_h = img->d_h;
-          } else {
-            stream_w = display_size[0];
-            stream_h = display_size[1];
+      if (img && do_scale) {
+        if (frame_out == 1) {
+          // If the output frames are to be scaled to a fixed display size then
+          // use the width and height specified in the container. If either of
+          // these is set to 0, use the display size set in the first frame
+          // header.
+          display_width = vpx_input_ctx.width;
+          display_height = vpx_input_ctx.height;
+          if (!display_width || !display_height) {
+            int display_size[2];
+            if (vpx_codec_control(&decoder, VP9D_GET_DISPLAY_SIZE,
+                                  display_size)) {
+              // As last resort use size of first frame as display size.
+              display_width = img->d_w;
+              display_height = img->d_h;
+            } else {
+              display_width = display_size[0];
+              display_height = display_size[1];
+            }
           }
-          scaled_img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420,
-                                     stream_w, stream_h, 16);
+          scaled_img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, display_width,
+                                     display_height, 16);
         }
-        if (img && (img->d_w != stream_w || img->d_h != stream_h)) {
+
+        if (img->d_w != display_width || img->d_h != display_height) {
           assert(img->fmt == VPX_IMG_FMT_I420);
           I420Scale(img->planes[VPX_PLANE_Y], img->stride[VPX_PLANE_Y],
                     img->planes[VPX_PLANE_U], img->stride[VPX_PLANE_U],
@@ -846,7 +856,7 @@ int main_loop(int argc, const char **argv_) {
                     scaled_img->stride[VPX_PLANE_U],
                     scaled_img->planes[VPX_PLANE_V],
                     scaled_img->stride[VPX_PLANE_V],
-                    stream_w, stream_h,
+                    display_width, display_height,
                     kFilterBox);
           img = scaled_img;
         }