add bluray dv, misc fixes
[goodguy/history.git] / cinelerra-5.1 / cinelerra / libdv.C
1 /*
2  * Grabbing algorithm is from dvgrab
3  */
4
5 #ifdef HAVE_DV
6
7 #include "bccmodels.h"
8 #include "libdv.h"
9
10 #include <pthread.h>
11 #include <stdio.h>
12 #include <string.h>
13
14 #ifdef USE_MMX
15 #include "mmx.h"
16 #endif
17
18
19 #define DV_WIDTH 720
20 #define DV_HEIGHT 576
21
22
23 static int dv_initted = 0;
24 static pthread_mutex_t dv_lock;
25
26 dv_t* dv_new()
27 {
28         dv_t *dv = (dv_t *)calloc(1, sizeof(dv_t));
29         if(!dv_initted)
30         {
31                 pthread_mutexattr_t attr;
32                 dv_initted = 1;
33 //              dv_init();
34                 pthread_mutexattr_init(&attr);
35                 pthread_mutex_init(&dv_lock, &attr);
36         }
37
38         dv->decoder = dv_decoder_new(0, 0, 0);
39         dv_set_error_log (dv->decoder, 0);
40         dv->decoder->quality = DV_QUALITY_BEST;
41         dv->decoder->prev_frame_decoded = 0;
42         dv->use_mmx = 1;
43         return dv;
44 }
45
46
47 int dv_delete(dv_t *dv)
48 {
49         int i;
50         if(dv->decoder)
51         {
52                 dv_decoder_free( dv->decoder );
53         }
54
55         if(dv->temp_video)
56                 free(dv->temp_video);
57
58         if(dv->temp_audio[0])
59         {
60                 for(i = 0; i < 4; i++)
61                         free(dv->temp_audio[i]);
62         }
63
64         if(dv->encoder)
65         {
66                 dv_encoder_free( dv->encoder );
67         }
68
69         free(dv);
70         return 0;
71 }
72
73 // Decodes BC_YUV422 only
74
75
76
77 int dv_read_video(dv_t *dv,
78                 unsigned char **output_rows,
79                 unsigned char *data,
80                 long bytes,
81                 int color_model)
82 {
83         int i;
84         int pitches[3];
85         int use_temp = color_model != BC_YUV422;
86         unsigned char *pixels[3];
87
88 //printf("dv_read_video 1 %d\n", color_model);
89         pthread_mutex_lock(&dv_lock);
90         switch(bytes)
91         {
92                 case DV_PAL_SIZE:
93                         break;
94                 case DV_NTSC_SIZE:
95                         break;
96                 default:
97                         return 1;
98                         break;
99         }
100
101         if(data[0] != 0x1f) return 1;
102
103         pitches[0] = DV_WIDTH * 2;
104         pitches[1] = 0;
105         pitches[2] = 0;
106         pixels[1] = 0;
107         pixels[2] = 0;
108
109         dv_parse_header(dv->decoder, data);
110
111         if(!use_temp)
112         {
113 //printf("dv_read_video 1\n");
114                 pixels[0] = output_rows[0];
115                 dv_decode_full_frame(dv->decoder,
116                         data,
117                         e_dv_color_yuv,
118                         output_rows,
119                         pitches);
120 //printf("dv_read_video 2\n");
121         }
122         else
123         {
124                 unsigned char *temp_rows[DV_HEIGHT];
125                 if(!dv->temp_video)
126                         dv->temp_video = (unsigned char *)calloc(1, DV_WIDTH * DV_HEIGHT * 2);
127
128                 for(i = 0; i < DV_HEIGHT; i++)
129                 {
130                         temp_rows[i] = dv->temp_video + i * DV_WIDTH * 2;
131                 }
132
133                 pixels[0] = dv->temp_video;
134 //printf("dv_read_video 3 %p\n", data);
135                 dv_decode_full_frame(dv->decoder,
136                         data,
137                         e_dv_color_yuv,
138                         pixels,
139                         pitches);
140 //printf("dv_read_video 4\n");
141
142                 BC_CModels::transfer(output_rows,
143                         temp_rows,
144                         output_rows[0],
145                         output_rows[1],
146                         output_rows[2],
147                         0,
148                         0,
149                         0,
150                         0,
151                         0,
152                         DV_WIDTH,
153                         dv->decoder->height,
154                         0,
155                         0,
156                         DV_WIDTH,
157                         dv->decoder->height,
158                         BC_YUV422,
159                         color_model,
160                         0,
161                         DV_WIDTH,
162                         DV_WIDTH);
163         }
164         dv->decoder->prev_frame_decoded = 1;
165         pthread_mutex_unlock(&dv_lock);
166         return 0;
167 }
168
169
170
171
172
173
174 int dv_read_audio(dv_t *dv,
175                 unsigned char *samples,
176                 unsigned char *data,
177                 long size,
178                 int channels,
179                 int bits)
180 {
181         int i, j;
182         short *samples_int16 = (short*)samples;
183         int samples_read;
184         if(channels > 4) channels = 4;
185
186 // For some reason someone had problems with libdv's maxmimum audio samples
187 #define MAX_AUDIO_SAMPLES 2048
188         if(!dv->temp_audio[0])
189         {
190                 for(i = 0; i < 4; i++)
191                         dv->temp_audio[i] = (int16_t*)calloc(1, sizeof(int16_t) * MAX_AUDIO_SAMPLES);
192         }
193
194         switch(size) {
195                 case DV_PAL_SIZE: break;
196                 case DV_NTSC_SIZE: break;
197                 default: return 0;
198         }
199
200         if(data[0] != 0x1f) return 0;
201
202         dv_parse_header(dv->decoder, data);
203         dv_decode_full_audio(dv->decoder, data, dv->temp_audio);
204         samples_read = dv->decoder->audio->samples_this_frame;
205
206         for(i = 0; i < channels; i++)
207         {
208                 for(j = 0; j < samples_read; j++)
209                 {
210                         samples_int16[i + j * channels] = dv->temp_audio[i][j];
211                         if(samples_int16[i + j * channels] == -0x8000)
212                                 samples_int16[i + j * channels] = 0;
213                 }
214         }
215
216
217
218
219
220
221         return samples_read;
222 }
223
224
225
226
227
228 // Encodes BC_YUV422 only
229
230 void dv_write_video(dv_t *dv,
231                 unsigned char *data,
232                 unsigned char **input_rows,
233                 int color_model,
234                 int norm)
235 {
236         int encode_dv_colormodel = 0;
237
238         if(!dv->encoder)
239         {
240                 dv->encoder = dv_encoder_new(
241                         0,
242                         0,
243                         0);
244         }
245
246         switch( color_model )
247         {
248                 case BC_YUV422:
249                         encode_dv_colormodel = e_dv_color_yuv;
250                         break;
251                 case BC_RGB888:
252                         encode_dv_colormodel = e_dv_color_rgb;
253                         break;
254                 default:
255                         return;
256                         break;
257         }
258         dv->encoder->is16x9 = 0;
259         dv->encoder->vlc_encode_passes = 3;
260         dv->encoder->static_qno = 0;
261         dv->encoder->force_dct = DV_DCT_AUTO;
262         dv->encoder->isPAL = (norm == DV_PAL);
263
264         dv_encode_full_frame( dv->encoder,
265                 input_rows,
266                 (dv_color_space_t)encode_dv_colormodel,
267                 data );
268 }
269
270
271
272 int dv_write_audio(dv_t *dv,
273                 unsigned char *data,
274                 unsigned char *input_samples,
275                 int max_samples,
276                 int channels,
277                 int bits,
278                 int rate,
279                 int norm)
280 {
281         int i, j;
282
283         if(!dv->encoder)
284         {
285                 dv->encoder = dv_encoder_new(
286                         0,
287                         0,
288                         0 );
289         }
290         dv->encoder->isPAL = (norm == DV_PAL);
291
292
293 // Get sample count from a libdv function
294         int samples = dv_calculate_samples(dv->encoder, rate, dv->audio_frames);
295         dv->audio_frames++;
296
297         if(!dv->temp_audio[0])
298         {
299                 for(i = 0; i < 4; i++)
300                         dv->temp_audio[i] = (int16_t*)calloc(1, sizeof(int16_t) * MAX_AUDIO_SAMPLES);
301         }
302
303         for(i = 0; i < channels; i++)
304         {
305                 short *temp_audio = dv->temp_audio[i];
306                 short *input_channel = (short*)input_samples + i;
307                 for(j = 0; j < samples; j++)
308                 {
309                         temp_audio[j] = input_channel[j * channels];
310                 }
311         }
312
313
314         dv_encode_full_audio(dv->encoder,
315                 dv->temp_audio,
316                 channels,
317                 rate,
318                 data);
319         return samples;
320 }
321
322 #endif