← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/imbuf/intern/indexer_dv.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/imbuf/intern/indexer_dv.c
22
22
 * ***** END GPL LICENSE BLOCK *****
23
23
 */
24
24
 
25
 
#include "IMB_indexer.h"
26
25
#include "MEM_guardedalloc.h"
 
26
 
27
27
#include "BLI_utildefines.h"
 
28
#include "BLI_path_util.h"
 
29
 
 
30
#include "IMB_indexer.h"
28
31
#include <time.h>
29
32
 
30
33
typedef struct indexer_dv_bitstream {
31
 
        unsigned char* buffer;
 
34
        unsigned char *buffer;
32
35
        int bit_pos;
33
36
} indexer_dv_bitstream;
34
37
 
35
 
static indexer_dv_bitstream bitstream_new(unsigned char* buffer_) 
 
38
static indexer_dv_bitstream bitstream_new(unsigned char *buffer_)
36
39
{
37
40
        indexer_dv_bitstream rv;
38
41
 
42
45
        return rv;
43
46
}
44
47
 
45
 
static unsigned long bitstream_get_bits(indexer_dv_bitstream * This, int num) 
 
48
static unsigned long bitstream_get_bits(indexer_dv_bitstream *This, int num)
46
49
{
47
50
        int byte_pos = This->bit_pos >> 3;
48
51
        unsigned long i = 
49
 
                This->buffer[byte_pos] | (This->buffer[byte_pos + 1] << 8) |
50
 
                (This->buffer[byte_pos + 2] << 16) | 
51
 
                (This->buffer[byte_pos + 3] << 24);
 
52
                This->buffer[byte_pos] | (This->buffer[byte_pos + 1] << 8) |
 
53
                (This->buffer[byte_pos + 2] << 16) |
 
54
                (This->buffer[byte_pos + 3] << 24);
52
55
        int rval = (i >> (This->bit_pos & 0x7)) & ((1 << num) - 1);
53
56
        This->bit_pos += num;
54
57
        return rval;
55
58
}
56
59
 
57
 
static int parse_num(indexer_dv_bitstream * b, int numbits)
 
60
static int parse_num(indexer_dv_bitstream *b, int numbits)
58
61
{
59
62
        return bitstream_get_bits(b, numbits);
60
63
}
61
64
 
62
 
static int parse_bcd(indexer_dv_bitstream * b, int n) 
 
65
static int parse_bcd(indexer_dv_bitstream *b, int n)
63
66
{
64
67
        char s[256];
65
 
        char * p = s + (n+3)/4;
 
68
        char *p = s + (n + 3) / 4;
66
69
 
67
70
        *p-- = 0;
68
71
 
93
96
        return atol(s);
94
97
}
95
98
 
96
 
typedef struct indexer_dv_context
97
 
{
 
99
typedef struct indexer_dv_context {
98
100
        int rec_curr_frame;
99
101
        int rec_curr_second;
100
102
        int rec_curr_minute;
119
121
        anim_index_entry backbuffer[31];
120
122
        int fsize;
121
123
 
122
 
        anim_index_builder * idx;
 
124
        anim_index_builder *idx;
123
125
} indexer_dv_context;
124
126
 
125
 
static void parse_packet(indexer_dv_context * This, unsigned char * p)
 
127
static void parse_packet(indexer_dv_context *This, unsigned char *p)
126
128
{
127
129
        indexer_dv_bitstream b;
128
130
        int type = p[0];
130
132
        b = bitstream_new(p + 1);
131
133
 
132
134
        switch (type) {
133
 
                case 0x62: // Record date
 
135
                case 0x62: /* Record date */
134
136
                        parse_num(&b, 8);
135
137
                        This->rec_curr_day = parse_bcd(&b, 6);
136
138
                        parse_num(&b, 2);
145
147
                        }
146
148
                        This->got_record_date = 1;
147
149
                        break;
148
 
                case 0x63: // Record time
 
150
                case 0x63: /* Record time */
149
151
                        This->rec_curr_frame = parse_bcd(&b, 6);
150
152
                        parse_num(&b, 2);
151
153
                        This->rec_curr_second = parse_bcd(&b, 7);
158
160
        }
159
161
}
160
162
 
161
 
static void parse_header_block(indexer_dv_context * This, unsigned char* target)
 
163
static void parse_header_block(indexer_dv_context *This, unsigned char *target)
162
164
{
163
165
        int i;
164
166
        for (i = 3; i < 80; i += 5) {
169
171
}
170
172
 
171
173
static void parse_subcode_blocks(
172
 
        indexer_dv_context * This, unsigned char* target)
 
174
        indexer_dv_context *This, unsigned char *target)
