~victored/noise/lp-1099591

« back to all changes in this revision

Viewing changes to src/GStreamer/CoverImport.vala

  • Committer: RabbitBot
  • Author(s): Victor Martinez
  • Date: 2014-02-09 12:00:38 UTC
  • mfrom: (1556.1.1 trunk)
  • Revision ID: rabbitbot-20140209120038-7kehivthd4aus2jt
Fix cover art import for some file types.

This usually failed when reading tags from m4a (aac-encoded) audio files, which store the cover art under the "preview-image" tag instead.

Show diffs side-by-side

added added

removed removed

Lines of Context:
133
133
        }
134
134
 
135
135
        if (gstreamer_discovery_successful) {
136
 
            debug ("Importing with GStreamer: %s", uri);
137
 
 
138
136
            var m = libraries_manager.local_library.media_from_uri (uri);
139
137
 
140
138
            // Get cover art
141
139
            if (m != null)
142
 
                import_art_async.begin (m, info);
 
140
                yield import_art_async (m, info);
143
141
        }
144
142
 
145
143
    }
149
147
        if (cache.has_image (m))
150
148
            return;
151
149
 
 
150
        debug ("Importing cover art for: %s", info.get_uri ());
 
151
 
152
152
        var pix = get_image (info.get_tags ());
153
153
 
154
154
        if (pix != null)
155
 
            cache.cache_image_async.begin (m, pix);
 
155
            yield cache.cache_image_async (m, pix);
156
156
        else
157
157
            warning ("Could not find embedded image for '%s'", info.get_uri ());
158
158
            
159
159
    }
160
160
 
161
 
    private static Gdk.Pixbuf? get_image (Gst.TagList tag) {
162
 
        Gst.Buffer? buffer = null;
 
161
    private static Gdk.Pixbuf? get_image (Gst.TagList tag_list) {
 
162
        var sample = get_cover_sample (tag_list);
 
163
 
 
164
        if (sample == null)
 
165
            tag_list.get_sample_index (Gst.Tags.PREVIEW_IMAGE, 0, out sample);
 
166
 
 
167
        if (sample != null) {
 
168
            var buffer = sample.get_buffer ();
 
169
 
 
170
            if (buffer != null)
 
171
                return get_pixbuf_from_buffer (buffer);
 
172
 
 
173
            debug ("Final image buffer is NULL");
 
174
        } else {
 
175
            debug ("Image sample is NULL");
 
176
        }
 
177
 
 
178
        return null;
 
179
    }
 
180
 
 
181
    private static Gst.Sample? get_cover_sample (Gst.TagList tag_list) {
 
182
        Gst.Sample cover_sample = null;
163
183
 
164
184
        for (int i = 0; ; i++) {
165
 
            Gst.Sample? loop_sample = null;
166
 
            if (!tag.get_sample_index (Gst.Tags.IMAGE, i, out loop_sample))
167
 
                break;
168
 
 
169
 
            if (loop_sample == null)
170
 
                continue;
171
 
 
172
 
            var structure = loop_sample.get_caps ().get_structure (0).copy ();
173
 
            if (structure == null)
174
 
                continue;
175
 
 
176
 
            int image_type;
177
 
            structure.get_enum ("image-type", typeof (Gst.Tag.ImageType), out image_type);
178
 
 
179
 
            if (image_type == Gst.Tag.ImageType.FRONT_COVER) {
180
 
                buffer = loop_sample.get_buffer ();
181
 
                break;
182
 
            } else if (image_type == Gst.Tag.ImageType.UNDEFINED || buffer == null) {
183
 
                buffer = loop_sample.get_buffer ();
 
185
            Gst.Sample sample;
 
186
 
 
187
            if (!tag_list.get_sample_index (Gst.Tags.IMAGE, i, out sample))
 
188
                break;
 
189
 
 
190
            var caps = sample.get_caps ();
 
191
            unowned Gst.Structure caps_struct = caps.get_structure (0);
 
192
            int image_type = Gst.Tag.ImageType.UNDEFINED;
 
193
 
 
194
            caps_struct.get_enum ("image-type", typeof (Gst.Tag.ImageType), out image_type);
 
195
            
 
196
            if (image_type == Gst.Tag.ImageType.UNDEFINED) {
 
197
                if (cover_sample == null)
 
198
                    cover_sample = sample;
 
199
            } else if (image_type == Gst.Tag.ImageType.FRONT_COVER) {
 
200
                cover_sample = sample;
 
201
                break;
184
202
            }
185
203
        }
186
204
 
187
 
        if (buffer == null) {
188
 
            debug ("Final image buffer is null");
189
 
            return null;
190
 
        }
191
 
 
192
 
        return get_pixbuf_from_buffer (buffer);
 
205
        return cover_sample;
193
206
    }
194
207
 
195
208
    private static Gdk.Pixbuf? get_pixbuf_from_buffer (Gst.Buffer buffer) {
196
 
        var memory = buffer.get_memory (0);
197
 
        if (memory == null)
198
 
            return null;
199
 
 
200
209
        Gst.MapInfo map_info;
201
 
        if (!memory.map (out map_info, Gst.MapFlags.READ))
 
210
 
 
211
        if (!buffer.map (out map_info, Gst.MapFlags.READ)) {
 
212
            warning ("Could not map memory buffer");
202
213
            return null;
203
 
 
204
 
        Gdk.Pixbuf? pix = null;
205
 
 
206
 
        if (map_info.data != null) {
 
214
        }
 
215
 
 
216
        Gdk.Pixbuf pix = null;
 
217
 
 
218
        try {
207
219
            var loader = new Gdk.PixbufLoader ();
208
 
 
209
 
            try {
210
 
                if (loader.write (map_info.data))
211
 
                    pix = loader.get_pixbuf ();
212
 
                loader.close ();
213
 
            } catch (Error err) {
214
 
                warning ("Error processing image data: %s", err.message);
215
 
            }
 
220
 
 
221
            if (loader.write (map_info.data) && loader.close ())
 
222
                pix = loader.get_pixbuf ();
 
223
        } catch (Error err) {
 
224
            warning ("Error processing image data: %s", err.message);
216
225
        }
217
226
 
218
 
        memory.unmap (map_info);
 
227
        buffer.unmap (map_info);
219
228
 
220
229
        return pix;
221
230
    }
222
 
 
223
 
}
 
231
}
 
 
b'\\ No newline at end of file'