173
175
{
174
 
        int i,j;
 
176
        int i, j;
175
177
 
176
178
        for (j = 0; j < 2; j++) {
177
179
                for (i = 3; i < 80; i += 5) {
183
185
}
184
186
 
185
187
static void parse_vaux_blocks(
186
 
        indexer_dv_context * This, unsigned char* target)
 
188
        indexer_dv_context *This, unsigned char *target)
187
189
{
188
 
        int i,j;
 
190
        int i, j;
189
191
 
190
192
        for (j = 0; j < 3; j++) {
191
193
                for (i = 3; i < 80; i += 5) {
198
200
}
199
201
 
200
202
static void parse_audio_headers(
201
 
        indexer_dv_context * This, unsigned char* target)
 
203
        indexer_dv_context *This, unsigned char *target)
202
204
{
203
205
        int i;
204
206
 
210
212
        }
211
213
}
212
214
 
213
 
static void parse_frame(indexer_dv_context * This, 
214
 
                        unsigned char * framebuffer, int isPAL)
 
215
static void parse_frame(indexer_dv_context *This,
 
216
                        unsigned char *framebuffer, int isPAL)
215
217
{
216
218
        int numDIFseq = isPAL ? 12 : 10;
217
 
        unsigned char* target = framebuffer;
 
219
        unsigned char *target = framebuffer;
218
220
        int ds;
219
221
 
220
222
        for (ds = 0; ds < numDIFseq; ds++) {
229
231
        }
230
232
}
231
233
 
232
 
static void inc_frame(int * frame, time_t * t, int isPAL)
 
234
static void inc_frame(int *frame, time_t *t, int isPAL)
233
235
{
234
236
        if ((isPAL && *frame >= 25) || (!isPAL && *frame >= 30)) {
235
237
                fprintf(stderr, "Ouchie: inc_frame: invalid_frameno: %d\n",
246
248
        }
247
249
}
248
250
 
249
 
static void write_index(indexer_dv_context * This, anim_index_entry * entry)
 
251
static void write_index(indexer_dv_context *This, anim_index_entry *entry)
250
252
{
251
253
        IMB_index_builder_add_entry(
252
 
                This->idx, entry->frameno + This->frameno_offset, 
253
 
                entry->seek_pos, entry->seek_pos_dts, entry->pts);
 
254
                This->idx, entry->frameno + This->frameno_offset,
 
255
                entry->seek_pos, entry->seek_pos_dts, entry->pts);
254
256
}
255
257
 
256
 
static void fill_gap(indexer_dv_context * This, int isPAL)
 
258
static void fill_gap(indexer_dv_context *This, int isPAL)
257
259
{
258
260
        int i;
259
261
 
260
262
        for (i = 0; i < This->fsize; i++) {
261
263
                if (This->gap_start == This->ref_time_read &&
262
 
                        This->gap_frame == This->curr_frame) {
 
264
                    This->gap_frame == This->curr_frame)
 
265
                {
263
266
                        fprintf(stderr,
264
267
                                "indexer_dv::fill_gap: "
265
268
                                "can't seek backwards !\n");
269
272
        }
270
273
 
271
274
        while (This->gap_start != This->ref_time_read ||
272
 
               This->gap_frame != This->curr_frame) {
 
275
               This->gap_frame != This->curr_frame)
 
276
        {
273
277
                inc_frame(&This->gap_frame, &This->gap_start, isPAL);
274
278
                This->frameno_offset++;
275
279
        }
280
284
        This->fsize = 0;
281
285
}
282
286
 
283
 
static void proc_frame(indexer_dv_context * This,
284
 
                       unsigned char* UNUSED(framebuffer), int isPAL)
 
287
static void proc_frame(indexer_dv_context *This,
 
288
                       unsigned char *UNUSED(framebuffer), int isPAL)
285
289
{
286
290
        struct tm recDate;
287
291
        time_t t;
320
324
                                This->gap_frame = -1;
321
325
                        }
322
326
                }
323
 
                else if (This->ref_time_read_new  == This->ref_time_read) {
324
 
                        // do nothing
 
327
                else if (This->ref_time_read_new == This->ref_time_read) {
 
328
                        /* do nothing */
325
329
                }
326
330
                else {
327
331
                        This->gap_start = This->ref_time_read;
332
336
        }
333
337
}
334
338
 
335
 
static void indexer_dv_proc_frame(anim_index_builder * idx, 
336
 
                                  unsigned char * buffer,
 
339
static void indexer_dv_proc_frame(anim_index_builder *idx,
 
340
                                  unsigned char *buffer,
337
341
                                  int UNUSED(data_size),
338
 
                                  struct anim_index_entry * entry)
 
342
                                  struct anim_index_entry *entry)
339
343
{
340
344
        int isPAL;
341
345
        
342
 
        indexer_dv_context * This = (indexer_dv_context *) idx->private_data;
 
346
        indexer_dv_context *This = (indexer_dv_context *) idx->private_data;
343
347
 
344
348
        isPAL = (buffer[3] & 0x80);
345
349
 
362
366
                                "backbuffer overrun, emergency flush");
363
367
 
364
368
                        for (i = 0; i < This->fsize; i++) {
365
 
                                write_index(This, This->backbuffer+i);
 
369
                                write_index(This, This->backbuffer + i);
366
370
                        }
367
371
                        This->fsize = 0;
368
372
                }
369
373
        }
370
374
}
371
375
 
372
 
static void indexer_dv_delete(anim_index_builder * idx)
 
376
static void indexer_dv_delete(anim_index_builder *idx)
373
377
{
374
378
        int i = 0;
375
 
        indexer_dv_context * This = (indexer_dv_context *) idx->private_data;
 
379
        indexer_dv_context *This = (indexer_dv_context *) idx->private_data;
376
380
 
377
381
        for (i = 0; i < This->fsize; i++) {
378
 
                write_index(This, This->backbuffer+i);
 
382
                write_index(This, This->backbuffer + i);
379
383
        }
380
384
 
381
385
        MEM_freeN(This);
382
386
}
383
387
 
384
 
void IMB_indexer_dv_new(anim_index_builder * idx)
 
388
static void UNUSED_FUNCTION(IMB_indexer_dv_new)(anim_index_builder *idx)
385
389
{
386
 
        indexer_dv_context * rv = MEM_callocN(
387
 
                    sizeof(indexer_dv_context), "index_dv builder context");
 
390
        indexer_dv_context *rv = MEM_callocN(
 
391
                sizeof(indexer_dv_context), "index_dv builder context");
388
392
 
389
393
        rv->ref_time_read = -1;
390
394
        rv->curr_frame = -1;